chatccc 0.2.258 → 0.2.259

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/agent-activity.js

@@ -67,6 +67,10 @@ export function updateAgentActivity(tracker, block, now = Date.now()) {
     if (tracker.activeTools.size > 0)
         return false;
     switch (block.type) {
+        case "agent_progress":
+            return setActivity(tracker, { kind: "thinking", startedAt: now });
+        case "text_reset":
+            return setActivity(tracker, { kind: "responding", startedAt: now });
         case "agent_status":
             return setActivity(tracker, {
                 kind: block.status === "compacting" ? "compacting" : "responding",

package/dist/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/src/response-stall.js

@@ -2,10 +2,10 @@
  * Tracks how long the displayed output character count has remained unchanged.
  * Leaving a monitored phase clears the window; returning starts a fresh one.
  */
-export function observeResponseProgress(previous, isMonitoredPhase, totalChars, now = Date.now()) {
+export function observeResponseProgress(previous, isMonitoredPhase, totalChars, now = Date.now(), heartbeat = false) {
     if (!isMonitoredPhase)
         return undefined;
-    if (previous?.totalChars === totalChars)
+    if (!heartbeat && previous?.totalChars === totalChars)
         return previous;
     return { totalChars, unchangedSince: now };
 }

package/dist/src/session.js

@@ -233,7 +233,7 @@ function formatAutoEndedReply(finalReply) {
  * 状态或资源保护，不能把它们消耗的时间算入回复停滞窗口。
  */
 function monitorsOutputProgress(kind) {
-    return kind === "responding";
+    return kind === "responding" || kind === "thinking";
 }
 function formatTerminalReply(status, finalReply, terminalError) {
     if (status === "auto_ended")
@@ -528,9 +528,9 @@ export function getAdapterForTool(tool, sessionId) {
             apiKey: config.ccc.DEEPSEEK_API_KEY,
             baseURL: config.ccc.DEEPSEEK_BASE_URL,
             model: effectiveModel || undefined,
-            effort: effectiveEffort || undefined,
             compactionTimeoutMs: config.ccc.compactionTimeoutMs,
             contextWindow: config.ccc.contextWindow,
+            ...(effectiveEffort ? { effort: effectiveEffort } : {}),
             // 留空（""）不传 → ChatSession 跟随 DeepCCC 内核配置（~/.deepccc/config.json 或 DEEPCCC_PROVIDER）
             ...(config.ccc.provider ? { provider: config.ccc.provider } : {}),
             ...(config.ccc.subModel ? { subModel: config.ccc.subModel } : {}),
@@ -761,6 +761,14 @@ export function accumulateBlockContent(block, state, toolCallMap) {
             // 覆盖而非追加：适配器已保证这是一段完整最终文本（如 Cursor 流末快照）
             state.finalCompleteText = block.text;
             break;
+        case "text_reset":
+            state.accumulatedContent = "";
+            state.finalText = "";
+            state.finalCompleteText = "";
+            state.chunkCount = 0;
+            break;
+        case "agent_progress":
+            break;
         case "compact_boundary": {
             const triggerLabel = block.trigger === "manual" ? "手动" : "自动"; // 手动 / 自动
             state.accumulatedContent +=
@@ -1238,7 +1246,15 @@ export async function runAgentSession(sessionId, userText, platform, _chatId, ms
                 }
             }
             let activityChanged = false;
+            let progressHeartbeat = false;
+            let outputReset = false;
             for (const block of unifiedMsg.blocks) {
+                if (block.type === "agent_progress")
+                    progressHeartbeat = true;
+                if (block.type === "text_reset") {
+                    outputReset = true;
+                    toolCallMap.clear();
+                }
                 if (updateAgentActivity(activityTracker, block))
                     activityChanged = true;
                 accumulateBlockContent(block, state, toolCallMap);
@@ -1263,11 +1279,11 @@ export async function runAgentSession(sessionId, userText, platform, _chatId, ms
                 prompt.responseProgress = observeResponseProgress(
                 // starting → responding 本身是一次有效进展，即便首个文本块仍为空也应
                 // 重新计时；其它活动阶段会清空观察窗口。
-                activityChanged ? undefined : prompt.responseProgress, monitorsOutputProgress(activityTracker.activity.kind), totalChars, Date.now());
+                activityChanged ? undefined : prompt.responseProgress, monitorsOutputProgress(activityTracker.activity.kind), totalChars, Date.now(), progressHeartbeat);
             }
             // 定时写入文件
             const now2 = Date.now();
-            if (activityChanged || now2 - lastFileWrite >= FILE_WRITE_INTERVAL_MS) {
+            if (activityChanged || outputReset || now2 - lastFileWrite >= FILE_WRITE_INTERVAL_MS) {
                 lastFileWrite = now2;
                 await writeStreamState({
                     sessionId,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "chatccc",
-  "version": "0.2.258",
+  "version": "0.2.259",
   "description": "Feishu bot bridge for Claude Code",
   "license": "Apache-2.0",
   "type": "module",