import { routeInteractionRequest } from "./request-router.js";
import { appendInteractionEvent, bindActiveBook, clearCreationDraft, clearPendingDecision, updateCreationDraft, updateAutomationMode, } from "./session.js";
function extractToolMetadata(value) {
    const chapterNumber = typeof value === "object" && value !== null && "chapterNumber" in value
        && typeof value.chapterNumber === "number"
        ? value.chapterNumber
        : undefined;
    if (!value || typeof value !== "object" || !("__interaction" in value)) {
        return {
            ...(chapterNumber !== undefined ? { activeChapterNumber: chapterNumber } : {}),
        };
    }
    const interaction = value.__interaction;
    return {
        ...interaction,
        ...(interaction?.activeChapterNumber === undefined && chapterNumber !== undefined
            ? { activeChapterNumber: chapterNumber }
            : {}),
    };
}
function resolveRuntimeLanguage(request) {
    return request.language === "en" ? "en" : "zh";
}
function localize(language, messages) {
    return language === "en" ? messages.en : messages.zh;
}
function localizeMode(mode, language) {
    if (language === "en") {
        return mode;
    }
    return {
        auto: "自动",
        semi: "半自动",
        manual: "手动",
    }[mode] ?? mode;
}
function renderCreationDraft(draft, language) {
    const lines = language === "en"
        ? [
            "# Current Book Draft",
            draft.title ? `- Title: ${draft.title}` : undefined,
            draft.genre ? `- Genre: ${draft.genre}` : undefined,
            draft.platform ? `- Platform: ${draft.platform}` : undefined,
            draft.worldPremise ? `- World: ${draft.worldPremise}` : undefined,
            draft.protagonist ? `- Protagonist: ${draft.protagonist}` : undefined,
            draft.conflictCore ? `- Core Conflict: ${draft.conflictCore}` : undefined,
            draft.volumeOutline ? `- Volume Direction: ${draft.volumeOutline}` : undefined,
            draft.blurb ? `- Blurb: ${draft.blurb}` : undefined,
            draft.nextQuestion ? `- Next: ${draft.nextQuestion}` : undefined,
        ]
        : [
            "# 当前创作草案",
            draft.title ? `- 书名：${draft.title}` : undefined,
            draft.genre ? `- 题材：${draft.genre}` : undefined,
            draft.platform ? `- 平台：${draft.platform}` : undefined,
            draft.worldPremise ? `- 世界观：${draft.worldPremise}` : undefined,
            draft.protagonist ? `- 主角：${draft.protagonist}` : undefined,
            draft.conflictCore ? `- 核心冲突：${draft.conflictCore}` : undefined,
            draft.volumeOutline ? `- 卷纲方向：${draft.volumeOutline}` : undefined,
            draft.blurb ? `- 简介：${draft.blurb}` : undefined,
            draft.nextQuestion ? `- 下一步：${draft.nextQuestion}` : undefined,
        ];
    return lines.filter(Boolean).join("\n");
}
function buildTaskStartedState(session, request, language) {
    switch (request.intent) {
        case "write_next":
        case "continue_book":
            return {
                status: "planning",
                bookId: request.bookId ?? session.activeBookId,
                chapterNumber: session.activeChapterNumber,
                stageLabel: localize(language, {
                    zh: "准备章节输入",
                    en: "preparing chapter inputs",
                }),
            };
        case "develop_book":
            return {
                status: "planning",
                bookId: request.bookId ?? session.activeBookId,
                stageLabel: localize(language, {
                    zh: "收敛创作草案",
                    en: "developing book draft",
                }),
            };
        case "create_book":
            return {
                status: "planning",
                bookId: request.bookId ?? session.activeBookId,
                stageLabel: localize(language, {
                    zh: "创建作品基础",
                    en: "creating book foundation",
                }),
            };
        case "export_book":
            return {
                status: "persisting",
                bookId: request.bookId ?? session.activeBookId,
                chapterNumber: session.activeChapterNumber,
                stageLabel: localize(language, {
                    zh: "导出作品文件",
                    en: "exporting book artifacts",
                }),
            };
        case "revise_chapter":
        case "rewrite_chapter":
            return {
                status: "repairing",
                bookId: request.bookId ?? session.activeBookId,
                chapterNumber: request.chapterNumber ?? session.activeChapterNumber,
                stageLabel: request.intent === "rewrite_chapter"
                    ? localize(language, { zh: "重写章节", en: "rewriting chapter" })
                    : localize(language, { zh: "修订章节", en: "revising chapter" }),
            };
        case "update_focus":
        case "update_author_intent":
        case "edit_truth":
            return {
                status: "persisting",
                bookId: request.bookId ?? session.activeBookId,
                chapterNumber: session.activeChapterNumber,
                stageLabel: localize(language, {
                    zh: "应用项目修改",
                    en: "applying project edit",
                }),
            };
        case "pause_book":
        case "discard_book_draft":
            return {
                status: "blocked",
                bookId: request.bookId ?? session.activeBookId,
                chapterNumber: session.activeChapterNumber,
                stageLabel: localize(language, {
                    zh: "已由用户暂停",
                    en: "paused by user",
                }),
            };
        default:
            return {
                status: "planning",
                bookId: request.bookId ?? session.activeBookId,
                chapterNumber: session.activeChapterNumber,
                stageLabel: localize(language, {
                    zh: `处理中：${request.intent}`,
                    en: `handling ${request.intent}`,
                }),
            };
    }
}
function shouldWaitForHuman(automationMode, request) {
    const contentIntent = request.intent === "write_next"
        || request.intent === "continue_book"
        || request.intent === "revise_chapter"
        || request.intent === "rewrite_chapter"
        || request.intent === "patch_chapter_text";
    const editIntent = request.intent === "update_focus"
        || request.intent === "update_author_intent"
        || request.intent === "edit_truth"
        || request.intent === "rename_entity";
    if (automationMode === "auto") {
        return false;
    }
    if (automationMode === "semi") {
        return contentIntent;
    }
    return contentIntent || editIntent;
}
function buildPendingDecision(session, request, language, chapterNumber) {
    if (!shouldWaitForHuman(session.automationMode, request)) {
        return undefined;
    }
    const bookId = request.bookId ?? session.activeBookId;
    if (!bookId) {
        return undefined;
    }
    return {
        kind: "review-next-step",
        bookId,
        ...(chapterNumber !== undefined ? { chapterNumber } : {}),
        summary: session.automationMode === "manual"
            ? localize(language, {
                zh: "执行已完成。请明确选择下一步操作。",
                en: "Execution finished. Choose the next action explicitly.",
            })
            : localize(language, {
                zh: "执行已完成，等待你的下一步决定。",
                en: "Execution finished. Waiting for your next decision.",
            }),
    };
}
function buildWaitingExecution(session, request, language, chapterNumber) {
    return {
        status: "waiting_human",
        bookId: request.bookId ?? session.activeBookId,
        ...(chapterNumber !== undefined ? { chapterNumber } : {}),
        stageLabel: localize(language, {
            zh: "等待你的下一步决定",
            en: "waiting for your next decision",
        }),
    };
}
function appendToolEvents(session, events) {
    if (!events || events.length === 0) {
        return session;
    }
    const baseTimestamp = Date.now();
    return events.reduce((nextSession, event, index) => appendInteractionEvent(nextSession, {
        ...event,
        timestamp: baseTimestamp - events.length + index,
    }), session);
}
async function handleDraftLifecycleRequest(params) {
    const { session, request, tools, helpers } = params;
    const { language, addEvent, markCompleted } = helpers;
    switch (request.intent) {
        case "develop_book": {
            if (!tools.developBookDraft) {
                throw new Error(localize(language, {
                    zh: "创作草案会话暂未实现。",
                    en: "Book-draft ideation is not implemented yet.",
                }));
            }
            if (!request.instruction) {
                throw new Error(localize(language, {
                    zh: "创作草案需要一条用户输入。",
                    en: "Book-draft ideation requires user input.",
                }));
            }
            const toolResult = await tools.developBookDraft(request.instruction, session.creationDraft);
            const metadata = extractToolMetadata(toolResult);
            const draft = metadata.details?.creationDraft;
            if (!draft) {
                throw new Error(localize(language, {
                    zh: "创作草案工具没有返回草案数据。",
                    en: "Book-draft tool did not return draft data.",
                }));
            }
            const newRound = {
                roundId: (session.draftRounds?.length ?? 0) + 1,
                userMessage: request.instruction ?? "",
                assistantRaw: metadata.details?.draftRaw ?? "",
                fieldsUpdated: metadata.details?.fieldsUpdated ?? [],
                summary: metadata.details?.draftSummary ?? "",
                timestamp: Date.now(),
            };
            const withDraft = updateCreationDraft(session, draft);
            const withRounds = {
                ...withDraft,
                draftRounds: [...(withDraft.draftRounds ?? []), newRound],
            };
            const nextSession = appendToolEvents(withRounds, metadata.events);
            const completed = {
                ...markCompleted(nextSession),
                currentExecution: metadata.currentExecution ?? markCompleted(nextSession).currentExecution,
            };
            return {
                session: addEvent(completed, "task.completed", "completed", localize(language, {
                    zh: "已更新创作草案。",
                    en: "Updated the book draft.",
                })),
                responseText: metadata.responseText ?? localize(language, {
                    zh: "已更新创作草案。",
                    en: "Updated the book draft.",
                }),
                details: metadata.details,
            };
        }
        case "show_book_draft": {
            if (!session.creationDraft) {
                return {
                    session: markCompleted(session),
                    responseText: localize(language, {
                        zh: "当前还没有创作草案。先告诉我你想写什么，再逐步把书收出来。",
                        en: "There is no active book draft yet. Start by telling me what you want to write.",
                    }),
                };
            }
            return {
                session: markCompleted(session),
                responseText: renderCreationDraft(session.creationDraft, language),
            };
        }
        case "create_book": {
            if (!tools.createBook) {
                throw new Error(localize(language, {
                    zh: "交互运行时暂未实现创建作品。",
                    en: "Book creation is not implemented in the interaction runtime yet.",
                }));
            }
            const effectiveDraft = session.creationDraft;
            const title = request.title ?? effectiveDraft?.title;
            if (!title) {
                throw new Error(localize(language, {
                    zh: "创建作品需要标题。",
                    en: "Book creation requires a title.",
                }));
            }
            const toolResult = await tools.createBook({
                title,
                genre: request.genre ?? effectiveDraft?.genre,
                platform: request.platform ?? effectiveDraft?.platform,
                language: request.language ?? effectiveDraft?.language,
                chapterWordCount: request.chapterWordCount ?? effectiveDraft?.chapterWordCount,
                targetChapters: request.targetChapters ?? effectiveDraft?.targetChapters,
                blurb: request.blurb ?? effectiveDraft?.blurb,
                worldPremise: request.worldPremise ?? effectiveDraft?.worldPremise,
                settingNotes: request.settingNotes ?? effectiveDraft?.settingNotes,
                protagonist: request.protagonist ?? effectiveDraft?.protagonist,
                supportingCast: request.supportingCast ?? effectiveDraft?.supportingCast,
                conflictCore: request.conflictCore ?? effectiveDraft?.conflictCore,
                volumeOutline: request.volumeOutline ?? effectiveDraft?.volumeOutline,
                constraints: request.constraints ?? effectiveDraft?.constraints,
                authorIntent: request.authorIntent ?? effectiveDraft?.authorIntent,
                currentFocus: request.currentFocus ?? effectiveDraft?.currentFocus,
            });
            const metadata = extractToolMetadata(toolResult);
            const createdBookId = typeof toolResult === "object" && toolResult !== null && "bookId" in toolResult
                && typeof toolResult.bookId === "string"
                ? toolResult.bookId
                : undefined;
            if (!createdBookId) {
                throw new Error(localize(language, {
                    zh: "创建作品工具没有返回作品 ID。",
                    en: "Create-book tool did not return a book id.",
                }));
            }
            const nextSession = appendToolEvents(clearCreationDraft(bindActiveBook(session, createdBookId)), metadata.events);
            const completed = {
                ...markCompleted(nextSession),
                currentExecution: metadata.currentExecution ?? markCompleted(nextSession).currentExecution,
            };
            return {
                session: addEvent(completed, "task.completed", "completed", localize(language, {
                    zh: `已创建作品 ${createdBookId}。`,
                    en: `Created ${createdBookId}.`,
                })),
                responseText: metadata.responseText ?? localize(language, {
                    zh: `已创建作品 ${createdBookId}。`,
                    en: `Created ${createdBookId}.`,
                }),
                details: metadata.details,
            };
        }
        case "discard_book_draft": {
            const completed = markCompleted(clearCreationDraft(session));
            return {
                session: addEvent(completed, "task.completed", "completed", localize(language, {
                    zh: "已丢弃当前创作草案。",
                    en: "Discarded the current book draft.",
                })),
                responseText: localize(language, {
                    zh: "已丢弃当前创作草案。",
                    en: "Discarded the current book draft.",
                }),
            };
        }
        default:
            return undefined;
    }
}
async function handleBookSelectionRequest(params) {
    const { session, request, tools, helpers } = params;
    const { language, addEvent, markCompleted } = helpers;
    switch (request.intent) {
        case "list_books": {
            const books = await tools.listBooks();
            const completed = markCompleted(session);
            return {
                session: addEvent(completed, "task.completed", "completed", localize(language, {
                    zh: `已列出 ${books.length} 本作品。`,
                    en: `Listed ${books.length} book(s).`,
                })),
                responseText: books.length > 0
                    ? localize(language, {
                        zh: `作品列表：${books.join("、")}`,
                        en: `Books: ${books.join(", ")}`,
                    })
                    : localize(language, {
                        zh: "当前项目下没有作品。",
                        en: "No books found in this project.",
                    }),
            };
        }
        case "select_book": {
            if (!request.bookId) {
                throw new Error(localize(language, {
                    zh: "切换作品需要提供作品 ID。",
                    en: "Book selection requires a book id.",
                }));
            }
            const books = await tools.listBooks();
            if (!books.includes(request.bookId)) {
                throw new Error(localize(language, {
                    zh: `当前项目中找不到作品「${request.bookId}」。`,
                    en: `Book "${request.bookId}" not found in this project.`,
                }));
            }
            const completed = markCompleted(bindActiveBook(session, request.bookId));
            return {
                session: addEvent(completed, "task.completed", "completed", localize(language, {
                    zh: `已切换当前作品到 ${request.bookId}。`,
                    en: `Bound active book to ${request.bookId}.`,
                })),
                responseText: localize(language, {
                    zh: `当前作品：${request.bookId}`,
                    en: `Active book: ${request.bookId}`,
                }),
            };
        }
        default:
            return undefined;
    }
}
export async function runInteractionRequest(params) {
    const request = routeInteractionRequest(params.request);
    const language = resolveRuntimeLanguage(request);
    let session = params.session;
    const addEvent = (nextSession, kind, status, detail) => appendInteractionEvent(nextSession, {
        kind,
        timestamp: Date.now(),
        status,
        bookId: nextSession.activeBookId,
        chapterNumber: nextSession.activeChapterNumber,
        detail,
    });
    if (request.mode) {
        session = updateAutomationMode(session, request.mode);
    }
    session = clearPendingDecision({
        ...session,
        currentExecution: buildTaskStartedState(session, request, language),
    });
    session = addEvent(session, "task.started", session.currentExecution.status, localize(language, {
        zh: `开始执行 ${request.intent}。`,
        en: `Started ${request.intent}.`,
    }));
    const markCompleted = (nextSession) => ({
        ...nextSession,
        currentExecution: {
            status: "completed",
            bookId: nextSession.activeBookId,
            chapterNumber: nextSession.activeChapterNumber,
            stageLabel: localize(language, {
                zh: "已完成",
                en: "completed",
            }),
        },
    });
    const helperContext = {
        language,
        addEvent,
        markCompleted,
    };
    const draftLifecycleResult = await handleDraftLifecycleRequest({
        session,
        request,
        tools: params.tools,
        helpers: helperContext,
    });
    if (draftLifecycleResult) {
        return draftLifecycleResult;
    }
    const bookSelectionResult = await handleBookSelectionRequest({
        session,
        request,
        tools: params.tools,
        helpers: helperContext,
    });
    if (bookSelectionResult) {
        return bookSelectionResult;
    }
    switch (request.intent) {
        case "write_next":
        case "continue_book": {
            const bookId = request.bookId ?? session.activeBookId;
            if (!bookId) {
                throw new Error(localize(language, {
                    zh: "当前交互会话还没有绑定作品。",
                    en: "No active book is bound to the interaction session.",
                }));
            }
            const toolResult = await params.tools.writeNextChapter(bookId);
            const metadata = extractToolMetadata(toolResult);
            session = bindActiveBook(session, bookId, metadata.activeChapterNumber);
            session = appendToolEvents(session, metadata.events);
            const pendingDecision = metadata.pendingDecision ?? buildPendingDecision(session, request, language, metadata.activeChapterNumber);
            const completed = pendingDecision
                ? {
                    ...session,
                    pendingDecision,
                    currentExecution: metadata.currentExecution ?? buildWaitingExecution(session, request, language, metadata.activeChapterNumber),
                }
                : {
                    ...markCompleted(session),
                    currentExecution: metadata.currentExecution ?? markCompleted(session).currentExecution,
                };
            return {
                session: addEvent(completed, "task.completed", "completed", localize(language, {
                    zh: `已为 ${bookId} 完成下一章写作。`,
                    en: `Completed write_next for ${bookId}.`,
                })),
                responseText: metadata.responseText ?? (pendingDecision
                    ? localize(language, {
                        zh: `已为 ${bookId} 完成下一章写作，等待你的下一步决定。`,
                        en: `Completed write_next for ${bookId}; waiting for your next decision.`,
                    })
                    : localize(language, {
                        zh: `已为 ${bookId} 完成下一章写作。`,
                        en: `Completed write_next for ${bookId}.`,
                    })),
            };
        }
        case "revise_chapter":
        case "rewrite_chapter": {
            const bookId = request.bookId ?? session.activeBookId;
            if (!bookId) {
                throw new Error(localize(language, {
                    zh: "当前交互会话还没有绑定作品。",
                    en: "No active book is bound to the interaction session.",
                }));
            }
            if (!request.chapterNumber) {
                throw new Error(localize(language, {
                    zh: "修订章节需要章节号。",
                    en: "Chapter number is required for chapter revision.",
                }));
            }
            const mode = request.intent === "rewrite_chapter" ? "rewrite" : "local-fix";
            const toolResult = await params.tools.reviseDraft(bookId, request.chapterNumber, mode);
            const metadata = extractToolMetadata(toolResult);
            const chapterNumber = metadata.activeChapterNumber ?? request.chapterNumber;
            session = bindActiveBook(session, bookId, chapterNumber);
            session = appendToolEvents(session, metadata.events);
            const pendingDecision = metadata.pendingDecision ?? buildPendingDecision(session, request, language, chapterNumber);
            const completed = pendingDecision
                ? {
                    ...session,
                    pendingDecision,
                    currentExecution: metadata.currentExecution ?? buildWaitingExecution(session, request, language, chapterNumber),
                }
                : {
                    ...markCompleted(session),
                    currentExecution: metadata.currentExecution ?? markCompleted(session).currentExecution,
                };
            return {
                session: addEvent(completed, "task.completed", "completed", localize(language, {
                    zh: request.intent === "rewrite_chapter"
                        ? `已为 ${bookId} 完成章节重写。`
                        : `已为 ${bookId} 完成章节修订。`,
                    en: `Completed ${request.intent} for ${bookId}.`,
                })),
                responseText: metadata.responseText ?? (pendingDecision
                    ? localize(language, {
                        zh: request.intent === "rewrite_chapter"
                            ? `已为 ${bookId} 完成章节重写，等待你的下一步决定。`
                            : `已为 ${bookId} 完成章节修订，等待你的下一步决定。`,
                        en: `Completed ${request.intent} for ${bookId}; waiting for your next decision.`,
                    })
                    : localize(language, {
                        zh: request.intent === "rewrite_chapter"
                            ? `已为 ${bookId} 完成章节重写。`
                            : `已为 ${bookId} 完成章节修订。`,
                        en: `Completed ${request.intent} for ${bookId}.`,
                    })),
            };
        }
        case "patch_chapter_text": {
            const bookId = request.bookId ?? session.activeBookId;
            if (!bookId) {
                throw new Error(localize(language, {
                    zh: "当前交互会话还没有绑定作品。",
                    en: "No active book is bound to the interaction session.",
                }));
            }
            if (!request.chapterNumber || !request.targetText || !request.replacementText) {
                throw new Error(localize(language, {
                    zh: "正文修补需要章节号、目标文本和替换文本。",
                    en: "Chapter patch requires chapter number, target text, and replacement text.",
                }));
            }
            const toolResult = await params.tools.patchChapterText(bookId, request.chapterNumber, request.targetText, request.replacementText);
            const metadata = extractToolMetadata(toolResult);
            const chapterNumber = metadata.activeChapterNumber ?? request.chapterNumber;
            session = bindActiveBook(session, bookId, chapterNumber);
            session = appendToolEvents(session, metadata.events);
            const pendingDecision = metadata.pendingDecision ?? buildPendingDecision(session, request, language, chapterNumber);
            const completed = pendingDecision
                ? {
                    ...session,
                    pendingDecision,
                    currentExecution: metadata.currentExecution ?? buildWaitingExecution(session, request, language, chapterNumber),
                }
                : {
                    ...markCompleted(session),
                    currentExecution: metadata.currentExecution ?? markCompleted(session).currentExecution,
                };
            return {
                session: addEvent(completed, "task.completed", "completed", localize(language, {
                    zh: `已修补 ${bookId} 的第 ${chapterNumber} 章。`,
                    en: `Patched chapter ${chapterNumber} for ${bookId}.`,
                })),
                responseText: metadata.responseText ?? (pendingDecision
                    ? localize(language, {
                        zh: `已修补 ${bookId} 的第 ${chapterNumber} 章，等待你的下一步决定。`,
                        en: `Patched chapter ${chapterNumber} for ${bookId}; waiting for your next decision.`,
                    })
                    : localize(language, {
                        zh: `已修补 ${bookId} 的第 ${chapterNumber} 章。`,
                        en: `Patched chapter ${chapterNumber} for ${bookId}.`,
                    })),
            };
        }
        case "rename_entity": {
            const bookId = request.bookId ?? session.activeBookId;
            if (!bookId) {
                throw new Error(localize(language, {
                    zh: "当前交互会话还没有绑定作品。",
                    en: "No active book is bound to the interaction session.",
                }));
            }
            if (!request.oldValue || !request.newValue) {
                throw new Error(localize(language, {
                    zh: "实体改名需要旧值和新值。",
                    en: "Entity rename requires old and new values.",
                }));
            }
            const toolResult = await params.tools.renameEntity(bookId, request.oldValue, request.newValue);
            const metadata = extractToolMetadata(toolResult);
            session = bindActiveBook(session, bookId, metadata.activeChapterNumber);
            session = appendToolEvents(session, metadata.events);
            const pendingDecision = metadata.pendingDecision ?? buildPendingDecision(session, request, language, metadata.activeChapterNumber);
            const completed = pendingDecision
                ? {
                    ...session,
                    pendingDecision,
                    currentExecution: metadata.currentExecution ?? buildWaitingExecution(session, request, language, metadata.activeChapterNumber),
                }
                : {
                    ...markCompleted(session),
                    currentExecution: metadata.currentExecution ?? markCompleted(session).currentExecution,
                };
            return {
                session: addEvent(completed, "task.completed", "completed", localize(language, {
                    zh: `已在 ${bookId} 中把 ${request.oldValue} 改成 ${request.newValue}。`,
                    en: `Renamed ${request.oldValue} to ${request.newValue} in ${bookId}.`,
                })),
                responseText: metadata.responseText ?? (pendingDecision
                    ? localize(language, {
                        zh: `已在 ${bookId} 中把 ${request.oldValue} 改成 ${request.newValue}，等待你的下一步决定。`,
                        en: `Renamed ${request.oldValue} to ${request.newValue} in ${bookId}; waiting for your next decision.`,
                    })
                    : localize(language, {
                        zh: `已在 ${bookId} 中把 ${request.oldValue} 改成 ${request.newValue}。`,
                        en: `Renamed ${request.oldValue} to ${request.newValue} in ${bookId}.`,
                    })),
            };
        }
        case "update_focus": {
            const bookId = request.bookId ?? session.activeBookId;
            if (!bookId) {
                throw new Error(localize(language, {
                    zh: "当前交互会话还没有绑定作品。",
                    en: "No active book is bound to the interaction session.",
                }));
            }
            if (!request.instruction) {
                throw new Error(localize(language, {
                    zh: "更新焦点需要提供内容。",
                    en: "Focus update requires instruction content.",
                }));
            }
            const toolResult = await params.tools.updateCurrentFocus(bookId, request.instruction);
            const metadata = extractToolMetadata(toolResult);
            session = bindActiveBook(session, bookId);
            session = appendToolEvents(session, metadata.events);
            const pendingDecision = metadata.pendingDecision ?? buildPendingDecision(session, request, language);
            const completed = pendingDecision
                ? {
                    ...session,
                    pendingDecision,
                    currentExecution: metadata.currentExecution ?? buildWaitingExecution(session, request, language),
                }
                : {
                    ...markCompleted(session),
                    currentExecution: metadata.currentExecution ?? markCompleted(session).currentExecution,
                };
            return {
                session: addEvent(completed, "task.completed", "completed", localize(language, {
                    zh: `已更新 ${bookId} 的当前焦点。`,
                    en: `Updated current focus for ${bookId}.`,
                })),
                responseText: metadata.responseText ?? (pendingDecision
                    ? localize(language, {
                        zh: `已更新 ${bookId} 的当前焦点，等待你的下一步决定。`,
                        en: `Updated current focus for ${bookId}; waiting for your next decision.`,
                    })
                    : localize(language, {
                        zh: `已更新 ${bookId} 的当前焦点。`,
                        en: `Updated current focus for ${bookId}.`,
                    })),
            };
        }
        case "update_author_intent": {
            const bookId = request.bookId ?? session.activeBookId;
            if (!bookId) {
                throw new Error(localize(language, {
                    zh: "当前交互会话还没有绑定作品。",
                    en: "No active book is bound to the interaction session.",
                }));
            }
            if (!request.instruction) {
                throw new Error(localize(language, {
                    zh: "更新作者意图需要提供内容。",
                    en: "Author intent update requires instruction content.",
                }));
            }
            const toolResult = await params.tools.updateAuthorIntent(bookId, request.instruction);
            const metadata = extractToolMetadata(toolResult);
            session = bindActiveBook(session, bookId);
            session = appendToolEvents(session, metadata.events);
            const pendingDecision = metadata.pendingDecision ?? buildPendingDecision(session, request, language);
            const completed = pendingDecision
                ? {
                    ...session,
                    pendingDecision,
                    currentExecution: metadata.currentExecution ?? buildWaitingExecution(session, request, language),
                }
                : {
                    ...markCompleted(session),
                    currentExecution: metadata.currentExecution ?? markCompleted(session).currentExecution,
                };
            return {
                session: addEvent(completed, "task.completed", "completed", localize(language, {
                    zh: `已更新 ${bookId} 的作者意图。`,
                    en: `Updated author intent for ${bookId}.`,
                })),
                responseText: metadata.responseText ?? (pendingDecision
                    ? localize(language, {
                        zh: `已更新 ${bookId} 的作者意图，等待你的下一步决定。`,
                        en: `Updated author intent for ${bookId}; waiting for your next decision.`,
                    })
                    : localize(language, {
                        zh: `已更新 ${bookId} 的作者意图。`,
                        en: `Updated author intent for ${bookId}.`,
                    })),
            };
        }
        case "edit_truth": {
            const bookId = request.bookId ?? session.activeBookId;
            if (!bookId) {
                throw new Error(localize(language, {
                    zh: "当前交互会话还没有绑定作品。",
                    en: "No active book is bound to the interaction session.",
                }));
            }
            if (!request.fileName || !request.instruction) {
                throw new Error(localize(language, {
                    zh: "编辑真相文件需要文件名和内容。",
                    en: "Truth-file edit requires a file name and content.",
                }));
            }
            const toolResult = await params.tools.writeTruthFile(bookId, request.fileName, request.instruction);
            const metadata = extractToolMetadata(toolResult);
            session = bindActiveBook(session, bookId);
            session = appendToolEvents(session, metadata.events);
            const pendingDecision = metadata.pendingDecision ?? buildPendingDecision(session, request, language);
            const completed = pendingDecision
                ? {
                    ...session,
                    pendingDecision,
                    currentExecution: metadata.currentExecution ?? buildWaitingExecution(session, request, language),
                }
                : {
                    ...markCompleted(session),
                    currentExecution: metadata.currentExecution ?? markCompleted(session).currentExecution,
                };
            return {
                session: addEvent(completed, "task.completed", "completed", localize(language, {
                    zh: `已更新 ${bookId} 的 ${request.fileName}。`,
                    en: `Updated ${request.fileName} for ${bookId}.`,
                })),
                responseText: metadata.responseText ?? (pendingDecision
                    ? localize(language, {
                        zh: `已更新 ${bookId} 的 ${request.fileName}，等待你的下一步决定。`,
                        en: `Updated ${request.fileName} for ${bookId}; waiting for your next decision.`,
                    })
                    : localize(language, {
                        zh: `已更新 ${bookId} 的 ${request.fileName}。`,
                        en: `Updated ${request.fileName} for ${bookId}.`,
                    })),
            };
        }
        case "export_book": {
            const bookId = request.bookId ?? session.activeBookId;
            if (!params.tools.exportBook) {
                throw new Error(localize(language, {
                    zh: "交互运行时暂未实现导出作品。",
                    en: "Book export is not implemented in the interaction runtime yet.",
                }));
            }
            if (!bookId) {
                throw new Error(localize(language, {
                    zh: "当前交互会话还没有绑定作品。",
                    en: "No active book is bound to the interaction session.",
                }));
            }
            const toolResult = await params.tools.exportBook(bookId, {
                format: request.format,
                approvedOnly: request.approvedOnly,
                outputPath: request.outputPath,
            });
            const metadata = extractToolMetadata(toolResult);
            session = bindActiveBook(session, bookId, metadata.activeChapterNumber);
            session = appendToolEvents(session, metadata.events);
            const completed = {
                ...markCompleted(session),
                currentExecution: metadata.currentExecution ?? markCompleted(session).currentExecution,
            };
            return {
                session: addEvent(completed, "task.completed", "completed", localize(language, {
                    zh: `已导出 ${bookId}。`,
                    en: `Exported ${bookId}.`,
                })),
                responseText: metadata.responseText ?? localize(language, {
                    zh: `已导出 ${bookId}。`,
                    en: `Exported ${bookId}.`,
                }),
                details: metadata.details,
            };
        }
        case "switch_mode":
            session = markCompleted(session);
            return {
                session: addEvent(session, "task.completed", "completed", localize(language, {
                    zh: `已切换到${localizeMode(session.automationMode, language)}模式。`,
                    en: `Switched mode to ${session.automationMode}.`,
                })),
                responseText: localize(language, {
                    zh: `已切换到${localizeMode(session.automationMode, language)}模式。`,
                    en: `Switched mode to ${session.automationMode}.`,
                }),
            };
        case "pause_book": {
            const bookId = request.bookId ?? session.activeBookId;
            const paused = {
                ...session,
                currentExecution: {
                    status: "blocked",
                    bookId,
                    chapterNumber: session.activeChapterNumber,
                    stageLabel: localize(language, {
                        zh: "已由用户暂停",
                        en: "paused by user",
                    }),
                },
            };
            return {
                session: addEvent(paused, "task.completed", "blocked", localize(language, {
                    zh: `已暂停${bookId ?? "当前作品"}。`,
                    en: `Paused ${bookId ?? "current book"}.`,
                })),
                responseText: localize(language, {
                    zh: `已暂停${bookId ?? "当前作品"}。`,
                    en: `Paused ${bookId ?? "current book"}.`,
                }),
            };
        }
        case "resume_book": {
            const bookId = request.bookId ?? session.activeBookId;
            const resumed = {
                ...session,
                currentExecution: {
                    status: "completed",
                    bookId,
                    chapterNumber: session.activeChapterNumber,
                    stageLabel: localize(language, {
                        zh: "可继续执行",
                        en: "ready to continue",
                    }),
                },
            };
            return {
                session: addEvent(resumed, "task.completed", "completed", localize(language, {
                    zh: `已恢复${bookId ?? "当前作品"}。`,
                    en: `Resumed ${bookId ?? "current book"}.`,
                })),
                responseText: localize(language, {
                    zh: `已恢复${bookId ?? "当前作品"}。`,
                    en: `Resumed ${bookId ?? "current book"}.`,
                }),
            };
        }
        case "chat": {
            const bookId = request.bookId ?? session.activeBookId;
            const prompt = request.instruction?.trim().toLowerCase() ?? "";
            const toolResult = params.tools.chat
                ? await params.tools.chat(request.instruction ?? "", {
                    bookId,
                    automationMode: session.automationMode,
                })
                : undefined;
            const metadata = extractToolMetadata(toolResult);
            const responseText = metadata.responseText ?? (/^(hi|hello|hey|你好|嗨|哈喽)$/i.test(prompt)
                ? (bookId
                    ? localize(language, {
                        zh: `你好。当前作品是 ${bookId}。你可以让我继续写、修订章节，或者解释当前卡住的原因。`,
                        en: `Hi. Active book is ${bookId}. Ask me to continue, revise a chapter, or explain what is blocked.`,
                    })
                    : localize(language, {
                        zh: "你好。当前还没有激活作品。你可以先打开作品、列出作品，或者直接告诉我你要写什么。",
                        en: "Hi. No active book yet. Open a book, list books, or tell me what you want to write.",
                    }))
                : (bookId
                    ? localize(language, {
                        zh: `我在。当前作品是 ${bookId}。你可以让我继续写、修订章节、重写、调整焦点，或者查看流水线为何停止。`,
                        en: `I’m here. Active book is ${bookId}. You can ask me to continue, revise a chapter, rewrite, change focus, or inspect why the pipeline stopped.`,
                    })
                    : localize(language, {
                        zh: "我在。当前还没有绑定作品。先打开作品、列出作品，或者直接描述你要写什么。",
                        en: "I’m here. No active book is bound yet. Open a book, list books, or describe what you want to write.",
                    })));
            const completed = markCompleted(session);
            return {
                session: addEvent(completed, "task.completed", "completed", responseText),
                responseText,
            };
        }
        case "explain_status":
        case "explain_failure": {
            const bookId = request.bookId ?? session.activeBookId;
            const baselineExecution = params.session.currentExecution;
            const stage = baselineExecution?.stageLabel ?? baselineExecution?.status ?? "idle";
            const summary = request.intent === "explain_failure"
                ? localize(language, {
                    zh: `当前失败上下文：${bookId ?? "当前无激活作品"} 处于 ${stage}。`,
                    en: `Current failure context: ${bookId ?? "no active book"} is at ${stage}.`,
                })
                : localize(language, {
                    zh: `当前状态：${bookId ?? "当前无激活作品"} 处于 ${stage}。`,
                    en: `Current status: ${bookId ?? "no active book"} is at ${stage}.`,
                });
            const completed = markCompleted(session);
            return {
                session: addEvent(completed, "task.completed", "completed", summary),
                responseText: summary,
            };
        }
        default:
            throw new Error(localize(language, {
                zh: `交互运行时暂未实现意图「${request.intent}」。`,
                en: `Intent "${request.intent}" is not implemented in the interaction runtime yet.`,
            }));
    }
}
//# sourceMappingURL=runtime.js.map