@jingyi0605/codingns4dsh 0.2.1-beta.11 → 0.2.1-beta.13

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

@@ -1,5 +1,6 @@
 import { runAsyncCommand } from './process-utils.js';
 import { spawn, spawnSync } from 'node:child_process';
+import { randomUUID } from 'node:crypto';
 import { homedir } from 'node:os';
 import { basename, dirname, isAbsolute, join, relative, resolve, sep } from 'node:path';
 import { JsonRpcProcess } from './json-rpc-process.js';
@@ -14,13 +15,17 @@ import { ACP_FORM_CLIENT_CAPABILITIES, acpElicitationResponse, readAcpElicitatio
 import { readAgentQuestions } from './interaction-events.js';
 import { commandEnvironment, WINDOWS } from './process-utils.js';
 import { imageArtifactPathsFromValue, stripImageMarkdown } from '../image-artifact-store.js';
+import { advanceCodingNsSegment, createCodingNsSegmentState, decorateCodingNsSegmentEvent } from './stream-normalizer.js';
+import { GrokContextUsage, GrokPromptUsage } from './grok-usage.js';
 /** Grok Build 的 ACP stdio 驱动。ACP 会话和权限细节只在 Host 进程内处理。 */
 export class GrokBuildDriver {
     descriptor = { id: 'grok', name: 'Grok Build', protocol: 'acp', capabilities: ['models', 'skills', 'stream', 'tool-events', 'reasoning', 'usage', 'permission', 'questions'] };
+    supportsStreamStepSplitting = true;
     binaries;
     runSpawnSync;
     runSpawn;
     sessionRoots;
+    now;
     cachedBinary = null;
     processes = new Set();
     sessions = new Map();
@@ -28,6 +33,7 @@ export class GrokBuildDriver {
         this.binaries = options.binaries ?? ['grok', 'grok-build'];
         this.runSpawnSync = options.spawnSync ?? spawnSync;
         this.runSpawn = options.spawn ?? spawn;
+        this.now = options.now ?? Date.now;
         this.sessionRoots = options.sessionRoots ?? [join(process.env.GROK_HOME ?? join(homedir(), '.grok'), 'sessions')];
     }
     async detect() {
@@ -106,26 +112,45 @@ export class GrokBuildDriver {
         const rpc = state.rpc;
         let providerSessionId = state.providerSessionId;
         let stream;
+        let reusable = false;
+        const promptId = randomUUID();
+        const segmentState = createCodingNsSegmentState();
+        let stepPhase;
+        let stepStreamId;
+        const activeTools = new Map();
+        const streamedToolInputs = new Map();
         try {
             if (providerSessionId === '') {
                 const session = await rpc.request('session/new', {
                     cwd: input.cwd ?? process.cwd(),
                     mcpServers: acpBridgeMcpServers(input.sessionId, this.descriptor.id),
-                    ...(!isProviderDefaultModel(input.modelId) ? { model: input.modelId } : {}),
                 }, { signal: input.signal });
                 providerSessionId = readSessionId(session) ?? input.sessionId;
+                state.contextUsage.observe(session);
                 state.providerSessionId = providerSessionId;
                 this.sessions.set(input.sessionId, state);
                 this.sessions.set(providerSessionId, state);
             }
             yield { type: 'session-binding', providerSessionId };
+            // Grok 1.0.52 ignores the model field on session/new. Apply explicit
+            // selections after both creation and restoration, including reused sessions.
+            if (input.modelId && !isProviderDefaultModel(input.modelId)) {
+                const selected = await rpc.request('session/set_model', { sessionId: providerSessionId, modelId: input.modelId }, { signal: input.signal });
+                state.contextUsage.modelId = input.modelId;
+                state.contextUsage.observe(selected);
+            }
+            if (input.effortId) {
+                await rpc.request('session/set_config_option', { sessionId: providerSessionId, configId: 'reasoning_effort', value: input.effortId }, { signal: input.signal });
+            }
             // Skill 斜杠命令由 Grok 在用户输入开头解析，不能把普通提示插到命令前。
             const nativeCommand = /^\s*\/[A-Za-z0-9][A-Za-z0-9._:-]*(?:\s|$)/u.test(input.prompt);
             const prompt = [
                 ...(nativeCommand ? [] : [{ type: 'text', text: GROK_QUESTION_GUIDANCE }]),
                 ...await buildAcpPromptBlocks(input.prompt, input.attachments ?? []),
             ];
-            stream = streamGrokPrompt(rpc, providerSessionId, prompt, input.signal, (notification) => {
+            const usage = new GrokPromptUsage(promptId, state.contextUsage, this.now);
+            stream = streamGrokPrompt(rpc, providerSessionId, promptId, prompt, input.signal, (notification) => {
+                usage.observe(notification);
                 const elicitation = readAcpElicitationRequest(notification);
                 if (elicitation !== null)
                     state.questions.set(elicitation.requestId, elicitation);
@@ -136,8 +161,9 @@ export class GrokBuildDriver {
                 // 已回答的问题被重新登记。tool_call 可以先显示问题卡并暂存用户答案。
                 const requestId = interactionRequestId(notification);
                 if (requestId !== null && notification.id !== undefined && notification.id !== null)
-                    state.requests.set(requestId, { rpcId: notification.id, ...permissionOptions(notification) });
-            });
+                    state.requests.set(requestId, { rpcId: notification.id, callId: permissionCallId(notification), ...permissionOptions(notification) });
+                return usage.takeObservation();
+            }, response => { usage.observeResponse(response); return usage.takeObservation(); });
             let finishResult;
             while (true) {
                 const item = await stream.next();
@@ -145,12 +171,25 @@ export class GrokBuildDriver {
                     finishResult = item.value;
                     break;
                 }
-                for (const rawChunk of acpMessageToChunks(item.value)) {
-                    const chunk = rawChunk.type === 'image-artifact'
+                if (item.value.codingnsGrokObservation !== undefined)
+                    yield item.value.codingnsGrokObservation;
+                const streamId = grokStreamId(item.value);
+                for (const rawChunk of grokToolInputChunks(item.value, streamedToolInputs) ?? acpMessageToChunks(item.value)) {
+                    // Settle native turn accounting once, after the terminal drain. Per-call
+                    // usage is retained by the RPC observer solely for timing and fallback.
+                    if (rawChunk.type === 'usage')
+                        continue;
+                    let resolved = rawChunk.type === 'image-artifact'
                         ? await resolveGrokImageArtifact(rawChunk, state, this.sessionRoots)
                         : rawChunk;
-                    if (chunk === null)
+                    if (resolved === null)
                         continue;
+                    if (resolved.type === 'tool-event' && resolved.status === 'failed' && resolved.callId) {
+                        const denial = state.permissionDenials.get(resolved.callId);
+                        if (denial !== undefined)
+                            resolved = { ...resolved, error: denial, output: denial, outputMode: 'snapshot' };
+                    }
+                    const chunk = decorateCodingNsSegmentEvent(resolved, input, segmentState, this.descriptor.id);
                     if (chunk.type === 'question-request' && state.grokQuestionCallIds.has(chunk.requestId)) {
                         if (state.grokQuestionEventIds.has(chunk.requestId))
                             continue;
@@ -160,15 +199,56 @@ export class GrokBuildDriver {
                     // 工具记录，否则历史里会重新出现空参数或重复的问题调用。
                     if (chunk.type === 'tool-event' && chunk.callId !== undefined && state.grokQuestionCallIds.has(chunk.callId))
                         continue;
+                    const phase = grokStepPhase(chunk);
+                    if (phase !== undefined) {
+                        // DSH persists assistant content only at step settlement. End the content
+                        // step before native tools are appended, and keep unfinished parallel calls
+                        // together so their results cannot be finalized by an intermediate step.
+                        if (input.splitToolSteps && stepPhase !== undefined && activeTools.size === 0
+                            && (phase !== stepPhase || (streamId !== undefined && stepStreamId !== undefined && streamId !== stepStreamId))) {
+                            yield { type: 'step-boundary' };
+                        }
+                        stepPhase = phase;
+                        if (streamId !== undefined)
+                            stepStreamId = streamId;
+                    }
+                    if (chunk.type === 'tool-event') {
+                        const callId = chunk.callId ?? chunk.toolName;
+                        if (chunk.status === 'completed' || chunk.status === 'failed')
+                            activeTools.delete(callId);
+                        else
+                            activeTools.set(callId, chunk.toolName === 'tool' ? activeTools.get(callId) ?? chunk.toolName : chunk.toolName);
+                    }
                     yield chunk;
+                    advanceCodingNsSegment(chunk, segmentState);
+                    if (chunk.type === 'question-request')
+                        segmentState.segment += 1;
                 }
             }
-            if (finishResult.reason === 'cancel') {
-                try {
-                    await rpc.request('session/cancel', { sessionId: providerSessionId }, { killOnAbort: false });
+            const settledUsage = usage.finish();
+            if (settledUsage !== undefined) {
+                const { requestPerformance: _observed, ...accounting } = settledUsage;
+                yield accounting;
+            }
+            if (finishResult.failure?.code === 'PERMISSION_DENIED') {
+                const denial = [...state.permissionDenials.values()].at(-1);
+                if (denial !== undefined)
+                    finishResult = { ...finishResult, failure: { message: denial, code: 'PERMISSION_DENIED' } };
+            }
+            // A normal prompt stop does not confirm pending tool execution. Keep the
+            // observed arguments and make the unknown outcome explicit without retrying.
+            if (activeTools.size > 0) {
+                for (const [callId, toolName] of activeTools) {
+                    const error = 'Grok ended the turn without reporting a final result for this tool; its outcome is unconfirmed.';
+                    yield decorateCodingNsSegmentEvent({ type: 'tool-event', callId, toolName, status: 'failed', error, output: error, outputMode: 'snapshot' }, input, segmentState, this.descriptor.id);
                 }
-                catch { /* 不同 ACP 版本的取消方法可能不同，请求级取消已经先行发出。 */ }
+                if (finishResult.reason === 'stop')
+                    finishResult = {
+                        reason: 'error',
+                        failure: { message: 'Grok ended the turn before all tool results were confirmed.', code: 'INCOMPLETE_TOOL_RESULT' },
+                    };
             }
+            reusable = finishResult.reason === 'stop' && !input.signal?.aborted;
             yield { type: 'finish', reason: finishResult.reason, ...(finishResult.failure === undefined ? {} : { failure: finishResult.failure }) };
         }
         finally {
@@ -182,7 +262,15 @@ export class GrokBuildDriver {
             state.grokQuestions.clear();
             state.grokQuestionCallIds.clear();
             state.grokQuestionEventIds.clear();
-            // ACP 进程和会话跨轮复用，统一由 dispose() 回收。
+            state.questions.clear();
+            state.requests.clear();
+            state.permissionDenials.clear();
+            if (!reusable) {
+                // An abandoned prompt can keep producing updates without prompt metadata.
+                // Reload its persisted session on a fresh transport before accepting new input.
+                await rpc.disposeAndWait();
+                this.processes.delete(rpc);
+            }
         }
     }
     respondPermission(sessionId, response) {
@@ -194,7 +282,10 @@ export class GrokBuildDriver {
             throw new Error('The Grok permission request does not exist');
         state.requests.delete(response.requestId);
         const optionId = response.approved ? pending.allowOptionId : pending.rejectOptionId;
-        state.rpc.respond(pending.rpcId, { outcome: { outcome: 'selected', optionId } });
+        if (!response.approved || optionId === undefined) {
+            state.permissionDenials.set(pending.callId ?? response.requestId, response.reason ?? (response.approved ? 'Grok did not offer a one-time approval option.' : 'Grok tool execution was denied.'));
+        }
+        state.rpc.respond(pending.rpcId, { outcome: optionId === undefined ? { outcome: 'cancelled' } : { outcome: 'selected', optionId } });
     }
     respondQuestion(sessionId, response) {
         const state = this.sessions.get(sessionId);
@@ -216,25 +307,39 @@ export class GrokBuildDriver {
     dispose() { for (const process of this.processes)
         process.dispose(); this.processes.clear(); this.sessions.clear(); this.cachedBinary = null; }
     async getSession(input, command) {
+        const alwaysApprove = input.permission?.sandboxMode === 'danger-full-access' && input.permission.approvalPolicy === 'never';
         const previous = this.sessions.get(input.sessionId);
-        if (previous !== undefined && previous.cwd === input.cwd)
+        if (previous !== undefined && previous.cwd === input.cwd && previous.alwaysApprove === alwaysApprove && !previous.rpc.isClosed)
             return previous;
-        previous?.rpc.dispose();
-        const rpc = new JsonRpcProcess({ command, args: ['agent', '--no-leader', 'stdio'], cwd: input.cwd, env: grokRuntimeEnvironment(), spawn: this.runSpawn });
+        if (previous !== undefined) {
+            await previous.rpc.disposeAndWait();
+            this.processes.delete(previous.rpc);
+        }
+        const resumeId = input.providerSessionId ?? (previous?.cwd === input.cwd ? previous?.providerSessionId : undefined);
+        const rpc = new JsonRpcProcess({ command, args: ['agent', '--no-leader', ...(alwaysApprove ? ['--always-approve'] : []), 'stdio'], cwd: input.cwd, env: grokRuntimeEnvironment(), spawn: this.runSpawn });
         this.processes.add(rpc);
-        const state = { rpc, cwd: input.cwd, rawStoreRef: input.rawStoreRef, providerSessionId: '', requests: new Map(), questions: new Map(), grokQuestions: new Map(), grokQuestionCallIds: new Set(), grokQuestionEventIds: new Set() };
-        await rpc.request('initialize', {
+        const state = { rpc, contextUsage: new GrokContextUsage(), cwd: input.cwd, rawStoreRef: input.rawStoreRef, alwaysApprove, providerSessionId: '', requests: new Map(), permissionDenials: new Map(), questions: new Map(), grokQuestions: new Map(), grokQuestionCallIds: new Set(), grokQuestionEventIds: new Set() };
+        rpc.addNotificationListener(message => {
+            const params = isRecord(message.params) ? message.params : {};
+            const owner = state.providerSessionId || resumeId;
+            if (owner && typeof params.sessionId === 'string' && params.sessionId !== owner)
+                return;
+            state.contextUsage.observe(message);
+        });
+        const initialized = await rpc.request('initialize', {
             protocolVersion: 1,
             clientInfo: { name: 'codingns4dsh', version: '0.1.1' },
             // 旧版 Grok 读取 capabilities；标准 ACP 读取 clientCapabilities。
             capabilities: ACP_FORM_CLIENT_CAPABILITIES,
             clientCapabilities: ACP_FORM_CLIENT_CAPABILITIES,
         });
+        state.contextUsage.observe(initialized);
         rpc.notify('initialized', {});
-        if (input.providerSessionId) {
+        if (resumeId) {
             try {
-                const loaded = await rpc.request('session/load', { sessionId: input.providerSessionId, cwd: input.cwd ?? process.cwd(), mcpServers: acpBridgeMcpServers(input.sessionId, this.descriptor.id) });
-                state.providerSessionId = readSessionId(loaded) ?? input.providerSessionId;
+                const loaded = await rpc.request('session/load', { sessionId: resumeId, cwd: input.cwd ?? process.cwd(), mcpServers: acpBridgeMcpServers(input.sessionId, this.descriptor.id) });
+                state.contextUsage.observe(loaded);
+                state.providerSessionId = readSessionId(loaded) ?? resumeId;
             }
             catch { /* 旧版 ACP 没有 load，下一轮在同一进程创建新会话 */ }
         }
@@ -263,7 +368,7 @@ export class GrokBuildDriver {
             const requestId = interactionRequestId(message);
             if (requestId === null || message.id === undefined || message.id === null)
                 return { outcome: { outcome: 'cancelled' } };
-            state.requests.set(requestId, { rpcId: message.id, ...permissionOptions(message) });
+            state.requests.set(requestId, { rpcId: message.id, callId: permissionCallId(message), ...permissionOptions(message) });
             return new Promise(() => undefined);
         });
         this.sessions.set(input.sessionId, state);
@@ -293,13 +398,14 @@ const GROK_QUESTION_GUIDANCE = [
  * Grok 可能先返回 prompt 响应，再补发最后一批 session/update。
  * 响应或终态任一先到都会启动固定排空窗口，窗口内的文本和错误仍会被消费。
  */
-async function* streamGrokPrompt(rpc, sessionId, prompt, signal, onNotification) {
+async function* streamGrokPrompt(rpc, sessionId, promptId, prompt, signal, onNotification, onResponse) {
     const queue = [];
     const requestController = new AbortController();
     let wake;
     let drainDeadline = null;
     let terminalReason = null;
     let failure;
+    let completed = false;
     const notify = () => { wake?.(); wake = undefined; };
     const beginDrain = () => {
         if (drainDeadline === null)
@@ -307,8 +413,10 @@ async function* streamGrokPrompt(rpc, sessionId, prompt, signal, onNotification)
         notify();
     };
     const listener = (message) => {
-        queue.push(message);
-        onNotification(message);
+        if (!isGrokPromptMessage(message, sessionId, promptId))
+            return;
+        const observation = onNotification(message);
+        queue.push(observation === undefined ? message : { ...message, codingnsGrokObservation: observation });
         const notificationReason = grokNotificationReason(message);
         if (notificationReason === null) {
             notify();
@@ -320,8 +428,6 @@ async function* streamGrokPrompt(rpc, sessionId, prompt, signal, onNotification)
             if (detail !== undefined)
                 failure = detail;
         }
-        // 部分 Grok 版本只发终态通知而不回复 prompt，主动取消可清理待处理请求。
-        requestController.abort();
         beginDrain();
     };
     const removeListener = rpc.addNotificationListener(listener);
@@ -336,19 +442,29 @@ async function* streamGrokPrompt(rpc, sessionId, prompt, signal, onNotification)
         onAbort();
     else
         signal?.addEventListener('abort', onAbort, { once: true });
-    void rpc.request('session/prompt', {
-        sessionId,
-        prompt,
-    }, { signal: requestController.signal, killOnAbort: false }).then((response) => {
-        const responseReason = grokPromptReason(response);
-        if (responseReason !== null)
-            terminalReason = mergeGrokReason(terminalReason, responseReason);
-        beginDrain();
-    }, () => {
-        if (terminalReason === null)
-            terminalReason = signal?.aborted ? 'cancel' : 'error';
-        beginDrain();
-    });
+    if (!signal?.aborted)
+        void rpc.request('session/prompt', {
+            sessionId,
+            prompt,
+            _meta: { promptId },
+        }, { signal: requestController.signal, killOnAbort: false }).then((response) => {
+            if (signal?.aborted)
+                return;
+            const observation = onResponse(response);
+            if (observation !== undefined)
+                queue.push({ method: 'codingns/grok-observation', codingnsGrokObservation: observation });
+            const responseReason = grokPromptReason(response);
+            if (responseReason !== null)
+                terminalReason = mergeGrokReason(terminalReason, responseReason);
+            failure ??= grokPermissionFailure(response);
+            beginDrain();
+        }, () => {
+            if (requestController.signal.aborted)
+                return;
+            if (terminalReason === null)
+                terminalReason = signal?.aborted ? 'cancel' : 'error';
+            beginDrain();
+        });
     try {
         while (true) {
             if (queue.length > 0) {
@@ -368,18 +484,81 @@ async function* streamGrokPrompt(rpc, sessionId, prompt, signal, onNotification)
             ]);
             wake = undefined;
         }
+        completed = true;
         return { reason: terminalReason ?? 'stop', ...(failure === undefined ? {} : { failure }) };
     }
     finally {
         signal?.removeEventListener('abort', onAbort);
         removeListener();
+        if (!completed || signal?.aborted) {
+            // ACP cancellation is a notification; waiting for an RPC response can hang.
+            try {
+                rpc.notify('session/cancel', { sessionId });
+            }
+            catch { /* The process may already have exited. */ }
+        }
+        // Terminal-only providers and consumers that close the iterator both need cleanup.
+        requestController.abort();
     }
 }
+function isGrokPromptMessage(message, sessionId, promptId) {
+    const params = isRecord(message.params) ? message.params : message;
+    if (typeof params.sessionId === 'string' && params.sessionId !== sessionId)
+        return false;
+    const update = isRecord(params.update) ? params.update : params;
+    const meta = isRecord(params._meta) ? params._meta : {};
+    if (meta.isReplay === true)
+        return false;
+    const owner = firstToolText(update.prompt_id, update.promptId, meta.promptId);
+    return owner === undefined || owner === promptId;
+}
+function grokToolInputChunks(message, inputs) {
+    const params = isRecord(message.params) ? message.params : message;
+    const update = isRecord(params.update) ? params.update : params;
+    if (update.sessionUpdate !== 'tool_call_delta_chunk' || !Number.isInteger(update.tool_index))
+        return null;
+    const index = update.tool_index;
+    const callId = firstToolText(update.tool_call_id, update.toolCallId);
+    // Argument fragments omit the call id; a new id resets a reused model-call index.
+    let pending = inputs.get(index);
+    const started = callId !== undefined && pending?.callId !== callId;
+    if (started) {
+        pending = { callId, toolName: firstToolText(update.name, update.title) ?? 'tool', arguments: '' };
+        inputs.set(index, pending);
+    }
+    if (pending === undefined)
+        return [];
+    if (typeof update.arguments_delta === 'string')
+        pending.arguments += update.arguments_delta;
+    let input;
+    try {
+        const parsed = JSON.parse(pending.arguments);
+        if (isRecord(parsed))
+            input = JSON.stringify(parsed);
+    }
+    catch { /* Do not persist incomplete JSON as a tool's final arguments. */ }
+    if (!started && input === undefined)
+        return [];
+    return [{
+            type: 'tool-event', callId: pending.callId, toolName: pending.toolName, status: 'running',
+            ...(input === undefined ? {} : { input }),
+        }];
+}
 function grokPromptReason(value) {
-    if (!isRecord(value) || typeof value.stopReason !== 'string')
+    if (!isRecord(value))
         return null;
-    const reason = value.stopReason.toLowerCase();
-    return reason === 'cancelled' || reason === 'error' || reason === 'failed' ? 'error' : 'stop';
+    const reason = firstToolText(value.stopReason, value.stop_reason)?.toLowerCase();
+    if (reason === undefined)
+        return null;
+    if (reason === 'cancelled' || reason === 'canceled')
+        return grokPermissionFailure(value) === undefined ? 'cancel' : 'error';
+    return reason === 'error' || reason === 'failed' ? 'error' : 'stop';
+}
+function grokPermissionFailure(value) {
+    if (!isRecord(value) || !isRecord(value._meta) || value._meta.cancellationCategory !== 'PermissionRejected')
+        return undefined;
+    const context = isRecord(value._meta.cancellationContext) ? value._meta.cancellationContext : {};
+    return { message: firstToolText(context.reason) ?? 'Grok tool execution was denied.', code: 'PERMISSION_DENIED' };
 }
 function mergeGrokReason(current, next) {
     if (current === 'error' || next === 'error')
@@ -396,15 +575,20 @@ function grokNotificationReason(message) {
         : typeof update.type === 'string'
             ? update.type.toLowerCase()
             : '';
-    if (type.includes('error') || type.includes('failed'))
+    if (['turn_error', 'turn_failed', 'error', 'failed'].includes(type))
         return 'error';
-    if (type.includes('turn_completed') || type.includes('turn_complete') || type === 'completed' || type === 'done')
-        return 'stop';
+    if (['turn_completed', 'turn_complete', 'prompt_complete', 'completed', 'done'].includes(type)) {
+        const reason = grokPromptReason(update) ?? 'stop';
+        return reason === 'cancel' && grokPermissionFailure(params) !== undefined ? 'error' : reason;
+    }
     return null;
 }
 function grokFailure(message) {
     const params = isRecord(message.params) ? message.params : message;
     const update = isRecord(params.update) ? params.update : params;
+    const permissionFailure = grokPermissionFailure(update) ?? grokPermissionFailure(params);
+    if (permissionFailure !== undefined)
+        return permissionFailure;
     const error = isRecord(update.error) ? update.error : update;
     const detail = firstToolText(error.message, error.errorMessage, error.error_message, error.detail, error.reason);
     if (detail === undefined)
@@ -481,6 +665,23 @@ function grokQuestionResponse(pending, response) {
         ...(Object.keys(annotations).length === 0 ? {} : { annotations }),
     };
 }
+function grokStreamId(message) {
+    const params = isRecord(message.params) ? message.params : message;
+    const meta = isRecord(params._meta) ? params._meta : {};
+    return typeof meta.streamStartMs === 'number' && Number.isFinite(meta.streamStartMs)
+        ? `grok-stream-${meta.streamStartMs}` : undefined;
+}
+function grokStepPhase(event) {
+    switch (event.type) {
+        case 'text-delta':
+        case 'reasoning-delta': return event.text.length > 0 ? 'message' : undefined;
+        case 'image-artifact': return 'message';
+        case 'tool-event':
+        case 'question-request':
+        case 'permission-request': return 'tools';
+        default: return undefined;
+    }
+}
 function acpMessageToChunks(message) {
     const params = isRecord(message.params) ? message.params : message;
     const update = isRecord(params.update) ? params.update : params;
@@ -506,9 +707,12 @@ function acpMessageToChunks(message) {
     const markdownPaths = imageArtifactPathsFromValue(text ?? '');
     const imagePaths = [...new Set([...artifactPaths, ...markdownPaths])];
     const imageEvents = imagePaths.map((path) => ({ type: 'image-artifact', path }));
+    // Grok identifies each model call independently of the enclosing user prompt.
+    const messageId = grokStreamId(message);
+    const identity = messageId === undefined ? {} : { messageId };
     const reasoning = reasoningText(update);
     if (reasoning !== null)
-        return [...imageEvents, { type: 'reasoning-delta', text: reasoning }];
+        return [...imageEvents, { type: 'reasoning-delta', text: reasoning, ...identity }];
     if (type.includes('permission')) {
         const requestId = permissionRequestId(message) ?? (typeof update.requestId === 'string' ? update.requestId : typeof update.id === 'string' ? update.id : null);
         if (requestId !== null) {
@@ -520,13 +724,13 @@ function acpMessageToChunks(message) {
     }
     if (type.includes('agent_message') || type.includes('text') || type === 'message') {
         const visible = text === null ? '' : stripImageMarkdown(text, markdownPaths);
-        const textEvent = visible === '' ? undefined : { type: 'text-delta', text: visible };
+        const textEvent = visible === '' ? undefined : { type: 'text-delta', text: visible, ...identity };
         return [...imageEvents, ...(textEvent === undefined ? [] : [textEvent])];
     }
     if (type.includes('image') || type.includes('artifact') || type.includes('generated'))
         return imageEvents;
     if (type.includes('thought') || type.includes('reason'))
-        return text ? [{ type: 'reasoning-delta', text }] : [];
+        return text ? [{ type: 'reasoning-delta', text, ...identity }] : [];
     if (type.includes('tool') || type.includes('command')) {
         const tool = isToolRecord(update.toolCall) ? update.toolCall : isToolRecord(update.tool_call) ? update.tool_call : update;
         const name = firstToolText(tool.name, tool.toolName, tool.tool_name, tool.title, update.name, update.toolName, update.title);
@@ -534,13 +738,19 @@ function acpMessageToChunks(message) {
         if (!name && !callId)
             return [];
         const input = serializeToolValue(tool.rawInput ?? tool.input ?? tool.arguments ?? tool.args ?? update.rawInput);
-        const output = serializeToolValue(tool.rawOutput ?? tool.output ?? tool.result ?? update.rawOutput);
+        // ACP tool results can contain nested text blocks without a rawOutput field.
+        const content = tool.content ?? update.content;
+        const contentText = Array.isArray(content)
+            ? content.flatMap((block) => isRecord(block) ? textValue(block.content ?? block) ?? [] : []).join('\n') || undefined
+            : undefined;
+        const rawOutput = serializeToolValue(tool.rawOutput ?? tool.output ?? tool.result ?? update.rawOutput);
+        const output = rawOutput ?? contentText;
         const error = serializeToolValue(tool.error ?? update.error);
         const agentId = firstToolText(tool.agentId, tool.agent_id, update.agentId, update.agent_id);
         const detail = serializeToolValue(tool.detail ?? update.detail ?? update.content);
         const fallback = error !== undefined || type.includes('error') || type.includes('fail')
             ? 'failed'
-            : output !== undefined || type.includes('result') || type.includes('complete')
+            : rawOutput !== undefined || type.includes('result') || type.includes('complete')
                 ? 'completed'
                 : 'running';
         return [...imageEvents, {
@@ -599,6 +809,12 @@ function permissionRequestId(message) {
 function interactionRequestId(message) {
     return permissionRequestId(message);
 }
+function permissionCallId(message) {
+    const params = isRecord(message.params) ? message.params : message;
+    const update = isRecord(params.update) ? params.update : params;
+    const tool = isRecord(update.toolCall) ? update.toolCall : isRecord(update.tool_call) ? update.tool_call : update;
+    return firstToolText(tool.toolCallId, tool.tool_call_id, tool.callId, tool.call_id);
+}
 function permissionOptions(message) {
     const params = isRecord(message.params) ? message.params : {};
     const options = Array.isArray(params.options) ? params.options : [];
@@ -610,9 +826,17 @@ function permissionOptions(message) {
             return [];
         return [{ id, kind: firstToolText(option.kind, option.type)?.toLowerCase() ?? '' }];
     });
+    if (ids.length === 0)
+        return { allowOptionId: 'allow-once', rejectOptionId: 'reject-once' };
+    // Grok lists allow_always before allow_once. A DSH one-time approval must
+    // never become a persistent grant merely because of provider option order.
     return {
-        allowOptionId: ids.find((option) => /allow|approve|accept/u.test(option.kind))?.id ?? ids[0]?.id ?? 'allow-once',
-        rejectOptionId: ids.find((option) => /reject|deny|decline|cancel/u.test(option.kind))?.id ?? ids[1]?.id ?? 'reject-once',
+        allowOptionId: ids.find((option) => option.kind === 'allow_once')?.id
+            ?? ids.find((option) => /^(allow|approve|accept)$/u.test(option.kind))?.id
+            ?? (ids[0]?.kind === '' ? ids[0].id : undefined),
+        rejectOptionId: ids.find((option) => option.kind === 'reject_once')?.id
+            ?? ids.find((option) => /^(reject|deny|decline|cancel)$/u.test(option.kind))?.id
+            ?? (ids[1]?.kind === '' ? ids[1].id : undefined),
     };
 }
 function readSessionId(value) {