chatccc 0.2.272 → 0.2.276

package/dist/deepccc-agent/src/context.js

@@ -2,7 +2,7 @@ import { createHash, randomBytes } from "node:crypto";
 import { existsSync, mkdirSync, readdirSync, readFileSync, renameSync, writeFileSync } from "node:fs";
 import { homedir } from "node:os";
 import { join } from "node:path";
-import { hasMalformedToolProtocolText } from "./tool-protocol.js";
+import { hasImitatedToolTranscriptText, hasMalformedToolProtocolText, } from "./tool-protocol.js";
 export const DEFAULT_BUILTIN_CONTEXT_DIR = join(homedir(), ".deepccc", "sessions");
 /** 默认模型上下文窗口：1M（DeepSeek V4 Pro/Flash 原生规格）。 */
 export const DEFAULT_CONTEXT_WINDOW_TOKENS = 1_048_576;
@@ -15,6 +15,11 @@ const RECENT_CONTEXT_BUDGET_RATIO = 0.6;
 const MAX_COMPACTION_SUMMARY_CHARS = 8_000;
 const MAX_COMPACTION_MESSAGE_CHARS = 24_000;
 const MAX_COMPACTION_SOURCE_CHARS = 64_000;
+export const DEFAULT_MAX_TOOL_CONTEXT_TOKENS = 64_000;
+const TOOL_CONTEXT_BUDGET_RATIO = 0.25;
+const RECENT_TOOL_CONTEXT_BUDGET_RATIO = 0.6;
+const STORED_TOOL_TRANSCRIPT_MARKER = "\n\n[工具记录]\n";
+const QUARANTINED_PROTOCOL_REPLY = "[上一轮响应因工具协议异常已隔离，不能视为已执行；请根据后续用户消息继续。]";
 export function normalizeBuiltinSessionId(value) {
     return value.replace(/[^a-zA-Z0-9_.-]+/g, "_").replace(/^_+|_+$/g, "") || "default";
 }
@@ -49,8 +54,42 @@ function normalizeMessage(value) {
     const toolCalls = normalizeToolCalls(raw.toolCalls);
     if (toolCalls.length > 0)
         message.toolCalls = toolCalls;
+    const timeline = normalizeTimeline(raw.timeline);
+    if (timeline.length > 0)
+        message.timeline = timeline;
     return message;
 }
+function normalizeTimeline(value) {
+    if (!Array.isArray(value))
+        return [];
+    const entries = [];
+    for (const item of value.slice(0, 1000)) {
+        if (!item || typeof item !== "object" || Array.isArray(item))
+            continue;
+        const raw = item;
+        if (raw.type === "text" && typeof raw.text === "string") {
+            entries.push({ type: "text", text: raw.text });
+        }
+        else if (raw.type === "tool_use" && typeof raw.id === "string" && typeof raw.name === "string") {
+            entries.push({
+                type: "tool_use",
+                id: raw.id,
+                name: raw.name,
+                ...(typeof raw.input === "string" ? { input: raw.input } : {}),
+            });
+        }
+        else if (raw.type === "tool_result" && typeof raw.tool_use_id === "string") {
+            entries.push({
+                type: "tool_result",
+                tool_use_id: raw.tool_use_id,
+                ...(typeof raw.name === "string" ? { name: raw.name } : {}),
+                ...(typeof raw.output === "string" ? { output: raw.output } : {}),
+                ...(typeof raw.is_error === "boolean" ? { is_error: raw.is_error } : {}),
+            });
+        }
+    }
+    return entries;
+}
 function normalizeToolCalls(value) {
     if (!Array.isArray(value))
         return [];
@@ -62,6 +101,8 @@ function normalizeToolCalls(value) {
         if (typeof raw.name !== "string" || raw.name.length === 0)
             continue;
         const call = { name: raw.name };
+        if (typeof raw.id === "string" && raw.id.length > 0)
+            call.id = raw.id;
         if (typeof raw.input === "string")
             call.input = raw.input;
         if (typeof raw.output === "string")
@@ -135,6 +176,18 @@ function readSessionInfo(contextDir, sessionId) {
 export function getBuiltinContextSession(sessionId, contextDir = DEFAULT_BUILTIN_CONTEXT_DIR) {
     return readSessionInfo(contextDir, sessionId);
 }
+export function readBuiltinContextState(sessionId, contextDir = DEFAULT_BUILTIN_CONTEXT_DIR) {
+    const normalizedSessionId = normalizeBuiltinSessionId(sessionId);
+    const filePath = contextFilePath(contextDir, normalizedSessionId);
+    if (!existsSync(filePath))
+        return null;
+    try {
+        return normalizeState(JSON.parse(readFileSync(filePath, "utf8")), normalizedSessionId);
+    }
+    catch {
+        return null;
+    }
+}
 export function listBuiltinContextSessions(contextDir = DEFAULT_BUILTIN_CONTEXT_DIR) {
     if (!existsSync(contextDir))
         return [];
@@ -161,8 +214,11 @@ export function latestBuiltinSessionForCwd(cwd, contextDir = DEFAULT_BUILTIN_CON
  * 按字符类型加权，比旧版 chars/3 更接近真实：CJK 字符 ≈ 1 token/字，
  * 其他字符 ≈ 3.5 chars/token。避免中文长上下文被严重低估导致压缩过晚。
  */
-export function estimateBuiltinContextTokens(summary, messages) {
-    const text = summary + messages.reduce((sum, m) => sum + `${m.role}\n${m.content}\n`, "");
+function stripStoredToolTranscript(content) {
+    const markerIndex = content.indexOf(STORED_TOOL_TRANSCRIPT_MARKER);
+    return markerIndex >= 0 ? content.slice(0, markerIndex) : content;
+}
+function estimateTextTokens(text) {
     let cjk = 0;
     for (const ch of text) {
         if (/[\u3400-\u4DBF\u4E00-\u9FFF\uF900-\uFAFF\u3000-\u303F\uFF00-\uFFEF]/.test(ch))
@@ -171,6 +227,30 @@ export function estimateBuiltinContextTokens(summary, messages) {
     const other = text.length - cjk;
     return Math.ceil(cjk + other / 3.5);
 }
+export function estimateBuiltinToolContextTokens(messages) {
+    let text = "";
+    for (const message of messages) {
+        if (message.role !== "assistant")
+            continue;
+        if (message.toolCalls?.length) {
+            for (const call of message.toolCalls) {
+                text += `${call.name}\n${call.input ?? ""}\n${call.output ?? ""}\n`;
+            }
+            continue;
+        }
+        for (const entry of message.timeline ?? []) {
+            if (entry.type === "tool_use")
+                text += `${entry.name}\n${entry.input ?? ""}\n`;
+            if (entry.type === "tool_result")
+                text += `${entry.name ?? ""}\n${entry.output ?? ""}\n`;
+        }
+    }
+    return estimateTextTokens(text);
+}
+export function estimateBuiltinContextTokens(summary, messages) {
+    const text = summary + messages.reduce((sum, message) => sum + `${message.role}\n${stripStoredToolTranscript(message.content)}\n`, "");
+    return estimateTextTokens(text) + estimateBuiltinToolContextTokens(messages);
+}
 export function serializeMessagesForSummary(messages) {
     return messages
         .map((message, index) => `### ${index + 1}. ${message.role}\n${message.content}`)
@@ -188,23 +268,205 @@ export const DEFAULT_PERSISTED_ASSISTANT_TEXT_CHARS = 32_000;
 export const DEFAULT_PERSISTED_TOOL_TRANSCRIPT_CHARS = 24_000;
 const ASSISTANT_TRUNCATED_MARKER = "...[助手回复已在上下文中截断]...";
 const TOOL_TRANSCRIPT_TRUNCATED_MARKER = "...[工具记录已截断]...";
+function truncateStructuredToolCalls(calls, maxChars) {
+    const payloads = calls.flatMap((call) => [call.input ?? "", call.output ?? ""]).filter(Boolean);
+    const total = payloads.reduce((sum, value) => sum + value.length, 0);
+    if (total <= maxChars)
+        return calls;
+    const sharedBudget = Math.max(0, maxChars - payloads.length);
+    const truncatePayload = (value) => {
+        if (value === undefined || value.length === 0)
+            return value;
+        const budget = 1 + Math.floor(sharedBudget * value.length / Math.max(1, total));
+        return truncateMiddle(value, budget, TOOL_TRANSCRIPT_TRUNCATED_MARKER);
+    };
+    return calls.map((call) => ({
+        ...call,
+        ...(call.input !== undefined ? { input: truncatePayload(call.input) } : {}),
+        ...(call.output !== undefined ? { output: truncatePayload(call.output) } : {}),
+    }));
+}
 /**
- * 构造持久化的 assistant 消息：content 保持既有"正文 + [Tool transcript]"文本格式
- * （模型上下文行为不变），同时附加结构化 toolCalls 存档（供 session-search 等检索）。
+ * 构造持久化 assistant 消息。content 仅保存回答正文，工具事件保存在
+ * toolCalls/timeline，避免内部 transcript 语法回流并诱导模型伪造工具执行。
  */
 export function buildPersistedAssistantMessage(params) {
     const maxAssistantChars = params.maxAssistantChars ?? DEFAULT_PERSISTED_ASSISTANT_TEXT_CHARS;
     const maxTranscriptChars = params.maxTranscriptChars ?? DEFAULT_PERSISTED_TOOL_TRANSCRIPT_CHARS;
     const persistedAssistantText = truncateMiddle(params.fullText, maxAssistantChars, ASSISTANT_TRUNCATED_MARKER);
-    const content = params.transcriptLines.length > 0
-        ? `${persistedAssistantText}\n\n[工具记录]\n${truncateMiddle(params.transcriptLines.join("\n"), maxTranscriptChars, TOOL_TRANSCRIPT_TRUNCATED_MARKER)}`
-        : persistedAssistantText;
-    const message = { role: "assistant", content };
-    const toolCalls = normalizeToolCalls(params.toolCalls);
+    const message = { role: "assistant", content: persistedAssistantText };
+    const toolCalls = truncateStructuredToolCalls(normalizeToolCalls(params.toolCalls), maxTranscriptChars);
     if (toolCalls.length > 0)
         message.toolCalls = toolCalls;
+    const timeline = truncatePersistedTimeline(normalizeTimeline(params.timeline));
+    if (timeline.length > 0)
+        message.timeline = timeline;
     return message;
 }
+function truncatePersistedTimeline(entries) {
+    const maxTextChars = DEFAULT_PERSISTED_ASSISTANT_TEXT_CHARS;
+    const maxToolChars = DEFAULT_PERSISTED_TOOL_TRANSCRIPT_CHARS;
+    const totalText = entries.reduce((sum, entry) => sum + (entry.type === "text" ? entry.text.length : 0), 0);
+    const textPayloads = entries.filter((entry) => entry.type === "text" && entry.text.length > 0).length;
+    const totalTool = entries.reduce((sum, entry) => {
+        if (entry.type === "tool_use")
+            return sum + (entry.input?.length ?? 0);
+        if (entry.type === "tool_result")
+            return sum + (entry.output?.length ?? 0);
+        return sum;
+    }, 0);
+    const toolPayloads = entries.filter((entry) => (entry.type === "tool_use" && (entry.input?.length ?? 0) > 0)
+        || (entry.type === "tool_result" && (entry.output?.length ?? 0) > 0)).length;
+    const payloadBudget = (length, total, count, maximum) => {
+        if (total <= maximum)
+            return length;
+        const sharedBudget = Math.max(0, maximum - count);
+        return length > 0 ? 1 + Math.floor(sharedBudget * length / Math.max(1, total)) : 0;
+    };
+    const truncatePayload = (value, budget, marker) => {
+        if (value.length <= budget)
+            return value;
+        if (budget <= marker.length + 2)
+            return value.slice(0, budget);
+        return truncateMiddle(value, budget, marker);
+    };
+    return entries.map((entry) => {
+        if (entry.type === "text") {
+            const budget = payloadBudget(entry.text.length, totalText, textPayloads, maxTextChars);
+            return { ...entry, text: truncatePayload(entry.text, budget, ASSISTANT_TRUNCATED_MARKER) };
+        }
+        if (entry.type === "tool_use" && entry.input !== undefined) {
+            const budget = payloadBudget(entry.input.length, totalTool, toolPayloads, maxToolChars);
+            return { ...entry, input: truncatePayload(entry.input, budget, TOOL_TRANSCRIPT_TRUNCATED_MARKER) };
+        }
+        if (entry.type === "tool_result" && entry.output !== undefined) {
+            const budget = payloadBudget(entry.output.length, totalTool, toolPayloads, maxToolChars);
+            return { ...entry, output: truncatePayload(entry.output, budget, TOOL_TRANSCRIPT_TRUNCATED_MARKER) };
+        }
+        return entry;
+    });
+}
+function parseToolInput(value) {
+    if (!value?.trim())
+        return {};
+    try {
+        return JSON.parse(value);
+    }
+    catch {
+        return { raw: value };
+    }
+}
+function parseToolOutput(value) {
+    if (!value?.trim())
+        return { type: "text", value: "" };
+    try {
+        return { type: "json", value: JSON.parse(value) };
+    }
+    catch {
+        return { type: "text", value };
+    }
+}
+function replayStructuredAssistantMessage(message, messageIndex) {
+    const plainText = stripStoredToolTranscript(message.content);
+    const hasStructuredTools = Boolean(message.toolCalls?.length
+        || message.timeline?.some((entry) => entry.type === "tool_use" || entry.type === "tool_result"));
+    if (!hasStructuredTools)
+        return [{ role: "assistant", content: plainText }];
+    const timeline = message.timeline?.length
+        ? message.timeline
+        : [
+            ...(message.toolCalls ?? []).map((call, callIndex) => ({
+                type: "tool_use",
+                id: call.id ?? `context-tool-${messageIndex}-${callIndex}`,
+                name: call.name,
+                ...(call.input !== undefined ? { input: call.input } : {}),
+            })),
+            ...(message.toolCalls ?? []).map((call, callIndex) => ({
+                type: "tool_result",
+                tool_use_id: call.id ?? `context-tool-${messageIndex}-${callIndex}`,
+                name: call.name,
+                ...(call.output !== undefined ? { output: call.output } : {}),
+                ...(call.is_error !== undefined ? { is_error: call.is_error } : {}),
+            })),
+            ...(plainText ? [{ type: "text", text: plainText }] : []),
+        ];
+    const messages = [];
+    let assistantParts = [];
+    let toolParts = [];
+    const pendingCalls = new Map();
+    const knownNames = new Map();
+    const emittedCallIds = new Set();
+    const flushAssistant = () => {
+        if (!assistantParts.length)
+            return;
+        messages.push({ role: "assistant", content: assistantParts });
+        assistantParts = [];
+    };
+    const completeToolStep = () => {
+        // OpenAI/LiteLLM requires every tool message to immediately follow the
+        // assistant message that declared all matching tool_calls for that step.
+        flushAssistant();
+        for (const [toolCallId, toolName] of pendingCalls) {
+            toolParts.push({
+                type: "tool-result",
+                toolCallId,
+                toolName,
+                output: { type: "text", value: "[tool execution interrupted; result unavailable]" },
+            });
+        }
+        pendingCalls.clear();
+        if (!toolParts.length)
+            return;
+        messages.push({ role: "tool", content: toolParts });
+        toolParts = [];
+    };
+    for (const entry of timeline) {
+        if (entry.type === "text") {
+            if (pendingCalls.size > 0 || toolParts.length > 0)
+                completeToolStep();
+            const previous = assistantParts[assistantParts.length - 1];
+            if (previous?.type === "text")
+                previous.text += entry.text;
+            else if (entry.text)
+                assistantParts.push({ type: "text", text: entry.text });
+        }
+        else if (entry.type === "tool_use") {
+            // Consecutive tool calls belong to one assistant step. Only close the
+            // previous step after at least one result has arrived.
+            if (toolParts.length > 0)
+                completeToolStep();
+            knownNames.set(entry.id, entry.name);
+            pendingCalls.set(entry.id, entry.name);
+            emittedCallIds.add(entry.id);
+            assistantParts.push({
+                type: "tool-call",
+                toolCallId: entry.id,
+                toolName: entry.name,
+                input: parseToolInput(entry.input),
+            });
+        }
+        else {
+            if (!emittedCallIds.has(entry.tool_use_id))
+                continue;
+            const toolName = entry.name ?? knownNames.get(entry.tool_use_id);
+            if (!toolName)
+                continue;
+            flushAssistant();
+            pendingCalls.delete(entry.tool_use_id);
+            toolParts.push({
+                type: "tool-result",
+                toolCallId: entry.tool_use_id,
+                toolName,
+                output: parseToolOutput(entry.output),
+            });
+        }
+    }
+    if (pendingCalls.size > 0 || toolParts.length > 0)
+        completeToolStep();
+    else
+        flushAssistant();
+    return messages;
+}
 function serializeMessagesForCompaction(messages) {
     const sections = [];
     let remaining = MAX_COMPACTION_SOURCE_CHARS;
@@ -245,6 +507,7 @@ export class BuiltinContextManager {
     contextDir;
     sessionId;
     compactAtTokens;
+    maxToolContextTokens;
     keepRecentMessages;
     cwd;
     state;
@@ -255,6 +518,8 @@ export class BuiltinContextManager {
         this.cwd = options.cwd;
         this.compactAtTokens = options.compactAtTokens
             ?? Math.floor((options.contextWindow ?? DEFAULT_CONTEXT_WINDOW_TOKENS) * COMPACTION_THRESHOLD_RATIO);
+        this.maxToolContextTokens = Math.max(1, options.maxToolContextTokens
+            ?? Math.min(DEFAULT_MAX_TOOL_CONTEXT_TOKENS, Math.floor(this.compactAtTokens * TOOL_CONTEXT_BUDGET_RATIO)));
         this.keepRecentMessages = Math.max(1, options.keepRecentMessages ?? DEFAULT_KEEP_RECENT_MESSAGES);
         this.state = this.load();
     }
@@ -294,7 +559,12 @@ export class BuiltinContextManager {
         // Keep malformed provider output on disk for diagnosis, but quarantine it
         // from future prompts so one protocol failure cannot teach the model to
         // repeat the same invalid tool syntax on every later turn.
-        messages.push(...this.modelSafeMessages());
+        for (const [index, message] of this.modelSafeMessages().entries()) {
+            if (message.role === "user")
+                messages.push({ role: "user", content: message.content });
+            else
+                messages.push(...replayStructuredAssistantMessage(message, index));
+        }
         return messages;
     }
     planCompaction() {
@@ -302,16 +572,19 @@ export class BuiltinContextManager {
         // leaks here too, otherwise a later summary could reintroduce the bad syntax.
         const messages = this.modelSafeMessages();
         const estimated = estimateBuiltinContextTokens(this.state.summary, messages);
-        if (estimated <= this.compactAtTokens)
+        const toolEstimated = estimateBuiltinToolContextTokens(messages);
+        if (estimated <= this.compactAtTokens && toolEstimated <= this.maxToolContextTokens)
             return null;
         if (messages.length <= 1)
             return null;
         const earliestAllowed = Math.max(0, messages.length - this.keepRecentMessages);
         const recentTokenBudget = Math.max(1, Math.floor(this.compactAtTokens * RECENT_CONTEXT_BUDGET_RATIO));
+        const recentToolBudget = Math.max(1, Math.floor(this.maxToolContextTokens * RECENT_TOOL_CONTEXT_BUDGET_RATIO));
         let splitAt = messages.length - 1;
         for (let index = messages.length - 2; index >= earliestAllowed; index -= 1) {
             const candidate = messages.slice(index);
-            if (estimateBuiltinContextTokens("", candidate) > recentTokenBudget)
+            if (estimateBuiltinContextTokens("", candidate) > recentTokenBudget
+                || estimateBuiltinToolContextTokens(candidate) > recentToolBudget)
                 break;
             splitAt = index;
         }
@@ -322,8 +595,8 @@ export class BuiltinContextManager {
             splitAt = 1;
         return {
             previousSummary: this.state.summary,
-            oldMessages: this.state.messages.slice(0, splitAt),
-            recentMessages: this.state.messages.slice(splitAt),
+            oldMessages: messages.slice(0, splitAt),
+            recentMessages: messages.slice(splitAt),
         };
     }
     applyCompaction(summary, plan) {
@@ -347,7 +620,17 @@ export class BuiltinContextManager {
         renameSync(tmp, this.contextFilePath);
     }
     modelSafeMessages() {
-        return this.state.messages.filter((message) => message.role !== "assistant" || !hasMalformedToolProtocolText(message.content));
+        return this.state.messages.map((message) => {
+            if (message.role !== "assistant")
+                return message;
+            const hasStructuredTools = Boolean(message.toolCalls?.length
+                || message.timeline?.some((entry) => entry.type === "tool_use" || entry.type === "tool_result"));
+            const copiedStoredTranscript = hasImitatedToolTranscriptText(message.content) && hasStructuredTools;
+            if (hasMalformedToolProtocolText(message.content) && !copiedStoredTranscript) {
+                return { role: "assistant", content: QUARANTINED_PROTOCOL_REPLY };
+            }
+            return { ...message, content: stripStoredToolTranscript(message.content) };
+        });
     }
     load() {
         if (!this.persist || !existsSync(this.contextFilePath))

package/dist/deepccc-agent/src/file-tools.js

@@ -8,6 +8,7 @@ import { basename, dirname, isAbsolute, join, relative, resolve, sep } from "nod
 import { createInterface } from "node:readline";
 import { jsonSchema, tool } from "ai";
 import { isDangerousCommand } from "./permissions.js";
+import { detectImageMime, MAX_ATTACHMENT_BYTES } from "./attachments.js";
 import { killProcessTree } from "./proc-tree-kill.js";
 import { searchBuiltinSessions, } from "./session-search.js";
 import { webFetchForTool, webSearchForTool, } from "./web-tools.js";
@@ -74,6 +75,25 @@ async function pathExists(path) {
         return false;
     }
 }
+export async function presentFileForTool(cwd, input) {
+    const path = resolveToolPath(cwd, input.path);
+    const info = await stat(path).catch(() => null);
+    if (!info?.isFile())
+        throw new Error(`Image file not found: ${input.path}`);
+    if (info.size > MAX_ATTACHMENT_BYTES)
+        throw new Error(`Image file exceeds the 20 MB limit: ${input.path}`);
+    const mimeType = detectImageMime(await readFile(path));
+    if (!mimeType)
+        throw new Error(`present_file only supports PNG, JPEG, or WebP images: ${input.path}`);
+    const caption = input.caption?.trim();
+    return {
+        path,
+        name: basename(path),
+        mimeType,
+        size: info.size,
+        ...(caption ? { caption: caption.slice(0, 500) } : {}),
+    };
+}
 function sha256(buffer) {
     return createHash("sha256").update(buffer).digest("hex");
 }
@@ -1011,6 +1031,19 @@ export function createBuiltinFileTools(cwd, options = {}) {
             }),
             execute: (input, options) => searchCodeForTool(cwd, input, options.abortSignal),
         }),
+        present_file: tool({
+            description: "把本地 PNG、JPEG 或 WebP 图片作为会话图片展示给用户。仅在图片文件已经生成并需要交付时调用。",
+            inputSchema: jsonSchema({
+                type: "object",
+                additionalProperties: false,
+                properties: {
+                    path: { type: "string", description: "图片绝对路径或相对于会话工作目录的路径。" },
+                    caption: { type: "string", description: "可选的图片说明。" },
+                },
+                required: ["path"],
+            }),
+            execute: (input) => presentFileForTool(cwd, input),
+        }),
         run_command: tool({
             description: "在本地工作区运行非交互式 shell 命令。用于测试、git 和包脚本。返回 stdout/stderr 和 exitCode；非零退出码不是工具错误。",
             inputSchema: jsonSchema({

package/dist/deepccc-agent/src/index.js

@@ -5,7 +5,7 @@
  */
 import { createOpenAICompatible } from "@ai-sdk/openai-compatible";
 import { createAnthropic } from "@ai-sdk/anthropic";
-import { generateText, isLoopFinished, stepCountIs, streamText } from "ai";
+import { generateText, isLoopFinished, stepCountIs, streamText, } from "ai";
 import { existsSync, readFileSync } from "node:fs";
 import { homedir } from "node:os";
 import { isAbsolute, join, resolve } from "node:path";
@@ -144,7 +144,7 @@ function addAnthropicToolJsonCompatibilityNote(messages) {
     // 部分 Anthropic→OpenAI/Ark 转换器会用 response_format=json_object
     // 实现工具调用，却只在 messages 中校验 JSON 关键词、不读取顶层 system。
     // 这里仅声明工具参数的编码方式，并明确不要求普通最终回复输出 JSON。
-    return messages.map((message, index) => (index === lastUserIndex
+    return messages.map((message, index) => (index === lastUserIndex && message.role === "user" && typeof message.content === "string"
         ? {
             ...message,
             content: `${message.content}\n\n${ANTHROPIC_TOOL_JSON_COMPATIBILITY_NOTE}`,
@@ -161,11 +161,13 @@ function addAnthropicToolJsonCompatibilityNote(messages) {
 function maybeAppendCompactionRecoveryHint(messages, summary, rawLogsEnabled, sessionId) {
     if (!summary.trim())
         return messages;
-    const summaryIndex = messages.findIndex((message) => message.role === "user" && message.content.startsWith("以下是更早的对话摘要"));
+    const summaryIndex = messages.findIndex((message) => message.role === "user"
+        && typeof message.content === "string"
+        && message.content.startsWith("以下是更早的对话摘要"));
     if (summaryIndex < 0)
         return messages;
     const hint = rawLogsEnabled ? buildCompactionRecoveryHint(sessionId) : COMPACTION_RECOVERY_HINT_DISABLED;
-    return messages.map((message, index) => (index === summaryIndex
+    return messages.map((message, index) => (index === summaryIndex && message.role === "user" && typeof message.content === "string"
         ? { ...message, content: `${message.content}\n\n${hint}` }
         : message));
 }
@@ -249,6 +251,7 @@ export class ChatSession {
     maxSteps;
     effort;
     maxOutputTokens;
+    streaming;
     permissionMode;
     permissionResolver;
     permissionGate;
@@ -316,6 +319,7 @@ export class ChatSession {
         this.provider = normalizeDeepCccProvider(overrides.provider ?? appConfig.provider);
         this.effort = (overrides.effort ?? appConfig.effort ?? "").trim();
         this.maxOutputTokens = normalizeMaxOutputTokens(overrides.maxOutputTokens ?? appConfig.maxOutputTokens);
+        this.streaming = overrides.streaming ?? appConfig.streaming;
         this.apiKey = apiKey;
         this.baseURL = baseURL;
         const provider = this.provider === "anthropic"
@@ -351,6 +355,7 @@ export class ChatSession {
             cwd: this.cwd,
             contextWindow: options.contextWindow ?? appConfig.contextWindow,
             compactAtTokens: options.compactAtTokens,
+            maxToolContextTokens: options.maxToolContextTokens,
             keepRecentMessages: options.keepRecentMessages,
         });
         this.permissionGate = new PermissionGate(this.permissionMode, this.permissionResolver);
@@ -391,6 +396,8 @@ export class ChatSession {
         // assistant 消息 toolCalls 字段；[Tool transcript] 文本视图仍按原格式生成。
         const toolCallsById = new Map();
         const toolCallOrder = [];
+        const timeline = [];
+        let toolContext = [];
         try {
             if (this.context.planCompaction()) {
                 yield { type: "status", phase: "compacting" };
@@ -458,9 +465,10 @@ export class ChatSession {
             for (let attempt = 0; attempt < 2; attempt += 1) {
                 fullText = "";
                 safeAccumulated = "";
-                const toolContext = [];
+                toolContext = [];
                 toolCallsById.clear();
                 toolCallOrder.length = 0;
+                timeline.length = 0;
                 let lastReasoningProgressAt;
                 const attemptMessages = attempt === 0
                     ? modelMessages
@@ -470,7 +478,7 @@ export class ChatSession {
                     messages: attemptMessages,
                 };
                 let stream;
-                if (appConfig.streaming) {
+                if (this.streaming) {
                     const result = streamText(generationOptions);
                     stream = result.fullStream ?? textStreamToFullStream(result.textStream);
                 }
@@ -491,6 +499,11 @@ export class ChatSession {
                     }
                     else if (part.type === "text-delta") {
                         fullText += part.text;
+                        const previous = timeline[timeline.length - 1];
+                        if (previous?.type === "text")
+                            previous.text += part.text;
+                        else
+                            timeline.push({ type: "text", text: part.text });
                         // 隐私替换只在展示层：safeAccumulated 供事件消费者（终端/JSONL）使用，
                         // fullText 原文用于持久化上下文，避免替换结果回流污染上下文。
                         const safeText = applyPrivacy(part.text);
@@ -498,9 +511,11 @@ export class ChatSession {
                         yield { type: "text", text: safeText, accumulated: safeAccumulated };
                     }
                     else if (part.type === "tool-call") {
-                        toolContext.push(`tool_call ${part.toolName}: ${safeJson(part.input)}`);
-                        toolCallsById.set(part.toolCallId, { name: part.toolName, input: safeJson(part.input) });
+                        const input = safeJson(part.input);
+                        toolContext.push(`tool_call ${part.toolName}: ${input}`);
+                        toolCallsById.set(part.toolCallId, { id: part.toolCallId, name: part.toolName, input });
                         toolCallOrder.push(part.toolCallId);
+                        timeline.push({ type: "tool_use", id: part.toolCallId, name: part.toolName, input });
                         yield {
                             type: "tool_use",
                             id: part.toolCallId,
@@ -509,10 +524,12 @@ export class ChatSession {
                         };
                     }
                     else if (part.type === "tool-result") {
-                        toolContext.push(`tool_result ${part.toolName}: ${truncateToolContext(safeJson(part.output))}`);
+                        const output = truncateToolContext(safeJson(part.output));
+                        toolContext.push(`tool_result ${part.toolName}: ${output}`);
                         const call = toolCallsById.get(part.toolCallId);
                         if (call)
-                            call.output = truncateToolContext(safeJson(part.output));
+                            call.output = output;
+                        timeline.push({ type: "tool_result", tool_use_id: part.toolCallId, name: part.toolName, output });
                         yield {
                             type: "tool_result",
                             tool_use_id: part.toolCallId,
@@ -529,6 +546,7 @@ export class ChatSession {
                             call.output = message;
                             call.is_error = true;
                         }
+                        timeline.push({ type: "tool_result", tool_use_id: part.toolCallId, name: part.toolName, output: message, is_error: true });
                         yield {
                             type: "tool_result",
                             tool_use_id: part.toolCallId,
@@ -544,7 +562,7 @@ export class ChatSession {
                     }
                 }
                 if (hasMalformedToolProtocolText(fullText)) {
-                    console.warn(`[DeepCCC] malformed DSML tool output detected for ${this.context.sessionId} `
+                    console.warn(`[DeepCCC] malformed tool protocol text detected for ${this.context.sessionId} `
                         + `(attempt ${attempt + 1}/2, structuredToolCalls=${toolCallOrder.length})`);
                     rawLog?.writeLine(safeRawStreamJson({
                         type: "deepccc_tool_protocol_recovery",
@@ -557,8 +575,8 @@ export class ChatSession {
                         continue;
                     }
                     throw new Error(toolCallOrder.length > 0
-                        ? "工具调用协议异常：检测到混合的结构化与 DSML 文本调用，为避免重复执行工具，本轮已安全终止"
-                        : "工具调用协议异常：模型重试后仍输出了无效的 DSML 工具调用");
+                        ? "工具调用协议异常：检测到混合的结构化调用与伪造工具文本，为避免重复执行工具，本轮已安全终止"
+                        : "工具调用协议异常：模型重试后仍输出了无效或伪造的工具调用文本");
                 }
                 completed = true;
                 const collectedToolCalls = toolCallOrder
@@ -568,6 +586,7 @@ export class ChatSession {
                     fullText,
                     transcriptLines: toolContext,
                     toolCalls: collectedToolCalls,
+                    timeline,
                 }));
                 yield { type: "done", text: safeAccumulated };
                 return;
@@ -579,9 +598,22 @@ export class ChatSession {
             if (malformedProtocolOutput)
                 yield { type: "text_reset" };
             if (err.name === "AbortError" || signal?.aborted) {
-                // 被中断时，不保存不完整的助手消息
-                if (fullText && !malformedProtocolOutput) {
-                    this.context.appendMessage({ role: "assistant", content: `${fullText}\n[interrupted]` });
+                if ((fullText || toolCallOrder.length > 0) && !malformedProtocolOutput) {
+                    const collectedToolCalls = toolCallOrder
+                        .map((id) => toolCallsById.get(id))
+                        .filter((call) => call !== undefined);
+                    const interruptedTimeline = timeline.map((entry) => ({ ...entry }));
+                    const previous = interruptedTimeline[interruptedTimeline.length - 1];
+                    if (previous?.type === "text")
+                        previous.text += "\n[interrupted]";
+                    else
+                        interruptedTimeline.push({ type: "text", text: "[interrupted]" });
+                    this.context.appendMessage(buildPersistedAssistantMessage({
+                        fullText: `${fullText}\n[interrupted]`,
+                        transcriptLines: toolContext,
+                        toolCalls: collectedToolCalls,
+                        timeline: interruptedTimeline,
+                    }));
                 }
                 yield { type: "done", text: safeAccumulated };
                 return;