@musnows/scriverse 0.7.1 → 0.7.3

package/dist/ai.js

@@ -1,3 +1,4 @@
+import { ANALYSIS_TASK_TYPES, HISTORICAL_ANALYSIS_TASK_TYPES } from "./domain.js";
 import { buildCompletionRequestBody, isAiProviderProtocol, normalizeProviderBaseUrl, parseCompletionPayload, providerCompletionEndpoint, providerModelEndpoints, providerProtocolLabelText, providerRequestHeaders } from "./ai-protocol.js";
 import { AGENT_TOOL_RESULT_MAX_CHARS, DEFAULT_AGENT_TOOL_CALL_GLOBAL_MULTIPLIER, MIN_AGENT_TOOL_CALL_LIMIT, agentToolCallGlobalLimit, agentToolCallQuotaNoticeBudgetChars, agentToolCallQuotaUsedAfterCompact, agentToolCallSoftWarningThreshold, clampAgentToolCallGlobalMultiplier, paginateToolResultRecords, resolveMaxAgentToolCallLimit, shouldRejectAgentToolCalls, shouldRejectGlobalToolCalls, structuralToolResultRecords, withAgentToolCallQuotaNotice } from "./ai-tool-results.js";
 import { PLATFORM_AI_WORK_ID } from "./database.js";
@@ -28,6 +29,13 @@ const AUTO_RUN_MAX_ATTEMPTS = 3;
 const AUTO_RUN_RETRY_DELAYS_MS = [5_000, 30_000];
 const AI_INTERACTIVE_TIMEOUT_MS = 60_000;
 const AI_LONG_RUNNING_TIMEOUT_MS = 300_000;
+const analysisTaskTypes = new Set(ANALYSIS_TASK_TYPES);
+function isAnalysisTaskType(value) {
+    return analysisTaskTypes.has(value);
+}
+function unsupportedTaskType(taskType) {
+    return new AppError(400, "UNSUPPORTED_TASK_TYPE", `不支持的任务类型：${taskType}`);
+}
 // A small but non-transparent 128x128 PNG. The model test must exercise an actual image_url
 // payload, while keeping the request cheap and avoiding any user data in the probe.
 const MULTIMODAL_TEST_IMAGE_DATA_URL = "data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAIAAAACACAYAAADDPmHLAAAACXBIWXMAAAPoAAAD6AG1e1JrAAACfklEQVR4nO2cwY3EQBACJ8LOglRJyw4DJOpR/xOUuF17Zp91H9xsBi/9B8AhABIcC4AEx78AJDg+AyDB8SEQCY5vAUhwfA1EguM5ABIcD4KQ4HgSiATHo2AkON4FIMHxMggJjreBSHC8DkaC4zwAEhwHQpDgOBGEBMeRMCQ4zgQiwXEoFAmOU8FIcBwLR4LjXgASHBdDkOC4GYQEx9UwJDjuBiLBcTkUCY7bwUhwXA8319P5fQCPS8APRChfAgIUBOFRWADlS0CAgiA8CgugfAkIUBCER2EBlC8BAQqC8CgsgPIlIEBBEB6FBVC+BAQoCMKjsADKl4AABUF4FBZA+RIQoCAIj8ICKF8CAhQE4VFYAOVLQICCIDwKC6B8CQhQEIRHYQGULwEBCoLwKCyA8iUgQEEQHoUFUL4EBCgIwqOwAMqXgAAFQXgUFkD5EhCgIAiPwgIoXwICFAThUVgA5UtAgIIgPAoLoHwJCFAQhEdhAZQvAQEKgvAoLIDyJSBAQRAehQVQvgQEKAjCo7AAypeAAAVBeBQWQPkSEKAgCI/CAihfAgIUBOFRWADlS0CAgiA8CgugfAkIUBCER2EBlC8BAQqC8CgsgPIlIEBBEB6FBVC+BAQoCMKjsADKl4AABUF4FBZA+RIQoCAIj8ICKF8CAhQE4VFYAOVLQICCIDwKC6B8CQhQEIRHYQGULwEBCoLwKCyA8iUgQEEQHoUFUL4EBCgIwqOwAMqXgAAFQXgUFkD5EhCgIAiPwgIoXwICFAThUVgA5UtAgIIgPAoLoHwJCFAQhEdhAZQvAQEKgvAoLIDyJSBAQRAehQVQvgQEKAjCo7AAypeAAAVBeJQfFY4JQ620WGEAAAAASUVORK5CYII=";
@@ -1929,7 +1937,7 @@ export class AiManager {
                 failures: [{ message, ...(error instanceof AppError ? { code: error.code } : {}) }]
             });
         }
-        if (current.status !== "partial")
+        if (current.status !== "partial" && current.status !== "failed")
             return;
         const disposition = autoRunFailureDisposition(error, Number(current.attemptCount));
         const settings = this.store.recordAutoRunFailure(workId, message, disposition.pauseImmediately);
@@ -2549,7 +2557,11 @@ export class AiManager {
     }
     rerunTask(taskId, modelOverrideId) {
         const original = this.store.getTask(taskId);
-        const rerunnableStatuses = new Set(["review", "completed", "partial", "expired", "cancelled"]);
+        const originalTaskType = String(original.taskType);
+        if (HISTORICAL_ANALYSIS_TASK_TYPES.some((taskType) => taskType === originalTaskType)) {
+            throw new AppError(409, "TASK_NOT_RERUNNABLE", `任务类型“${originalTaskType}”已经不支持重跑`);
+        }
+        const rerunnableStatuses = new Set(["review", "completed", "partial", "failed", "expired", "cancelled"]);
         if (!rerunnableStatuses.has(String(original.status))) {
             throw new AppError(409, "TASK_NOT_RERUNNABLE", "只有已结束的分析任务可以按原配置重跑");
         }
@@ -2565,7 +2577,7 @@ export class AiManager {
         if (modelId)
             this.resolveModel(String(original.workId), this.analysisTaskModelPurpose(String(original.taskType)), modelId);
         const rerun = this.store.createTask(String(original.workId), {
-            taskType: String(original.taskType),
+            taskType: originalTaskType,
             scope,
             ...(modelId ? { modelId } : {}),
             rerunOfTaskId: taskId
@@ -2618,12 +2630,7 @@ export class AiManager {
             && firstUserContent
             && titleModelId
             && (conversationBefore?.title === "新对话" || conversationBefore?.title === defaultTitle));
-        const chatTools = this.enabledAgentTools(input.workId, "chat", input.agentToolIds, input.conversationId);
-        const generated = chatTools.length
-            ? await this.generate({ ...input, taskType: "chat" })
-            : await this.generateStream({ ...input, taskType: "chat" }, onDelta);
-        if (chatTools.length)
-            onDelta(generated.content);
+        const generated = await this.generate({ ...input, taskType: "chat" }, onDelta);
         const chapter = input.scope.chapterId ? this.store.getChapter(input.scope.chapterId) : null;
         const suggestionId = id("suggestion");
         this.store.db.run(`INSERT INTO ai_suggestions (id, call_id, work_id, chapter_id, chapter_version, task_type, instruction,
@@ -2984,7 +2991,10 @@ export class AiManager {
         const taskController = new AbortController();
         this.taskControllers.set(taskId, taskController);
         try {
-            const taskType = String(task.taskType);
+            const taskTypeValue = String(task.taskType);
+            if (!isAnalysisTaskType(taskTypeValue))
+                throw unsupportedTaskType(taskTypeValue);
+            const taskType = taskTypeValue;
             const scope = task.scope;
             let result;
             if (taskType === "chapter-analysis") {
@@ -3011,11 +3021,11 @@ export class AiManager {
             else if (taskType === "consistency-check") {
                 result = await this.runConsistencyCheck(workId, scope, selectedModelId, taskId);
             }
-            else {
+            else if (taskType === "book-analysis") {
                 const generated = await this.generate({
                     workId,
                     taskId,
-                    taskType: taskType === "book-analysis" ? "book-analysis" : "chapter-analysis",
+                    taskType: "book-analysis",
                     instruction: "请基于上下文完成分析，给出有原文依据的中文结论。",
                     scope,
                     signal: taskController.signal,
@@ -3023,6 +3033,9 @@ export class AiManager {
                 });
                 result = { content: generated.content, callId: generated.callId };
             }
+            else {
+                throw unsupportedTaskType(taskType);
+            }
             if (!this.taskCanCommit(taskId)) {
                 logger.warn("ai.task.result_discarded", { taskId, workId, durationMs: Number(process.hrtime.bigint() - startedAt) / 1_000_000 });
                 return this.store.getTask(taskId);
@@ -3054,7 +3067,8 @@ export class AiManager {
                     throw error;
                 }
             }
-            this.store.updateTask(taskId, { status: "partial", progress: 100, failures: [failure] });
+            const failedStatus = error instanceof AppError && error.code === "UNSUPPORTED_TASK_TYPE" ? "failed" : "partial";
+            this.store.updateTask(taskId, { status: failedStatus, progress: 100, failures: [failure] });
             logger.error("ai.task.failed", { taskId, workId, durationMs: Number(process.hrtime.bigint() - startedAt) / 1_000_000, error: aiErrorForLog(error) });
             throw error;
         }
@@ -3194,6 +3208,13 @@ export class AiManager {
         const compactedUsage = this.getContextUsage({ ...input, taskType: "chat" });
         return { action: "compacted", usage: compactedUsage, compaction };
     }
+    /** 解析本轮消息中的自动角色提及；不使用会话累计排除集，也不改写累计注入状态。 */
+    resolveInstructionMentions(input) {
+        if (input.taskType !== "chat" || this.roleplayCharacterId(input.workId, input.conversationId))
+            return input.scope;
+        const matches = this.matchInstructionEntities(input.workId, input.instruction, input.scope, { characters: [], races: [], organizations: [] });
+        return this.mergeInstructionEntityMatches(input.scope, matches);
+    }
     async compactConversation(input) {
         const conversation = this.store.getAiConversationContext(input.conversationId, input.workId);
         const { model } = this.resolveModel(input.workId, "chat", input.modelId);
@@ -3404,13 +3425,10 @@ export class AiManager {
             : this.applyKeywordEntityMentions(input.workId, input.instruction, baseScope, input.conversationId, persistKeywordInjections);
         return this.contextBuilder.buildPlan(input.workId, scope, workContextBudgetTokens, bookSummaryMaximumTokens, input.instruction);
     }
-    applyKeywordEntityMentions(workId, instruction, scope, conversationId, persist) {
-        const injected = conversationId
-            ? this.store.getAiConversationInjectedEntities(conversationId, workId)
-            : { characters: [], races: [], organizations: [] };
+    matchInstructionEntities(workId, instruction, scope, injected) {
         const proseSettingInfoOn = scope.suppressAutomaticContext !== true && (scope.includeSettingInfo === true || (PROSE_CONTEXT_SCOPE_TYPES.has(scope.type)
             && scope.includeSettingInfo !== false));
-        const matches = matchKeywordEntities(this.store, workId, instruction, {
+        return matchKeywordEntities(this.store, workId, instruction, {
             excludeCharacterIds: [
                 ...(scope.characterIds ?? []),
                 ...(scope.mentionCharacterIds ?? []),
@@ -3421,9 +3439,23 @@ export class AiManager {
             // 正文范围已整表注入组织/种族时，关键词不再重复塞提及卡
             skipRacesAndOrganizations: proseSettingInfoOn
         });
+    }
+    mergeInstructionEntityMatches(scope, matches) {
         const mentionCharacterIds = [...new Set([...(scope.mentionCharacterIds ?? []), ...matches.characterIds])];
         const raceIds = [...new Set([...(scope.raceIds ?? []), ...matches.raceIds])];
         const organizationIds = [...new Set([...(scope.organizationIds ?? []), ...matches.organizationIds])];
+        return {
+            ...scope,
+            ...(mentionCharacterIds.length ? { mentionCharacterIds } : {}),
+            ...(raceIds.length ? { raceIds } : {}),
+            ...(organizationIds.length ? { organizationIds } : {})
+        };
+    }
+    applyKeywordEntityMentions(workId, instruction, scope, conversationId, persist) {
+        const injected = conversationId
+            ? this.store.getAiConversationInjectedEntities(conversationId, workId)
+            : { characters: [], races: [], organizations: [] };
+        const matches = this.matchInstructionEntities(workId, instruction, scope, injected);
         if (persist && conversationId && (matches.characterIds.length || matches.raceIds.length || matches.organizationIds.length)) {
             this.store.mergeAiConversationInjectedEntities(conversationId, workId, {
                 characters: matches.characterIds,
@@ -3431,12 +3463,7 @@ export class AiManager {
                 organizations: matches.organizationIds
             });
         }
-        return {
-            ...scope,
-            ...(mentionCharacterIds.length ? { mentionCharacterIds } : {}),
-            ...(raceIds.length ? { raceIds } : {}),
-            ...(organizationIds.length ? { organizationIds } : {})
-        };
+        return this.mergeInstructionEntityMatches(scope, matches);
     }
     buildContext(input, model) {
         return collapseAiBlankLines(this.buildContextPlan(input, model, undefined, true).context);
@@ -4199,7 +4226,7 @@ export class AiManager {
             extraSystemPrompt: [input.extraSystemPrompt, systemRequirement].filter(Boolean).join("\n")
         });
     }
-    async generate(input) {
+    async generate(input, onDelta) {
         const generationRoleplayCharacterId = this.roleplayCharacterId(input.workId, input.conversationId);
         const { model, provider } = this.resolveModel(input.workId, input.taskType, input.modelId);
         const preset = safeJsonObject(stringValue(model, "preset_json"));
@@ -4271,7 +4298,7 @@ export class AiManager {
             providerId: stringValue(provider, "id"),
             modelId: stringValue(model, "id"),
             protocol,
-            streaming: false,
+            streaming: Boolean(onDelta),
             contextChars: context.length,
             instructionChars: input.instruction.length,
             toolCount: tools.length
@@ -4308,11 +4335,19 @@ export class AiManager {
             let cacheUsageComplete = true;
             let totalInputTokens = 0;
             let totalCachedInputTokens = 0;
+            const processSteps = [];
+            const completionDelivery = new WeakMap();
+            let streamedContent = "";
+            let streamingGenerationRound = 0;
             const requestCompletion = async (toolChoice, options = {}) => {
                 const requestMessages = options.messages ?? completionMessages;
                 const requestParameters = options.parameters ?? parameters;
                 const purpose = options.purpose ?? "generation";
                 const requestTools = toolChoice === "auto" ? tools : [];
+                const streamResponse = Boolean(onDelta) && purpose === "generation";
+                const processRound = streamResponse ? streamingGenerationRound + 1 : 0;
+                if (streamResponse)
+                    streamingGenerationRound = processRound;
                 const roundParameters = this.constrainParametersForDailyTokenQuota(input.workId, requestMessages, this.constrainParametersForContext(model, requestMessages, requestParameters, requestTools), requestTools, trackedInputTokens + trackedOutputTokens);
                 const traceRound = {
                     round: traceRounds.length + 1,
@@ -4330,9 +4365,11 @@ export class AiManager {
                 };
                 traceRounds.push(traceRound);
                 saveTrace();
+                let streamedThinkingStep = null;
                 let lastFailure = null;
                 for (let attempt = 1; attempt <= maximumAttempts; attempt += 1) {
                     let retryable = true;
+                    let attemptEmitted = false;
                     const attemptStartedAt = process.hrtime.bigint();
                     const traceAttempt = {
                         attempt,
@@ -4354,18 +4391,57 @@ export class AiManager {
                             try {
                                 const response = await this.outboundFetch(endpoint, {
                                     method: "POST",
-                                    headers: providerRequestHeaders(protocol, accessToken, "application/json"),
+                                    headers: providerRequestHeaders(protocol, accessToken, streamResponse ? "text/event-stream" : "application/json"),
                                     body: JSON.stringify(buildCompletionRequestBody({
                                         protocol,
                                         model: stringValue(model, "model_id"),
                                         messages: requestMessages,
                                         parameters: roundParameters,
                                         tools: requestTools,
-                                        toolChoice
+                                        toolChoice,
+                                        ...(streamResponse ? { stream: true } : {})
                                     })),
                                     signal: controller.signal
                                 });
-                                return { ok: response.ok, status: response.status, body: await readResponseTextLimited(response) };
+                                if (!response.ok) {
+                                    return { ok: false, status: response.status, body: await readResponseTextLimited(response) };
+                                }
+                                const isEventStream = response.headers.get("content-type")?.toLowerCase().includes("text/event-stream") ?? false;
+                                if (!streamResponse || !isEventStream) {
+                                    const body = await readResponseTextLimited(response);
+                                    try {
+                                        const payload = parseCompletionPayload(protocol, redactProviderSecrets(JSON.parse(body), activeSecrets));
+                                        return { ok: true, status: response.status, payload, delivery: "json" };
+                                    }
+                                    catch {
+                                        throw new Error(`${providerProtocolLabelText(protocol)} returned invalid JSON: ${body.slice(0, 500)}`);
+                                    }
+                                }
+                                const payload = await this.readCompletionStream(response, protocol, activeSecrets, (delta) => {
+                                    attemptEmitted = true;
+                                    streamedContent += delta;
+                                    onDelta?.(delta);
+                                }, (delta) => {
+                                    attemptEmitted = true;
+                                    if (!streamedThinkingStep) {
+                                        streamedThinkingStep = {
+                                            id: id("process"),
+                                            type: "thinking",
+                                            round: processRound,
+                                            content: "",
+                                            createdAt: now()
+                                        };
+                                        processSteps.push(streamedThinkingStep);
+                                    }
+                                    streamedThinkingStep.content += delta;
+                                    input.onProcessStep?.({ ...streamedThinkingStep, content: delta, append: true });
+                                });
+                                return {
+                                    ok: true,
+                                    status: response.status,
+                                    payload: redactProviderSecrets(payload, activeSecrets),
+                                    delivery: "sse"
+                                };
                             }
                             finally {
                                 clearTimeout(timeout);
@@ -4377,31 +4453,28 @@ export class AiManager {
                             attempt,
                             status: candidate.status,
                             ok: candidate.ok,
-                            durationMs: Number(process.hrtime.bigint() - attemptStartedAt) / 1_000_000
+                            durationMs: Number(process.hrtime.bigint() - attemptStartedAt) / 1_000_000,
+                            streaming: streamResponse
                         });
                         if (candidate.ok) {
-                            try {
-                                const parsed = parseCompletionPayload(protocol, redactProviderSecrets(JSON.parse(candidate.body), activeSecrets));
-                                traceAttempt.completedAt = now();
-                                traceAttempt.status = "completed";
-                                traceAttempt.httpStatus = candidate.status;
-                                traceAttempt.response = sanitizeCompletionTraceResponse(parsed);
-                                saveTrace();
-                                completionRequestCount += 1;
-                                const cacheUsage = resolveInputCacheUsage(parsed.usage);
-                                if (!cacheUsage)
-                                    cacheUsageComplete = false;
-                                else {
-                                    totalInputTokens += cacheUsage.inputTokens;
-                                    totalCachedInputTokens += cacheUsage.cachedInputTokens;
-                                }
-                                const outputText = completionPayloadOutputText(parsed);
-                                trackUsage(resolveAiTokenUsage(parsed.usage, estimateAiTokens(JSON.stringify(requestMessages)), outputText ? estimateAiTokens(outputText) : 0));
-                                return parsed;
-                            }
-                            catch {
-                                throw new Error(`${providerProtocolLabelText(protocol)} returned invalid JSON: ${candidate.body.slice(0, 500)}`);
+                            const parsed = candidate.payload;
+                            completionDelivery.set(parsed, candidate.delivery);
+                            traceAttempt.completedAt = now();
+                            traceAttempt.status = "completed";
+                            traceAttempt.httpStatus = candidate.status;
+                            traceAttempt.response = sanitizeCompletionTraceResponse(parsed);
+                            saveTrace();
+                            completionRequestCount += 1;
+                            const cacheUsage = resolveInputCacheUsage(parsed.usage);
+                            if (!cacheUsage)
+                                cacheUsageComplete = false;
+                            else {
+                                totalInputTokens += cacheUsage.inputTokens;
+                                totalCachedInputTokens += cacheUsage.cachedInputTokens;
                             }
+                            const outputText = completionPayloadOutputText(parsed);
+                            trackUsage(resolveAiTokenUsage(parsed.usage, estimateAiTokens(JSON.stringify(requestMessages)), outputText ? estimateAiTokens(outputText) : 0));
+                            return parsed;
                         }
                         lastFailure = new Error(`HTTP ${candidate.status}: ${candidate.body.slice(0, 500)}`);
                         traceAttempt.completedAt = now();
@@ -4427,11 +4500,12 @@ export class AiManager {
                         logger.warn("ai.call.attempt_failed", {
                             callId,
                             attempt,
-                            retryable: retryable && attempt < maximumAttempts && !input.signal?.aborted,
+                            retryable: retryable && !attemptEmitted && attempt < maximumAttempts && !input.signal?.aborted,
                             durationMs: Number(process.hrtime.bigint() - attemptStartedAt) / 1_000_000,
+                            streaming: streamResponse,
                             error: aiErrorForLog(error)
                         });
-                        if (input.signal?.aborted)
+                        if (input.signal?.aborted || attemptEmitted)
                             throw error;
                         if (!retryable || attempt >= maximumAttempts)
                             throw error;
@@ -4441,7 +4515,6 @@ export class AiManager {
                 }
                 throw lastFailure instanceof Error ? lastFailure : new Error("AI request failed after all retries.");
             };
-            const processSteps = [];
             const baseMessageCount = messages.length;
             const firstUserMessageIndex = messages.findIndex((message) => message.role !== "system");
             const compactedMessageIndex = firstUserMessageIndex < 0 ? messages.length : firstUserMessageIndex;
@@ -4559,15 +4632,17 @@ export class AiManager {
             let payload = await requestCompletion("auto");
             let choice = payload.choices?.[0];
             const executedToolCalls = [];
-            const recordChoiceProcess = (currentChoice, round, includeIntermediate) => {
+            const recordChoiceProcess = (currentPayload, round, includeIntermediate) => {
+                const currentChoice = currentPayload.choices?.[0];
+                const deliveredAsSse = completionDelivery.get(currentPayload) === "sse";
                 const reasoning = currentChoice?.message?.reasoning_content;
-                if (reasoning?.trim()) {
+                if (!deliveredAsSse && reasoning?.trim()) {
                     const step = { id: id("process"), type: "thinking", round, content: reasoning, createdAt: now() };
                     processSteps.push(step);
                     input.onProcessStep?.(step);
                 }
                 const intermediate = currentChoice?.message?.content;
-                if (includeIntermediate && intermediate?.trim()) {
+                if (!deliveredAsSse && includeIntermediate && intermediate?.trim()) {
                     const step = { id: id("process"), type: "intermediate", round, content: intermediate, createdAt: now() };
                     processSteps.push(step);
                     input.onProcessStep?.(step);
@@ -4576,7 +4651,7 @@ export class AiManager {
             let toolRound = 0;
             while (choice?.message?.tool_calls?.length) {
                 const round = toolRound + 1;
-                recordChoiceProcess(choice, round, true);
+                recordChoiceProcess(payload, round, true);
                 const toolCalls = choice.message.tool_calls;
                 if (shouldRejectGlobalToolCalls(globalToolCallUsed, toolCalls.length, globalToolCallLimit)) {
                     logger.warn("ai.tool_call.global_limit_reached", {
@@ -4649,16 +4724,21 @@ export class AiManager {
                 payload = await requestCompletion("auto");
                 choice = payload.choices?.[0];
             }
-            recordChoiceProcess(choice, toolRound + 1, false);
-            const content = choice?.message?.content;
-            if (!content?.trim()) {
+            recordChoiceProcess(payload, toolRound + 1, false);
+            const finalContent = choice?.message?.content;
+            if (!finalContent?.trim()) {
                 const reasoningLength = choice?.message?.reasoning_content?.length ?? 0;
                 const suffix = choice?.finish_reason === "length" || reasoningLength > 0
                     ? `；模型已生成 ${reasoningLength} 个推理字符，请提高 max_tokens 输出预算`
                     : "";
                 throw new Error(`${providerProtocolLabelText(protocol)} 响应缺少可用正文，finish_reason=${choice?.finish_reason ?? "unknown"}${suffix}`);
             }
-            const outputTokens = resolveOutputTokens(payload.usage, content);
+            if (onDelta && completionDelivery.get(payload) !== "sse") {
+                streamedContent += finalContent;
+                onDelta(finalContent);
+            }
+            const content = onDelta ? streamedContent : finalContent;
+            const outputTokens = resolveOutputTokens(payload.usage, finalContent);
             const cacheHitPercent = cacheUsageComplete && completionRequestCount > 0 && totalInputTokens > 0
                 ? Math.round(totalCachedInputTokens / totalInputTokens * 1_000) / 10
                 : undefined;
@@ -4671,12 +4751,19 @@ export class AiManager {
                 callId,
                 workId: input.workId,
                 taskType: input.taskType,
-                streaming: false,
+                streaming: Boolean(onDelta),
                 durationMs: Number(process.hrtime.bigint() - callStartedAt) / 1_000_000,
                 outputChars: content.length,
                 outputTokens,
                 toolCallCount: executedToolCalls.length
             });
+            const finalAnthropicContent = choice?.message?.anthropic_content;
+            const replayAnthropicContent = onDelta && finalAnthropicContent?.length && content !== finalContent
+                ? [
+                    ...finalAnthropicContent.filter((block) => block.type !== "text" && block.type !== "tool_use"),
+                    { type: "text", text: content }
+                ]
+                : finalAnthropicContent;
             return {
                 callId,
                 content,
@@ -4685,7 +4772,7 @@ export class AiManager {
                     ? { reasoningContent: choice.message.reasoning_content }
                     : {}),
                 ...(cacheHitPercent === undefined ? {} : { cacheHitPercent }),
-                ...(choice?.message?.anthropic_content?.length ? { anthropicContent: choice.message.anthropic_content } : {}),
+                ...(replayAnthropicContent?.length ? { anthropicContent: replayAnthropicContent } : {}),
                 provider: this.mapProvider(provider),
                 model: this.mapModel(model),
                 context,
@@ -4706,7 +4793,7 @@ export class AiManager {
                 callId,
                 workId: input.workId,
                 taskType: input.taskType,
-                streaming: false,
+                streaming: Boolean(onDelta),
                 durationMs: Number(process.hrtime.bigint() - callStartedAt) / 1_000_000,
                 error: aiErrorForLog(error)
             });
@@ -4720,175 +4807,7 @@ export class AiManager {
             throw new AppError(502, "AI_CALL_FAILED", "AI 调用失败", { callId, failure: message, ...failureTarget });
         }
     }
-    async generateStream(input, onDelta) {
-        const { model, provider } = this.resolveModel(input.workId, input.taskType, input.modelId);
-        const context = this.buildContext(input, model);
-        const preset = safeJsonObject(stringValue(model, "preset_json"));
-        const messages = this.buildMessages(input, context);
-        let parameters;
-        try {
-            parameters = this.constrainParametersForContext(model, messages, {
-                ...this.sanitizeParameters({ ...preset, ...(input.parameters ?? {}) }, stringValue(model, "model_id")),
-                ...thinkingParameters(provider, model)
-            });
-        }
-        catch (error) {
-            if (!(error instanceof AppError) || error.code !== "CONTEXT_WINDOW_EXCEEDED")
-                throw error;
-            throw initialContextWindowError(error, provider, model);
-        }
-        parameters = this.constrainParametersForDailyTokenQuota(input.workId, messages, parameters);
-        const callId = id("call");
-        this.store.db.run(`INSERT INTO ai_calls (id, work_id, task_type, provider_id, model_id, context_scope_json, parameters_json,
-       status, input_chars, created_at, created_by_user_id) VALUES (?, ?, ?, ?, ?, ?, ?, 'running', ?, ?, ?)`, callId, input.workId, input.taskType, stringValue(provider, "id"), stringValue(model, "id"), JSON.stringify(input.scope), JSON.stringify(parameters), context.length + input.instruction.length, now(), currentRequestActor()?.userId ?? null);
-        const callStartedAt = process.hrtime.bigint();
-        const protocol = providerProtocol(provider);
-        logger.info("ai.call.started", {
-            callId,
-            workId: input.workId,
-            taskType: input.taskType,
-            providerId: stringValue(provider, "id"),
-            modelId: stringValue(model, "id"),
-            protocol,
-            streaming: true,
-            contextChars: context.length,
-            instructionChars: input.instruction.length
-        });
-        let activeSecrets = [];
-        try {
-            const { accessToken, credentialSecret } = await this.resolveProviderAccessToken(provider);
-            activeSecrets = [credentialSecret, accessToken];
-            const endpoint = providerCompletionEndpoint(stringValue(provider, "base_url"), protocol);
-            const maximumAttempts = Math.round(clamp(input.maxAttempts ?? 3, 1, 5));
-            let streamedResult = null;
-            let lastFailure = null;
-            let emitted = false;
-            const thinkingStepId = id("process");
-            const thinkingCreatedAt = now();
-            for (let attempt = 1; attempt <= maximumAttempts; attempt += 1) {
-                const attemptStartedAt = process.hrtime.bigint();
-                logger.info("ai.call.attempt_started", { callId, attempt, maximumAttempts, streaming: true });
-                try {
-                    const candidate = await this.scheduleProviderRequest(provider, input.signal, async () => {
-                        const controller = new AbortController();
-                        const forwardAbort = () => controller.abort(input.signal?.reason);
-                        if (input.signal?.aborted)
-                            forwardAbort();
-                        else
-                            input.signal?.addEventListener("abort", forwardAbort, { once: true });
-                        const timeout = setTimeout(() => controller.abort(new Error(`AI 请求超时（${Math.round(AI_INTERACTIVE_TIMEOUT_MS / 1_000)} 秒）`)), AI_INTERACTIVE_TIMEOUT_MS);
-                        try {
-                            const response = await this.outboundFetch(endpoint, {
-                                method: "POST",
-                                headers: providerRequestHeaders(protocol, accessToken, "text/event-stream"),
-                                body: JSON.stringify(buildCompletionRequestBody({
-                                    protocol,
-                                    model: stringValue(model, "model_id"),
-                                    messages,
-                                    parameters,
-                                    stream: true
-                                })),
-                                signal: controller.signal
-                            });
-                            if (!response.ok)
-                                return { ok: false, status: response.status, body: await readResponseTextLimited(response) };
-                            const streamed = await this.readCompletionStream(response, protocol, estimateAiTokens(JSON.stringify(messages)), activeSecrets, (delta) => {
-                                emitted = true;
-                                onDelta(delta);
-                            }, (delta) => {
-                                emitted = true;
-                                input.onProcessStep?.({ id: thinkingStepId, type: "thinking", round: 1, content: delta, createdAt: thinkingCreatedAt, append: true });
-                            });
-                            return { ok: true, status: response.status, result: streamed };
-                        }
-                        finally {
-                            clearTimeout(timeout);
-                            input.signal?.removeEventListener("abort", forwardAbort);
-                        }
-                    });
-                    logger.info("ai.call.attempt_completed", {
-                        callId,
-                        attempt,
-                        status: candidate.status,
-                        ok: candidate.ok,
-                        durationMs: Number(process.hrtime.bigint() - attemptStartedAt) / 1_000_000,
-                        streaming: true
-                    });
-                    if (candidate.ok) {
-                        streamedResult = candidate.result;
-                        break;
-                    }
-                    lastFailure = new Error(`HTTP ${candidate.status}: ${candidate.body.slice(0, 500)}`);
-                    if (candidate.status !== 429 && candidate.status < 500)
-                        attempt = maximumAttempts;
-                }
-                catch (error) {
-                    lastFailure = error;
-                    logger.warn("ai.call.attempt_failed", {
-                        callId,
-                        attempt,
-                        retryable: !input.signal?.aborted && !emitted && attempt < maximumAttempts,
-                        durationMs: Number(process.hrtime.bigint() - attemptStartedAt) / 1_000_000,
-                        streaming: true,
-                        error: aiErrorForLog(error)
-                    });
-                    if (input.signal?.aborted || emitted || attempt >= maximumAttempts)
-                        throw error;
-                }
-                if (attempt < maximumAttempts)
-                    await new Promise((resolve) => setTimeout(resolve, attempt * 1200));
-            }
-            if (streamedResult === null)
-                throw lastFailure instanceof Error ? lastFailure : new Error("AI 流式请求重试后仍未返回响应");
-            const { content, reasoning, outputTokens, cacheHitPercent, anthropicContent, tokenUsage } = streamedResult;
-            const processSteps = reasoning.trim()
-                ? [{ id: thinkingStepId, type: "thinking", round: 1, content: reasoning, createdAt: thinkingCreatedAt }]
-                : [];
-            this.store.db.run(`UPDATE ai_calls
-         SET status = 'completed', output_chars = ?, input_tokens = ?, output_tokens = ?,
-             cached_input_tokens = ?, cache_eligible_input_tokens = ?, cache_usage_available = ?,
-             token_usage_source = ?, completed_at = ?
-         WHERE id = ?`, content.length, tokenUsage.inputTokens, tokenUsage.outputTokens, tokenUsage.cachedInputTokens, tokenUsage.cacheEligibleInputTokens, tokenUsage.cacheEligibleInputTokens > 0 ? 1 : 0, tokenUsage.source, now(), callId);
-            logger.info("ai.call.completed", {
-                callId,
-                workId: input.workId,
-                taskType: input.taskType,
-                streaming: true,
-                durationMs: Number(process.hrtime.bigint() - callStartedAt) / 1_000_000,
-                outputChars: content.length,
-                outputTokens
-            });
-            return {
-                callId,
-                content,
-                outputTokens,
-                ...(reasoning.length > 0 ? { reasoningContent: reasoning } : {}),
-                ...(cacheHitPercent === undefined ? {} : { cacheHitPercent }),
-                ...(anthropicContent?.length ? { anthropicContent } : {}),
-                provider: this.mapProvider(provider),
-                model: this.mapModel(model),
-                context,
-                toolCalls: [],
-                processSteps,
-                contextUsage: this.completionContextUsage(input, model, messages, [])
-            };
-        }
-        catch (error) {
-            const message = error instanceof Error ? redactProviderSecretsText(error.message, ...activeSecrets) : "AI 流式调用失败";
-            const failureTarget = aiFailureTargetDetails(provider, model);
-            this.store.db.run("UPDATE ai_calls SET status = 'failed', failure = ?, completed_at = ? WHERE id = ?", message, now(), callId);
-            logger.error("ai.call.failed", {
-                callId,
-                workId: input.workId,
-                taskType: input.taskType,
-                streaming: true,
-                durationMs: Number(process.hrtime.bigint() - callStartedAt) / 1_000_000,
-                error: aiErrorForLog(error)
-            });
-            throw new AppError(502, "AI_CALL_FAILED", "AI 调用失败", { callId, failure: message, ...failureTarget });
-        }
-    }
-    async readCompletionStream(response, protocol, estimatedInputTokens, apiKey, onDelta, onThinkingDelta) {
+    async readCompletionStream(response, protocol, apiKey, onDelta, onThinkingDelta) {
         const protocolLabel = providerProtocolLabelText(protocol);
         if (!response.body)
             throw new Error(`${protocolLabel} 流式响应缺少正文`);
@@ -4918,6 +4837,9 @@ export class AiManager {
         };
         const anthropicBlocks = new Map();
         const anthropicToolInputJson = new Map();
+        const finalizedAnthropicToolInputs = new Map();
+        const openAiToolCalls = new Map();
+        let openAiToolCallsFinalized = false;
         const eventIndex = (payload) => {
             const index = payload.index;
             return typeof index === "number" && Number.isInteger(index) && index >= 0 ? index : null;
@@ -4937,16 +4859,18 @@ export class AiManager {
         const finalizeAnthropicToolInput = (index) => {
             const block = anthropicBlocks.get(index);
             const inputJson = anthropicToolInputJson.get(index);
-            if (!block || block.type !== "tool_use" || inputJson === undefined)
+            if (!block || block.type !== "tool_use")
                 return;
+            const completeInputJson = inputJson ?? JSON.stringify(block.input ?? {});
             try {
-                const parsed = JSON.parse(inputJson);
+                const parsed = JSON.parse(completeInputJson);
                 if (parsed && typeof parsed === "object" && !Array.isArray(parsed))
                     block.input = parsed;
             }
             catch {
                 block.input = {};
             }
+            finalizedAnthropicToolInputs.set(index, completeInputJson);
             anthropicToolInputJson.delete(index);
         };
         const consumeEvent = (eventText) => {
@@ -4982,6 +4906,12 @@ export class AiManager {
                         if (contentBlock.type === "tool_use" && !contentBlock.input)
                             contentBlock.input = {};
                         anthropicBlocks.set(index, contentBlock);
+                        if (contentBlock.type === "text" && typeof contentBlock.text === "string" && contentBlock.text.length > 0) {
+                            appendContent(contentBlock.text);
+                        }
+                        if (contentBlock.type === "thinking" && typeof contentBlock.thinking === "string" && contentBlock.thinking.length > 0) {
+                            appendReasoning(contentBlock.thinking);
+                        }
                     }
                 }
                 const eventUsage = payload.usage && typeof payload.usage === "object" && !Array.isArray(payload.usage)
@@ -5028,6 +4958,8 @@ export class AiManager {
                 if (eventDelta.type === "text_delta" && typeof eventDelta.text === "string" && eventDelta.text.length > 0) {
                     appendContent(eventDelta.text);
                 }
+                if (type === "message_stop")
+                    upstreamDone = true;
                 return;
             }
             const streamUsage = payload.usage && typeof payload.usage === "object" && !Array.isArray(payload.usage)
@@ -5039,11 +4971,38 @@ export class AiManager {
             const choice = choices[0] && typeof choices[0] === "object" && !Array.isArray(choices[0])
                 ? choices[0]
                 : null;
-            if (typeof choice?.finish_reason === "string")
+            if (typeof choice?.finish_reason === "string") {
                 finishReason = choice.finish_reason;
+                if (finishReason === "tool_calls")
+                    openAiToolCallsFinalized = true;
+            }
             const deltaRecord = choice?.delta && typeof choice.delta === "object" && !Array.isArray(choice.delta)
                 ? choice.delta
                 : {};
+            const toolCallDeltas = Array.isArray(deltaRecord.tool_calls) ? deltaRecord.tool_calls : [];
+            for (const [position, value] of toolCallDeltas.entries()) {
+                const toolCallDelta = value && typeof value === "object" && !Array.isArray(value)
+                    ? value
+                    : {};
+                const index = typeof toolCallDelta.index === "number" && Number.isInteger(toolCallDelta.index) && toolCallDelta.index >= 0
+                    ? toolCallDelta.index
+                    : position;
+                const current = openAiToolCalls.get(index) ?? {
+                    id: "",
+                    type: "function",
+                    function: { name: "", arguments: "" }
+                };
+                if (!current.id && typeof toolCallDelta.id === "string")
+                    current.id = toolCallDelta.id;
+                const fn = toolCallDelta.function && typeof toolCallDelta.function === "object" && !Array.isArray(toolCallDelta.function)
+                    ? toolCallDelta.function
+                    : {};
+                if (typeof fn.name === "string")
+                    current.function.name += fn.name;
+                if (typeof fn.arguments === "string")
+                    current.function.arguments = `${String(current.function.arguments)}${fn.arguments}`;
+                openAiToolCalls.set(index, current);
+            }
             const thinkingDelta = deltaRecord.reasoning_content;
             if (typeof thinkingDelta === "string" && thinkingDelta.length > 0) {
                 appendReasoning(thinkingDelta);
@@ -5091,25 +5050,64 @@ export class AiManager {
             reasoning += finalReasoning;
             onThinkingDelta(finalReasoning);
         }
-        if (!content.trim())
+        const sortedOpenAiToolCalls = [...openAiToolCalls.entries()].sort(([left], [right]) => left - right);
+        const openAiToolCallsComplete = openAiToolCallsFinalized
+            && sortedOpenAiToolCalls.length > 0
+            && sortedOpenAiToolCalls.every(([, toolCall]) => Boolean(toolCall.id && toolCall.function.name));
+        const anthropicToolBlocks = [...anthropicBlocks.entries()]
+            .filter(([, block]) => block.type === "tool_use")
+            .sort(([left], [right]) => left - right);
+        const anthropicToolCallsComplete = finishReason === "tool_use"
+            && anthropicToolBlocks.length > 0
+            && anthropicToolBlocks.every(([index, block]) => (finalizedAnthropicToolInputs.has(index)
+                && typeof block.id === "string"
+                && block.id.length > 0
+                && typeof block.name === "string"
+                && block.name.length > 0));
+        const toolCalls = protocol === "anthropic-messages"
+            ? anthropicToolCallsComplete
+                ? anthropicToolBlocks.map(([index, block]) => ({
+                    id: String(block.id),
+                    type: "function",
+                    function: {
+                        name: String(block.name),
+                        arguments: finalizedAnthropicToolInputs.get(index) ?? "{}"
+                    }
+                }))
+                : []
+            : openAiToolCallsComplete
+                ? sortedOpenAiToolCalls.map(([, toolCall]) => toolCall)
+                : [];
+        if ((finishReason === "tool_calls" || finishReason === "tool_use") && toolCalls.length === 0) {
+            throw new Error(`${protocolLabel} 流式工具调用不完整，finish_reason=${finishReason}`);
+        }
+        if (!content.trim() && toolCalls.length === 0) {
             throw new Error(`${protocolLabel} 流式响应缺少可用正文，finish_reason=${finishReason}`);
-        const cacheHitPercent = resolveCacheHitPercent(usage);
-        const outputTokens = resolveOutputTokens(usage, content);
+        }
         const anthropicContent = protocol === "anthropic-messages"
             ? [...anthropicBlocks.entries()]
                 .sort(([left], [right]) => left - right)
-                .map(([index, block]) => {
-                finalizeAnthropicToolInput(index);
-                return redactProviderSecrets(block, apiKey);
-            })
+                .map(([, block]) => redactProviderSecrets(block, apiKey))
             : undefined;
+        const usageRecord = usage && typeof usage === "object" && !Array.isArray(usage)
+            ? usage
+            : undefined;
+        const normalizedFinishReason = finishReason === "unknown"
+            ? null
+            : protocol === "anthropic-messages" && finishReason === "max_tokens"
+                ? "length"
+                : finishReason;
         return {
-            content,
-            reasoning,
-            outputTokens,
-            ...(cacheHitPercent === undefined ? {} : { cacheHitPercent }),
-            ...(anthropicContent?.length ? { anthropicContent } : {}),
-            tokenUsage: resolveAiTokenUsage(usage, estimatedInputTokens, outputTokens)
+            ...(usageRecord ? { usage: usageRecord } : {}),
+            choices: [{
+                    finish_reason: normalizedFinishReason,
+                    message: {
+                        content: content || null,
+                        reasoning_content: reasoning || null,
+                        ...(toolCalls.length ? { tool_calls: toolCalls } : {}),
+                        ...(anthropicContent?.length ? { anthropic_content: anthropicContent } : {})
+                    }
+                }]
         };
     }
     async runChapterAnalysis(workId, scope, modelId, taskId) {