chatccc 0.2.258 → 0.2.260

package/README.md

@@ -1,8 +1,8 @@
 # ChatCCC
 
-**用飞书或微信聊天控制 Claude Code / Cursor / Codex / CCC Agent。**
+**用飞书或微信聊天控制 Claude Code / Cursor / Codex / CCC Agent / DeepSeek Harness。**
 
-ChatCCC 把本地 AI 编程工具接入即时通讯软件。你可以在手机上发消息，让 Claude Code、Cursor Agent、Codex 或内置 CCC Agent 继续写代码、查问题、跑命令；不用一直守在电脑前。
+ChatCCC 把本地 AI 编程工具接入即时通讯软件。你可以在手机上发消息，让 Claude Code、Cursor Agent、Codex、内置 CCC Agent 或 DeepSeek Harness 继续写代码、查问题、跑命令；不用一直守在电脑前。
 
 飞书是推荐入口：直接私聊机器人即可持续使用同一个专属会话，需要并行任务时再用 `/new` 创建独立会话群；卡片能流式更新，体验完整。微信 iLink 更适合快速试用或临时使用：扫码即可接入，但只能走私聊文本模式。
 
@@ -21,7 +21,7 @@ ChatCCC 把本地 AI 编程工具接入即时通讯软件。你可以在手机
 - **手机上也能用 AI 编程工具**：在飞书或微信发消息，就像在终端给 Agent 下指令。
 - **飞书体验更完整**：私聊可持续对话，`/new` 创建的一群一会话支持多任务并行，CardKit 卡片可流式更新。
 - **微信接入更轻**：不用创建飞书应用，启动后扫码即可在微信私聊里使用。
-- **多 Agent 切换**：`/new` 使用默认 Agent，也可以用 `/new claude`、`/new cursor`、`/new codex`、`/new ccc` 指定工具。
+- **多 Agent 切换**：`/new` 使用默认 Agent，也可以用 `/new claude`、`/new cursor`、`/new codex`、`/new ccc`、`/new dsh` 指定工具。
 - **群里能跑 git**：`/git status`、`/git pull`、`/git log` 会在当前会话工作目录执行，并把输出发回聊天窗口。
 
 ## 飞书和微信的差异
@@ -216,7 +216,7 @@ chatccc
 
 ### 3. AI 工具配置
 
-Claude Code、Cursor 和 Codex 需要对应的本地工具；CCC Agent 内置于 ChatCCC，开箱即用，**模型接入不限于 DeepSeek**——它支持 OpenAI-compatible 和 Anthropic Messages 两种协议（详见下文 CCC Agent）。
+Claude Code、Cursor 和 Codex 需要对应的本地工具；CCC Agent 内置于 ChatCCC，开箱即用，**模型接入不限于 DeepSeek**——它支持 OpenAI-compatible 和 Anthropic Messages 两种协议（详见下文 CCC Agent）。DeepSeek Harness（DSH）采用按需安装，不计入 ChatCCC 主包生产依赖。
 
 #### CCC Agent
 
@@ -242,9 +242,15 @@ ChatCCC 会把 `ccc.DEEPSEEK_API_KEY`、`ccc.DEEPSEEK_BASE_URL`、模型和 effo
 
 #### Claude Code
 
-ChatCCC 通过 Anthropic Claude Agent SDK 调用 Claude Code 能力。SDK 引擎（含 Claude Code CLI 原生二进制，约 220MB）**按需下载**：在首次配置向导或 Web 管理页的「Claude Code」卡片点「安装 Claude Code SDK」（开关从关闭切到打开时也会弹出安装确认），页面会显示下载进度条，完成后即可使用。**只有启用 Claude Code 的用户才需要下载**，不使用 Claude Code 的安装不包含该引擎，chatccc 主包体积保持精简。
+ChatCCC 通过 Anthropic Claude Agent SDK 调用 Claude Code 能力。SDK 引擎（含 Claude Code CLI 原生二进制，约 220MB）**按需下载**：在首次配置向导或 Web 管理页打开 Claude Code 开关，或点击一次安装按钮，页面会连续显示环境检查、下载、校验、Runtime 验证、原子切换和清理进度，不需要逐步确认。**只有启用 Claude Code 的用户才需要下载**，不使用 Claude Code 的安装不包含该引擎，chatccc 主包体积保持精简。
 
-SDK 始终使用其内置的 Claude Code CLI（档位 b），不依赖用户自行安装的 `claude` 命令。本机完成 Claude Code 登录后即可使用（SDK 复用 `~/.claude` 登录态）；同时支持官方和第三方 Anthropic 兼容 API：使用官方服务无需额外配置，使用第三方 API 则填写 `claude.apiKey` 和 `claude.baseUrl`。`claude.model`、`claude.subagentModel`、`claude.effort`、`claude.apiKey`、`claude.baseUrl` 均为选填；`claude.maxTurn` 控制每次对话的最大轮数（默认 0，即无限制）。填写后会把对应配置传给 Claude Agent SDK；留空则以 `~/.claude/settings.json` 为准。
+SDK 始终使用其内置的 Claude Code CLI（档位 b），不依赖用户自行安装的 `claude` 命令。本机完成 Claude Code 登录后即可使用（SDK 复用 `~/.claude` 登录态）；同时支持官方和第三方 Anthropic 兼容 API：使用官方服务无需额外配置，使用第三方 API 则填写 `claude.apiKey` 和 `claude.baseUrl`。`claude.model`、`claude.subagentModel`、`claude.effort`、`claude.apiKey`、`claude.baseUrl` 均为选填；`claude.maxTurn` 控制每次对话的最大轮数（默认 0，即无限制）。填写后会把对应配置传给 Claude Agent SDK；留空则以 `~/.claude/settings.json` 为准。
+
+#### DeepSeek Harness
+
+DeepSeek Harness 是可选 Agent。在首次配置向导或 Web 管理页打开 DSH 开关，ChatCCC 会一次点击完成环境检查、临时目录准备、精确版本下载、包校验、Runtime 握手、原子切换和旧版本清理，并在页面逐步显示进度。安装失败时不会替换当前可用版本；刷新页面后仍可恢复安装进度。当前固定安装 `0.1.0-rc.6`，要求 Node.js >= 22.19.0。
+
+DSH 引擎安装在 `~/.chatccc/engines/dsh/`，不加入 ChatCCC 的 `dependencies`。配置 `dsh.apiKey`、`dsh.baseUrl`、`dsh.model`、`dsh.provider` 和 `dsh.maxTokens` 后，可设为默认 Agent 或使用 `/new dsh` 新建会话。安装验证只做本地 JSON-RPC Runtime 握手，不会调用付费模型。
 
 #### Cursor Agent CLI
 
@@ -374,13 +380,15 @@ Codex 的默认模型和推理强度可继续由 `~/.codex/config.toml` 管理
 | `ccc.model` | CCC Agent 默认模型 |
 | `ccc.subModel` | CCC Agent 子模型（选填）：用于内部轻量环节（压缩摘要生成、task 子代理任务）；留空跟随主模型 |
 | `ccc.compactionTimeoutMs` | CCC Agent 上下文压缩单轮超时（毫秒），默认 300000（5 分钟）；压缩超时会让整轮对话失败，建议保持默认或调大 |
-| `ccc.contextWindow` | CCC Agent 模型上下文窗口（token），默认 1048576（1M，DeepSeek V4 Pro/Flash 原生规格）；压缩阈值自动 = 窗口 × 80%；超过模型/服务端实际上限会被 API 拒绝，可在 Web UI 下拉选择或自定义（单位 k） |
+| `ccc.contextWindow` | CCC Agent 模型上下文窗口（token），默认 1048576（1M，DeepSeek V4 Pro/Flash 原生规格）；压缩阈值自动 = 窗口 × 80%；超过模型/服务端实际上限会被 API 拒绝，可在 Web UI 下拉选择或自定义（单位 k） |
+| `dsh.apiKey` / `dsh.baseUrl` | DeepSeek Harness 的 API Key 和官方 DeepSeek 服务地址 |
+| `dsh.model` / `dsh.provider` / `dsh.maxTokens` | DSH 默认模型、Runtime provider 和最大 token 数 |
 
 > **权限控制**：普通消息以 `bypassPermissions` 模式运行，跳过 Agent 操作确认。使用 `/plan` 或 `/ask` 前缀时，ChatCCC 自动切换为只读模式：Claude SDK 仅放行 Read + stop-stuck-loop 网络请求，Codex 使用 `--sandbox read-only`，Cursor 使用 `--mode plan/ask`。请只在可信环境中使用。
 
 ### 5. 开始使用
 
-**飞书：** 找到机器人后直接发送普通消息，即可在当前私聊中创建并持续使用专属 AI 会话；私聊工作目录固定为运行 ChatCCC 的系统账号用户目录。默认 Agent 发生变化后，下一条私聊普通消息会触发切换并创建新的空会话；若旧 Agent 正在生成，该消息会先排队，待当前回复完成后再切换。命令不会触发自动切换。需要独立任务时，发送 `/new`、`/new claude`、`/new cursor`、`/new codex` 或 `/new ccc`，机器人会另外创建会话群。
+**飞书：** 找到机器人后直接发送普通消息，即可在当前私聊中创建并持续使用专属 AI 会话；私聊工作目录固定为运行 ChatCCC 的系统账号用户目录。默认 Agent 发生变化后，下一条私聊普通消息会触发切换并创建新的空会话；若旧 Agent 正在生成，该消息会先排队，待当前回复完成后再切换。命令不会触发自动切换。需要独立任务时，发送 `/new`、`/new claude`、`/new cursor`、`/new codex`、`/new ccc` 或 `/new dsh`，机器人会另外创建会话群。
 
 **微信：** 扫码登录后，在机器人私聊里发送 `/new` 或指定 Agent 的 `/new ...` 命令即可开始。功能与飞书基本一致，但展示为纯文本。
 
@@ -396,7 +404,8 @@ Codex 的默认模型和推理强度可继续由 `~/.codex/config.toml` 管理
 | `/new claude` | 创建 Claude Code 会话；飞书中会创建新群 |
 | `/new cursor` | 创建 Cursor 会话；飞书中会创建新群 |
 | `/new codex` | 创建 Codex 会话；飞书中会创建新群 |
-| `/new ccc` | 创建内置 CCC Agent 会话；飞书中会创建新群 |
+| `/new ccc` | 创建内置 CCC Agent 会话；飞书中会创建新群 |
+| `/new dsh` | 创建 DeepSeek Harness 会话；飞书中会创建新群 |
 | `/forget` | 在当前聊天原地重置会话（忘掉上下文）；群聊保留工作目录，飞书私聊固定使用系统用户目录 |
 | `/model` | 查看或切换当前会话的模型 |
 | `/fast` | 查看当前 Codex 会话的 Fast 模式；使用 `/fast on` 或 `/fast off` 切换 |
@@ -406,7 +415,7 @@ Codex 的默认模型和推理强度可继续由 `~/.codex/config.toml` 管理
 | `/cd` | 查看或设置后续新建会话的默认工作目录，不改变当前会话；飞书私聊自身始终使用系统用户目录 |
 | `/sessions` | 查看所有会话状态 |
 | `/session <数字>` | 将当前群聊切换到 `/sessions` 列表中的指定会话；飞书私聊不支持切换 |
-| `/usage` | 查看当前会话对应 Agent 的用量；Codex 显示 5h/7天窗口，Cursor 显示当前周期用量，CCC Agent 仅在官方 DeepSeek 端点时显示账户余额（其他兼容端点自动跳过） |
+| `/usage` | 查看当前会话对应 Agent 的用量；Codex 显示 5h/7天窗口，Cursor 显示当前周期用量，CCC Agent 和 DSH 仅在官方 DeepSeek 端点时显示账户余额（其他兼容端点自动跳过） |
 | `/git <子命令>` | 在当前会话工作目录执行 `git ...` 并回传输出 |
 | `/abd<内容>` | 去掉 `/abd` 前缀后把内容发给 Agent，并在消息末尾追加第一性原理需求澄清提示 |
 | `/plan <内容>` | 只读计划模式：仅允许读文件和 stop-stuck-loop 请求，不执行任何写操作 |
@@ -425,4 +434,4 @@ Codex 的默认模型和推理强度可继续由 `~/.codex/config.toml` 管理
 
 ## 技术栈
 
-TypeScript（发布前编译为 JavaScript，tsx 仅用于开发）/ Node.js >= 20 / AI SDK / Anthropic Claude Agent SDK（按需下载，仅启用 Claude Code 时安装）/ Cursor Agent CLI / Codex CLI / 飞书 WebSocket API / CardKit / 微信 iLink
+TypeScript（发布前编译为 JavaScript，tsx 仅用于开发）/ Node.js >= 20 / AI SDK / Anthropic Claude Agent SDK（按需下载）/ DeepSeek Harness SDK + JSON-RPC Runtime（按需下载，要求 Node.js >= 22.19.0）/ Cursor Agent CLI / Codex CLI / 飞书 WebSocket API / CardKit / 微信 iLink

package/config.sample.json

@@ -37,14 +37,20 @@
       "retentionDays": 7,
       "keepCompleted": false
     },
-    "ccc": {
-      "enabled": false,
-      "maxBytesPerTurn": 52428800,
-      "retentionDays": 7,
-      "keepCompleted": false
+    "ccc": {
+      "enabled": false,
+      "maxBytesPerTurn": 52428800,
+      "retentionDays": 7,
+      "keepCompleted": false
+    },
+    "dsh": {
+      "enabled": false,
+      "maxBytesPerTurn": 52428800,
+      "retentionDays": 7,
+      "keepCompleted": false
     }
   },
-  "ccc": {
+  "ccc": {
     "enabled": false,
     "defaultAgent": false,
     "DEEPSEEK_API_KEY": "",
@@ -55,8 +61,17 @@
     "effort": "",
     "provider": "",
     "compactionTimeoutMs": 300000,
-    "contextWindow": 1048576
-  },
+    "contextWindow": 1048576
+  },
+  "dsh": {
+    "enabled": false,
+    "defaultAgent": false,
+    "apiKey": "",
+    "baseUrl": "https://api.deepseek.com/v1",
+    "model": "deepseek-v4-flash",
+    "provider": "deepseek-official",
+    "maxTokens": 49152
+  },
   "claude": {
     "enabled": false,
     "defaultAgent": true,

package/deepccc-agent/package.json

@@ -1,6 +1,6 @@
 {
   "name": "deepccc",
-  "version": "0.1.26",
+  "version": "0.1.27",
   "description": "A lightweight coding agent with OpenAI-compatible and Anthropic Messages API support.",
   "license": "Apache-2.0",
   "keywords": [

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

@@ -2,6 +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";
 export const DEFAULT_BUILTIN_CONTEXT_DIR = join(homedir(), ".deepccc", "sessions");
 /** 默认模型上下文窗口：1M（DeepSeek V4 Pro/Flash 原生规格）。 */
 export const DEFAULT_CONTEXT_WINDOW_TOKENS = 1_048_576;
@@ -290,14 +291,19 @@ export class BuiltinContextManager {
                 ].join("\n"),
             });
         }
-        messages.push(...this.state.messages);
+        // 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());
         return messages;
     }
     planCompaction() {
-        const estimated = estimateBuiltinContextTokens(this.state.summary, this.state.messages);
+        // The compaction model is still a model input: exclude quarantined protocol
+        // 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)
             return null;
-        const messages = this.state.messages;
         if (messages.length <= 1)
             return null;
         const earliestAllowed = Math.max(0, messages.length - this.keepRecentMessages);
@@ -340,6 +346,9 @@ export class BuiltinContextManager {
         writeFileSync(tmp, content, "utf8");
         renameSync(tmp, this.contextFilePath);
     }
+    modelSafeMessages() {
+        return this.state.messages.filter((message) => message.role !== "assistant" || !hasMalformedToolProtocolText(message.content));
+    }
     load() {
         if (!this.persist || !existsSync(this.contextFilePath))
             return emptyState(this.sessionId, this.cwd);

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

@@ -15,6 +15,7 @@ import { createRawStreamLog, } from "./raw-stream-log.js";
 import { buildPersistedAssistantMessage, buildSummaryPrompt, BuiltinContextManager, defaultBuiltinSessionId, } from "./context.js";
 import { createBuiltinFileTools, MAX_TASK_OUTPUT_CHARS } from "./file-tools.js";
 import { PermissionGate } from "./permissions.js";
+import { hasMalformedToolProtocolText, TOOL_PROTOCOL_RECOVERY_PROMPT, } from "./tool-protocol.js";
 import { buildDefaultSkillDirs, buildSkillsIndexPrompt, scanSkillsDirs, } from "./skills.js";
 import { applyPrivacy, applyPrivacyToJson } from "./privacy.js";
 // ---------------------------------------------------------------------------
@@ -400,7 +401,6 @@ export class ChatSession {
             catch (err) {
                 console.error(`[DeepCCC raw stream log] create failed: ${errorMessage(err)}`);
             }
-            const toolContext = [];
             const maxSteps = this.maxSteps;
             // 每次对话前重新扫描技能索引（并行 + mtime 缓存，开销极小）：
             // 新技能/修改的技能在下一次对话自动生效（热加载）。
@@ -423,10 +423,9 @@ export class ChatSession {
                     ? { deepseek: { reasoningEffort: this.effort } }
                     : { anthropic: { effort: this.effort } };
             }
-            const generationOptions = {
+            const baseGenerationOptions = {
                 model: this.model,
                 system,
-                messages: modelMessages,
                 tools: createBuiltinFileTools(this.cwd, {
                     permissionGate: this.permissionGate,
                     runTask: this.runTask,
@@ -435,88 +434,132 @@ export class ChatSession {
                 abortSignal: signal,
                 ...(effortProviderOptions ? { providerOptions: effortProviderOptions } : {}),
             };
-            let stream;
-            if (appConfig.streaming) {
-                const result = streamText(generationOptions);
-                stream = result.fullStream ?? textStreamToFullStream(result.textStream);
-            }
-            else {
-                const result = await generateText(generationOptions);
-                stream = generateResultToFullStream(result);
-            }
-            for await (const part of stream) {
-                rawLog?.writeLine(safeRawStreamJson(part));
-                if (part.type === "text-delta") {
-                    fullText += part.text;
-                    // 隐私替换只在展示层：safeAccumulated 供事件消费者（终端/JSONL）使用，
-                    // fullText 原文用于持久化上下文，避免替换结果回流污染上下文。
-                    const safeText = applyPrivacy(part.text);
-                    safeAccumulated += safeText;
-                    yield { type: "text", text: safeText, accumulated: safeAccumulated };
+            for (let attempt = 0; attempt < 2; attempt += 1) {
+                fullText = "";
+                safeAccumulated = "";
+                const toolContext = [];
+                toolCallsById.clear();
+                toolCallOrder.length = 0;
+                let lastReasoningProgressAt;
+                const attemptMessages = attempt === 0
+                    ? modelMessages
+                    : [...modelMessages, { role: "user", content: TOOL_PROTOCOL_RECOVERY_PROMPT }];
+                const generationOptions = {
+                    ...baseGenerationOptions,
+                    messages: attemptMessages,
+                };
+                let stream;
+                if (appConfig.streaming) {
+                    const result = streamText(generationOptions);
+                    stream = result.fullStream ?? textStreamToFullStream(result.textStream);
                 }
-                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) });
-                    toolCallOrder.push(part.toolCallId);
-                    yield {
-                        type: "tool_use",
-                        id: part.toolCallId,
-                        name: part.toolName,
-                        input: applyPrivacyToJson(part.input),
-                    };
+                else {
+                    const result = await generateText(generationOptions);
+                    stream = generateResultToFullStream(result);
                 }
-                else if (part.type === "tool-result") {
-                    toolContext.push(`tool_result ${part.toolName}: ${truncateToolContext(safeJson(part.output))}`);
-                    const call = toolCallsById.get(part.toolCallId);
-                    if (call) {
-                        call.output = truncateToolContext(safeJson(part.output));
+                for await (const part of stream) {
+                    rawLog?.writeLine(safeRawStreamJson(part));
+                    if (part.type === "reasoning-start" || part.type === "reasoning-delta") {
+                        // Reasoning content remains private. A throttled heartbeat is enough
+                        // for ChatCCC to distinguish active inference from a stalled stream.
+                        const now = Date.now();
+                        if (lastReasoningProgressAt === undefined || now - lastReasoningProgressAt >= 1_000) {
+                            lastReasoningProgressAt = now;
+                            yield { type: "progress", phase: "reasoning" };
+                        }
                     }
-                    yield {
-                        type: "tool_result",
-                        tool_use_id: part.toolCallId,
-                        name: part.toolName,
-                        content: applyPrivacyToJson(part.output),
-                        is_error: false,
-                    };
-                }
-                else if (part.type === "tool-error") {
-                    const message = errorMessage(part.error);
-                    toolContext.push(`tool_error ${part.toolName}: ${message}`);
-                    const call = toolCallsById.get(part.toolCallId);
-                    if (call) {
-                        call.output = message;
-                        call.is_error = true;
+                    else if (part.type === "text-delta") {
+                        fullText += part.text;
+                        // 隐私替换只在展示层：safeAccumulated 供事件消费者（终端/JSONL）使用，
+                        // fullText 原文用于持久化上下文，避免替换结果回流污染上下文。
+                        const safeText = applyPrivacy(part.text);
+                        safeAccumulated += safeText;
+                        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) });
+                        toolCallOrder.push(part.toolCallId);
+                        yield {
+                            type: "tool_use",
+                            id: part.toolCallId,
+                            name: part.toolName,
+                            input: applyPrivacyToJson(part.input),
+                        };
+                    }
+                    else if (part.type === "tool-result") {
+                        toolContext.push(`tool_result ${part.toolName}: ${truncateToolContext(safeJson(part.output))}`);
+                        const call = toolCallsById.get(part.toolCallId);
+                        if (call)
+                            call.output = truncateToolContext(safeJson(part.output));
+                        yield {
+                            type: "tool_result",
+                            tool_use_id: part.toolCallId,
+                            name: part.toolName,
+                            content: applyPrivacyToJson(part.output),
+                            is_error: false,
+                        };
+                    }
+                    else if (part.type === "tool-error") {
+                        const message = errorMessage(part.error);
+                        toolContext.push(`tool_error ${part.toolName}: ${message}`);
+                        const call = toolCallsById.get(part.toolCallId);
+                        if (call) {
+                            call.output = message;
+                            call.is_error = true;
+                        }
+                        yield {
+                            type: "tool_result",
+                            tool_use_id: part.toolCallId,
+                            name: part.toolName,
+                            content: applyPrivacy(message),
+                            is_error: true,
+                        };
+                    }
+                    else if (part.type === "error") {
+                        const message = errorMessage(part.error);
+                        yield { type: "error", message: applyPrivacy(message) };
+                        throw new Error(message);
                     }
-                    yield {
-                        type: "tool_result",
-                        tool_use_id: part.toolCallId,
-                        name: part.toolName,
-                        content: applyPrivacy(message),
-                        is_error: true,
-                    };
                 }
-                else if (part.type === "error") {
-                    const message = errorMessage(part.error);
-                    yield { type: "error", message: applyPrivacy(message) };
-                    throw new Error(message);
+                if (hasMalformedToolProtocolText(fullText)) {
+                    console.warn(`[DeepCCC] malformed DSML tool output detected for ${this.context.sessionId} `
+                        + `(attempt ${attempt + 1}/2, structuredToolCalls=${toolCallOrder.length})`);
+                    rawLog?.writeLine(safeRawStreamJson({
+                        type: "deepccc_tool_protocol_recovery",
+                        attempt: attempt + 1,
+                        structuredToolCalls: toolCallOrder.length,
+                    }));
+                    yield { type: "text_reset" };
+                    if (attempt === 0 && toolCallOrder.length === 0) {
+                        yield { type: "status", phase: "generating" };
+                        continue;
+                    }
+                    throw new Error(toolCallOrder.length > 0
+                        ? "工具调用协议异常：检测到混合的结构化与 DSML 文本调用，为避免重复执行工具，本轮已安全终止"
+                        : "工具调用协议异常：模型重试后仍输出了无效的 DSML 工具调用");
                 }
+                completed = true;
+                const collectedToolCalls = toolCallOrder
+                    .map((id) => toolCallsById.get(id))
+                    .filter((call) => call !== undefined);
+                this.context.appendMessage(buildPersistedAssistantMessage({
+                    fullText,
+                    transcriptLines: toolContext,
+                    toolCalls: collectedToolCalls,
+                }));
+                yield { type: "done", text: safeAccumulated };
+                return;
             }
-            completed = true;
-            const collectedToolCalls = toolCallOrder
-                .map((id) => toolCallsById.get(id))
-                .filter((call) => call !== undefined);
-            this.context.appendMessage(buildPersistedAssistantMessage({
-                fullText,
-                transcriptLines: toolContext,
-                toolCalls: collectedToolCalls,
-            }));
-            yield { type: "done", text: safeAccumulated };
         }
         catch (err) {
             const message = err instanceof Error ? err.message : String(err);
+            const malformedProtocolOutput = hasMalformedToolProtocolText(fullText);
+            if (malformedProtocolOutput)
+                yield { type: "text_reset" };
             if (err.name === "AbortError" || signal?.aborted) {
                 // 被中断时，不保存不完整的助手消息
-                if (fullText) {
+                if (fullText && !malformedProtocolOutput) {
                     this.context.appendMessage({ role: "assistant", content: `${fullText}\n[interrupted]` });
                 }
                 yield { type: "done", text: safeAccumulated };

package/dist/deepccc-agent/src/progress/reducer.js

@@ -57,6 +57,10 @@ export function reduceProgress(prev, event) {
         case "text":
             // accumulated 是全文累积，直接全量替换，天然幂等
             return withProgressView(prev, { text: event.accumulated });
+        case "progress":
+            return withProgressView(prev, { headerTitle: "思考中..." });
+        case "text_reset":
+            return withProgressView(prev, { text: "", tools: [] });
         case "tool_use": {
             const tool = {
                 id: event.id ?? `tool-${prev.tools.length + 1}`,

package/dist/deepccc-agent/src/tool-protocol.js

@@ -0,0 +1,17 @@
+/**
+ * Detects provider output that leaked DeepSeek's internal DSML tool-call syntax
+ * into normal assistant text. A trailing closing tag is intentionally required:
+ * mentioning DSML in prose or a code sample must not trigger recovery.
+ */
+const MALFORMED_DSML_TRAILER = /<\/[|｜]{2}DSML[|｜]{2}(?:parameter|invoke)>\s*$/iu;
+const RENDERED_TOOL_CALL = /\[调用\s+[A-Za-z_][\w.-]*\]/u;
+const DSML_INVOKE_TAG = /<[|｜]{2}DSML[|｜]{2}invoke\b/iu;
+export function hasMalformedToolProtocolText(text) {
+    return MALFORMED_DSML_TRAILER.test(text)
+        && (RENDERED_TOOL_CALL.test(text) || DSML_INVOKE_TAG.test(text));
+}
+export const TOOL_PROTOCOL_RECOVERY_PROMPT = [
+    "[系统恢复提示] 上一次响应泄漏了内部工具调用协议，因此已被丢弃。",
+    "请重新完成当前用户请求。需要调用工具时，只能使用 API 提供的结构化工具调用；不要把 DSML 或工具参数作为普通文本输出。",
+    "不要提及本恢复提示，也不要假装工具已经执行。",
+].join("\n");

package/dist/src/adapters/ccc-adapter.js

@@ -55,6 +55,18 @@ export function createCccAdapter(options = {}) {
                             }],
                     };
                 }
+                else if (event.type === "progress") {
+                    yield {
+                        type: "assistant",
+                        blocks: [{ type: "agent_progress", phase: event.phase }],
+                    };
+                }
+                else if (event.type === "text_reset") {
+                    yield {
+                        type: "assistant",
+                        blocks: [{ type: "text_reset" }],
+                    };
+                }
                 else if (event.type === "text") {
                     yield {
                         type: "assistant",

package/dist/src/adapters/claude-adapter.js

@@ -14,7 +14,7 @@ import { parseUserCommand } from "./adapter-interface.js";
 import { CHATCCC_PORT, config, PROJECT_ROOT, RAW_STREAM_LOGS_DIR } from "../config.js";
 import { defaultClaudeSessionMetaStore, } from "./claude-session-meta-store.js";
 import { createRawStreamLog, } from "./raw-stream-log.js";
-import { getClaudeSdkEntryPath } from "../claude-sdk-installer.js";
+import { engineManager } from "../engines/engine-specs.js";
 const CLAUDE_SPECIFIC_PROMPT_PATH = join(PROJECT_ROOT, "agent-prompts", "claude_specific.md");
 export function buildSdkEnv(subagentModel, apiKey, baseUrl) {
     const subagentModelTrim = (subagentModel ?? "").trim();
@@ -230,7 +230,8 @@ let sdkModulePromise = null;
  */
 export function loadClaudeSdkModule() {
     if (!sdkModulePromise) {
-        sdkModulePromise = import(__rewriteRelativeImportExtension(pathToFileURL(getClaudeSdkEntryPath()).href))
+        sdkModulePromise = engineManager.getEntryPath("claude")
+            .then((entryPath) => import(__rewriteRelativeImportExtension(pathToFileURL(entryPath).href)))
             .then((m) => m)
             .catch((err) => {
             sdkModulePromise = null;