chatccc 0.2.286 → 0.2.288

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

@@ -459,6 +459,10 @@ async function runRepl(args) {
     }
     let currentAbort = null;
     const ctrlCState = createCtrlCState();
+    // 协作式让位：agent 运行期间用户仍可输入，新行进入注入队列，由内核在每个
+    // model step 边界 drain 后吸收到当前 turn（而非等待整轮结束）。
+    let chatRunning = false;
+    const pendingInjections = [];
     rl.prompt();
     rl.on("line", async (line) => {
         ctrlCState.reset();
@@ -467,6 +471,17 @@ async function runRepl(args) {
             rl.prompt();
             return;
         }
+        if (chatRunning) {
+            // 运行期间不并发启动新 turn：把输入注入当前 turn 的 step 边界。
+            if (input === "exit" || input.startsWith("/")) {
+                process.stdout.write(`${C.dim}[running] 命令将在本轮结束后生效；或按两次 Ctrl+C 中断${C.reset}\n`);
+                return;
+            }
+            pendingInjections.push(buildAttachmentPrompt(input, pendingAttachments));
+            pendingAttachments = [];
+            process.stdout.write(`${C.dim}[queued] 消息将在当前步骤后注入本轮${C.reset}\n`);
+            return;
+        }
         if (input === "exit") {
             process.stdout.write(`${C.dim}bye${C.reset}\n`);
             rl.close();
@@ -510,10 +525,11 @@ async function runRepl(args) {
             const chatInput = buildAttachmentPrompt(input, pendingAttachments);
             pendingAttachments = [];
             let lastAccumulated = "";
-            for await (const event of session.chat(chatInput, signal)) {
+            chatRunning = true;
+            for await (const event of session.chat(chatInput, signal, () => pendingInjections.shift())) {
                 if (renderer && view) {
                     view = reduceProgress(view, event);
-                    if (event.type === "text" || event.type === "compact" || event.type === "status") {
+                    if (event.type === "text" || event.type === "compact" || event.type === "status" || event.type === "input_injected") {
                         renderer.render(view);
                     }
                     else {
@@ -543,6 +559,9 @@ async function runRepl(args) {
                     const status = event.is_error ? "error" : "ok";
                     console.log(`${C.dim}[tool result] ${event.name ?? event.tool_use_id} ${status}${C.reset}`);
                 }
+                else if (event.type === "input_injected") {
+                    console.log(`\n${C.dim}[injected] ${event.text}${C.reset}`);
+                }
                 else if (event.type === "error") {
                     console.log(`\n${C.yellow}[error] ${event.message}${C.reset}`);
                 }
@@ -561,6 +580,7 @@ async function runRepl(args) {
         finally {
             activeRenderer = null;
             activeView = null;
+            chatRunning = false;
             if (renderer && view && !rendererEnded) {
                 // 定型终态区块（完成/已停止/异常结束）留在屏幕上，恢复光标
                 renderer.end(view);

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

@@ -246,6 +246,17 @@ function normalizeAnthropicBaseURL(baseURL) {
     // DeepSeek Anthropic 端点示例：https://api.deepseek.com/anthropic/v1。
     return baseURL.trim().replace(/\/+$/, "");
 }
+/**
+ * 协作式让位的内部中断信号：在 prepareStep（每个模型 step 前）检测到外部
+ * 注入消息时抛出，触发 chat() 持久化当前中间态 → 注入 user 消息 → 以新
+ * messages 重启 streamText，让 agent 在当前 turn 内吸收新指令而非结束整轮。
+ */
+class InputInjectionInterrupt extends Error {
+    constructor() {
+        super("input injection requested at step boundary");
+        this.name = "InputInjectionInterrupt";
+    }
+}
 export class ChatSession {
     model;
     /** 子模型实例；未配置 subModel 时与主模型同一实例 */
@@ -396,7 +407,7 @@ export class ChatSession {
         }
         return systemContent.join("\n");
     }
-    async *chat(userMessage, signal) {
+    async *chat(userMessage, signal, drainInput) {
         this.context.appendMessage({ role: "user", content: userMessage });
         let fullText = "";
         let safeAccumulated = "";
@@ -469,6 +480,13 @@ export class ChatSession {
                     ? { [OPENAI_COMPATIBLE_PROVIDER_NAME]: { reasoningEffort: this.effort } }
                     : { anthropic: { effort: this.effort } };
             }
+            // 协作式让位（仅 streaming 模式）：外部可在每个 model step 边界 drain 一条
+            // 新消息注入当前 turn。non-streaming 下 generateText 是原子请求，无法在 step
+            // 边界取回中间工具结果，因此忽略 drainInput（消息留在上层队列，整轮结束后消费）。
+            const canInject = this.streaming && typeof drainInput === "function";
+            // pendingInjection 是 prepareStep 与 catch 之间的注入信号槽。用标志而非
+            // instanceof 判断，因为 provider SDK 可能包装抛出的错误。
+            let pendingInjection = null;
             const baseGenerationOptions = {
                 model: this.model,
                 system,
@@ -483,6 +501,13 @@ export class ChatSession {
                 stopWhen: maxSteps !== undefined ? stepCountIs(maxSteps) : isLoopFinished(),
                 abortSignal: signal,
                 prepareStep: ({ messages, stepNumber }) => {
+                    if (canInject) {
+                        const injected = drainInput();
+                        if (injected) {
+                            pendingInjection = injected;
+                            throw new InputInjectionInterrupt();
+                        }
+                    }
                     const compacted = compactToolLoopMessages(messages);
                     if (compacted.compactedResults > 0) {
                         rawLog?.writeLine(safeRawStreamJson({
@@ -500,151 +525,198 @@ export class ChatSession {
                     : {}),
                 ...(effortProviderOptions ? { providerOptions: effortProviderOptions } : {}),
             };
-            for (let attempt = 0; attempt < 2; attempt += 1) {
-                fullText = "";
-                safeAccumulated = "";
-                toolContext = [];
-                toolCallsById.clear();
-                toolCallOrder.length = 0;
-                timeline.length = 0;
-                let lastReasoningProgressAt;
-                const attemptMessages = attempt === 0
-                    ? modelMessages
-                    : [...modelMessages, { role: "user", content: TOOL_PROTOCOL_RECOVERY_PROMPT }];
-                const generationOptions = {
-                    ...baseGenerationOptions,
-                    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.
-                        const now = Date.now();
-                        if (lastReasoningProgressAt === undefined || now - lastReasoningProgressAt >= 1_000) {
-                            lastReasoningProgressAt = now;
-                            yield { type: "progress", phase: "reasoning" };
-                        }
-                    }
-                    else if (part.type === "text-delta") {
-                        fullText += part.text;
-                        const previous = timeline[timeline.length - 1];
-                        if (previous?.type === "text")
-                            previous.text += part.text;
-                        else
-                            timeline.push({ type: "text", text: part.text });
-                        // 隐私替换只在展示层：safeAccumulated 供事件消费者（终端/JSONL）使用，
-                        // fullText 原文用于持久化上下文，避免替换结果回流污染上下文。
-                        const safeText = applyPrivacy(part.text);
-                        safeAccumulated += safeText;
-                        yield { type: "text", text: safeText, accumulated: safeAccumulated };
-                    }
-                    else if (part.type === "tool-call") {
-                        const input = safeJson(part.input);
-                        toolContext.push(`tool_call ${part.toolName}: ${input}`);
-                        toolCallsById.set(part.toolCallId, { id: part.toolCallId, name: part.toolName, input });
-                        toolCallOrder.push(part.toolCallId);
-                        timeline.push({ type: "tool_use", id: part.toolCallId, name: part.toolName, input });
-                        yield {
-                            type: "tool_use",
-                            id: part.toolCallId,
-                            name: part.toolName,
-                            input: applyPrivacyToJson(part.input),
-                        };
-                    }
-                    else if (part.type === "tool-result") {
-                        const output = truncateToolContext(safeJson(part.output));
-                        toolContext.push(`tool_result ${part.toolName}: ${output}`);
-                        const call = toolCallsById.get(part.toolCallId);
-                        if (call)
-                            call.output = output;
-                        timeline.push({ type: "tool_result", tool_use_id: part.toolCallId, name: part.toolName, output });
-                        yield {
-                            type: "tool_result",
-                            tool_use_id: part.toolCallId,
-                            name: part.toolName,
-                            content: applyPrivacyToJson(part.output),
-                            is_error: false,
+            // 注入重启后 context 已变（中间 assistant + 注入 user），需要重新构建并应用
+            // 与首次一致的 recovery-hint / anthropic 兼容提示。
+            const decorateMessages = (msgs) => {
+                const hinted = maybeAppendCompactionRecoveryHint(msgs, this.context.summary, appConfig.rawStreamLogs.enabled, this.context.sessionId);
+                return this.provider === "anthropic"
+                    ? addAnthropicToolJsonCompatibilityNote(hinted)
+                    : hinted;
+            };
+            let currentMessages = modelMessages;
+            while (true) {
+                pendingInjection = null;
+                try {
+                    for (let attempt = 0; attempt < 2; attempt += 1) {
+                        fullText = "";
+                        toolContext = [];
+                        toolCallsById.clear();
+                        toolCallOrder.length = 0;
+                        timeline.length = 0;
+                        // safeAccumulated 是整轮展示累积：注入延续时不重置，只有工具协议恢复
+                        // （重新生成、已 yield text_reset）才重置。
+                        if (attempt === 1)
+                            safeAccumulated = "";
+                        let lastReasoningProgressAt;
+                        const attemptMessages = attempt === 0
+                            ? currentMessages
+                            : [...currentMessages, { role: "user", content: TOOL_PROTOCOL_RECOVERY_PROMPT }];
+                        const generationOptions = {
+                            ...baseGenerationOptions,
+                            messages: attemptMessages,
                         };
-                    }
-                    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;
+                        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);
                         }
-                        timeline.push({ type: "tool_result", tool_use_id: part.toolCallId, name: part.toolName, output: message, is_error: true });
-                        yield {
-                            type: "tool_result",
-                            tool_use_id: part.toolCallId,
-                            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);
+                        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.
+                                const now = Date.now();
+                                if (lastReasoningProgressAt === undefined || now - lastReasoningProgressAt >= 1_000) {
+                                    lastReasoningProgressAt = now;
+                                    yield { type: "progress", phase: "reasoning" };
+                                }
+                            }
+                            else if (part.type === "text-delta") {
+                                fullText += part.text;
+                                const previous = timeline[timeline.length - 1];
+                                if (previous?.type === "text")
+                                    previous.text += part.text;
+                                else
+                                    timeline.push({ type: "text", text: part.text });
+                                // 隐私替换只在展示层：safeAccumulated 供事件消费者（终端/JSONL）使用，
+                                // fullText 原文用于持久化上下文，避免替换结果回流污染上下文。
+                                const safeText = applyPrivacy(part.text);
+                                safeAccumulated += safeText;
+                                yield { type: "text", text: safeText, accumulated: safeAccumulated };
+                            }
+                            else if (part.type === "tool-call") {
+                                const input = safeJson(part.input);
+                                toolContext.push(`tool_call ${part.toolName}: ${input}`);
+                                toolCallsById.set(part.toolCallId, { id: part.toolCallId, name: part.toolName, input });
+                                toolCallOrder.push(part.toolCallId);
+                                timeline.push({ type: "tool_use", id: part.toolCallId, name: part.toolName, input });
+                                yield {
+                                    type: "tool_use",
+                                    id: part.toolCallId,
+                                    name: part.toolName,
+                                    input: applyPrivacyToJson(part.input),
+                                };
+                            }
+                            else if (part.type === "tool-result") {
+                                const output = truncateToolContext(safeJson(part.output));
+                                toolContext.push(`tool_result ${part.toolName}: ${output}`);
+                                const call = toolCallsById.get(part.toolCallId);
+                                if (call)
+                                    call.output = output;
+                                timeline.push({ type: "tool_result", tool_use_id: part.toolCallId, name: part.toolName, output });
+                                yield {
+                                    type: "tool_result",
+                                    tool_use_id: part.toolCallId,
+                                    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;
+                                }
+                                timeline.push({ type: "tool_result", tool_use_id: part.toolCallId, name: part.toolName, output: message, is_error: true });
+                                yield {
+                                    type: "tool_result",
+                                    tool_use_id: part.toolCallId,
+                                    name: part.toolName,
+                                    content: applyPrivacy(message),
+                                    is_error: true,
+                                };
+                            }
+                            else if (part.type === "error") {
+                                if (pendingInjection !== null) {
+                                    // prepareStep 里的注入中断被 provider 转成了 error part。
+                                    throw new InputInjectionInterrupt();
+                                }
+                                const message = errorMessage(part.error);
+                                yield { type: "error", message: applyPrivacy(message) };
+                                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})`);
+                            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
+                                ? "工具调用协议异常：检测到混合的结构化调用与伪造工具文本，为避免重复执行工具，本轮已安全终止"
+                                : "工具调用协议异常：模型重试后仍输出了无效或伪造的工具调用文本");
+                        }
+                        completed = true;
+                        const collectedToolCalls = toolCallOrder
+                            .map((id) => toolCallsById.get(id))
+                            .filter((call) => call !== undefined);
+                        this.context.appendMessage(buildPersistedAssistantMessage({
+                            fullText,
+                            transcriptLines: toolContext,
+                            toolCalls: collectedToolCalls,
+                            timeline,
+                        }));
+                        yield { type: "done", text: safeAccumulated };
+                        return;
                     }
                 }
-                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})`);
-                    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" };
+                catch (err) {
+                    if (pendingInjection !== null) {
+                        // 协作式让位：持久化本段中间态 → 注入 user → 重建 messages → 继续当前 turn。
+                        if (fullText.trim() || toolCallOrder.length > 0) {
+                            const collectedToolCalls = toolCallOrder
+                                .map((id) => toolCallsById.get(id))
+                                .filter((call) => call !== undefined);
+                            this.context.appendMessage(buildPersistedAssistantMessage({
+                                fullText,
+                                transcriptLines: toolContext,
+                                toolCalls: collectedToolCalls,
+                                timeline: timeline.map((entry) => ({ ...entry })),
+                            }));
+                        }
+                        const injectedText = pendingInjection;
+                        this.context.appendMessage({ role: "user", content: injectedText });
+                        rawLog?.writeLine(safeRawStreamJson({
+                            type: "deepccc_input_injected",
+                            text: injectedText,
+                        }));
+                        yield { type: "input_injected", text: injectedText };
+                        currentMessages = decorateMessages(this.context.buildModelMessages());
                         continue;
                     }
-                    throw new Error(toolCallOrder.length > 0
-                        ? "工具调用协议异常：检测到混合的结构化调用与伪造工具文本，为避免重复执行工具，本轮已安全终止"
-                        : "工具调用协议异常：模型重试后仍输出了无效或伪造的工具调用文本");
+                    throw err;
                 }
-                completed = true;
-                const collectedToolCalls = toolCallOrder
-                    .map((id) => toolCallsById.get(id))
-                    .filter((call) => call !== undefined);
-                this.context.appendMessage(buildPersistedAssistantMessage({
-                    fullText,
-                    transcriptLines: toolContext,
-                    toolCalls: collectedToolCalls,
-                    timeline,
-                }));
-                yield { type: "done", text: safeAccumulated };
-                return;
             }
         }
         catch (err) {

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

@@ -102,5 +102,11 @@ export function reduceProgress(prev, event) {
         case "compact":
             // 旧上下文压缩不影响当前过程展示
             return prev;
+        case "input_injected": {
+            // 协作式让位：在当前 turn 的 step 边界注入了新消息，仅在头部提示，
+            // 不改动正文与工具状态。
+            const preview = event.text.length > 40 ? `${event.text.slice(0, 40)}…` : event.text;
+            return withProgressView(prev, { headerTitle: `已注入新消息：${preview}` });
+        }
     }
 }

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

@@ -52,7 +52,7 @@ export function createCccAdapter(options = {}) {
             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)) {
+            for await (const event of session.chat(userText, signal, _promptOptions?.drainInput)) {
                 if (event.type === "text")
                     completion.observe({ type: "assistant", blocks: [{ type: "text", text: event.text }] });
                 if (event.type === "text_reset")
@@ -78,6 +78,12 @@ export function createCccAdapter(options = {}) {
                         blocks: [{ type: "text_reset" }],
                     };
                 }
+                else if (event.type === "input_injected") {
+                    yield {
+                        type: "assistant",
+                        blocks: [{ type: "input_injected", text: event.text }],
+                    };
+                }
                 else if (event.type === "text") {
                     yield {
                         type: "assistant",