chatccc 0.2.282 → 0.2.283

package/README.md

@@ -451,7 +451,9 @@ ChatCCC 的内部重启和更新使用跨平台父子进程握手：替代进程
 
 飞书接收长连接启用 15 秒握手超时和 30 秒心跳应答超时；首次启动最多等待 45 秒真实连接确认后才提示就绪。运行期间连接持续异常 90 秒时，会关闭并重新建立接收连接，保留会话、消息去重和正在执行的任务。没有用户消息不会触发重连。连接状态与恢复记录写入运行日志和 `startup-trace.log`（`FEISHU-CONNECTION` / `feishu-connection`）。卡片更新遇到网络失败或序号冲突时不会当成送达成功，错误通知保留文本兜底；TLS 断线会明确显示为网络连接失败，已中断的 Agent 任务不会因此自动重放。
 
-> **模型切换**：`/model` 查看当前会话 Agent 的可选模型清单，`/model <名称>` 模糊匹配切换，`/model clear` 恢复默认。可选模型来自当前 Agent 的配置：Claude 使用 `claude.model` / `claude.subagentModel`；Cursor、Codex、CCC Agent 和 DSH 使用各自的 `model` / `alternativeModel`。
+> **模型切换**：`/model` 查看当前会话 Agent 的可选模型清单，`/model <名称>` 模糊匹配切换，`/model clear` 恢复默认。可选模型来自当前 Agent 的配置：Claude 使用 `claude.model` / `claude.subagentModel`；Cursor、Codex、CCC Agent 和 DSH 使用各自的 `model` / `alternativeModel`。
+
+Agent 的初始化、输入回显与重连通知不代表任务成功。Cursor、Codex 和 Claude 缺少成功完成事件，或任一 Agent 没有产生有效回复时，会明确提示异常；已生成的部分回复会保留并标为可能不完整。Cursor 重连过程显示在状态区，上游的 `resource_exhausted` / `unavailable` 分别提示请求受限 / 服务暂不可用，不推断为余额耗尽。执行失败不会自动重放整条任务。
 
 > **Codex Fast 模式**：Web UI 中的“Fast 模式”设置新 Codex 会话的全局默认值，默认关闭。进入 Codex 会话后，`/fast` 查询当前状态，`/fast on` 和 `/fast off` 只覆盖当前会话并从下一条消息生效。ChatCCC 会显式向 Codex CLI 传入 `service_tier="fast"` 或 `service_tier="default"`，因此关闭时不会继承用户 `config.toml` 中可能开启的 Fast。
 

package/deepccc-agent/README.md

@@ -8,6 +8,8 @@ DeepCCC 是一个本地优先的开源 Coding Agent，同时提供浏览器多
 
 ## 安装与快速开始
 
+模型原生流未收到完成事件、返回错误结束原因或达到输出长度限制时，会报告异常并保留已经输出的内容，不将不完整回复判为成功。没有回复且没有工具执行的空结果也会明确报错。用户主动取消仍按中断处理。
+
 全局安装：
 
 ```bash

package/deepccc-agent/package.json

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

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

@@ -478,16 +478,25 @@ export class ChatSession {
                     messages: attemptMessages,
                 };
                 let stream;
+                let requiresFinish = false;
+                let receivedFinish = false;
+                let finishReason;
                 if (this.streaming) {
                     const result = streamText(generationOptions);
+                    requiresFinish = result.fullStream != null;
                     stream = result.fullStream ?? textStreamToFullStream(result.textStream);
                 }
                 else {
                     const result = await generateText(generationOptions);
+                    finishReason = result.finishReason;
                     stream = generateResultToFullStream(result);
                 }
                 for await (const part of stream) {
                     rawLog?.writeLine(safeRawStreamJson(part));
+                    if (part.type === "finish") {
+                        receivedFinish = true;
+                        finishReason = part.finishReason;
+                    }
                     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.
@@ -561,6 +570,14 @@ export class ChatSession {
                         throw new Error(message);
                     }
                 }
+                if (!signal?.aborted) {
+                    if (requiresFinish && !receivedFinish)
+                        throw new Error("DeepCCC 输出流中断：未收到模型完成事件，回复可能不完整");
+                    if (finishReason === "error" || finishReason === "length")
+                        throw new Error(`DeepCCC 未正常完成：finishReason=${finishReason}，回复可能不完整`);
+                    if (!fullText.trim() && toolCallOrder.length === 0)
+                        throw new Error("DeepCCC 本轮未产生有效回复");
+                }
                 if (hasMalformedToolProtocolText(fullText)) {
                     console.warn(`[DeepCCC] malformed tool protocol text detected for ${this.context.sessionId} `
                         + `(attempt ${attempt + 1}/2, structuredToolCalls=${toolCallOrder.length})`);

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

@@ -2,6 +2,7 @@ import { ChatSession } from "../../deepccc-agent/src/index.js";
 import { config as deepCccConfig } from "../../deepccc-agent/src/config.js";
 import { getBuiltinContextSession, newBuiltinSessionId, normalizeBuiltinSessionId, } from "../../deepccc-agent/src/context.js";
 import { config, CCC_SESSION_PREFIX } from "../config.js";
+import { createTurnCompletion } from "./turn-completion.js";
 function toChatSessionOptions(sessionId, cwd, options) {
     return {
         cwd,
@@ -50,7 +51,12 @@ export function createCccAdapter(options = {}) {
         async *prompt(sessionId, userText, cwd, signal, _promptOptions) {
             const normalizedSessionId = normalizeBuiltinSessionId(sessionId);
             const session = new ChatSession(chatConfig, toChatSessionOptions(normalizedSessionId, cwd, options));
+            const completion = createTurnCompletion("CCC Agent");
             for await (const event of session.chat(userText, signal)) {
+                if (event.type === "text")
+                    completion.observe({ type: "assistant", blocks: [{ type: "text", text: event.text }] });
+                if (event.type === "text_reset")
+                    completion.observe({ type: "assistant", blocks: [{ type: "text_reset" }] });
                 if (event.type === "status") {
                     yield {
                         type: "assistant",
@@ -101,6 +107,7 @@ export function createCccAdapter(options = {}) {
                     };
                 }
                 else if (event.type === "done" && !signal?.aborted) {
+                    completion.complete();
                     yield {
                         type: "assistant",
                         blocks: [],
@@ -111,6 +118,8 @@ export function createCccAdapter(options = {}) {
                     throw new Error(event.message);
                 }
             }
+            if (!signal?.aborted)
+                completion.assertComplete();
         },
         async getSessionInfo(sessionId) {
             const normalizedSessionId = normalizeBuiltinSessionId(sessionId);

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

@@ -11,6 +11,8 @@ import { homedir } from "node:os";
 import { delimiter, join } from "node:path";
 import { pathToFileURL } from "node:url";
 import { parseUserCommand } from "./adapter-interface.js";
+import { createTurnCompletion } from "./turn-completion.js";
+import { sanitizeTerminalErrorDetail } from "../terminal-error.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";
@@ -127,6 +129,9 @@ function logMcpConfig() {
     }
 }
 export function normalizeSdkMessage(msg) {
+    if (msg.type === "result" && (msg.subtype !== "success" || msg.is_error === true)) {
+        throw new Error(`Claude 执行失败：${sanitizeTerminalErrorDetail(JSON.stringify(msg.errors ?? msg.result ?? msg.subtype ?? "未提供错误详情"))}`);
+    }
     // SDK result/success 是 Claude 对本轮完整结束的权威确认。文本已经由之前的
     // assistant 消息累计，因此这里只发送终态信号，避免重复追加 result 文本。
     if (msg.type === "result" && msg.subtype === "success") {
@@ -399,6 +404,7 @@ class ClaudeAdapter {
             return;
         let aborted = false;
         let completed = false;
+        const completion = createTurnCompletion("Claude");
         const rawLogConfig = config.rawStreamLogs.claude;
         let rawLog = null;
         const sdk = await loadClaudeSdkModule();
@@ -449,10 +455,24 @@ class ClaudeAdapter {
                     }
                 }
                 const normalized = normalizeSdkMessage(msg);
+                completion.observe(normalized);
+                if (msg.type === "result") {
+                    // Some SDK modes only put the final reply in result.result.
+                    if (msg.result?.trim()) {
+                        const final = { type: "assistant", blocks: [{ type: "text_final", text: msg.result }] };
+                        completion.observe(final);
+                        yield final;
+                    }
+                    completion.complete();
+                    completed = true;
+                }
                 if (normalized)
                     yield normalized;
+                if (completed)
+                    break;
             }
-            completed = !aborted && !abortController.signal.aborted;
+            if (!aborted && !abortController.signal.aborted)
+                completion.assertComplete();
         }
         finally {
             removeAbortListener?.();

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

@@ -7,6 +7,7 @@
 // - getSessionInfo: 从持久化映射读取 cwd / threadId
 // =============================================================================
 import { spawn } from "node:child_process";
+import { createTurnCompletion } from "./turn-completion.js";
 import { existsSync, readFileSync } from "node:fs";
 import { join } from "node:path";
 import { randomUUID } from "node:crypto";
@@ -71,8 +72,8 @@ function resolveCodexEffort() {
 // normalizeCodexMessage — Codex 事件 → UnifiedStreamMessage | null
 // ---------------------------------------------------------------------------
 export function normalizeCodexMessage(msg) {
-    if (msg.type === "error" && msg.message?.trim()) {
-        throw new Error(`Codex turn failed: ${msg.message.trim()}`);
+    if (msg.type === "error") {
+        throw new Error(`Codex turn failed: ${msg.message?.trim() || "未提供错误详情"}`);
     }
     if (msg.type === "turn.failed") {
         const detail = typeof msg.error === "string" ? msg.error : msg.error?.message;
@@ -160,10 +161,18 @@ function spawnCodex(args, cwd, stdinText, modelOverride, effortOverride, fastMod
         shell: true,
     });
     let stderr = "";
+    let exitCode = null;
+    let signal = null;
+    let settleClose = () => { };
+    const closed = new Promise(resolve => { settleClose = resolve; });
+    proc.once("error", (error) => { stderr += `\n${error.message}`; settleClose(); });
     proc.stderr.on("data", (chunk) => {
         stderr += chunk.toString();
     });
-    proc.on("close", (code) => {
+    proc.on("close", (code, exitSignal) => {
+        exitCode = code;
+        signal = exitSignal;
+        settleClose();
         if (code !== 0 && stderr.trim()) {
             console.error(`[Codex stderr] exit=${code}: ${stderr.trim().slice(0, 2000)}`);
         }
@@ -172,7 +181,17 @@ function spawnCodex(args, cwd, stdinText, modelOverride, effortOverride, fastMod
         proc.stdin.write(stdinText);
         proc.stdin.end();
     }
-    return proc;
+    return { proc, async failureDetail() {
+            let timer;
+            try {
+                await Promise.race([closed, new Promise(resolve => { timer = setTimeout(resolve, 2_000); })]);
+                return `exit=${exitCode ?? "unknown"}; signal=${signal ?? "none"}; ${stderr.trim() || "无 stderr 详情"}`;
+            }
+            finally {
+                if (timer)
+                    clearTimeout(timer);
+            }
+        } };
 }
 async function* readJsonLines(proc, signal, rawLog) {
     yield* readJsonLinesWithBadJsonIdleWatchdog({
@@ -219,7 +238,8 @@ class CodexAdapter {
         const args = isFirstPrompt
             ? [...baseArgs, "-C", cwd, "-"]
             : [...baseArgs, "resume", threadId, "-"];
-        const proc = spawnCodex(args, cwd, buildCodexPromptText(userText), this.modelOverride, this.effortOverride, this.fastModeOverride);
+        const handle = spawnCodex(args, cwd, buildCodexPromptText(userText), this.modelOverride, this.effortOverride, this.fastModeOverride);
+        const proc = handle.proc;
         if (proc.pid !== undefined)
             options?.onProcessStart?.({ pid: proc.pid });
         const rawLogConfig = config.rawStreamLogs.codex;
@@ -245,12 +265,11 @@ class CodexAdapter {
         const onAbort = () => { void killProcessTree(proc.pid); };
         signal?.addEventListener("abort", onAbort, { once: true });
         let completed = false;
+        const completion = createTurnCompletion("Codex");
         try {
             for await (const raw of readJsonLines(proc, signal, rawLog)) {
                 if (signal?.aborted)
                     break;
-                if (raw.type === "turn.completed")
-                    completed = true;
                 if (isFirstPrompt &&
                     raw.type === "thread.started" &&
                     raw.thread_id) {
@@ -259,9 +278,18 @@ class CodexAdapter {
                         .catch(() => { });
                 }
                 const normalized = normalizeCodexMessage(raw);
+                completion.observe(normalized);
+                if (raw.type === "turn.completed") {
+                    completion.complete();
+                    completed = true;
+                }
                 if (normalized)
                     yield normalized;
+                if (completed)
+                    break;
             }
+            if (!signal?.aborted && !completed)
+                completion.assertComplete(await handle.failureDetail());
         }
         finally {
             signal?.removeEventListener("abort", onAbort);

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

@@ -8,6 +8,7 @@ import { spawn } from "node:child_process";
 import { existsSync, readFileSync } from "node:fs";
 import { join } from "node:path";
 import { parseUserCommand } from "./adapter-interface.js";
+import { createTurnCompletion } from "./turn-completion.js";
 import { config, CURSOR_AGENT_COMMAND, CURSOR_AGENT_ARGS, PROJECT_ROOT, RAW_STREAM_LOGS_DIR } from "../config.js";
 import { defaultCursorSessionMetaStore, } from "./cursor-session-meta-store.js";
 import { killProcessTree } from "./proc-tree-kill.js";
@@ -106,6 +107,15 @@ function mapToolCallKey(key) {
     return KEY_MAP[key] ?? key;
 }
 export function normalizeCursorMessage(msg) {
+    if (msg.type === "error" || (msg.type === "result" && (msg.is_error === true || msg.subtype?.startsWith("error")))) {
+        throw new Error(`Cursor 执行失败：${formatCursorVisibleStderr(JSON.stringify(msg.errors ?? msg.error ?? msg.result ?? msg.subtype ?? "未提供错误详情"))}`);
+    }
+    if (msg.type === "connection" || msg.type === "retry") {
+        return { type: "system", blocks: [{ type: "agent_status",
+                    status: msg.subtype === "reconnected" ? "responding" : "reconnecting",
+                    ...(Number.isInteger(msg.attempt) && msg.attempt > 0 ? { attempt: msg.attempt } : {}),
+                }] };
+    }
     if (msg.type === "assistant" && msg.message?.content) {
         // 按 cursor 官方 stream-json 规范区分三类 assistant 事件，避免 text 重复累加：
         //   ┌────────────────┬───────────────┬─────────────────┐
@@ -312,8 +322,17 @@ function spawnAgent(extraArgs, cwd, stdinText, modelOverride, mode, spawnImpl =
         waitForClose: async () => {
             if (closeInfo)
                 return { ...closeInfo, stderr };
-            const info = await closePromise;
-            return { ...info, stderr };
+            let timer;
+            try {
+                const info = await Promise.race([closePromise, new Promise(resolve => {
+                        timer = setTimeout(() => resolve({ code: null, signal: null, stderr }), 2_000);
+                    })]);
+                return { ...info, stderr };
+            }
+            finally {
+                if (timer)
+                    clearTimeout(timer);
+            }
         },
     };
 }
@@ -425,6 +444,7 @@ class CursorAdapter {
         const onAbort = () => { void killProcessTree(proc.pid); };
         signal?.addEventListener("abort", onAbort, { once: true });
         let sawResult = false;
+        const completion = createTurnCompletion("Cursor");
         const stats = createCursorStreamStats();
         try {
             for await (const raw of readJsonLines(proc, signal, sessionId, rawLog, stats, this.badJsonIdleTimeoutMs)) {
@@ -439,10 +459,15 @@ class CursorAdapter {
                         .catch(() => { });
                 }
                 const normalized = normalizeCursorMessage(raw);
+                completion.observe(normalized);
+                if (raw.type === "result")
+                    completion.complete();
                 if (normalized)
                     yield normalized;
                 // result 是流末事件，收到后立即结束进程，防止 CLI 僵死导致 readline 挂起。
                 if (raw.type === "result") {
+                    if (!normalized?.isFinalResponse)
+                        yield { type: "assistant", blocks: [], isFinalResponse: true };
                     sawResult = true;
                     void killProcessTree(proc.pid);
                     break;
@@ -462,6 +487,7 @@ class CursorAdapter {
                     };
                     throw createCursorAgentFailureError(closeInfo);
                 }
+                completion.assertComplete(`exit=${closeInfo.code ?? "unknown"}; signal=${closeInfo.signal ?? "none"}; ${formatCursorVisibleStderr(closeInfo.stderr) || "无 stderr 详情"}`);
             }
         }
         finally {

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

@@ -125,22 +125,18 @@ export function createDshAdapter(options = {}) {
                                 queue.push(message);
                         },
                     });
-                    if (result.finalResponse) {
+                    if (turnError) {
+                        if (result.finalResponse?.trim())
+                            queue.push({ type: "assistant", blocks: [{ type: "text_final", text: result.finalResponse }] });
+                        queue.fail(turnError);
+                    }
+                    else if (result.finalResponse?.trim()) {
                         rawLog?.writeLine(JSON.stringify({ type: "run.result", result }));
                         queue.push({ type: "assistant", blocks: [{ type: "text_final", text: result.finalResponse }], isFinalResponse: true });
                         completed = true;
                     }
-                    else if (turnError) {
-                        queue.fail(turnError);
-                    }
                     else {
-                        // 引擎正常结束但零输出（无错误、无回复）：给出明确提示，避免用户只看到"失败"。
-                        queue.push({
-                            type: "assistant",
-                            blocks: [{ type: "text_final", text: "DeepSeek Harness 本轮未产生任何回复（引擎未报告错误）。" }],
-                            isFinalResponse: true,
-                        });
-                        completed = true;
+                        queue.fail(new Error("DeepSeek Harness 本轮未产生有效回复（引擎未报告错误）。"));
                     }
                     if (completed) {
                         knownSessions.set(sessionId, { sessionId, cwd, lastModified: Date.now(), model: options.model ?? "deepseek-v4-flash" });

package/dist/src/adapters/turn-completion.js

@@ -0,0 +1,25 @@
+import { sanitizeTerminalErrorDetail } from "../terminal-error.js";
+/** Protocol output (init, echo, heartbeat, tools) is not a successful reply. */
+export function createTurnCompletion(tool) {
+    let hasReply = false;
+    let completed = false;
+    return {
+        observe(message) {
+            for (const block of message?.blocks ?? []) {
+                if (block.type === "text_reset")
+                    hasReply = false;
+                if (message?.type === "assistant" && (block.type === "text" || block.type === "text_final") && block.text.trim())
+                    hasReply = true;
+            }
+        },
+        complete() {
+            if (!hasReply)
+                throw new Error(`${tool} 本轮未产生有效回复（收到结束事件，但回复为空）。`);
+            completed = true;
+        },
+        assertComplete(detail = "") {
+            if (!completed)
+                throw new Error(`${tool} 未正常完成：输出流结束但未收到成功完成事件${detail ? `；${sanitizeTerminalErrorDetail(detail)}` : ""}。`);
+        },
+    };
+}

package/dist/src/agent-activity.js

@@ -7,6 +7,7 @@ export function createAgentActivityTracker(now = Date.now()) {
 }
 function sameVisibleActivity(left, right) {
     return left.kind === right.kind
+        && left.attempt === right.attempt
         && left.toolName === right.toolName
         && left.toolCount === right.toolCount;
 }
@@ -73,8 +74,9 @@ export function updateAgentActivity(tracker, block, now = Date.now()) {
             return setActivity(tracker, { kind: "responding", startedAt: now });
         case "agent_status":
             return setActivity(tracker, {
-                kind: block.status === "compacting" ? "compacting" : "responding",
+                kind: block.status,
                 startedAt: now,
+                ...(block.attempt ? { attempt: block.attempt } : {}),
             });
         case "thinking":
         case "redacted_thinking":
@@ -126,6 +128,9 @@ export function formatAgentActivityTitle(activity, now = Date.now()) {
         case "responding":
             label = "正在生成回复";
             break;
+        case "reconnecting":
+            label = `正在重新连接模型服务${activity.attempt ? `（第 ${activity.attempt} 次）` : ""}`;
+            break;
         case "searching":
             label = "正在处理搜索结果";
             break;

package/dist/src/terminal-error.js

@@ -37,7 +37,7 @@ export function classifyTerminalError(error, occurredAt = Date.now()) {
     const lower = raw.toLowerCase();
     const attempts = parsePositiveInt(raw, /\bafter\s+(\d+)\s+attempts?\b/i);
     const timeoutMs = parsePositiveInt(raw, /\btimeout\s*:\s*(\d+)\s*ms\b/i);
-    if (/\b429\b|rate[ _-]?limit|too many requests/.test(lower)) {
+    if (/\b429\b|rate[ _-]?limit|too many requests|resource_exhausted/.test(lower)) {
         return {
             kind: "rate_limit",
             title: "请求受到限流",
@@ -73,7 +73,7 @@ export function classifyTerminalError(error, occurredAt = Date.now()) {
         };
     }
     const httpStatus = raw.match(/\b(?:HTTP\s*)?(5\d\d)\b/i)?.[1];
-    if (httpStatus || /service unavailable|bad gateway|gateway timeout|provider error/.test(lower)) {
+    if (httpStatus || /service unavailable|\[unavailable\]|bad gateway|gateway timeout|provider error/.test(lower)) {
         return {
             kind: "provider",
             title: "模型服务暂时不可用",

package/package.json

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