@jingyi0605/codingns4dsh 0.1.1 → 0.1.7-rc.2

package/data/build/dist/host/cli-adapters/command-code-driver.js

@@ -5,7 +5,7 @@ import { join } from 'node:path';
 import readline from 'node:readline';
 import { firstToolText, serializeToolValue } from './tool-observation.js';
 import { usageChunk } from './rpc-driver-utils.js';
-import { terminateChildProcess } from './process-utils.js';
+import { commandEnvironment, resolveCommandPath, terminateChildProcess } from './process-utils.js';
 const WINDOWS = process.platform === 'win32';
 const COMMAND_CODE_BINARIES = WINDOWS
     ? ['command-code', 'commandcode', 'cmdc']
@@ -91,8 +91,12 @@ const CATALOG_EFFORTS = new Map([
     ['xai/grok-4.7', ['low', 'medium', 'high', 'xhigh']],
 ]);
 /**
- * Command Code 驱动：沿用附件中的 `--session + -p + --output-format json` 方式。
- * 它只负责 CLI 进程和事件转换，不把 Command Code 私有事件泄漏给上层。
+ * Command Code 驱动：沿用 `--session + -p + --output-format json` 的 NDJSON 事件流。
+ *
+ * 与 Codex 驱动保持同一套消息优化：正文/推理增量携带 assistant 消息身份，工具完成后
+ * 的下一条 assistant 消息之前结束当前 DSH step，因此一个 Provider 运行会被切成多个
+ * step，而不是把整轮正文堆积到最后一条结算消息里。驱动只输出公共事件契约，工具历史、
+ * usage 和原生组件映射全部交给公共消息投影层。
  */
 export class CommandCodeDriver {
     descriptor = {
@@ -101,12 +105,16 @@ export class CommandCodeDriver {
         protocol: 'command',
         capabilities: ['models', 'stream', 'resume', 'interrupt', 'tool-events', 'reasoning', 'usage'],
     };
+    /** 驱动自己维护 Provider turn 边界，Host 可以把工具边界映射为 DSH step。 */
+    supportsSegmentedTurns = true;
     homeDirectory;
     binaries;
     runSpawnSync;
     runSpawn;
     cachedBinary = null;
+    cachedEnvironment;
     processes = new Set();
+    turns = new Map();
     constructor(options = {}) {
         this.homeDirectory = options.homeDirectory ?? join(homedir(), '.commandcode');
         this.binaries = options.binaries ?? COMMAND_CODE_BINARIES;
@@ -115,28 +123,47 @@ export class CommandCodeDriver {
     }
     async detect() {
         for (const command of this.binaries) {
-            try {
-                const result = this.runSpawnSync(command, ['--version'], { encoding: 'utf8', timeout: 3_000, windowsHide: true, shell: WINDOWS });
-                const output = `${result.stdout ?? ''}${result.stderr ?? ''}`.trim();
-                const version = output.match(/\d+\.\d+\.\d+/u)?.[0] ?? null;
-                if (result.status === 0 && version !== null) {
-                    this.cachedBinary = command;
-                    return { installed: true, version, command };
-                }
-            }
-            catch {
-                // PATH 中不存在候选命令属于正常的未安装状态。
-            }
+            const direct = this.detectCommand(command);
+            if (direct !== null)
+                return direct;
+            if (!this.lookupAfterDetectionFailure)
+                continue;
+            const resolved = resolveCommandPath(command, this.runSpawnSync);
+            if (resolved === null)
+                continue;
+            const fallback = this.detectCommand(resolved);
+            if (fallback !== null)
+                return fallback;
         }
         return { installed: false, version: null, command: null };
     }
+    lookupAfterDetectionFailure = false;
+    detectCommand(command) {
+        this.lookupAfterDetectionFailure = false;
+        try {
+            const result = this.runSpawnSync(command, ['--version'], { encoding: 'utf8', timeout: 3_000, windowsHide: true, shell: WINDOWS, env: commandEnvironment(command) });
+            const output = `${result.stdout ?? ''}${result.stderr ?? ''}`.trim();
+            const version = output.match(/\d+\.\d+\.\d+/u)?.[0] ?? null;
+            if (result.status === 0 && version !== null) {
+                this.cachedBinary = command;
+                this.cachedEnvironment = commandEnvironment(command);
+                return { installed: true, version, command };
+            }
+            this.lookupAfterDetectionFailure = result.status === null;
+        }
+        catch {
+            // PATH 中不存在候选命令属于正常的未安装状态。
+            this.lookupAfterDetectionFailure = true;
+        }
+        return null;
+    }
     async listModels() {
         const detection = await this.detect();
         if (!detection.installed || detection.command === null)
             return emptyCatalog();
         let stdout = '';
         try {
-            const result = this.runSpawnSync(detection.command, ['--list-models'], { encoding: 'utf8', timeout: 12_000, windowsHide: true, shell: WINDOWS });
+            const result = this.runSpawnSync(detection.command, ['--list-models'], { encoding: 'utf8', timeout: 12_000, windowsHide: true, shell: WINDOWS, ...(this.cachedEnvironment === undefined ? {} : { env: this.cachedEnvironment }) });
             stdout = result.stdout ?? '';
         }
         catch {
@@ -177,6 +204,52 @@ export class CommandCodeDriver {
         const binary = this.cachedBinary ?? (await this.detect()).command;
         if (binary === null)
             throw new Error('Command Code 未安装');
+        const segmented = input.splitToolSteps === true;
+        const turn = segmented ? this.acquireTurn(input, binary) : this.startTurn(input, binary);
+        let suspended = false;
+        const onAbort = () => { turn.aborted = true; this.disposeTurn(turn); };
+        input.signal?.addEventListener('abort', onAbort, { once: true });
+        if (input.signal?.aborted)
+            onAbort();
+        try {
+            yield* this.consumeTurn(turn, input, segmented, () => { suspended = true; });
+        }
+        finally {
+            input.signal?.removeEventListener('abort', onAbort);
+            // 只有驱动自己为下一个 DSH step 挂起时才保留进程；正常结束、取消和调用方
+            // 提前关闭流都必须回收 CLI 进程与临时 transcript。
+            if (!suspended)
+                this.disposeTurn(turn);
+        }
+    }
+    dispose() {
+        for (const turn of [...this.turns.values()])
+            this.disposeTurn(turn);
+        this.turns.clear();
+        for (const child of this.processes)
+            terminateChildProcess(child);
+        this.processes.clear();
+        this.cachedBinary = null;
+    }
+    /** 丢弃等待下一个 DSH step 的 `-p` 运行，避免旧进程继续占用新一轮输出。 */
+    discardSegmentedTurn(sessionId) {
+        const turn = this.turns.get(sessionId);
+        if (turn !== undefined)
+            this.disposeTurn(turn);
+    }
+    /** 只有 Host 显式声明续段时才复用常驻进程；新的用户回合必须重新启动。 */
+    acquireTurn(input, binary) {
+        const existing = this.turns.get(input.sessionId);
+        if (existing !== undefined) {
+            if (input.resumeSegmentedTurn === true && !existing.disposed && !existing.finished)
+                return existing;
+            this.disposeTurn(existing);
+        }
+        const turn = this.startTurn(input, binary);
+        this.turns.set(input.sessionId, turn);
+        return turn;
+    }
+    startTurn(input, binary) {
         const transcriptPath = join(tmpdir(), `codingns4dsh-cc-${safeId(input.sessionId)}.jsonl`);
         writeTranscript(transcriptPath, input);
         const args = ['--session', transcriptPath, '-p', input.prompt, '--output-format', 'json', '--tools-all', '--yolo'];
@@ -184,15 +257,39 @@ export class CommandCodeDriver {
             args.push('-m', input.modelId);
         if (input.effortId && input.effortId !== 'default' && input.effortId !== 'Default')
             args.push('--effort', input.effortId);
-        const child = this.runSpawn(binary, args, { cwd: input.cwd ?? process.cwd(), env: { ...process.env }, stdio: ['ignore', 'pipe', 'pipe'], windowsHide: true, shell: WINDOWS });
+        const child = this.runSpawn(binary, args, { cwd: input.cwd ?? process.cwd(), env: this.cachedEnvironment ?? commandEnvironment(binary), stdio: ['ignore', 'pipe', 'pipe'], windowsHide: true, shell: WINDOWS });
         this.processes.add(child);
-        let finished = false;
-        const onAbort = () => { terminateChildProcess(child); };
-        input.signal?.addEventListener('abort', onAbort, { once: true });
         // 必须消费 stderr，错误内容不能回传给 DSH，避免泄露命令参数或文件片段。
-        child.stderr.on('data', () => undefined);
+        child.stderr?.on('data', () => undefined);
+        const turn = {
+            sessionId: input.sessionId,
+            child,
+            transcriptPath,
+            queue: createEventQueue(),
+            currentMessageId: undefined,
+            sawCompletedTool: false,
+            pendingChunk: undefined,
+            terminal: false,
+            finished: false,
+            aborted: false,
+            failure: null,
+            disposed: false,
+        };
+        // 未监听 error 的 ChildProcess 会把 spawn 失败升级成宿主进程异常。
+        if (typeof child.on === 'function') {
+            child.on('error', (error) => {
+                turn.failure ??= error;
+                turn.queue.close();
+            });
+        }
+        void this.pumpTurn(turn);
+        return turn;
+    }
+    /** 常驻读取 stdout：NDJSON 转成公共事件，进程结束后关闭队列。 */
+    async pumpTurn(turn) {
+        const state = createStreamState(() => turn.aborted);
         try {
-            const lines = readline.createInterface({ input: child.stdout });
+            const lines = readline.createInterface({ input: turn.child.stdout });
             try {
                 for await (const line of lines) {
                     if (!line.trim())
@@ -201,62 +298,234 @@ export class CommandCodeDriver {
                     if (item === null)
                         continue;
                     const event = item.type === 'event' && isRecord(item.event) ? item.event : item;
-                    const eventType = textValue(event.type).toLowerCase();
-                    const chunks = commandCodeEventChunks(event, input.signal?.aborted ?? false);
-                    for (const chunk of chunks) {
+                    for (const chunk of commandCodeEventChunks(event, state)) {
                         if (chunk.type === 'finish')
-                            finished = true;
-                        yield chunk;
+                            turn.terminal = true;
+                        turn.queue.push(chunk);
                     }
-                    if (eventType === 'result' && !finished)
-                        finished = true;
                 }
             }
             finally {
                 lines.close();
             }
-            if (!finished) {
-                if (input.signal?.aborted)
-                    yield { type: 'finish', reason: 'cancel' };
-                else
-                    throw new Error('Command Code 执行失败');
-            }
+        }
+        catch (error) {
+            turn.failure ??= error instanceof Error ? error : new Error(String(error));
         }
         finally {
-            input.signal?.removeEventListener('abort', onAbort);
-            this.processes.delete(child);
-            terminateChildProcess(child);
-            try {
-                rmSync(transcriptPath, { force: true });
+            turn.queue.close();
+            this.processes.delete(turn.child);
+        }
+    }
+    async *consumeTurn(turn, input, segmented, suspend) {
+        while (true) {
+            let chunk;
+            if (turn.pendingChunk !== undefined) {
+                chunk = turn.pendingChunk;
+                turn.pendingChunk = undefined;
+            }
+            else {
+                const next = await turn.queue.next();
+                if (next.done) {
+                    if (turn.failure !== null)
+                        throw turn.failure;
+                    if (turn.terminal)
+                        return;
+                    if (turn.aborted || input.signal?.aborted === true) {
+                        yield { type: 'finish', reason: 'cancel' };
+                        return;
+                    }
+                    throw new Error('Command Code 执行失败');
+                }
+                chunk = next.value;
+            }
+            // 一个 `-p` 运行会在同一进程里连续跑多个 agent turn。把新 assistant 消息的
+            // 首个正文留给下一次 llm/stream，当前流只返回边界，确保 DSH 先创建新 step。
+            if (segmented
+                && (chunk.type === 'text-delta' || chunk.type === 'reasoning-delta')
+                && chunk.messageId !== undefined) {
+                const previousMessageId = turn.currentMessageId;
+                if (previousMessageId !== undefined
+                    && previousMessageId !== chunk.messageId
+                    && turn.sawCompletedTool) {
+                    turn.pendingChunk = chunk;
+                    turn.currentMessageId = chunk.messageId;
+                    turn.sawCompletedTool = false;
+                    suspend();
+                    yield { type: 'step-boundary' };
+                    return;
+                }
+                turn.currentMessageId = chunk.messageId;
+            }
+            if (chunk.type === 'tool-event' && (chunk.status === 'completed' || chunk.status === 'failed')) {
+                turn.sawCompletedTool = true;
             }
-            catch { /* 临时文件清理尽力而为 */ }
+            if (chunk.type === 'finish')
+                turn.finished = true;
+            yield chunk;
         }
     }
-    dispose() {
-        for (const child of this.processes)
-            terminateChildProcess(child);
-        this.processes.clear();
-        this.cachedBinary = null;
+    disposeTurn(turn) {
+        if (turn.disposed)
+            return;
+        turn.disposed = true;
+        turn.queue.close();
+        if (this.turns.get(turn.sessionId) === turn)
+            this.turns.delete(turn.sessionId);
+        this.processes.delete(turn.child);
+        terminateChildProcess(turn.child);
+        try {
+            rmSync(turn.transcriptPath, { force: true });
+        }
+        catch { /* 临时文件清理尽力而为 */ }
     }
 }
-function commandCodeEventChunks(event, cancelled) {
+function createStreamState(aborted) {
+    return {
+        messageSequence: 0,
+        messageId: null,
+        emittedText: '',
+        emittedReasoning: '',
+        sawText: false,
+        perRequestUsageSeen: false,
+        turnUsageSeen: false,
+        sessionId: null,
+        aborted,
+    };
+}
+function createEventQueue() {
+    const values = [];
+    const waiters = [];
+    let closed = false;
+    const next = () => {
+        const value = values.shift();
+        if (value !== undefined)
+            return Promise.resolve({ done: false, value });
+        if (closed)
+            return Promise.resolve({ done: true, value: undefined });
+        return new Promise((resolve) => waiters.push(resolve));
+    };
+    return {
+        next,
+        push(event) {
+            if (closed)
+                return;
+            const waiter = waiters.shift();
+            if (waiter !== undefined)
+                waiter({ done: false, value: event });
+            else
+                values.push(event);
+        },
+        close() {
+            if (closed)
+                return;
+            closed = true;
+            while (waiters.length > 0)
+                waiters.shift()?.({ done: true, value: undefined });
+        },
+    };
+}
+/**
+ * Command Code NDJSON → 公共 Agent 事件。
+ *
+ * 关键约定（对照本机 1.66.0 真实事件流）：
+ * - `turn_start` / `message_start` 标识新的 assistant 消息，正文和推理增量都带上它；
+ * - `tool_*` 使用 `toolCallId` 作为稳定调用 ID，同一调用的 queued/running/completed
+ *   只能投影成一个 DSH 工具节点；
+ * - `model_request_end` 的 usage 是当前请求的上下文占用；`run_end`/最终 `result`
+ *   的 usage 是整个运行的累计值，只在完全没有单请求 usage 时兜底。
+ */
+function commandCodeEventChunks(event, state) {
     const chunks = [];
     const type = textValue(event.type).trim().toLowerCase();
-    const sessionId = textValue(event.sessionId ?? event.session_id ?? recordValue(event.session)?.id ?? recordValue(event.result)?.sessionId).trim();
-    if (sessionId)
+    const sessionId = readSessionId(event);
+    if (sessionId !== null && sessionId !== state.sessionId) {
+        state.sessionId = sessionId;
         chunks.push({ type: 'session-binding', providerSessionId: sessionId });
-    if (type === 'thinking_delta' || type === 'thinking-delta') {
-        const text = textValue(event.delta ?? event.thinking ?? event.content);
-        if (text)
-            chunks.push({ type: 'reasoning-delta', text });
-    }
-    else if (type === 'text_delta' || type === 'text-delta') {
-        const text = textValue(event.delta ?? event.text ?? event.content);
-        if (text)
-            chunks.push({ type: 'text-delta', text });
     }
-    else if (type === 'message' || type === 'message_update' || type === 'message-update') {
-        appendMessageSnapshots(chunks, event);
+    switch (type) {
+        case 'turn_start':
+        case 'turn-start':
+            beginMessage(state);
+            break;
+        case 'message_start':
+        case 'message-start':
+            // 正常一轮只有一个模型请求；没有 turn_start 的旧版本由这里补消息身份。
+            if (state.messageId === null)
+                beginMessage(state);
+            break;
+        case 'text_delta':
+        case 'text-delta': {
+            const text = textValue(event.delta ?? event.text ?? event.content);
+            if (text) {
+                ensureMessage(state);
+                state.emittedText += text;
+                state.sawText = true;
+                chunks.push(textDelta(text, state));
+            }
+            break;
+        }
+        case 'thinking_delta':
+        case 'thinking-delta': {
+            const text = textValue(event.delta ?? event.thinking ?? event.content);
+            if (text) {
+                ensureMessage(state);
+                state.emittedReasoning += text;
+                chunks.push(reasoningDelta(text, state));
+            }
+            break;
+        }
+        case 'message':
+        case 'message_update':
+        case 'message-update':
+        case 'message_end':
+        case 'message-end':
+            // 只补齐增量流没有覆盖到的正文，避免累计快照被重复追加。
+            appendContentFallback(chunks, event.content ?? recordValue(event.message)?.content, state);
+            break;
+        case 'model_request_end':
+        case 'model-request-end': {
+            const usage = usageChunk(recordValue(event.usage));
+            if (usage !== null) {
+                state.perRequestUsageSeen = true;
+                state.turnUsageSeen = true;
+                chunks.push(usage);
+            }
+            break;
+        }
+        case 'turn_end':
+        case 'turn-end': {
+            // 旧版本可能只在 turn_end 带 usage；与 model_request_end 去重，不重复结算。
+            if (!state.turnUsageSeen) {
+                const usage = usageChunk(recordValue(event.usage));
+                if (usage !== null) {
+                    state.perRequestUsageSeen = true;
+                    state.turnUsageSeen = true;
+                    chunks.push(usage);
+                }
+            }
+            break;
+        }
+        case 'result': {
+            if (!state.perRequestUsageSeen) {
+                const usage = usageChunk(recordValue(event.usage));
+                if (usage !== null)
+                    chunks.push(usage);
+            }
+            if (!state.sawText) {
+                const finalText = textValue(event.finalText ?? recordValue(event.result)?.finalText ?? (typeof event.result === 'string' ? event.result : undefined));
+                if (finalText) {
+                    ensureMessage(state);
+                    state.sawText = true;
+                    state.emittedText += finalText;
+                    chunks.push(textDelta(finalText, state));
+                }
+            }
+            chunks.push({ type: 'finish', reason: state.aborted() ? 'cancel' : resultReason(event) });
+            break;
+        }
+        default:
+            break;
     }
     if (isToolStart(type)) {
         const tool = readToolChunk(event, type === 'tool_queued' || type === 'tool_started' ? 'started' : 'running');
@@ -264,62 +533,82 @@ function commandCodeEventChunks(event, cancelled) {
             chunks.push(tool);
     }
     else if (isToolResult(type)) {
-        const tool = readToolChunk(event, type.includes('error') || type.includes('fail') || type.includes('denied') ? 'failed' : 'completed');
-        if (tool !== null)
+        const failed = type.includes('error') || type.includes('fail') || type.includes('denied') || type.includes('blocked');
+        const tool = readToolChunk(event, failed ? 'failed' : 'completed');
+        if (tool !== null) {
             chunks.push(tool);
-    }
-    const resultRecord = recordValue(event.result);
-    const usage = recordValue(event.usage) ?? recordValue(resultRecord?.usage);
-    const usageEvent = usageChunk(usage);
-    if (usageEvent !== null)
-        chunks.push(usageEvent);
-    if (type === 'result') {
-        const finalText = textValue(event.finalText ?? resultRecord?.finalText ?? (typeof event.result === 'string' ? event.result : undefined) ?? event.output ?? event.text);
-        if (finalText)
-            chunks.push({ type: 'text-snapshot', text: finalText });
-        chunks.push({ type: 'finish', reason: cancelled ? 'cancel' : 'stop' });
+            // 工具完成后的正文属于下一条 assistant 消息。即使 CLI 没有发送
+            // turn_start/message_start，也要让公共投影层看到消息身份切换。
+            if (tool.status === 'completed' || tool.status === 'failed')
+                resetMessageIdentity(state);
+        }
     }
     return chunks;
 }
-function appendMessageSnapshots(chunks, event) {
-    const payload = recordValue(event.message ?? event.data) ?? event;
-    if (Array.isArray(payload.content)) {
-        const snapshots = new Map();
-        for (const block of payload.content) {
-            const value = recordValue(block);
-            if (value === null)
-                continue;
-            const blockType = textValue(value.type).toLowerCase();
-            const channel = blockType.includes('thinking') || blockType.includes('reasoning') ? 'reasoning' : 'text';
-            const text = channel === 'reasoning'
-                ? textValue(value.thinking ?? value.reasoning ?? value.text ?? value.content)
-                : textValue(value.text ?? value.content);
-            if (!text)
-                continue;
-            const values = snapshots.get(channel) ?? [];
-            values.push(text);
-            snapshots.set(channel, values);
-        }
-        for (const [channel, values] of snapshots)
-            chunks.push({ type: `${channel}-snapshot`, text: values.join('') });
+function beginMessage(state) {
+    state.messageSequence += 1;
+    state.messageId = `command-code-message-${state.messageSequence}`;
+    state.emittedText = '';
+    state.emittedReasoning = '';
+    state.turnUsageSeen = false;
+}
+/** 丢弃当前消息身份；下一条正文增量会懒加载新的身份。 */
+function resetMessageIdentity(state) {
+    state.messageId = null;
+    state.emittedText = '';
+    state.emittedReasoning = '';
+}
+function ensureMessage(state) {
+    if (state.messageId === null)
+        beginMessage(state);
+}
+function textDelta(text, state) {
+    return { type: 'text-delta', text, ...(state.messageId === null ? {} : { messageId: state.messageId }) };
+}
+function reasoningDelta(text, state) {
+    return { type: 'reasoning-delta', text, ...(state.messageId === null ? {} : { messageId: state.messageId }) };
+}
+/** 用完整的 assistant content 补齐缺失的正文/推理增量（只发送尚未发送的尾部）。 */
+function appendContentFallback(chunks, content, state) {
+    if (!Array.isArray(content))
         return;
+    let text = '';
+    let reasoning = '';
+    for (const block of content) {
+        const value = recordValue(block);
+        if (value === null)
+            continue;
+        const blockType = textValue(value.type).toLowerCase();
+        const isReasoning = blockType.includes('thinking') || blockType.includes('reasoning')
+            || typeof value.thinking === 'string' || typeof value.reasoning === 'string';
+        if (isReasoning)
+            reasoning += textValue(value.thinking ?? value.reasoning ?? value.text ?? value.content);
+        else
+            text += textValue(value.text ?? value.content);
+    }
+    if (text.length > state.emittedText.length) {
+        const delta = text.slice(state.emittedText.length);
+        ensureMessage(state);
+        state.emittedText = text;
+        state.sawText = true;
+        chunks.push(textDelta(delta, state));
+    }
+    if (reasoning.length > state.emittedReasoning.length) {
+        const delta = reasoning.slice(state.emittedReasoning.length);
+        ensureMessage(state);
+        state.emittedReasoning = reasoning;
+        chunks.push(reasoningDelta(delta, state));
     }
-    const reasoning = textValue(payload.thinking ?? payload.reasoning);
-    if (reasoning)
-        chunks.push({ type: 'reasoning-snapshot', text: reasoning });
-    const text = textValue(payload.text ?? payload.content ?? event.text ?? event.content);
-    if (text)
-        chunks.push({ type: 'text-snapshot', text });
 }
 function readToolChunk(event, status) {
-    const callId = textValue(event.callId ?? event.call_id ?? event.toolUseId ?? event.tool_use_id ?? event.id);
+    const callId = firstToolText(event.callId, event.call_id, event.toolCallId, event.tool_call_id, event.toolUseId, event.tool_use_id, event.id);
     const fn = recordValue(event.function);
-    const toolName = textValue(event.name ?? event.toolName ?? event.tool ?? fn?.name) || 'tool';
-    const error = textValue(event.error ?? event.reason);
+    const toolName = textValue(event.name ?? event.toolName ?? event.tool_name ?? event.tool ?? fn?.name) || 'tool';
+    const error = textValue(event.error ?? event.reason ?? event.message);
     const output = textValue(event.output ?? event.result ?? event.content);
     const input = event.input ?? fn?.arguments ?? event.arguments;
     const agentId = firstToolText(event.agentId, event.agent_id);
-    const detail = serializeToolValue(event.detail ?? event.metadata);
+    const detail = serializeToolValue(event.detail ?? event.metadata ?? event.description);
     if (!callId && !toolName)
         return null;
     return {
@@ -339,7 +628,21 @@ function isToolStart(type) {
     return ['tool_queued', 'tool_started', 'tool_running', 'tool_use', 'tool_call', 'function_call'].includes(type);
 }
 function isToolResult(type) {
-    return ['tool_completed', 'tool_result', 'tool_return', 'tool_failed', 'tool_error', 'tool_denied', 'function_result'].includes(type);
+    return ['tool_completed', 'tool_result', 'tool_return', 'tool_failed', 'tool_error', 'tool_denied', 'tool_hook_blocked', 'function_result'].includes(type);
+}
+function resultReason(event) {
+    const resultRecord = recordValue(event.result);
+    const stopReason = textValue(event.stopReason ?? resultRecord?.stopReason).toLowerCase();
+    const subtype = textValue(event.subtype).toLowerCase();
+    if (event.error !== undefined || subtype === 'error' || stopReason.includes('error') || stopReason.includes('fail'))
+        return 'error';
+    if (stopReason.includes('interrupt') || stopReason.includes('cancel') || stopReason === 'aborted')
+        return 'cancel';
+    return 'stop';
+}
+function readSessionId(event) {
+    const value = textValue(event.sessionId ?? event.session_id ?? recordValue(event.session)?.id ?? recordValue(event.result)?.sessionId).trim();
+    return value === '' ? null : value;
 }
 function textValue(value) {
     return typeof value === 'string' ? value : value === undefined || value === null ? '' : structuredText(value);

package/data/build/dist/host/cli-adapters/driver.d.ts

@@ -29,6 +29,8 @@ export interface CodingNsCliDriver {
     readonly descriptor: Omit<CodingNsCliAdapterDescriptor, 'installed' | 'enabled' | 'version' | 'command'>;
     /** 驱动是否已经自行维护 Provider turn 的 step 边界。 */
     readonly supportsSegmentedTurns?: boolean;
+    /** 丢弃等待下一个 DSH step 的 Provider 运行；只有自行分段的驱动需要实现。 */
+    discardSegmentedTurn?(sessionId: string): void;
     detect(): Promise<Pick<CodingNsCliAdapterDescriptor, 'installed' | 'version' | 'command'>>;
     listModels(): Promise<CodingNsCliModelCatalog>;
     probeSession?(input: CodingNsCliSessionProbeInput): Promise<CodingNsCliSessionProbeResult>;

package/data/build/dist/host/cli-adapters/dsh-message-projector.d.ts

@@ -27,6 +27,8 @@ export declare class CodingNsDshMessageProjector {
     private reasoningText;
     private textText;
     private finished;
+    /** 只要收到正文、工具、usage 或交互事件，就说明 Provider 确实产出了结果。 */
+    private receivedProviderEvent;
     constructor(options: CodingNsDshMessageProjectorOptions);
     get isFinished(): boolean;
     push(event: CodingNsAgentEvent): Promise<readonly CodingNsDshStreamChunk[]>;