@musnows/scriverse 0.7.2 → 0.7.4

package/dist/ai.js

@@ -1,9 +1,13 @@
+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 { AiConnectivityTestGate, hashAiConnectivityConfiguration } from "./ai-connectivity-test.js";
+import { DEFAULT_AI_STREAM_IDLE_TIMEOUT_MS } from "./ai-stream-timeout.js";
+import { characterExtractionHash, characterExtractionSelectionFingerprint, editableCharacterExtractionCandidate, normalizeCharacterExtractionCandidate, parseStoredCharacterExtractionCandidates } from "./character-extraction.js";
 import { PLATFORM_AI_WORK_ID } from "./database.js";
 import { AppError, notFound } from "./errors.js";
 import { assertOfficialGoogleVertexBaseUrl, fetchGoogleOAuthAccessToken, GoogleVertexTokenCache, maskServiceAccountHint, parseGoogleServiceAccount } from "./google-vertex-auth.js";
-import { HYBRID_SEARCH_TYPES, buildHybridSearchSnippet, documentParagraphLineRange, fuseHybridSearchChannels } from "./hybrid-search.js";
+import { HYBRID_SEARCH_TYPES, MAXIMUM_WORK_SEARCH_QUERY_LENGTH, buildHybridSearchSnippet, documentParagraphLineRange, fuseHybridSearchChannels, normalizeWorkSearchQuery } from "./hybrid-search.js";
 import { logger, sanitizeError } from "./logger.js";
 import { paginated, paginationSql } from "./pagination.js";
 import { currentRequestActor } from "./request-context.js";
@@ -24,10 +28,89 @@ export function aiErrorForLog(error) {
         return { name: sanitized.name ?? "Error", message: "Provider returned invalid JSON" };
     return sanitized;
 }
+function connectivityTestErrorForLog(error) {
+    if (error instanceof AppError) {
+        return { category: "application_error", status: error.status, code: error.code };
+    }
+    if (!(error instanceof Error))
+        return { category: "upstream_failure" };
+    if (error.name === "AbortError")
+        return { category: "timeout" };
+    const httpStatus = error.message.match(/^HTTP ([1-5]\d{2})(?::|$)/u)?.[1];
+    if (httpStatus)
+        return { category: "upstream_http", status: Number(httpStatus) };
+    if (/无效 JSON|响应缺少可用回复|没有返回(?:模型列表|可用模型)/u.test(error.message)) {
+        return { category: "invalid_response" };
+    }
+    if (error instanceof TypeError)
+        return { category: "network_error" };
+    return { category: "upstream_failure" };
+}
 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);
+const interactiveStreamErrorCodes = new Set([
+    "AI_STREAM_IDLE_TIMEOUT",
+    "AI_STREAM_UPSTREAM_CLOSED",
+    "AI_STREAM_NETWORK_ERROR",
+    "AI_STREAM_REQUEST_CANCELLED"
+]);
+function isInteractiveStreamError(error) {
+    return error instanceof AppError && interactiveStreamErrorCodes.has(error.code);
+}
+function interactiveStreamRequestCancelledError() {
+    return new AppError(499, "AI_STREAM_REQUEST_CANCELLED", "AI 流式请求已取消");
+}
+class InteractiveStreamIdleWatchdog {
+    controller;
+    timeoutMs;
+    timer = null;
+    completed = false;
+    failure = null;
+    constructor(controller, timeoutMs) {
+        this.controller = controller;
+        this.timeoutMs = timeoutMs;
+    }
+    start() {
+        this.arm("first_event");
+    }
+    receivedEvent() {
+        this.arm("between_events");
+    }
+    complete() {
+        this.completed = true;
+        this.clear();
+    }
+    dispose() {
+        this.clear();
+    }
+    arm(phase) {
+        if (this.completed || this.failure)
+            return;
+        this.clear();
+        this.timer = setTimeout(() => {
+            const idleTimeoutSeconds = this.timeoutMs / 1_000;
+            this.failure = new AppError(504, "AI_STREAM_IDLE_TIMEOUT", phase === "first_event"
+                ? `等待 AI 首个流事件超时（${idleTimeoutSeconds} 秒无新事件），流已关闭`
+                : `AI 流已因 ${idleTimeoutSeconds} 秒无新事件而关闭，已保留已生成内容`, { phase, idleTimeoutSeconds });
+            this.controller.abort(this.failure);
+        }, this.timeoutMs);
+    }
+    clear() {
+        if (!this.timer)
+            return;
+        clearTimeout(this.timer);
+        this.timer = null;
+    }
+}
+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=";
@@ -246,7 +329,7 @@ function redactProviderSecrets(value, secrets, depth = 0) {
         return null;
     return Object.fromEntries(Object.entries(value).map(([key, item]) => [key, redactProviderSecrets(item, list, depth + 1)]));
 }
-class ProviderSecretStreamRedactor {
+export class ProviderSecretStreamRedactor {
     pending = "";
     secrets;
     constructor(apiKey) {
@@ -267,10 +350,21 @@ class ProviderSecretStreamRedactor {
         this.pending = retainedLength > 0 ? combined.slice(-retainedLength) : "";
         return retainedLength > 0 ? combined.slice(0, -retainedLength) : combined;
     }
-    flush() {
-        const value = redactProviderSecretsText(this.pending, ...this.secrets);
+    flush(options = {}) {
+        const pending = this.pending;
+        const value = redactProviderSecretsText(pending, ...this.secrets);
         this.pending = "";
-        return value;
+        if (!options.interrupted || !pending)
+            return value;
+        const matchingSecrets = this.secrets.filter((secret) => secret.startsWith(pending));
+        if (matchingSecrets.length === 0)
+            return value;
+        const visiblePrefixLength = Math.min(...matchingSecrets.map((secret) => secret.length > 7 ? 4 : 0));
+        if (pending.length <= visiblePrefixLength)
+            return value;
+        if (visiblePrefixLength === 0)
+            return "********";
+        return `${pending.slice(0, visiblePrefixLength)}*****`;
     }
 }
 function sanitizeCompletionTraceResponse(value) {
@@ -330,7 +424,7 @@ const grepArguments = z.object({
     cursor: agentToolCursor
 }).strict();
 const searchStoryEntitiesArguments = z.object({
-    query: z.string().trim().min(1).max(200),
+    query: z.string().trim().min(1).max(MAXIMUM_WORK_SEARCH_QUERY_LENGTH),
     categories: z.array(z.enum(["setting", "character", "race", "organization", "timeline", "relationship", "outline", "foreshadow"])).max(8).default([]),
     limit: z.number().int().min(1).max(30).default(30),
     cursor: agentToolCursor
@@ -395,7 +489,7 @@ const AGENT_TOOL_DEFINITIONS = {
         function: {
             name: "search_story_entities",
             description: "按短关键词在结构化作品实体中进行元数据、精确全文和拼音混合检索：设定、人物（含 Markdown 档案章节）、种族、组织、时间线、关系、大纲和伏笔。人物、种族、组织结果分别包含权威布尔状态 isDead、isExtinct、isDissolved；只有值为 true 才能判定该角色已死亡、该种族已灭绝或该组织已解散，字段为 false 时必须视为仍存活、未灭绝或未解散，禁止根据正文情节自行改判。不是语义问答；请传入实体名、别名、标题、拼音或短关键词，不要传入自然语言整句。结果按综合相关度排序；人物结果含 sectionId 时可再调用 read_character_sections 精读。无匹配时改用更短关键词，或改用 story_index / grep。",
-            parameters: { type: "object", properties: { query: { type: "string", minLength: 1, maxLength: 200 }, categories: { type: "array", items: { type: "string", enum: ["setting", "character", "race", "organization", "timeline", "relationship", "outline", "foreshadow"] }, maxItems: 8 }, limit: { type: "integer", minimum: 1, maximum: 30, default: 30 }, cursor: agentToolCursorParameter }, required: ["query"], additionalProperties: false }
+            parameters: { type: "object", properties: { query: { type: "string", minLength: 1, maxLength: MAXIMUM_WORK_SEARCH_QUERY_LENGTH }, categories: { type: "array", items: { type: "string", enum: ["setting", "character", "race", "organization", "timeline", "relationship", "outline", "foreshadow"] }, maxItems: 8 }, limit: { type: "integer", minimum: 1, maximum: 30, default: 30 }, cursor: agentToolCursorParameter }, required: ["query"], additionalProperties: false }
         }
     },
     read_character_sections: {
@@ -684,6 +778,36 @@ function numberValue(row, key) {
 function boolValue(row, key) {
     return Number(row[key] ?? 0) === 1;
 }
+const providerConnectivityConfigurationFields = [
+    "name",
+    "base_url",
+    "protocol",
+    "encrypted_key",
+    "key_iv",
+    "key_tag",
+    "status",
+    "concurrency_limit",
+    "rpm_limit",
+    "max_tokens",
+    "default_model_id",
+    "note"
+];
+const modelConnectivityConfigurationFields = [
+    "display_name",
+    "model_id",
+    "purposes_json",
+    "context_note",
+    "context_window",
+    "output_note",
+    "preset_json",
+    "thinking_enabled",
+    "multimodal_enabled",
+    "enabled",
+    "note"
+];
+function connectivityConfigurationValues(row, fields) {
+    return fields.map((field) => row[field] ?? null);
+}
 function safeJsonObject(value) {
     return json(value, {});
 }
@@ -1417,6 +1541,7 @@ export class AiManager {
     authorizeTaskRun;
     attachmentStorage;
     contextBuilder;
+    interactiveStreamIdleTimeoutMs;
     taskControllers = new Map();
     autoRunStarting = new Map();
     autoRunTimers = new Map();
@@ -1430,13 +1555,19 @@ export class AiManager {
     relationshipIndexDisposed = false;
     providerSchedules = new Map();
     vertexTokenCache = new GoogleVertexTokenCache();
-    constructor(store, vault, fetchImpl = fetch, validateOutboundUrl, authorizeTaskRun, attachmentStorage) {
+    connectivityTestGate;
+    constructor(store, vault, fetchImpl = fetch, validateOutboundUrl, authorizeTaskRun, attachmentStorage, options = {}) {
         this.store = store;
         this.vault = vault;
         this.fetchImpl = fetchImpl;
         this.validateOutboundUrl = validateOutboundUrl;
         this.authorizeTaskRun = authorizeTaskRun;
         this.attachmentStorage = attachmentStorage;
+        this.connectivityTestGate = new AiConnectivityTestGate(store.db);
+        this.interactiveStreamIdleTimeoutMs = Number.isSafeInteger(options.interactiveStreamIdleTimeoutMs)
+            && Number(options.interactiveStreamIdleTimeoutMs) > 0
+            ? Number(options.interactiveStreamIdleTimeoutMs)
+            : DEFAULT_AI_STREAM_IDLE_TIMEOUT_MS;
         this.contextBuilder = new ContextBuilder(store);
         this.store.setAnalysisTaskQueuedHandler((workId) => this.scheduleAutoRun(workId));
         this.autoRunStartupTimer = setTimeout(() => {
@@ -1449,7 +1580,7 @@ export class AiManager {
             this.relationshipIndexTimer = null;
             void this.schedulePendingRelationshipIndexes();
         }, 0);
-        logger.info("ai.manager.ready");
+        logger.info("ai.manager.ready", { interactiveStreamIdleTimeoutMs: this.interactiveStreamIdleTimeoutMs });
     }
     getPlatformTokenUsage(timezoneOffset) {
         return this.getTokenUsage(null, timezoneOffset, true);
@@ -1482,7 +1613,7 @@ export class AiManager {
     }
     async searchWork(workId, query, options = {}) {
         this.store.getWork(workId);
-        const normalizedQuery = normalizeRelationshipSearchText(query).trim();
+        const normalizedQuery = normalizeWorkSearchQuery(query);
         if (!normalizedQuery)
             return [];
         const requestedTypes = options.type ? new Set([options.type]) : new Set(HYBRID_SEARCH_TYPES);
@@ -1929,7 +2060,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);
@@ -2067,7 +2198,7 @@ export class AiManager {
         this.vertexTokenCache.clear(providerId);
     }
     async testProvider(providerId) {
-        const row = this.getProviderRow(providerId);
+        const { row, configFingerprint, claim } = this.acquireProviderConnectivityTest(providerId);
         const protocol = providerProtocol(row);
         const controller = new AbortController();
         const timeout = setTimeout(() => controller.abort(), AI_INTERACTIVE_TIMEOUT_MS);
@@ -2115,39 +2246,62 @@ export class AiManager {
                     : `${lastFailure}；也可先添加模型后再测试连接`);
             }
             await this.probeProviderModel(row, accessToken, probeModel, controller.signal);
-            const timestamp = now();
-            this.store.db.run("UPDATE providers SET connection_status = 'success', last_error = NULL, last_success_at = ?, updated_at = ? WHERE id = ?", timestamp, timestamp, providerId);
+            const cooldown = this.connectivityTestGate.complete(claim, "success", {
+                isConfigurationCurrent: () => {
+                    try {
+                        return this.providerConnectivityTestFingerprint(this.getProviderRow(providerId)) === configFingerprint;
+                    }
+                    catch {
+                        return false;
+                    }
+                },
+                onApplied: (completedAt) => {
+                    this.store.db.run("UPDATE providers SET connection_status = 'success', last_error = NULL, last_success_at = ?, updated_at = ? WHERE id = ?", completedAt, completedAt, providerId);
+                }
+            });
             logger.info("ai.provider_test.completed", {
                 providerId,
                 protocol,
                 ok: true,
+                cooldownApplied: cooldown.reason !== "configuration_changed",
                 availableModelCount: availableModels.length,
                 durationMs: Number(process.hrtime.bigint() - startedAt) / 1_000_000
             });
-            return { ok: true, availableModels, provider: this.getProvider(providerId) };
+            return { ok: true, availableModels, cooldown, provider: this.getProvider(providerId) };
         }
         catch (error) {
             const message = error instanceof Error
                 ? redactProviderSecretsText(error.message, credentialSecret, accessToken)
                 : "连接失败";
-            this.store.db.run("UPDATE providers SET connection_status = 'failed', last_error = ?, updated_at = ? WHERE id = ?", message, now(), providerId);
+            const cooldown = this.connectivityTestGate.complete(claim, "failure", {
+                isConfigurationCurrent: () => {
+                    try {
+                        return this.providerConnectivityTestFingerprint(this.getProviderRow(providerId)) === configFingerprint;
+                    }
+                    catch {
+                        return false;
+                    }
+                },
+                onApplied: (completedAt) => {
+                    this.store.db.run("UPDATE providers SET connection_status = 'failed', last_error = ?, updated_at = ? WHERE id = ?", message, completedAt, providerId);
+                }
+            });
             logger.warn("ai.provider_test.completed", {
                 providerId,
                 protocol,
                 ok: false,
+                cooldownApplied: cooldown.reason !== "configuration_changed",
                 durationMs: Number(process.hrtime.bigint() - startedAt) / 1_000_000,
-                error: aiErrorForLog(error)
+                error: connectivityTestErrorForLog(error)
             });
-            return { ok: false, error: message, provider: this.getProvider(providerId) };
+            return { ok: false, error: message, cooldown, provider: this.getProvider(providerId) };
         }
         finally {
             clearTimeout(timeout);
         }
     }
     async testModel(modelId) {
-        const model = this.getModelRow(modelId);
-        const providerId = stringValue(model, "provider_id");
-        const provider = this.getProviderRow(providerId);
+        const { model, provider, providerId, configFingerprint, claim } = this.acquireModelConnectivityTest(modelId);
         const controller = new AbortController();
         const timeout = setTimeout(() => controller.abort(), AI_INTERACTIVE_TIMEOUT_MS);
         const startedAt = process.hrtime.bigint();
@@ -2159,31 +2313,60 @@ export class AiManager {
         try {
             ({ accessToken, credentialSecret } = await this.resolveProviderAccessToken(provider));
             await this.probeProviderModel(provider, accessToken, stringValue(model, "model_id"), controller.signal, { multimodal: multimodalTested });
-            const timestamp = now();
-            this.store.db.run("UPDATE providers SET connection_status = 'success', last_error = NULL, last_success_at = ?, updated_at = ? WHERE id = ?", timestamp, timestamp, providerId);
+            const cooldown = this.connectivityTestGate.complete(claim, "success", {
+                isConfigurationCurrent: () => {
+                    try {
+                        const currentModel = this.getModelRow(modelId);
+                        const currentProvider = this.getProviderRow(stringValue(currentModel, "provider_id"));
+                        return this.modelConnectivityTestFingerprint(currentModel, currentProvider) === configFingerprint;
+                    }
+                    catch {
+                        return false;
+                    }
+                },
+                onApplied: (completedAt) => {
+                    this.store.db.run("UPDATE providers SET connection_status = 'success', last_error = NULL, last_success_at = ?, updated_at = ? WHERE id = ?", completedAt, completedAt, providerId);
+                }
+            });
             logger.info("ai.model_test.completed", {
                 modelId,
                 providerId,
                 protocol,
                 ok: true,
+                cooldownApplied: cooldown.reason !== "configuration_changed",
                 durationMs: Number(process.hrtime.bigint() - startedAt) / 1_000_000
             });
-            return { ok: true, multimodalTested, model: this.getModel(modelId), provider: this.getProvider(providerId) };
+            return { ok: true, multimodalTested, cooldown, model: this.getModel(modelId), provider: this.getProvider(providerId) };
         }
         catch (error) {
             const message = error instanceof Error
                 ? redactProviderSecretsText(error.message, credentialSecret, accessToken)
                 : "连接失败";
-            this.store.db.run("UPDATE providers SET connection_status = 'failed', last_error = ?, updated_at = ? WHERE id = ?", message, now(), providerId);
+            const cooldown = this.connectivityTestGate.complete(claim, "failure", {
+                isConfigurationCurrent: () => {
+                    try {
+                        const currentModel = this.getModelRow(modelId);
+                        const currentProvider = this.getProviderRow(stringValue(currentModel, "provider_id"));
+                        return this.modelConnectivityTestFingerprint(currentModel, currentProvider) === configFingerprint;
+                    }
+                    catch {
+                        return false;
+                    }
+                },
+                onApplied: (completedAt) => {
+                    this.store.db.run("UPDATE providers SET connection_status = 'failed', last_error = ?, updated_at = ? WHERE id = ?", message, completedAt, providerId);
+                }
+            });
             logger.warn("ai.model_test.completed", {
                 modelId,
                 providerId,
                 protocol,
                 ok: false,
+                cooldownApplied: cooldown.reason !== "configuration_changed",
                 durationMs: Number(process.hrtime.bigint() - startedAt) / 1_000_000,
-                error: aiErrorForLog(error)
+                error: connectivityTestErrorForLog(error)
             });
-            return { ok: false, error: message, model: this.getModel(modelId), provider: this.getProvider(providerId) };
+            return { ok: false, error: message, cooldown, model: this.getModel(modelId), provider: this.getProvider(providerId) };
         }
         finally {
             clearTimeout(timeout);
@@ -2369,6 +2552,295 @@ export class AiManager {
             ...(modelId ? { modelId } : {})
         });
     }
+    assertCharacterExtractionTask(taskId) {
+        const task = this.store.getTask(taskId);
+        if (task.taskType !== "character-extraction" && task.taskType !== "character-summary") {
+            throw new AppError(409, "CHARACTER_EXTRACTION_TASK_REQUIRED", "只有角色抽取任务可以预览或应用角色档案");
+        }
+        if (task.status !== "review" && task.status !== "completed") {
+            throw new AppError(409, "CHARACTER_EXTRACTION_TASK_NOT_COMPLETED", "只有已成功完成的角色抽取任务可以应用角色档案");
+        }
+        return task;
+    }
+    characterExtractionMatches(candidate, characters) {
+        const candidateNames = [candidate.name, ...candidate.aliases];
+        const candidateNormalized = new Map(candidateNames.map((name) => [normalizeCharacterName(name), name]));
+        const stable = candidate.stableCharacterId
+            ? characters.find((character) => character.id === candidate.stableCharacterId)
+            : undefined;
+        const matches = new Map();
+        for (const character of characters) {
+            const primaryName = String(character.name);
+            const aliases = Array.isArray(character.aliases) ? character.aliases.map(String) : [];
+            const primaryNormalized = normalizeCharacterName(primaryName);
+            const aliasNormalized = new Set(aliases.map(normalizeCharacterName));
+            const matchedNames = [...candidateNormalized]
+                .filter(([normalized]) => normalized === primaryNormalized || aliasNormalized.has(normalized))
+                .map(([, name]) => name);
+            if (matchedNames.length === 0 && character !== stable)
+                continue;
+            const matchType = character === stable
+                ? "stable"
+                : matchedNames.some((name) => normalizeCharacterName(name) === primaryNormalized)
+                    ? "name"
+                    : "alias";
+            matches.set(String(character.id), {
+                characterId: String(character.id),
+                name: primaryName,
+                aliases,
+                versionNo: Number(character.versionNo),
+                matchType,
+                matchedNames
+            });
+        }
+        const conflicts = [];
+        if (candidate.stableCharacterId && !stable)
+            conflicts.push("任务生成时匹配的角色已不存在，请改为新建或跳过");
+        if (matches.size > 1)
+            conflicts.push("候选名称或别名分别命中了多个已有角色，必须明确选择目标或改名新建");
+        const priority = { stable: 0, name: 1, alias: 2 };
+        return {
+            matches: [...matches.values()].sort((left, right) => priority[left.matchType] - priority[right.matchType]
+                || left.name.localeCompare(right.name, "zh-CN")),
+            conflicts
+        };
+    }
+    characterExtractionPreviewData(task, result, candidates) {
+        const workId = String(task.workId);
+        const characters = this.store.listCharacters(workId, false, false, false);
+        const items = candidates.map((candidate) => {
+            const { matches, conflicts } = this.characterExtractionMatches(candidate, characters);
+            return {
+                ...candidate,
+                suggestedAction: matches.length === 0 ? "create" : matches.length === 1 || matches[0]?.matchType === "stable" ? "merge" : "skip",
+                matchCandidates: matches,
+                conflicts
+            };
+        });
+        const previewToken = characterExtractionHash({
+            taskId: task.id,
+            taskUpdatedAt: task.updatedAt,
+            candidates,
+            roster: characters.map((character) => ({
+                id: character.id,
+                name: character.name,
+                aliases: character.aliases,
+                raceId: character.raceId,
+                identity: character.attributes && typeof character.attributes === "object" && !Array.isArray(character.attributes)
+                    ? String(character.attributes.identity ?? "")
+                    : "",
+                firstChapterId: character.firstChapterId,
+                versionNo: character.versionNo
+            }))
+        });
+        const application = result.characterApplication && typeof result.characterApplication === "object"
+            && !Array.isArray(result.characterApplication)
+            ? result.characterApplication
+            : null;
+        return {
+            taskId: String(task.id),
+            status: application?.status === "applied" ? "applied" : "pending",
+            totalCount: candidates.length,
+            previewToken,
+            items,
+            ...(application?.status === "applied" ? { application } : {})
+        };
+    }
+    getCharacterExtractionPreview(taskId) {
+        const task = this.assertCharacterExtractionTask(taskId);
+        const result = this.store.getTaskStoredResult(taskId);
+        const application = result.characterApplication && typeof result.characterApplication === "object"
+            && !Array.isArray(result.characterApplication)
+            ? result.characterApplication
+            : null;
+        if (application?.status !== "applied" && !this.store.isTaskSourceCurrent(taskId)) {
+            throw new AppError(409, "CHARACTER_EXTRACTION_SOURCE_CHANGED", "任务分析的正文来源已发生变化，请重新运行角色抽取后再应用");
+        }
+        const candidates = parseStoredCharacterExtractionCandidates(result.characterCandidates);
+        return this.characterExtractionPreviewData(task, result, candidates);
+    }
+    characterExtractionFirstChapter(workId, candidate) {
+        if (!candidate.firstChapterId)
+            return { firstChapterId: null };
+        try {
+            const chapter = this.store.getChapter(candidate.firstChapterId);
+            if (chapter.workId === workId)
+                return { firstChapterId: candidate.firstChapterId };
+        }
+        catch {
+            // 原任务结果可能来自旧数据；应用时按当前作品重新核验。
+        }
+        return { firstChapterId: null, conflict: "首次登场章节已不存在或不属于当前作品，未写入该关联" };
+    }
+    applyCharacterExtractionPreview(taskId, previewToken, selections) {
+        this.assertCharacterExtractionTask(taskId);
+        const requestFingerprint = characterExtractionSelectionFingerprint(selections);
+        return this.store.db.transaction(() => {
+            const task = this.assertCharacterExtractionTask(taskId);
+            const result = this.store.getTaskStoredResult(taskId);
+            const application = result.characterApplication && typeof result.characterApplication === "object"
+                && !Array.isArray(result.characterApplication)
+                ? result.characterApplication
+                : null;
+            if (application?.status === "applied") {
+                if (application.requestFingerprint === requestFingerprint)
+                    return application;
+                throw new AppError(409, "CHARACTER_EXTRACTION_ALREADY_APPLIED", "本任务已按另一组确认结果应用，不能再次修改角色档案");
+            }
+            if (!this.store.isTaskSourceCurrent(taskId)) {
+                throw new AppError(409, "CHARACTER_EXTRACTION_SOURCE_CHANGED", "任务分析的正文来源已发生变化，请重新运行角色抽取后再应用");
+            }
+            const candidates = parseStoredCharacterExtractionCandidates(result.characterCandidates);
+            const selectionById = new Map(selections.map((selection) => [selection.candidateId, selection]));
+            if (selectionById.size !== selections.length
+                || selectionById.size !== candidates.length
+                || candidates.some((candidate) => !selectionById.has(candidate.candidateId))) {
+                throw new AppError(400, "CHARACTER_EXTRACTION_SELECTION_INVALID", "必须为预览中的每个角色候选明确选择新建、合并或跳过");
+            }
+            const preview = this.characterExtractionPreviewData(task, result, candidates);
+            if (preview.previewToken !== previewToken) {
+                throw new AppError(409, "CHARACTER_EXTRACTION_PREVIEW_STALE", "角色档案在预览后已发生变化，请刷新预览再确认");
+            }
+            const previewItems = new Map(preview.items
+                .map((item) => [item.candidateId, item]));
+            const workId = String(task.workId);
+            const appliedItems = [];
+            const characterIds = [];
+            for (const candidate of candidates) {
+                const selection = selectionById.get(candidate.candidateId);
+                if (selection.action === "skip") {
+                    appliedItems.push({ candidateId: candidate.candidateId, action: "skip", status: "skipped" });
+                    continue;
+                }
+                const editable = editableCharacterExtractionCandidate(candidate, selection);
+                const firstChapter = this.characterExtractionFirstChapter(workId, candidate);
+                const conflicts = firstChapter.conflict ? [firstChapter.conflict] : [];
+                const raceId = editable.species ? this.store.resolveRaceReference(workId, editable.species) : null;
+                if (editable.species && !raceId)
+                    conflicts.push(`种族“${editable.species}”未命中当前作品已有种族，未写入种族关联`);
+                if (selection.action === "create") {
+                    const created = this.store.createCharacter(workId, {
+                        name: editable.name,
+                        aliases: editable.aliases,
+                        raceId,
+                        attributes: editable.identity ? { identity: editable.identity } : {},
+                        firstChapterId: firstChapter.firstChapterId
+                    }, "ai", taskId, "应用 AI 角色抽取预览并新建档案");
+                    characterIds.push(String(created.id));
+                    appliedItems.push({
+                        candidateId: candidate.candidateId,
+                        action: "create",
+                        status: "created",
+                        characterId: String(created.id),
+                        characterName: String(created.name),
+                        ...(conflicts.length ? { conflicts } : {})
+                    });
+                    continue;
+                }
+                const previewItem = previewItems.get(candidate.candidateId);
+                const targetMatch = previewItem.matchCandidates.find((match) => match.characterId === selection.targetCharacterId);
+                if (!targetMatch || !selection.targetCharacterId) {
+                    throw new AppError(400, "CHARACTER_EXTRACTION_TARGET_INVALID", "合并目标不是服务端预览确认的候选角色", {
+                        candidateId: candidate.candidateId
+                    });
+                }
+                const target = this.store.getCharacter(selection.targetCharacterId);
+                if (target.workId !== workId || target.mergedIntoCharacterId) {
+                    throw new AppError(409, "CHARACTER_EXTRACTION_TARGET_STALE", "合并目标已失效，请刷新预览再确认", {
+                        candidateId: candidate.candidateId
+                    });
+                }
+                const existingAliases = Array.isArray(target.aliases) ? target.aliases.map(String) : [];
+                const existingNames = new Set([String(target.name), ...existingAliases].map(normalizeCharacterName));
+                const addedAliases = [];
+                for (const alias of [editable.name, ...editable.aliases]) {
+                    const normalized = normalizeCharacterName(alias);
+                    if (!normalized || existingNames.has(normalized))
+                        continue;
+                    const ownerId = this.store.resolveCharacterReference(workId, alias);
+                    if (ownerId && ownerId !== target.id) {
+                        conflicts.push(`名称或别名“${alias}”已属于其他角色，未合并该别名`);
+                        continue;
+                    }
+                    existingNames.add(normalized);
+                    addedAliases.push(alias);
+                }
+                const update = {};
+                if (addedAliases.length > 0)
+                    update.aliases = [...existingAliases, ...addedAliases];
+                const attributes = target.attributes && typeof target.attributes === "object" && !Array.isArray(target.attributes)
+                    ? target.attributes
+                    : {};
+                const existingIdentity = typeof attributes.identity === "string" ? attributes.identity.trim() : "";
+                if (editable.identity && !existingIdentity)
+                    update.attributes = { ...attributes, identity: editable.identity };
+                else if (editable.identity && normalizeCharacterName(editable.identity) !== normalizeCharacterName(existingIdentity)) {
+                    conflicts.push("已有身份与定位内容未被抽取结果覆盖");
+                }
+                if (editable.species) {
+                    if (!target.raceId && raceId)
+                        update.raceId = raceId;
+                    else if (target.raceId && (!raceId || target.raceId !== raceId))
+                        conflicts.push("已有种族关联未被抽取结果覆盖");
+                }
+                if (!target.firstChapterId && firstChapter.firstChapterId)
+                    update.firstChapterId = firstChapter.firstChapterId;
+                const changed = Object.keys(update).length > 0;
+                const updated = changed
+                    ? this.store.updateCharacter(String(target.id), update, "ai", taskId, "应用 AI 角色抽取预览并合并可靠信息", Number(target.versionNo))
+                    : target;
+                characterIds.push(String(updated.id));
+                appliedItems.push({
+                    candidateId: candidate.candidateId,
+                    action: "merge",
+                    status: changed ? "merged" : "unchanged",
+                    characterId: String(updated.id),
+                    characterName: String(updated.name),
+                    ...(addedAliases.length ? { addedAliases } : {}),
+                    ...(conflicts.length ? { conflicts } : {})
+                });
+            }
+            const appliedAt = now();
+            const applicationResult = {
+                status: "applied",
+                previewToken,
+                requestFingerprint,
+                ...(typeof application?.generatedAt === "string" ? { generatedAt: application.generatedAt } : {}),
+                appliedAt,
+                totalCount: candidates.length,
+                createdCount: appliedItems.filter((item) => item.status === "created").length,
+                mergedCount: appliedItems.filter((item) => item.status === "merged").length,
+                unchangedCount: appliedItems.filter((item) => item.status === "unchanged").length,
+                skippedCount: appliedItems.filter((item) => item.status === "skipped").length,
+                characterIds: [...new Set(characterIds)],
+                items: appliedItems
+            };
+            this.store.updateTask(taskId, {
+                status: String(task.status),
+                result: {
+                    ...result,
+                    characterIds: applicationResult.characterIds,
+                    savedCount: applicationResult.characterIds.length,
+                    characterApplication: applicationResult
+                }
+            });
+            this.store.audit(workId, "character.extraction.applied", "analysis-task", taskId, {
+                createdCount: applicationResult.createdCount,
+                mergedCount: applicationResult.mergedCount,
+                unchangedCount: applicationResult.unchangedCount,
+                skippedCount: applicationResult.skippedCount,
+                characterIds: applicationResult.characterIds
+            });
+            logger.info("ai.character_extraction.applied", {
+                taskId,
+                workId,
+                createdCount: applicationResult.createdCount,
+                mergedCount: applicationResult.mergedCount,
+                skippedCount: applicationResult.skippedCount
+            });
+            return applicationResult;
+        });
+    }
     applyRelationshipChangePreview(taskId) {
         const task = this.store.getTask(taskId);
         if (task.taskType !== "relationship-analysis") {
@@ -2549,7 +3021,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 +3041,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 +3094,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 +3455,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 +3485,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 +3497,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 +3531,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;
         }
@@ -3178,24 +3656,42 @@ export class AiManager {
             }
         };
     }
-    async prepareConversationContext(input) {
+    inspectConversationContext(input) {
         const usage = this.getContextUsage({ ...input, taskType: "chat" });
         const conversation = this.store.getAiConversationContext(input.conversationId, input.workId);
         if (!usage.compactRecommended) {
-            if (conversation.warningPending)
-                this.store.setAiConversationContextWarning(input.conversationId, false);
             return { action: "ready", usage: { ...usage, contextWarningPending: false } };
         }
         if (!conversation.warningPending) {
-            this.store.setAiConversationContextWarning(input.conversationId, true);
             return { action: "warn", usage: { ...usage, contextWarningPending: true } };
         }
+        return { action: "compact", usage };
+    }
+    async prepareConversationContext(input, options = {}) {
+        const inspection = this.inspectConversationContext(input);
+        if (inspection.action === "ready") {
+            const conversation = this.store.getAiConversationContext(input.conversationId, input.workId);
+            if (conversation.warningPending)
+                this.store.setAiConversationContextWarning(input.conversationId, false);
+            return inspection;
+        }
+        if (inspection.action === "warn" && !options.skipWarning) {
+            this.store.setAiConversationContextWarning(input.conversationId, true);
+            return inspection;
+        }
         const compaction = await this.compactConversation(input);
         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 conversation = this.store.getAiConversationContext(input.conversationId, input.workId, input.excludeConversationMessageId);
         const { model } = this.resolveModel(input.workId, "chat", input.modelId);
         const budget = this.contextBudget({ ...input, taskType: "chat", instruction: "" }, model);
         const recentTokenBudget = Math.max(128, Math.floor(Number(budget.conversationBudgetTokens) * 0.75));
@@ -3404,13 +3900,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 +3914,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 +3938,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 +4701,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,12 +4773,13 @@ 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
         });
         let activeSecrets = [];
+        let streamedContent = "";
         let trackedInputTokens = 0;
         let trackedOutputTokens = 0;
         let trackedCachedInputTokens = 0;
@@ -4308,11 +4811,18 @@ export class AiManager {
             let cacheUsageComplete = true;
             let totalInputTokens = 0;
             let totalCachedInputTokens = 0;
+            const processSteps = [];
+            const completionDelivery = new WeakMap();
+            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 +4840,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,
@@ -4350,25 +4862,85 @@ export class AiManager {
                                 forwardAbort();
                             else
                                 input.signal?.addEventListener("abort", forwardAbort, { once: true });
-                            const timeout = setTimeout(() => controller.abort(new Error(`AI 请求超时（${Math.round(timeoutMs / 1_000)} 秒）`)), timeoutMs);
+                            const streamWatchdog = streamResponse
+                                ? new InteractiveStreamIdleWatchdog(controller, this.interactiveStreamIdleTimeoutMs)
+                                : null;
+                            const timeout = streamResponse
+                                ? null
+                                : setTimeout(() => controller.abort(new Error(`AI 请求超时（${Math.round(timeoutMs / 1_000)} 秒）`)), timeoutMs);
+                            let responseReceived = false;
+                            streamWatchdog?.start();
                             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) };
+                                responseReceived = true;
+                                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 });
+                                }, () => streamWatchdog?.receivedEvent());
+                                streamWatchdog?.complete();
+                                return {
+                                    ok: true,
+                                    status: response.status,
+                                    payload: redactProviderSecrets(payload, activeSecrets),
+                                    delivery: "sse"
+                                };
+                            }
+                            catch (error) {
+                                if (streamResponse && input.signal?.aborted)
+                                    throw interactiveStreamRequestCancelledError();
+                                if (streamWatchdog?.failure)
+                                    throw streamWatchdog.failure;
+                                if (streamResponse && !responseReceived) {
+                                    throw new AppError(502, "AI_STREAM_NETWORK_ERROR", "AI 上游流连接失败，尚未收到首个事件");
+                                }
+                                throw error;
                             }
                             finally {
-                                clearTimeout(timeout);
+                                if (timeout)
+                                    clearTimeout(timeout);
+                                streamWatchdog?.dispose();
                                 input.signal?.removeEventListener("abort", forwardAbort);
                             }
                         });
@@ -4377,31 +4949,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();
@@ -4416,6 +4985,8 @@ export class AiManager {
                     }
                     catch (error) {
                         lastFailure = error;
+                        if (isInteractiveStreamError(error))
+                            retryable = false;
                         if (traceAttempt.status === "running") {
                             traceAttempt.completedAt = now();
                             traceAttempt.status = "failed";
@@ -4427,11 +4998,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 +5013,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 +5130,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 +5149,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 +5222,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 +5249,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 +5270,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,
@@ -4698,19 +5283,21 @@ export class AiManager {
             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 = ?, input_tokens = ?, output_tokens = ?,
+         SET status = 'failed', failure = ?, output_chars = ?, input_tokens = ?, output_tokens = ?,
              cached_input_tokens = ?, cache_eligible_input_tokens = ?, cache_usage_available = ?,
              token_usage_source = ?, completed_at = ?
-         WHERE id = ?`, message, trackedInputTokens, trackedOutputTokens, trackedCachedInputTokens, trackedCacheEligibleInputTokens, trackedCacheEligibleInputTokens > 0 ? 1 : 0, trackedUsageSource(), now(), callId);
+         WHERE id = ?`, message, streamedContent.length, trackedInputTokens, trackedOutputTokens, trackedCachedInputTokens, trackedCacheEligibleInputTokens, trackedCacheEligibleInputTokens > 0 ? 1 : 0, trackedUsageSource(), now(), callId);
             logger.error("ai.call.failed", {
                 callId,
                 workId: input.workId,
                 taskType: input.taskType,
-                streaming: false,
+                streaming: Boolean(onDelta),
                 durationMs: Number(process.hrtime.bigint() - callStartedAt) / 1_000_000,
                 error: aiErrorForLog(error)
             });
-            if (error instanceof AppError && (error.code === "CONTEXT_WINDOW_EXCEEDED" || error.code === "DAILY_TOKEN_QUOTA_EXCEEDED")) {
+            if (error instanceof AppError && (error.code === "CONTEXT_WINDOW_EXCEEDED"
+                || error.code === "DAILY_TOKEN_QUOTA_EXCEEDED"
+                || isInteractiveStreamError(error))) {
                 throw new AppError(error.status, error.code, error.message, {
                     callId,
                     ...(error.details && typeof error.details === "object" ? error.details : {}),
@@ -4720,175 +5307,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, onEvent) {
         const protocolLabel = providerProtocolLabelText(protocol);
         if (!response.body)
             throw new Error(`${protocolLabel} 流式响应缺少正文`);
@@ -4918,6 +5337,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 +5359,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) => {
@@ -4956,10 +5380,10 @@ export class AiManager {
                 .join("\n")
                 .trim();
             if (!data)
-                return;
+                return false;
             if (data === "[DONE]") {
                 upstreamDone = true;
-                return;
+                return true;
             }
             const payload = JSON.parse(data);
             const error = payload.error && typeof payload.error === "object" && !Array.isArray(payload.error)
@@ -4982,6 +5406,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,7 +5458,9 @@ export class AiManager {
                 if (eventDelta.type === "text_delta" && typeof eventDelta.text === "string" && eventDelta.text.length > 0) {
                     appendContent(eventDelta.text);
                 }
-                return;
+                if (type === "message_stop")
+                    upstreamDone = true;
+                return true;
             }
             const streamUsage = payload.usage && typeof payload.usage === "object" && !Array.isArray(payload.usage)
                 ? payload.usage
@@ -5039,11 +5471,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);
@@ -5052,64 +5511,133 @@ export class AiManager {
             if (typeof delta === "string" && delta.length > 0) {
                 appendContent(delta);
             }
+            return true;
+        };
+        let redactorsFlushed = false;
+        const flushRedactors = (interrupted) => {
+            if (redactorsFlushed)
+                return;
+            redactorsFlushed = true;
+            const finalContent = contentRedactor.flush({ interrupted });
+            if (finalContent) {
+                content += finalContent;
+                onDelta(finalContent);
+            }
+            const finalReasoning = reasoningRedactor.flush({ interrupted });
+            if (finalReasoning) {
+                reasoning += finalReasoning;
+                onThinkingDelta(finalReasoning);
+            }
         };
         let receivedBytes = 0;
-        while (true) {
-            const chunk = await reader.read();
-            if (chunk.value?.byteLength) {
-                receivedBytes += chunk.value.byteLength;
-                if (receivedBytes > AI_RESPONSE_MAX_BYTES) {
+        let readerEnded = false;
+        try {
+            while (true) {
+                let chunk;
+                try {
+                    chunk = await reader.read();
+                }
+                catch (error) {
+                    if (error instanceof AppError)
+                        throw error;
+                    throw new AppError(502, "AI_STREAM_NETWORK_ERROR", "AI 上游流连接中断，已保留已生成内容");
+                }
+                if (chunk.value?.byteLength) {
+                    receivedBytes += chunk.value.byteLength;
+                    if (receivedBytes > AI_RESPONSE_MAX_BYTES) {
+                        await reader.cancel().catch(() => undefined);
+                        throw new AppError(502, "AI_RESPONSE_TOO_LARGE", `AI 供应商响应超过 ${AI_RESPONSE_MAX_BYTES} 字节上限`);
+                    }
+                }
+                buffer += decoder.decode(chunk.value, { stream: !chunk.done });
+                const events = buffer.split(/\r?\n\r?\n/u);
+                buffer = events.pop() ?? "";
+                for (const eventText of events) {
+                    if (consumeEvent(eventText))
+                        onEvent();
+                    if (upstreamDone)
+                        break;
+                }
+                if (upstreamDone) {
                     await reader.cancel().catch(() => undefined);
-                    throw new AppError(502, "AI_RESPONSE_TOO_LARGE", `AI 供应商响应超过 ${AI_RESPONSE_MAX_BYTES} 字节上限`);
+                    buffer = "";
+                    break;
                 }
-            }
-            buffer += decoder.decode(chunk.value, { stream: !chunk.done });
-            const events = buffer.split(/\r?\n\r?\n/u);
-            buffer = events.pop() ?? "";
-            for (const eventText of events) {
-                consumeEvent(eventText);
-                if (upstreamDone)
+                if (chunk.done) {
+                    readerEnded = true;
                     break;
+                }
             }
-            if (upstreamDone) {
-                await reader.cancel().catch(() => undefined);
-                buffer = "";
-                break;
-            }
-            if (chunk.done)
-                break;
+            if (buffer.trim() && consumeEvent(buffer))
+                onEvent();
         }
-        if (buffer.trim())
-            consumeEvent(buffer);
-        const finalContent = contentRedactor.flush();
-        if (finalContent) {
-            content += finalContent;
-            onDelta(finalContent);
+        catch (error) {
+            flushRedactors(true);
+            throw error;
         }
-        const finalReasoning = reasoningRedactor.flush();
-        if (finalReasoning) {
-            reasoning += finalReasoning;
-            onThinkingDelta(finalReasoning);
+        const upstreamClosed = readerEnded && !upstreamDone && finishReason === "unknown";
+        flushRedactors(upstreamClosed);
+        if (upstreamClosed) {
+            throw new AppError(502, "AI_STREAM_UPSTREAM_CLOSED", "AI 上游流在正常结束前已关闭，已保留已生成内容");
+        }
+        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())
+        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) {
@@ -5708,9 +6236,12 @@ export class AiManager {
             return { interrupted: true, callIds };
         const byChapterId = new Map(chapters.map((chapter) => [String(chapter.id), chapter]));
         const groups = [];
+        const preprocessingSkipped = [];
         for (const candidate of rawCandidates) {
-            if (typeof candidate.canonicalName !== "string" || !candidate.canonicalName.trim())
+            if (typeof candidate.canonicalName !== "string" || !candidate.canonicalName.trim()) {
+                preprocessingSkipped.push({ name: "未命名候选", reason: "角色标准名为空，未进入入库预览" });
                 continue;
+            }
             const name = candidate.canonicalName.normalize("NFKC").trim();
             const aliases = (Array.isArray(candidate.aliases) ? candidate.aliases : [])
                 .filter((value) => typeof value === "string")
@@ -5722,8 +6253,10 @@ export class AiManager {
             const chapterId = evidence && typeof evidence.chapterId === "string" ? evidence.chapterId : null;
             const quote = evidence && typeof evidence.quote === "string" ? evidence.quote.trim() : "";
             if (!chapterId || !quote || quote.length > 80 || !byChapterId.has(chapterId)
-                || !this.quoteExists(String(byChapterId.get(chapterId)?.content ?? ""), quote))
+                || !this.quoteExists(String(byChapterId.get(chapterId)?.content ?? ""), quote)) {
+                preprocessingSkipped.push({ name: name.slice(0, 200), reason: "首次出现证据无效或无法在本次正文范围内核验" });
                 continue;
+            }
             const refs = new Set([name, ...aliases].map((value) => this.normalizeReference(value)));
             const matches = groups.filter((group) => [...refs].some((value) => group.references.has(value)));
             const group = matches[0] ?? {
@@ -5820,7 +6353,7 @@ export class AiManager {
                 addVerificationPair(candidateSubjects[leftIndex], existing);
             }
         }
-        const skipped = [];
+        const skipped = [...preprocessingSkipped];
         let verificationCallId = null;
         let confirmedSameCount = 0;
         let confirmedSeparateCount = 0;
@@ -5942,50 +6475,42 @@ export class AiManager {
             if (!blockedReasons.has(root) && blockedReasons.has(index))
                 blockedReasons.set(root, blockedReasons.get(index));
         }
-        const characterIds = [];
+        const characterCandidates = [];
         for (const [root, group] of mergedGroups) {
             if (blockedGroups.has(root)) {
                 skipped.push({ name: group.name, reason: blockedReasons.get(root) ?? "角色身份二次确认未通过" });
                 continue;
             }
             const aliases = [...group.aliases].filter((alias) => this.isSafeGlobalAlias(alias));
-            const extractedRaceId = group.species ? this.store.resolveRaceReference(workId, group.species) : null;
             const existingId = existingIdByRoot.get(root) ?? [group.name, ...aliases]
                 .map((value) => this.store.resolveCharacterReference(workId, value))
                 .find((value) => Boolean(value));
-            try {
-                if (existingId) {
-                    const existing = this.store.getCharacter(existingId);
-                    const mergedAliases = [...new Set([...existing.aliases, group.name, ...aliases])]
-                        .filter((alias) => this.isSafeGlobalAlias(alias) && this.normalizeReference(alias) !== this.normalizeReference(String(existing.name)));
-                    const updated = this.store.updateCharacter(existingId, {
-                        aliases: mergedAliases,
-                        raceId: existing.raceId ?? extractedRaceId,
-                        attributes: { ...existing.attributes, ...(group.identity ? { identity: group.identity } : {}) },
-                        firstChapterId: existing.firstChapterId ?? group.firstChapterId
-                    }, "ai", taskId ?? null, "全书角色抽取及身份二次确认");
-                    characterIds.push(String(updated.id));
-                }
-                else {
-                    const created = this.store.createCharacter(workId, {
-                        name: group.name,
-                        aliases,
-                        raceId: extractedRaceId,
-                        attributes: group.identity ? { identity: group.identity } : {},
-                        firstChapterId: group.firstChapterId
-                    });
-                    characterIds.push(String(created.id));
-                }
-            }
-            catch (error) {
-                skipped.push({ name: group.name, reason: error instanceof Error ? error.message : "名称冲突" });
-            }
+            const candidate = normalizeCharacterExtractionCandidate({
+                name: group.name,
+                aliases,
+                species: group.species,
+                identity: group.identity,
+                firstChapterId: group.firstChapterId,
+                firstEvidence: group.firstEvidence,
+                stableCharacterId: existingId ?? null
+            }, characterCandidates.length);
+            if (candidate)
+                characterCandidates.push(candidate);
+            else
+                skipped.push({ name: group.name.slice(0, 200), reason: "候选名称或属性不符合角色档案字段限制" });
         }
+        const generatedAt = now();
         return {
-            characterIds: [...new Set(characterIds)],
-            candidateCount: mergedGroups.size,
-            savedCount: new Set(characterIds).size,
+            characterIds: [],
+            characterCandidates,
+            candidateCount: characterCandidates.length,
+            savedCount: 0,
             skipped,
+            characterApplication: {
+                status: "pending",
+                totalCount: characterCandidates.length,
+                generatedAt
+            },
             batchCount: chunks.length,
             coveredChapterCount: chapters.length,
             fallbackSegmentCount,
@@ -8636,6 +9161,53 @@ export class AiManager {
             throw new AppError(500, "CREDENTIAL_DECRYPT_FAILED", "供应商凭据无法解密，请重新填写密钥或服务账号 JSON");
         }
     }
+    providerConnectivityTestFingerprint(row) {
+        const localModels = this.store.db.all("SELECT * FROM models WHERE provider_id = ? ORDER BY created_at, id", stringValue(row, "id")).map((model) => [
+            stringValue(model, "id"),
+            connectivityConfigurationValues(model, modelConnectivityConfigurationFields)
+        ]);
+        return hashAiConnectivityConfiguration([
+            "provider-connectivity-v1",
+            connectivityConfigurationValues(row, providerConnectivityConfigurationFields),
+            localModels
+        ]);
+    }
+    acquireProviderConnectivityTest(providerId) {
+        const acquired = this.connectivityTestGate.acquireWithConfiguration("provider", providerId, () => {
+            const row = this.getProviderRow(providerId);
+            const configFingerprint = this.providerConnectivityTestFingerprint(row);
+            return { configFingerprint, configuration: row };
+        });
+        return {
+            row: acquired.configuration,
+            configFingerprint: acquired.configFingerprint,
+            claim: acquired.claim
+        };
+    }
+    modelConnectivityTestFingerprint(model, provider) {
+        return hashAiConnectivityConfiguration([
+            "model-connectivity-v1",
+            connectivityConfigurationValues(provider, providerConnectivityConfigurationFields),
+            connectivityConfigurationValues(model, modelConnectivityConfigurationFields)
+        ]);
+    }
+    acquireModelConnectivityTest(modelId) {
+        const acquired = this.connectivityTestGate.acquireWithConfiguration("model", modelId, () => {
+            const model = this.getModelRow(modelId);
+            const providerId = stringValue(model, "provider_id");
+            const provider = this.getProviderRow(providerId);
+            const configFingerprint = this.modelConnectivityTestFingerprint(model, provider);
+            return {
+                configFingerprint,
+                configuration: { model, provider, providerId }
+            };
+        });
+        return {
+            ...acquired.configuration,
+            configFingerprint: acquired.configFingerprint,
+            claim: acquired.claim
+        };
+    }
     getProviderRow(providerId) {
         const row = this.store.db.get("SELECT * FROM providers WHERE id = ?", providerId);
         if (!row)