deepccc 0.1.26 → 0.1.28

package/README.md

@@ -46,8 +46,10 @@ deepccc 的本地缓存优化实测命中率 **96.7%**，有效降低重复请
 ```bash
 export DEEPCCC_API_KEY="sk-..."
 export DEEPCCC_BASE_URL="https://api.deepseek.com/v1"
-export DEEPCCC_MODEL="deepseek-v4-pro"
-export DEEPCCC_STREAMING="true"
+export DEEPCCC_MODEL="deepseek-v4-pro"
+export DEEPCCC_EFFORT="high"
+export DEEPCCC_MAX_OUTPUT_TOKENS="32768"
+export DEEPCCC_STREAMING="true"
 ```
 
 Windows PowerShell：
@@ -56,8 +58,10 @@ Windows PowerShell：
 $env:DEEPCCC_API_KEY="sk-..."
 $env:DEEPCCC_PROVIDER="openai"
 $env:DEEPCCC_BASE_URL="https://api.deepseek.com/v1"
-$env:DEEPCCC_MODEL="deepseek-v4-pro"
-$env:DEEPCCC_STREAMING="true"
+$env:DEEPCCC_MODEL="deepseek-v4-pro"
+$env:DEEPCCC_EFFORT="high"
+$env:DEEPCCC_MAX_OUTPUT_TOKENS="32768"
+$env:DEEPCCC_STREAMING="true"
 ```
 
 也兼容这些 DeepSeek 别名：
@@ -75,10 +79,18 @@ $env:DEEPCCC_STREAMING="true"
   "apiKey": "sk-...",
   "baseURL": "https://api.deepseek.com/v1",
   "model": "deepseek-v4-pro",
-  "subModel": "",
-  "effort": "",
-  "streaming": true,
+  "subModel": "",
+  "effort": "",
+  "maxOutputTokens": null,
+  "streaming": true,
   "contextWindow": 1048576,
+  "git": {
+    "coAuthor": {
+      "enabled": true,
+      "name": "DeepCCC",
+      "email": "20184052+wzj998@users.noreply.github.com"
+    }
+  },
   "rawStreamLogs": {
     "enabled": true,
     "maxBytesPerTurn": 1048576,
@@ -88,14 +100,24 @@ $env:DEEPCCC_STREAMING="true"
 }
 ```
 
+`git.coAuthor.enabled` 默认开启。DeepCCC 通过 `run_command` 创建 Git 提交时会保留用户为
+主 Author，并追加 `Co-authored-by: DeepCCC <20184052+wzj998@users.noreply.github.com>`。
+可设为 `false` 或用 `DEEPCCC_GIT_COAUTHOR=false` 全局关闭。ChatCCC 的
+`ccc.gitCoAuthor` 是三态 override：`null`/缺失跟随这里，`true` 强制开启，`false` 强制关闭。
+
 `provider` 可选 `openai` 或 `anthropic`，默认 `openai`，也可以通过
 `DEEPCCC_PROVIDER` 或命令行 `--provider` 覆盖：
 
 - `openai` 使用 OpenAI-compatible Chat Completions 协议，兼容 DeepSeek、OpenAI、LiteLLM、vLLM 等服务。
-- `anthropic` 使用 Anthropic Messages 协议。配置中的 `baseURL` **完全按填写值使用，不自动补 `/v1`**，请填写到完整版本化地址，例如 DeepSeek 官方 Anthropic 端点为 `https://api.deepseek.com/anthropic/v1`（官方 Anthropic SDK 使用的 `https://api.deepseek.com/anthropic` 基址会拼接为 `.../anthropic/v1/messages`）。`effort` 是 OpenAI/DeepSeek 扩展参数，在 Anthropic 模式下不会发送。
+- `anthropic` 使用 Anthropic Messages 协议。配置中的 `baseURL` **完全按填写值使用，不自动补 `/v1`**，请填写到完整版本化地址，例如 DeepSeek 官方 Anthropic 端点为 `https://api.deepseek.com/anthropic/v1`（官方 Anthropic SDK 使用的 `https://api.deepseek.com/anthropic` 基址会拼接为 `.../anthropic/v1/messages`）。`effort` 在 OpenAI-compatible 模式映射为 `reasoning_effort`，在 Anthropic 模式映射为 `output_config.effort`；目标服务不支持时应留空。
 
-`streaming` 控制主对话是否使用流式请求，默认 `true`；也可以通过
-`DEEPCCC_STREAMING=true|false` 覆盖。关闭后，终端会在整条模型响应完成后一次性显示结果。
+`streaming` 控制主对话是否使用流式请求，默认 `true`；也可以通过
+`DEEPCCC_STREAMING=true|false` 覆盖。关闭后，终端会在整条模型响应完成后一次性显示结果。
+
+`maxOutputTokens` 限制主对话单次最大输出 token，默认不配置（`null`/缺失），此时不向
+Provider 发送 `max_tokens`，使用模型服务端默认值。可通过 `DEEPCCC_MAX_OUTPUT_TOKENS`
+或命令行 `--max-output-tokens` 覆盖；只接受正整数。该限制会同时覆盖模型思考内容、
+工具参数和最终回答，设置过小可能导致工具调用或长回复被截断。
 
 `contextWindow` 是模型上下文窗口（token），默认 `1048576`（1M，DeepSeek V4 Pro/Flash
 原生规格）；上下文压缩阈值自动 = `contextWindow × 0.8`（超出即把较早消息压缩为摘要）。
@@ -166,7 +188,15 @@ deepccc --max-steps 20
 deepccc --effort high
 ```
 
-可选值：`none` / `minimal` / `low` / `medium` / `high` / `xhigh` / `max`（留空则不传 `reasoning_effort` 请求字段）。
+可选值：`none` / `minimal` / `low` / `medium` / `high` / `xhigh` / `max`（留空则不传 `reasoning_effort` 请求字段）。
+
+限制主对话最大输出 token：
+
+```bash
+deepccc --max-output-tokens 8192
+```
+
+不设置时使用 Provider 默认值。
 
 ## 权限机制
 

package/dist/cli.js

@@ -65,6 +65,10 @@ function parseArgs(argv = process.argv.slice(2)) {
             config.effort = next;
             i++;
         }
+        else if (arg === "--max-output-tokens" && next !== undefined) {
+            config.maxOutputTokens = parsePositiveIntegerOption("--max-output-tokens", next);
+            i++;
+        }
         else if (arg === "--base-url" && next !== undefined) {
             config.baseURL = next;
             i++;
@@ -131,6 +135,7 @@ function printHelp(appConfig) {
         `  --model <name>       Model name (current default ${appConfig.model})`,
         `  --sub-model <name>   Sub-model for lightweight steps (compaction/task; empty = follow main model)`,
         `  --effort <level>     Reasoning effort: none/minimal/low/medium/high/xhigh/max (overrides config.effort)`,
+        `  --max-output-tokens <n>  Maximum output tokens (unset = Provider default)`,
         `  --base-url <url>     Provider API base URL (current default ${appConfig.baseURL})`,
         "  --api-key <key>      API key",
         "  --cwd <path>         Working directory",

package/dist/config.d.ts

@@ -12,6 +12,8 @@ export interface DeepCccConfig {
     subModel: string;
     /** Reasoning effort（none/minimal/low/medium/high/xhigh/max），留空不传 reasoning_effort */
     effort: string;
+    /** 主对话最大输出 token；未配置时不传，使用 Provider 默认值。 */
+    maxOutputTokens?: number;
     /** 主对话是否使用流式请求；默认开启 */
     streaming: boolean;
     /**
@@ -19,6 +21,13 @@ export interface DeepCccConfig {
      * 上下文压缩阈值自动 = contextWindow × 0.8；超过模型/服务端实际上限会被 API 拒绝。
      */
     contextWindow: number;
+    git: {
+        coAuthor: {
+            enabled: boolean;
+            name: string;
+            email: string;
+        };
+    };
     rawStreamLogs: {
         enabled: boolean;
         maxBytesPerTurn: number;

package/dist/config.js

@@ -16,6 +16,13 @@ export const DEFAULT_CONFIG = {
     effort: "",
     streaming: true,
     contextWindow: 1_048_576,
+    git: {
+        coAuthor: {
+            enabled: true,
+            name: "DeepCCC",
+            email: "20184052+wzj998@users.noreply.github.com",
+        },
+    },
     rawStreamLogs: {
         // 默认开启：压缩后可通过 session_search（include_raw_logs=true）找回原文。
         // 如需关闭，在 ~/.deepccc/config.json 中设置 rawStreamLogs.enabled=false。
@@ -49,6 +56,12 @@ function numberEnv(name) {
     const value = Number(env(name));
     return Number.isFinite(value) && value >= 0 ? value : undefined;
 }
+function optionalPositiveInteger(value) {
+    if (value === undefined || value === null || value === "")
+        return undefined;
+    const parsed = Number(value);
+    return Number.isInteger(parsed) && parsed > 0 ? parsed : undefined;
+}
 export function normalizeDeepCccProvider(value) {
     if (value === undefined || value === null || String(value).trim() === "")
         return "openai";
@@ -62,6 +75,8 @@ function loadConfig() {
     const rawLogs = file.rawStreamLogs && typeof file.rawStreamLogs === "object"
         ? file.rawStreamLogs
         : {};
+    const git = file.git && typeof file.git === "object" ? file.git : {};
+    const coAuthor = git.coAuthor && typeof git.coAuthor === "object" ? git.coAuthor : {};
     return {
         provider: normalizeDeepCccProvider(env("DEEPCCC_PROVIDER") ?? file.provider ?? DEFAULT_CONFIG.provider),
         apiKey: env("DEEPCCC_API_KEY") ?? env("DEEPSEEK_API_KEY") ?? file.apiKey ?? DEFAULT_CONFIG.apiKey,
@@ -69,8 +84,17 @@ function loadConfig() {
         model: env("DEEPCCC_MODEL") ?? env("DEEPSEEK_MODEL") ?? file.model ?? DEFAULT_CONFIG.model,
         subModel: env("DEEPCCC_SUB_MODEL") ?? file.subModel ?? DEFAULT_CONFIG.subModel,
         effort: env("DEEPCCC_EFFORT") ?? env("DEEPSEEK_EFFORT") ?? file.effort ?? DEFAULT_CONFIG.effort,
+        maxOutputTokens: optionalPositiveInteger(env("DEEPCCC_MAX_OUTPUT_TOKENS"))
+            ?? optionalPositiveInteger(file.maxOutputTokens),
         streaming: boolEnv("DEEPCCC_STREAMING") ?? file.streaming ?? DEFAULT_CONFIG.streaming,
         contextWindow: numberEnv("DEEPCCC_CONTEXT_WINDOW") ?? file.contextWindow ?? DEFAULT_CONFIG.contextWindow,
+        git: {
+            coAuthor: {
+                enabled: boolEnv("DEEPCCC_GIT_COAUTHOR") ?? coAuthor.enabled ?? DEFAULT_CONFIG.git.coAuthor.enabled,
+                name: coAuthor.name?.trim() || DEFAULT_CONFIG.git.coAuthor.name,
+                email: coAuthor.email?.trim() || DEFAULT_CONFIG.git.coAuthor.email,
+            },
+        },
         rawStreamLogs: {
             enabled: boolEnv("DEEPCCC_RAW_STREAM_LOGS") ?? rawLogs.enabled ?? DEFAULT_CONFIG.rawStreamLogs.enabled,
             maxBytesPerTurn: numberEnv("DEEPCCC_RAW_STREAM_MAX_BYTES") ?? rawLogs.maxBytesPerTurn ?? DEFAULT_CONFIG.rawStreamLogs.maxBytesPerTurn,

package/dist/context.d.ts

@@ -111,5 +111,6 @@ export declare class BuiltinContextManager {
     applyCompaction(summary: string, plan: BuiltinCompactionPlan): void;
     reset(): void;
     save(): void;
+    private modelSafeMessages;
     private load;
 }

package/dist/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/file-tools.d.ts

@@ -71,6 +71,13 @@ export interface RunCommandOutput {
     truncated: boolean;
     durationMs: number;
 }
+export interface GitCoAuthorOptions {
+    enabled: boolean;
+    name: string;
+    email: string;
+}
+/** Adds DeepCCC attribution to git commit commands without replacing the user's author. */
+export declare function withGitCoAuthor(command: string, coAuthor?: GitCoAuthorOptions): string;
 export interface FileEdit {
     oldText: string;
     newText: string;
@@ -143,7 +150,7 @@ export declare function expandHomePath(value: string): string;
 export declare function readFileForTool(cwd: string, input: ReadFileInput): Promise<ReadFileOutput>;
 export declare function listDirForTool(cwd: string, input?: ListDirInput): Promise<ListDirOutput>;
 export declare function searchCodeForTool(cwd: string, input: SearchCodeInput, signal?: AbortSignal, runtimeOptions?: SearchCodeRuntimeOptions): Promise<SearchCodeOutput>;
-export declare function runCommandForTool(cwd: string, input: RunCommandInput, abortSignal?: AbortSignal): Promise<RunCommandOutput>;
+export declare function runCommandForTool(cwd: string, input: RunCommandInput, abortSignal?: AbortSignal, coAuthor?: GitCoAuthorOptions): Promise<RunCommandOutput>;
 export declare function editFileForTool(cwd: string, input: EditFileInput): Promise<EditFileOutput>;
 export declare function createFileForTool(cwd: string, input: CreateFileInput): Promise<FileWriteOutput>;
 export declare function deleteFileForTool(cwd: string, input: DeleteFileInput): Promise<DeleteFileOutput>;
@@ -152,6 +159,8 @@ export declare function applyPatchForTool(cwd: string, input: ApplyPatchInput):
 export interface BuiltinFileToolsOptions {
     /** 权限门控：副作用工具（run_command/文件写操作）执行前会先经过 gate.check */
     permissionGate?: PermissionGate;
+    /** Git commits created by DeepCCC receive this Co-authored-by trailer when enabled. */
+    gitCoAuthor?: GitCoAuthorOptions;
     /** session_search 工具的会话/原始日志目录（默认 ~/.deepccc/sessions 与 raw-stream-logs；测试可注入） */
     sessionSearch?: {
         contextDir?: string;

package/dist/file-tools.js

@@ -26,6 +26,13 @@ const MAX_COMMAND_TIMEOUT_MS = 900_000;
 export const MAX_TASK_OUTPUT_CHARS = 32_000;
 const requireFromHere = createRequire(import.meta.url);
 const FALLBACK_SKIPPED_DIRECTORIES = new Set([".git", "node_modules"]);
+/** Adds DeepCCC attribution to git commit commands without replacing the user's author. */
+export function withGitCoAuthor(command, coAuthor) {
+    if (!coAuthor?.enabled || command.includes(coAuthor.email))
+        return command;
+    const trailer = ` --trailer "Co-authored-by: ${coAuthor.name} <${coAuthor.email}>"`;
+    return command.replace(/(^|(?:&&|\|\||;|\|)\s*)(git\s+commit)\b/g, (_match, prefix, gitCommit) => `${prefix}${gitCommit}${trailer}`);
+}
 /**
  * 把 `~` / `~/x`（含反斜杠 `~\\x`）展开为用户主目录绝对路径。
  * `~user/x` 形式不展开（Node 无内置支持），保持原样交给后续解析。
@@ -676,8 +683,8 @@ export async function searchCodeForTool(cwd, input, signal, runtimeOptions = {})
             : fallback.truncated,
     };
 }
-export async function runCommandForTool(cwd, input, abortSignal) {
-    const command = input.command?.trim();
+export async function runCommandForTool(cwd, input, abortSignal, coAuthor) {
+    const command = withGitCoAuthor(input.command?.trim(), coAuthor);
     if (!command)
         throw new Error("command is required");
     const commandCwd = resolveToolPath(cwd, input.cwd);
@@ -1016,14 +1023,14 @@ export function createBuiltinFileTools(cwd, options = {}) {
                 },
                 required: ["command"],
             }),
-            execute: async (input, options) => {
+            execute: async (input, execOptions) => {
                 await guard({
                     tool: "run_command",
                     action: input.command,
                     reason: isDangerousCommand(input.command) ? "high-risk" : "rule",
                     detail: `运行命令: ${input.command}`,
                 });
-                return runCommandForTool(cwd, input, options.abortSignal);
+                return runCommandForTool(cwd, input, execOptions.abortSignal, options.gitCoAuthor);
             },
         }),
         task: tool({

package/dist/index.d.ts

@@ -37,6 +37,8 @@ export interface ChatSessionConfig {
      * overrides config.effort; empty omits the reasoning_effort request field.
      */
     effort?: string;
+    /** Maximum output tokens for the main conversation; unset uses the Provider default. */
+    maxOutputTokens?: number;
 }
 export interface ChatSessionOptions {
     /** Session working directory. */
@@ -78,6 +80,8 @@ export interface ChatSessionOptions {
      * 调用）自动拒绝高危命令，常规文件操作与低危命令不受影响。
      */
     permissionResolver?: PermissionResolver;
+    /** Overrides ~/.deepccc/config.json git.coAuthor.enabled for this integration. */
+    gitCoAuthor?: boolean;
 }
 /**
  * 流式响应事件
@@ -85,6 +89,9 @@ export interface ChatSessionOptions {
 export type ChatEvent = {
     type: "status";
     phase: "compacting" | "generating";
+} | {
+    type: "progress";
+    phase: "reasoning";
 } | {
     type: "compact";
     compactedMessages: number;
@@ -103,6 +110,8 @@ export type ChatEvent = {
     type: "text";
     text: string;
     accumulated: string;
+} | {
+    type: "text_reset";
 } | {
     type: "done";
     text: string;
@@ -131,9 +140,11 @@ export declare class ChatSession {
     private compactionTimeoutMs;
     private maxSteps?;
     private effort;
+    private maxOutputTokens?;
     private permissionMode;
     private permissionResolver?;
     private permissionGate;
+    private gitCoAuthorEnabled;
     private skillDirs;
     private customSystemPrompt;
     /** 最近一次 chat() 使用的 system prompt（供 history 等读取） */

package/dist/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";
 // ---------------------------------------------------------------------------
@@ -76,6 +77,7 @@ const COMPACTION_RECOVERY_HINT_DISABLED = [
 ].join("\n");
 export const DEFAULT_COMPACTION_TIMEOUT_MS = 5 * 60 * 1000;
 const MAX_COMPACTION_OUTPUT_TOKENS = 16_384;
+const OPENAI_COMPATIBLE_PROVIDER_NAME = "deepccc";
 /** task 子代理工具：子代理单轮对话的最大工具步数（防失控循环，结果收敛后即结束） */
 const TASK_MAX_STEPS = 20;
 /** 子代理最终输出截断：保留前 MAX_TASK_OUTPUT_CHARS 字符，尾部注明截断信息 */
@@ -218,6 +220,14 @@ function normalizeMaxSteps(value) {
     }
     return value;
 }
+function normalizeMaxOutputTokens(value) {
+    if (value === undefined)
+        return undefined;
+    if (!Number.isFinite(value) || !Number.isInteger(value) || value <= 0) {
+        throw new Error("maxOutputTokens must be a positive integer when provided");
+    }
+    return value;
+}
 function normalizeAnthropicBaseURL(baseURL) {
     // 完全按用户填写的地址使用，不自动补 /v1（AI SDK 仅对官方 api.anthropic.com
     // 特判补一次 /v1，其他地址原样拼接 /messages）。
@@ -238,9 +248,11 @@ export class ChatSession {
     compactionTimeoutMs;
     maxSteps;
     effort;
+    maxOutputTokens;
     permissionMode;
     permissionResolver;
     permissionGate;
+    gitCoAuthorEnabled;
     skillDirs;
     customSystemPrompt;
     /** 最近一次 chat() 使用的 system prompt（供 history 等读取） */
@@ -265,6 +277,7 @@ export class ChatSession {
                 baseURL: this.baseURL,
                 model: this.subModelId || this.modelId,
                 effort: this.effort,
+                maxOutputTokens: this.maxOutputTokens,
             }, {
                 cwd: taskCwd,
                 persist: false,
@@ -302,6 +315,7 @@ export class ChatSession {
         this.subModelId = (overrides.subModel ?? appConfig.subModel ?? "").trim();
         this.provider = normalizeDeepCccProvider(overrides.provider ?? appConfig.provider);
         this.effort = (overrides.effort ?? appConfig.effort ?? "").trim();
+        this.maxOutputTokens = normalizeMaxOutputTokens(overrides.maxOutputTokens ?? appConfig.maxOutputTokens);
         this.apiKey = apiKey;
         this.baseURL = baseURL;
         const provider = this.provider === "anthropic"
@@ -310,7 +324,7 @@ export class ChatSession {
                 apiKey,
             })
             : createOpenAICompatible({
-                name: "deepccc",
+                name: OPENAI_COMPATIBLE_PROVIDER_NAME,
                 baseURL,
                 apiKey,
                 includeUsage: true,
@@ -324,6 +338,7 @@ export class ChatSession {
         this.customSystemPrompt = options.systemPrompt ?? "";
         this.permissionMode = options.permissionMode ?? "ask";
         this.permissionResolver = options.permissionResolver;
+        this.gitCoAuthorEnabled = options.gitCoAuthor ?? appConfig.git.coAuthor.enabled;
         // 技能目录在构造时确定；技能内容在每次 chat() 前重新扫描（mtime 热加载），
         // 因此创建/修改技能后下一次对话自动生效，无需重启。
         this.skillDirs =
@@ -400,7 +415,6 @@ export class ChatSession {
             catch (err) {
                 console.error(`[DeepCCC raw stream log] create failed: ${errorMessage(err)}`);
             }
-            const toolContext = [];
             const maxSteps = this.maxSteps;
             // 每次对话前重新扫描技能索引（并行 + mtime 缓存，开销极小）：
             // 新技能/修改的技能在下一次对话自动生效（热加载）。
@@ -413,110 +427,160 @@ export class ChatSession {
                 ? addAnthropicToolJsonCompatibilityNote(hintedMessages)
                 : hintedMessages;
             // effort 按协议映射：
-            // - OpenAI 兼容：providerOptions.deepseek.reasoningEffort 由 @ai-sdk/openai-compatible
-            //   自动映射为请求体 reasoning_effort 字段（DeepSeek 原生支持）；
+            // - OpenAI 兼容：providerOptions 的 key 必须与 createOpenAICompatible.name 一致；
+            //   reasoningEffort 由 SDK 映射为请求体 reasoning_effort 字段；
             // - Anthropic：providerOptions.anthropic.effort 由 @ai-sdk/anthropic 组装为请求体
             //   output_config.effort（官方 Effort API，见 platform.claude.com/docs/en/build-with-claude/effort）
             let effortProviderOptions;
             if (this.effort) {
                 effortProviderOptions = this.provider === "openai"
-                    ? { deepseek: { reasoningEffort: this.effort } }
+                    ? { [OPENAI_COMPATIBLE_PROVIDER_NAME]: { 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,
+                    gitCoAuthor: {
+                        ...appConfig.git.coAuthor,
+                        enabled: this.gitCoAuthorEnabled,
+                    },
                 }),
                 stopWhen: maxSteps !== undefined ? stepCountIs(maxSteps) : isLoopFinished(),
                 abortSignal: signal,
+                ...(this.maxOutputTokens !== undefined
+                    ? { maxOutputTokens: this.maxOutputTokens }
+                    : {}),
                 ...(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 };
@@ -581,7 +645,7 @@ export class ChatSession {
                 // output_config.effort=low），避免继承主对话的高 effort 拖慢"压缩上下文中"阶段。
                 maxOutputTokens: MAX_COMPACTION_OUTPUT_TOKENS,
                 providerOptions: this.provider === "openai"
-                    ? { deepseek: { reasoningEffort: "none" } }
+                    ? { [OPENAI_COMPATIBLE_PROVIDER_NAME]: { reasoningEffort: "none" } }
                     : { anthropic: { effort: "low" } },
             });
             if (!result.text.trim()) {

package/dist/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/tool-protocol.d.ts

@@ -0,0 +1,2 @@
+export declare function hasMalformedToolProtocolText(text: string): boolean;
+export declare const TOOL_PROTOCOL_RECOVERY_PROMPT: string;

package/dist/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/package.json

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