@musnows/scriverse 0.7.3 → 0.7.4

package/dist/app.js

@@ -10,18 +10,22 @@ import { tmpdir } from "node:os";
 import { pipeline } from "node:stream/promises";
 import { z, ZodError } from "zod";
 import { AI_PROVIDER_PROTOCOLS } from "./ai-protocol.js";
+import { aiConversationExportContentDisposition, exportAiConversationMarkdown } from "./ai-conversation-export.js";
+import { DEFAULT_AI_STREAM_IDLE_TIMEOUT_MS } from "./ai-stream-timeout.js";
 import { AttachmentStorage } from "./attachment-storage.js";
 import { AiManager } from "./ai.js";
 import { resolveMaxAgentToolCallLimit } from "./ai-tool-results.js";
+import { CHARACTER_EXTRACTION_MAX_ALIASES, CHARACTER_EXTRACTION_MAX_CANDIDATES, CHARACTER_EXTRACTION_MAX_IDENTITY_LENGTH, CHARACTER_EXTRACTION_MAX_NAME_LENGTH, CHARACTER_EXTRACTION_MAX_SPECIES_LENGTH } from "./character-extraction.js";
 import { CredentialVault } from "./credential-vault.js";
 import { Database } from "./database.js";
 import { assertSafeDocxArchive } from "./docx-security.js";
+import { EPUB_MIME_TYPE, epubContentDisposition } from "./epub-export.js";
 import { CREATABLE_ANALYSIS_TASK_TYPES, DRAFT_SETTING_MODULES, TASK_TYPES } from "./domain.js";
 import { AppError } from "./errors.js";
 import { isOfficialGoogleVertexBaseUrl, parseGoogleServiceAccount } from "./google-vertex-auth.js";
-import { HYBRID_SEARCH_TYPES } from "./hybrid-search.js";
+import { HYBRID_SEARCH_TYPES, MAXIMUM_WORK_SEARCH_QUERY_LENGTH } from "./hybrid-search.js";
 import { applyImportFileHints, parseNovelText } from "./parser.js";
-import { aiConversationTaskTypes, attachmentPermissionModules, Store, versionedEntityTypes } from "./store.js";
+import { aiConversationTaskTypes, attachmentPermissionModules, RECYCLE_BIN_RETENTION_DAYS, Store, versionedEntityTypes } from "./store.js";
 import { paginated, parsePagination } from "./pagination.js";
 import { normalizeUploadFileName } from "./utils.js";
 import { assertSafeAiEndpoint, assertSafeS3Endpoint, createApiRateLimitMiddleware, createAuthenticationRateLimitMiddleware, createBasicAuthMiddleware, createCaptchaRateLimitMiddleware, createExpensiveApiRateLimitMiddleware, createSameOriginMiddleware, createSecurityHeadersMiddleware, createUploadRateLimitMiddleware, enforceCaseInsensitiveRouting, normalizeApiPath, resolveTrustProxySetting, verifySetupToken } from "./security.js";
@@ -41,6 +45,8 @@ import { PresenceStore } from "./presence-store.js";
 import { analysisTaskReadModules, clearSessionCookie, createCliApiScopeMiddleware, createUserSessionMiddleware, createWorkAuthorizationMiddleware, relationshipAnalysisReadModules, setSessionCookie, UserAuthService } from "./user-auth.js";
 const nonEmpty = z.string().trim().min(1);
 const identifier = z.string().trim().min(1).max(200);
+const idempotencyKeySchema = z.string().trim().min(16).max(128)
+    .regex(/^[A-Za-z0-9][A-Za-z0-9._:-]*$/u, "幂等键只能包含英文字母、数字、点、下划线、冒号和短横线");
 const optionalStrings = z.array(z.string()).optional();
 const jsonObject = z.record(z.string(), z.unknown());
 const chapterTypeSchema = z.enum(["正文", "设定", "作者的话", "其他"]);
@@ -49,6 +55,18 @@ const versionedEntityTypeSchema = z.enum(versionedEntityTypes);
 const attachmentPermissionModuleSchema = z.enum(attachmentPermissionModules);
 const maximumImportedTextLength = 20_000_000;
 const maximumKnowledgeSectionsLength = 4_000_000;
+function stableJson(value) {
+    if (Array.isArray(value))
+        return `[${value.map((item) => stableJson(item)).join(",")}]`;
+    if (value && typeof value === "object") {
+        return `{${Object.entries(value)
+            .filter(([, item]) => item !== undefined)
+            .sort(([left], [right]) => left.localeCompare(right))
+            .map(([key, item]) => `${JSON.stringify(key)}:${stableJson(item)}`)
+            .join(",")}}`;
+    }
+    return JSON.stringify(value) ?? "null";
+}
 function assertImageUploadSize(byteLength, maximumBytes, message) {
     if (byteLength <= maximumBytes)
         return;
@@ -607,6 +625,34 @@ const analysisTaskSchema = z.union([
         }
     })
 ]);
+const characterExtractionSelectionSchema = z.object({
+    candidateId: z.string().trim().min(1).max(100).regex(/^[A-Za-z0-9_-]+$/u),
+    action: z.enum(["create", "merge", "skip"]),
+    targetCharacterId: identifier.optional(),
+    name: z.string().trim().min(1).max(CHARACTER_EXTRACTION_MAX_NAME_LENGTH).optional(),
+    aliases: z.array(z.string().trim().min(1).max(CHARACTER_EXTRACTION_MAX_NAME_LENGTH))
+        .max(CHARACTER_EXTRACTION_MAX_ALIASES).optional(),
+    species: z.string().trim().max(CHARACTER_EXTRACTION_MAX_SPECIES_LENGTH).optional(),
+    attributes: z.object({
+        identity: z.string().trim().max(CHARACTER_EXTRACTION_MAX_IDENTITY_LENGTH).optional()
+    }).strict().optional()
+}).strict().superRefine((selection, context) => {
+    if (selection.action === "merge" && !selection.targetCharacterId) {
+        context.addIssue({ code: z.ZodIssueCode.custom, path: ["targetCharacterId"], message: "合并角色候选必须选择目标角色" });
+    }
+    if (selection.action !== "merge" && selection.targetCharacterId !== undefined) {
+        context.addIssue({ code: z.ZodIssueCode.custom, path: ["targetCharacterId"], message: "只有合并操作可以指定目标角色" });
+    }
+});
+const characterExtractionApplySchema = z.object({
+    previewToken: z.string().regex(/^[a-f0-9]{64}$/u),
+    selections: z.array(characterExtractionSelectionSchema).min(1).max(CHARACTER_EXTRACTION_MAX_CANDIDATES)
+}).strict().superRefine((input, context) => {
+    const candidateIds = input.selections.map((selection) => selection.candidateId);
+    if (new Set(candidateIds).size !== candidateIds.length) {
+        context.addIssue({ code: z.ZodIssueCode.custom, path: ["selections"], message: "角色候选不能重复" });
+    }
+});
 export const RUNTIME_BACKUP_IDLE_TIMEOUT_MS = 9_000;
 function data(response, value, status = 200) {
     response.status(status).json({ data: value });
@@ -614,6 +660,18 @@ function data(response, value, status = 200) {
 function noContent(response) {
     response.status(204).end();
 }
+async function sendEpub(response, archive, title, fallbackStem) {
+    response.type(EPUB_MIME_TYPE);
+    response.setHeader("Content-Disposition", epubContentDisposition(title, fallbackStem));
+    response.setHeader("Cache-Control", "private, no-store");
+    await pipeline(archive.generateNodeStream({
+        type: "nodebuffer",
+        // 逐条目压缩后再写入，确保首个 mimetype 本地头包含确定长度且没有额外字段。
+        streamFiles: false,
+        compression: "DEFLATE",
+        compressionOptions: { level: 6 }
+    }), response);
+}
 function parse(schema, value) {
     return schema.parse(value);
 }
@@ -876,7 +934,9 @@ export function publicAiStreamError(error) {
             ...(typeof details?.providerName === "string" ? { providerName: details.providerName } : {}),
             ...(typeof details?.providerId === "string" ? { providerId: details.providerId } : {}),
             ...(typeof details?.modelId === "string" ? { modelId: details.modelId } : {}),
-            ...(typeof details?.modelRecordId === "string" ? { modelRecordId: details.modelRecordId } : {})
+            ...(typeof details?.modelRecordId === "string" ? { modelRecordId: details.modelRecordId } : {}),
+            ...(typeof details?.phase === "string" ? { phase: details.phase } : {}),
+            ...(typeof details?.idleTimeoutSeconds === "number" ? { idleTimeoutSeconds: details.idleTimeoutSeconds } : {})
         };
     }
     return { code: "AI_STREAM_FAILED", message: "AI 流式调用失败" };
@@ -1007,7 +1067,7 @@ export function createRuntime(options) {
             read: requiredModules,
             write: ["ai-analysis"]
         }, false, actor?.allowAdminAccess ?? false);
-    }, attachmentStorage);
+    }, attachmentStorage, { interactiveStreamIdleTimeoutMs: options.aiStreamIdleTimeoutMs ?? DEFAULT_AI_STREAM_IDLE_TIMEOUT_MS });
     const app = express();
     enforceCaseInsensitiveRouting(app);
     const upload = multer({
@@ -1226,6 +1286,23 @@ export function createRuntime(options) {
         const pagination = parsePagination(request.query);
         data(response, pagination ? store.listWorksPage(pagination) : store.listWorks());
     });
+    app.get("/api/recycle-bin/works", (_request, response) => {
+        data(response, { retentionDays: RECYCLE_BIN_RETENTION_DAYS, works: store.listDeletedWorks() });
+    });
+    app.post("/api/recycle-bin/works/:workId/restore", (request, response) => {
+        if (request.authUser)
+            auth.assertDeletedWorkAccess(request.authUser, request.params.workId, request.authMethod !== "api-key");
+        const input = parse(z.object({ expectedVersionNo: expectedVersionNoSchema }).strict(), request.body ?? {});
+        data(response, store.restoreWork(request.params.workId, input.expectedVersionNo));
+    });
+    app.delete("/api/recycle-bin/works/:workId/permanent", async (request, response) => {
+        if (request.authUser)
+            auth.assertDeletedWorkAccess(request.authUser, request.params.workId, request.authMethod !== "api-key");
+        const input = parse(z.object({ expectedVersionNo: expectedVersionNoSchema }).strict(), request.body ?? {});
+        store.permanentlyDeleteWork(request.params.workId, input.expectedVersionNo);
+        await cleanupAttachments();
+        noContent(response);
+    });
     app.post("/api/works", (request, response) => data(response, store.createWork(parse(workSchema, request.body)), 201));
     app.post("/api/works/import", upload.single("file"), async (request, response) => {
         if (!request.file)
@@ -1310,7 +1387,6 @@ export function createRuntime(options) {
     app.delete("/api/works/:workId", async (request, response) => {
         const input = parse(z.object({ expectedVersionNo: expectedVersionNoSchema }).strict(), request.body ?? {});
         store.deleteWork(request.params.workId, input.expectedVersionNo);
-        await cleanupAttachments();
         noContent(response);
     });
     app.get("/api/works/:workId/cover", (request, response) => {
@@ -1390,11 +1466,31 @@ export function createRuntime(options) {
             ? store.listVolumeChaptersPage(request.params.volumeId, pagination)
             : store.listVolumeChapters(request.params.volumeId));
     });
+    app.head("/api/volumes/:volumeId/export", (request, response) => {
+        parse(z.enum(["epub"]), request.query.format ?? "epub");
+        store.getVolume(request.params.volumeId);
+        noContent(response);
+    });
+    app.get("/api/volumes/:volumeId/export", async (request, response) => {
+        parse(z.enum(["epub"]), request.query.format ?? "epub");
+        const exported = await store.exportVolumeEpub(request.params.volumeId);
+        await sendEpub(response, exported.archive, exported.title, `volume-${request.params.volumeId}`);
+    });
     app.delete("/api/volumes/:volumeId", (request, response) => {
         const input = parse(z.object({ expectedVersionNo: expectedVersionNoSchema }).strict(), request.body ?? {});
         store.deleteVolume(request.params.volumeId, input.expectedVersionNo);
         noContent(response);
     });
+    app.post("/api/volumes/:volumeId/restore", (request, response) => {
+        const input = parse(z.object({ expectedVersionNo: expectedVersionNoSchema }).strict(), request.body ?? {});
+        data(response, store.restoreVolume(request.params.volumeId, input.expectedVersionNo));
+    });
+    app.delete("/api/volumes/:volumeId/permanent", async (request, response) => {
+        const input = parse(z.object({ expectedVersionNo: expectedVersionNoSchema }).strict(), request.body ?? {});
+        store.permanentlyDeleteVolume(request.params.volumeId, input.expectedVersionNo);
+        await cleanupAttachments();
+        noContent(response);
+    });
     app.post("/api/works/:workId/chapters", (request, response) => {
         const input = parse(z.object({ volumeId: identifier, title: nonEmpty.max(300), content: z.string().max(2_000_000).optional(), chapterType: chapterTypeSchema.optional() }), request.body);
         data(response, store.createChapter(request.params.workId, input), 201);
@@ -1405,6 +1501,9 @@ export function createRuntime(options) {
             ? store.listDeletedChaptersPage(request.params.workId, pagination)
             : store.listDeletedChapters(request.params.workId));
     });
+    app.get("/api/works/:workId/recycle-bin", (request, response) => {
+        data(response, store.getRecycleBin(request.params.workId));
+    });
     app.get("/api/chapters/:chapterId", (request, response) => data(response, store.getChapter(request.params.chapterId)));
     app.patch("/api/chapters/:chapterId", (request, response) => {
         const input = parse(z.object({ title: nonEmpty.max(300).optional(), content: z.string().max(2_000_000).optional(), excludedFromAnalysis: z.boolean().optional(), chapterType: chapterTypeSchema.optional(), source: z.enum(["manual", "auto"]).optional(), changeNote: changeNoteSchema, expectedVersionNo: expectedVersionNoSchema }).strict(), request.body);
@@ -1484,6 +1583,9 @@ export function createRuntime(options) {
         const pagination = parsePagination(request.query);
         data(response, pagination ? store.listChapterOutlinesPage(request.params.workId, pagination) : store.listChapterOutlines(request.params.workId));
     });
+    app.get("/api/works/:workId/outline-board", (request, response) => {
+        data(response, store.getChapterOutlineBoard(request.params.workId));
+    });
     app.get("/api/chapters/:chapterId/outline", (request, response) => data(response, store.getChapterOutline(request.params.chapterId)));
     app.put("/api/chapters/:chapterId/outline", (request, response) => {
         const { changeNote, expectedVersionNo, ...input } = parse(chapterOutlineSchema.extend({ changeNote: changeNoteSchema, expectedVersionNo: expectedVersionNoSchema }).strict(), request.body);
@@ -1495,6 +1597,13 @@ export function createRuntime(options) {
         store.deleteChapterOutline(request.params.chapterId, input.expectedVersionNo);
         noContent(response);
     });
+    app.get("/api/works/:workId/chapters/:chapterId/foreshadow-reminders", (request, response) => {
+        data(response, store.listChapterForeshadowReminders(request.params.workId, request.params.chapterId));
+    });
+    app.post("/api/works/:workId/chapters/:chapterId/foreshadow-reminders/:foreshadowId/resolve", (request, response) => {
+        const input = parse(z.object({ expectedVersionNo: expectedVersionNoSchema }).strict(), request.body ?? {});
+        data(response, store.resolveChapterForeshadowReminder(request.params.workId, request.params.chapterId, request.params.foreshadowId, input.expectedVersionNo));
+    });
     app.get("/api/works/:workId/foreshadows", (request, response) => {
         const query = parse(z.object({
             status: z.enum(["all", "unresolved", "resolved"]).default("all"),
@@ -2001,6 +2110,9 @@ export function createRuntime(options) {
         data(response, ai.resumeAutoRun(request.params.workId));
     });
     app.get("/api/tasks/:taskId/detail", (request, response) => data(response, redactTaskCharacterNames(store.getTaskDetail(request.params.taskId), requestPermissions(request))));
+    app.get("/api/tasks/:taskId/character-extraction/preview", (request, response) => {
+        data(response, ai.getCharacterExtractionPreview(request.params.taskId));
+    });
     app.get("/api/tasks/:taskId/result", (request, response) => {
         const task = store.getTaskResultPayload(request.params.taskId);
         const permissions = requestPermissions(request);
@@ -2042,6 +2154,14 @@ export function createRuntime(options) {
         data(response, redactTaskCharacterNames(ai.rerunTask(request.params.taskId, input.modelId), requestPermissions(request)), 201);
     });
     app.post("/api/tasks/:taskId/cancel", (request, response) => data(response, redactTaskCharacterNames(ai.cancelTask(request.params.taskId), requestPermissions(request))));
+    app.post("/api/tasks/:taskId/character-extraction/apply", (request, response) => {
+        const input = parse(characterExtractionApplySchema, request.body);
+        const applied = ai.applyCharacterExtractionPreview(request.params.taskId, input.previewToken, input.selections);
+        const characterIds = Array.isArray(applied.characterIds) ? applied.characterIds.filter((value) => typeof value === "string") : [];
+        for (const characterId of characterIds)
+            publishEntityChange(String(store.getTask(request.params.taskId).workId), "character", characterId);
+        data(response, applied);
+    });
     app.post("/api/tasks/:taskId/relationship-changes/apply", (request, response) => {
         parse(z.object({}).strict(), request.body ?? {});
         const applied = ai.applyRelationshipChangePreview(request.params.taskId);
@@ -2179,10 +2299,26 @@ export function createRuntime(options) {
         const permissions = requestPermissions(request, String(conversation.workId));
         data(response, redactAiConversation(conversation, permissions));
     });
+    app.get("/api/ai-conversations/:conversationId/export", (request, response) => {
+        const conversation = store.getAiConversation(request.params.conversationId);
+        const permissions = requestPermissions(request, String(conversation.workId));
+        const readableConversation = redactAiConversation(conversation, permissions);
+        response.type("text/markdown; charset=utf-8");
+        response.setHeader("Content-Disposition", aiConversationExportContentDisposition(readableConversation));
+        response.send(exportAiConversationMarkdown(readableConversation));
+    });
     app.post("/api/ai-conversations/:conversationId/fork", (request, response) => {
-        const input = parse(z.object({ messageId: identifier, title: z.string().max(200).optional() }), request.body);
-        const forked = store.forkAiConversation(request.params.conversationId, input.messageId, input.title);
-        const permissions = requestPermissions(request, String(forked.workId));
+        const input = parse(z.object({
+            messageId: identifier,
+            title: z.string().max(200).optional(),
+            requestId: identifier.optional()
+        }).strict(), request.body);
+        const sourceConversation = store.getAiConversationSummary(request.params.conversationId);
+        const permissions = requestPermissions(request, String(sourceConversation.workId));
+        if (sourceConversation.roleplayCharacter && !canReadWorkModule(permissions, "characters")) {
+            throw new AppError(403, "WORK_MODULE_READ_DENIED", "你没有读取“角色”模块的权限");
+        }
+        const forked = store.forkAiConversation(request.params.conversationId, input.messageId, input.title, input.requestId);
         data(response, redactAiConversation(forked, permissions), 201);
     });
     app.patch("/api/ai-conversations/:conversationId/task-type", (request, response) => {
@@ -2214,6 +2350,9 @@ export function createRuntime(options) {
                 outputTokens: z.number().int().min(0).max(10_000_000).optional(),
                 cacheHitPercent: z.number().min(0).max(100).optional(),
                 processDurationMs: z.number().int().min(0).max(86_400_000).optional(),
+                interrupted: z.boolean().optional(),
+                interruptionCode: z.string().max(100).optional(),
+                interruptionMessage: z.string().max(500).optional(),
                 toolCalls: z.array(aiToolCallResultSchema).max(12).optional(),
                 processSteps: z.array(aiProcessStepSchema).max(50).optional()
             }).optional()
@@ -2274,13 +2413,19 @@ export function createRuntime(options) {
         ai.deleteProvider(request.params.providerId);
         noContent(response);
     });
-    app.post("/api/providers/:providerId/test", async (request, response) => data(response, await ai.testProvider(request.params.providerId)));
+    app.post("/api/providers/:providerId/test", async (request, response) => {
+        parse(z.object({}).strict(), request.body ?? {});
+        data(response, await ai.testProvider(request.params.providerId));
+    });
     app.get("/api/providers/:providerId/models", (request, response) => {
         const pagination = parsePagination(request.query);
         data(response, pagination ? ai.listModelsPage(request.params.providerId, pagination) : ai.listModels(request.params.providerId));
     });
     app.post("/api/providers/:providerId/models", (request, response) => data(response, ai.createModel(request.params.providerId, parse(modelSchema, request.body)), 201));
-    app.post("/api/models/:modelId/test", async (request, response) => data(response, await ai.testModel(request.params.modelId)));
+    app.post("/api/models/:modelId/test", async (request, response) => {
+        parse(z.object({}).strict(), request.body ?? {});
+        data(response, await ai.testModel(request.params.modelId));
+    });
     app.get("/api/models/:modelId", (request, response) => data(response, ai.getModel(request.params.modelId)));
     app.patch("/api/models/:modelId", (request, response) => data(response, ai.updateModel(request.params.modelId, parse(modelSchema.partial(), request.body))));
     app.delete("/api/models/:modelId", (request, response) => {
@@ -2341,54 +2486,90 @@ export function createRuntime(options) {
             conversationId: identifier.optional(),
             currentMessageId: identifier.optional()
         }), request.body);
+        const providedIdempotencyKey = request.get("Idempotency-Key");
+        const idempotencyKey = providedIdempotencyKey
+            ? parse(idempotencyKeySchema, providedIdempotencyKey)
+            : randomUUID();
+        const actorScope = request.authUser ? `user:${request.authUser.userId}` : "auth-disabled";
+        const requestHash = store.hashContent(stableJson({ workId: request.params.workId, ...input }));
         const citations = input.citations ?? [];
         for (const citation of citations) {
             if (store.getChapter(citation.chapterId).workId !== request.params.workId)
                 throw new AppError(400, "CITATION_WORK_MISMATCH", "引用章节不属于当前作品");
         }
         const resolvedInstruction = instructionWithCitations(input.instruction, citations);
+        const existingRequest = store.findAiConversationStreamRequest(actorScope, request.params.workId, idempotencyKey);
+        if (existingRequest && input.conversationId && existingRequest.conversationId !== input.conversationId) {
+            throw new AppError(409, "IDEMPOTENCY_KEY_REUSED", "该请求标识已用于另一项 AI 对话请求");
+        }
+        const conversation = existingRequest
+            ? store.getAiConversationSummary(existingRequest.conversationId)
+            : input.conversationId
+                ? store.getAiConversationSummary(input.conversationId)
+                : store.createAiConversation(request.params.workId);
+        if (String(conversation.workId) !== request.params.workId) {
+            throw new AppError(400, "CONVERSATION_WORK_MISMATCH", "AI 对话不属于当前作品");
+        }
+        const conversationId = String(conversation.id);
+        const permissions = requestPermissions(request, request.params.workId);
         const controller = new AbortController();
         response.on("close", () => {
             if (!response.writableEnded)
                 controller.abort(new Error("浏览器已中断流式请求"));
         });
-        response.status(200);
-        response.setHeader("Content-Type", "text/event-stream; charset=utf-8");
-        response.setHeader("Cache-Control", "no-cache, no-transform");
-        response.setHeader("Connection", "keep-alive");
-        response.setHeader("X-Accel-Buffering", "no");
-        response.flushHeaders();
+        let streamRequestId = null;
+        let streamRequestFinished = false;
+        let lastStreamLeaseTouchAt = Date.now();
+        const startStream = () => {
+            if (response.headersSent)
+                return;
+            response.status(200);
+            response.setHeader("Content-Type", "text/event-stream; charset=utf-8");
+            response.setHeader("Cache-Control", "no-cache, no-transform");
+            response.setHeader("Connection", "keep-alive");
+            response.setHeader("X-Accel-Buffering", "no");
+            response.flushHeaders();
+        };
         const sendEvent = (event, payload) => {
+            if (streamRequestId && Date.now() - lastStreamLeaseTouchAt >= 30_000) {
+                store.touchAiConversationStreamRequest(streamRequestId);
+                lastStreamLeaseTouchAt = Date.now();
+            }
             if (!response.writableEnded && !response.destroyed)
                 response.write(`event: ${event}\ndata: ${JSON.stringify(payload)}\n\n`);
         };
-        sendEvent("ready", { streaming: true });
         try {
-            const conversation = input.conversationId
-                ? store.getAiConversationSummary(input.conversationId)
-                : store.createAiConversation(request.params.workId);
-            if (String(conversation.workId) !== request.params.workId) {
-                throw new AppError(400, "CONVERSATION_WORK_MISMATCH", "AI 对话不属于当前作品");
+            if (!existingRequest) {
+                store.assertAiConversationStreamAvailable(conversationId);
+                const inspection = ai.inspectConversationContext({
+                    conversationId,
+                    workId: request.params.workId,
+                    modelId: input.modelId,
+                    scope: input.scope,
+                    instruction: resolvedInstruction,
+                    excludeConversationMessageId: input.currentMessageId
+                });
+                if (inspection.action === "warn") {
+                    const prepared = await ai.prepareConversationContext({
+                        conversationId,
+                        workId: request.params.workId,
+                        modelId: input.modelId,
+                        scope: input.scope,
+                        instruction: resolvedInstruction,
+                        excludeConversationMessageId: input.currentMessageId
+                    });
+                    startStream();
+                    sendEvent("ready", { streaming: true, idempotencyKey });
+                    sendEvent("context", {
+                        ...prepared,
+                        conversation: redactAiConversation({
+                            ...store.getAiConversationSummary(conversationId),
+                            contextWarningPending: true
+                        }, permissions)
+                    });
+                    return;
+                }
             }
-            const conversationId = String(conversation.id);
-            const permissions = requestPermissions(request, request.params.workId);
-            const prepared = await ai.prepareConversationContext({
-                conversationId,
-                workId: request.params.workId,
-                modelId: input.modelId,
-                scope: input.scope,
-                instruction: resolvedInstruction,
-                excludeConversationMessageId: input.currentMessageId
-            });
-            sendEvent("context", {
-                ...prepared,
-                conversation: redactAiConversation({
-                    ...store.getAiConversationSummary(conversationId),
-                    contextWarningPending: prepared.action === "warn"
-                }, permissions)
-            });
-            if (prepared.action === "warn")
-                return;
             const resolvedScope = input.currentMessageId
                 ? input.scope
                 : ai.resolveInstructionMentions({
@@ -2402,17 +2583,71 @@ export function createRuntime(options) {
                     ...(resolvedScope.characterIds ?? []),
                     ...(resolvedScope.mentionCharacterIds ?? [])
                 ])];
-            const userMessage = input.currentMessageId
-                ? null
-                : store.addAiConversationMessage(conversationId, {
-                    role: "user",
+            const begun = store.beginAiConversationStreamRequest({
+                workId: request.params.workId,
+                conversationId,
+                actorScope,
+                idempotencyKey,
+                requestHash,
+                userMessage: {
                     content: input.instruction,
                     citations,
+                    ...(input.currentMessageId ? { existingMessageId: input.currentMessageId } : {}),
                     ...(mentionCharacterIds.length ? { metadata: { mentionCharacterIds } } : {})
-                });
-            const currentMessageId = input.currentMessageId ?? String(userMessage?.id ?? "");
-            if (userMessage)
-                sendEvent("user_message", { message: redactAiConversationMessage(userMessage, permissions) });
+                }
+            });
+            streamRequestId = begun.request.id;
+            startStream();
+            sendEvent("ready", { streaming: begun.disposition === "started", idempotencyKey });
+            if (begun.disposition !== "started") {
+                streamRequestFinished = true;
+                if (begun.userMessage) {
+                    sendEvent("user_message", { message: redactAiConversationMessage(begun.userMessage, permissions), replayed: true });
+                }
+                if (begun.request.status === "completed" && begun.assistantMessage) {
+                    const content = String(begun.assistantMessage.content ?? "");
+                    if (content)
+                        sendEvent("delta", { delta: content, replayed: true });
+                    sendEvent("complete", {
+                        replayed: true,
+                        conversationId,
+                        conversationTitle: store.getAiConversationSummary(conversationId).title,
+                        messageId: begun.assistantMessage.id,
+                        messageCreatedAt: begun.assistantMessage.createdAt
+                    });
+                }
+                else {
+                    sendEvent("request_status", {
+                        code: begun.request.status === "in_progress"
+                            ? "AI_IDEMPOTENT_REQUEST_IN_PROGRESS"
+                            : "AI_IDEMPOTENT_REQUEST_TERMINAL",
+                        message: begun.request.status === "in_progress"
+                            ? "相同请求正在处理中，请等待当前响应结束"
+                            : "相同请求已经结束，不会再次调用 AI",
+                        status: begun.request.status,
+                        terminalReason: begun.request.terminalReason
+                    });
+                }
+                return;
+            }
+            const currentMessageId = String(begun.userMessage?.id ?? input.currentMessageId ?? "");
+            if (begun.userMessage)
+                sendEvent("user_message", { message: redactAiConversationMessage(begun.userMessage, permissions) });
+            const prepared = await ai.prepareConversationContext({
+                conversationId,
+                workId: request.params.workId,
+                modelId: input.modelId,
+                scope: input.scope,
+                instruction: resolvedInstruction,
+                excludeConversationMessageId: currentMessageId
+            }, { skipWarning: true });
+            sendEvent("context", {
+                ...prepared,
+                conversation: redactAiConversation({
+                    ...store.getAiConversationSummary(conversationId),
+                    contextWarningPending: prepared.action === "warn"
+                }, permissions)
+            });
             const suggestion = await ai.createStreamingChat({
                 workId: request.params.workId,
                 instruction: resolvedInstruction,
@@ -2428,6 +2663,13 @@ export function createRuntime(options) {
                 ...(input.modelId ? { modelId: input.modelId } : {}),
                 ...(input.parameters ? { parameters: input.parameters } : {})
             }, (delta) => sendEvent("delta", { delta }));
+            const assistantMessageId = typeof suggestion.conversationMessage === "object" && suggestion.conversationMessage !== null
+                ? String(suggestion.conversationMessage.id ?? "")
+                : "";
+            if (!stopping) {
+                store.finishAiConversationStreamRequest(streamRequestId, "completed", "completed", assistantMessageId || undefined);
+            }
+            streamRequestFinished = true;
             sendEvent("complete", {
                 suggestionId: suggestion.id,
                 callId: suggestion.callId,
@@ -2450,6 +2692,18 @@ export function createRuntime(options) {
             });
         }
         catch (error) {
+            if (streamRequestId && !streamRequestFinished && !stopping) {
+                const code = error instanceof AppError ? error.code : "AI_STREAM_FAILED";
+                const status = code === "AI_STREAM_IDLE_TIMEOUT"
+                    ? "timed_out"
+                    : code === "AI_STREAM_REQUEST_CANCELLED" || controller.signal.aborted
+                        ? "cancelled"
+                        : "failed";
+                store.finishAiConversationStreamRequest(streamRequestId, status, code);
+                streamRequestFinished = true;
+            }
+            if (!response.headersSent)
+                throw error;
             if (!controller.signal.aborted) {
                 logger.error("ai.stream.failed", {
                     workId: request.params.workId,
@@ -2459,7 +2713,13 @@ export function createRuntime(options) {
             }
         }
         finally {
-            if (!response.writableEnded && !response.destroyed)
+            if (streamRequestId && !streamRequestFinished && !stopping) {
+                store.finishAiConversationStreamRequest(streamRequestId, "cancelled", "stream_closed");
+                streamRequestFinished = true;
+            }
+            if (stopping)
+                streamRequestFinished = true;
+            if (response.headersSent && !response.writableEnded && !response.destroyed)
                 response.end();
         }
     });
@@ -2500,7 +2760,7 @@ export function createRuntime(options) {
     });
     app.get("/api/works/:workId/search", async (request, response) => {
         const query = parse(z.object({
-            q: z.string().trim().min(1).max(500),
+            q: z.string().trim().min(1).max(MAXIMUM_WORK_SEARCH_QUERY_LENGTH),
             type: z.enum(HYBRID_SEARCH_TYPES).optional(),
             limit: z.coerce.number().int().min(1).max(100).optional()
         }).strict(), request.query);
@@ -2511,8 +2771,13 @@ export function createRuntime(options) {
             includeAgentHistory: permissions["ai-chat"] !== "none"
         }));
     });
+    app.head("/api/works/:workId/export", (request, response) => {
+        parse(z.enum(["epub"]), request.query.format ?? "epub");
+        store.getWork(request.params.workId);
+        noContent(response);
+    });
     app.get("/api/works/:workId/export", async (request, response) => {
-        const format = parse(z.enum(["json", "txt", "markdown", "docx"]), request.query.format ?? "json");
+        const format = parse(z.enum(["json", "txt", "markdown", "docx", "epub"]), request.query.format ?? "json");
         if (format === "json") {
             response.setHeader("Content-Disposition", `attachment; filename=novel-${request.params.workId}.json`);
             data(response, store.exportWork(request.params.workId));
@@ -2538,6 +2803,11 @@ export function createRuntime(options) {
             response.send(await store.exportDocx(request.params.workId));
             return;
         }
+        if (format === "epub") {
+            const exported = await store.exportEpub(request.params.workId);
+            await sendEpub(response, exported.archive, exported.title, `novel-${request.params.workId}`);
+            return;
+        }
         response.type("text/plain");
         response.setHeader("Content-Disposition", `attachment; filename=novel-${request.params.workId}.txt`);
         response.send(store.exportText(request.params.workId, format));
@@ -2650,7 +2920,7 @@ export function createRuntime(options) {
                 logger.error("http.request.application_error", logFields);
             else
                 logger.warn("http.request.application_error", logFields);
-            if (error.code === "LOGIN_LOCKED" && error.details && typeof error.details === "object") {
+            if ((error.code === "LOGIN_LOCKED" || error.status === 429) && error.details && typeof error.details === "object") {
                 const retryAfterSeconds = Number(error.details.retryAfterSeconds);
                 if (Number.isInteger(retryAfterSeconds) && retryAfterSeconds > 0) {
                     response.setHeader("Retry-After", String(retryAfterSeconds));
@@ -2682,6 +2952,9 @@ export function createRuntime(options) {
             logger.info("runtime.closing");
             backups.dispose();
             ai.dispose();
+            const cancelledStreamRequests = store.cancelActiveAiConversationStreamRequests();
+            if (cancelledStreamRequests > 0)
+                logger.info("ai.stream.requests_cancelled", { count: cancelledStreamRequests });
         }
         closePromise = (async () => {
             try {