@exreve/exk 1.0.48 → 1.0.50

package/dist/agentSession.js

@@ -99,6 +99,12 @@ function extractToolName(toolResult) {
             return 'Edit';
         return (toolResult.content !== undefined || toolResult.type === 'create') ? 'Write' : 'Read';
     }
+    // Grep: {mode, numFiles, filenames, content, numLines}
+    if (toolResult.numFiles !== undefined && toolResult.filenames !== undefined && toolResult.mode !== undefined)
+        return 'Grep';
+    // Glob: {type, pattern, files}
+    if (toolResult.files !== undefined && toolResult.pattern !== undefined && !toolResult.stdout)
+        return 'Glob';
     if (toolResult.stdout !== undefined || toolResult.stderr !== undefined)
         return 'Bash';
     // send_file tool: content is JSON with _type marker — detect before Bash fallback
@@ -122,7 +128,12 @@ function lookupToolNameFromHistory(messages, toolUseId) {
         const msg = messages[i];
         if (msg.role !== 'assistant')
             continue;
-        const content = typeof msg.content === 'string' ? null : msg.content;
+        // msg.content is the SDK message object: {role: 'assistant', content: [{type: 'text',...}, {type: 'tool_use',...}]}
+        let content = typeof msg.content === 'string' ? null : msg.content;
+        // Unwrap nested content: {content: [...]} → [...]
+        if (content && !Array.isArray(content) && Array.isArray(content.content)) {
+            content = content.content;
+        }
         if (!Array.isArray(content))
             continue;
         const toolUse = content.find((c) => c.type === 'tool_use' && c.id === toolUseId);
@@ -960,10 +971,14 @@ export class AgentSessionManager {
                         }
                         else if (message.type === 'user') {
                             const msg = message;
-                            // SDK 0.2.x: tool results appear in message.content as tool_result blocks.
-                            // The tool_use_id is ALWAYS in message.content[].tool_use_id — never in
-                            // the top-level tool_use_result field.  We must extract it from message.content
-                            // first, then use either parsed content blocks or tool_use_result as the data source.
+                            // SDK sends tool results with TWO data sources:
+                            //   message.content[0]  — {type:'tool_result', tool_use_id:'...', content: <raw text>}
+                            //   msg.tool_use_result  — structured object with {stdout,stderr} for Bash,
+                            //                          {type,file} for Read, or [{type:'text',text:'...'}] for MCP tools
+                            //
+                            // The tool_use_id lives ONLY in message.content[].tool_use_id.
+                            // The structured result lives in tool_use_result for built-in tools.
+                            // For MCP tools, tool_use_result is a content-block array we need to parse.
                             let toolResult = null;
                             let toolUseId = msg.parent_tool_use_id;
                             // STEP 1: Always extract tool_use_id from message.content (authoritative source)
@@ -974,8 +989,41 @@ export class AgentSessionManager {
                                     toolUseId = toolResultBlock.tool_use_id;
                                 }
                             }
-                            // STEP 2: Try to parse the actual result from message.content tool_result block
-                            if (Array.isArray(msg.message?.content)) {
+                            // STEP 2: Use tool_use_result as the primary data source.
+                            // For built-in tools (Bash, Read, Edit, Write, Glob, Grep) it's a structured
+                            // object like {stdout, stderr} or {type:'text', file:{...}} — use directly.
+                            // For MCP tools it's a content-block array [{type:'text', text:'...'}] — parse text.
+                            if (msg.tool_use_result) {
+                                const raw = msg.tool_use_result;
+                                if (Array.isArray(raw)) {
+                                    // MCP tool result: [{type:'text', text:'...'}] — extract and parse
+                                    const textParts = raw
+                                        .filter((c) => c.type === 'text')
+                                        .map((c) => c.text);
+                                    const rawContent = textParts.join('\n');
+                                    try {
+                                        toolResult = JSON.parse(rawContent);
+                                    }
+                                    catch {
+                                        toolResult = { content: rawContent, type: 'text' };
+                                    }
+                                }
+                                else if (typeof raw === 'object' && raw !== null) {
+                                    // Built-in tool result: {stdout, stderr, ...} or {type, file, ...} — use directly
+                                    toolResult = raw;
+                                }
+                                else if (typeof raw === 'string') {
+                                    try {
+                                        toolResult = JSON.parse(raw);
+                                    }
+                                    catch {
+                                        toolResult = { content: raw, type: 'text' };
+                                    }
+                                }
+                            }
+                            // STEP 3: Fallback to parsing message.content if tool_use_result wasn't available
+                            // (e.g. subagent calls where tool_use_result may be absent)
+                            if (!toolResult && Array.isArray(msg.message?.content)) {
                                 const contentBlocks = msg.message.content;
                                 const toolResultBlock = contentBlocks.find((c) => c.type === 'tool_result');
                                 if (toolResultBlock) {
@@ -988,7 +1036,6 @@ export class AgentSessionManager {
                                         }
                                     }
                                     else if (Array.isArray(toolResultBlock.content)) {
-                                        // Extract text from content blocks and try to parse as JSON
                                         const textParts = toolResultBlock.content
                                             .filter((c) => c.type === 'text')
                                             .map((c) => c.text);
@@ -1005,40 +1052,12 @@ export class AgentSessionManager {
                                     }
                                 }
                             }
-                            // STEP 3: Fallback to top-level tool_use_result if message.content didn't yield a result
-                            // (present in SDK 0.1.x and some 0.2.x messages).  Parse the raw content blocks.
-                            if (!toolResult && msg.tool_use_result) {
-                                const raw = msg.tool_use_result;
-                                if (Array.isArray(raw)) {
-                                    // tool_use_result is [{type:"text", text:"..."}] — extract and parse text
-                                    const textParts = raw
-                                        .filter((c) => c.type === 'text')
-                                        .map((c) => c.text);
-                                    const rawContent = textParts.join('\n');
-                                    try {
-                                        toolResult = JSON.parse(rawContent);
-                                    }
-                                    catch {
-                                        toolResult = { content: rawContent, type: 'text' };
-                                    }
-                                }
-                                else if (typeof raw === 'string') {
-                                    try {
-                                        toolResult = JSON.parse(raw);
-                                    }
-                                    catch {
-                                        toolResult = { content: raw, type: 'text' };
-                                    }
-                                }
-                                else {
-                                    toolResult = raw;
-                                }
-                            }
                             if (toolResult) {
+                                // History lookup is authoritative: the assistant's tool_use block names the tool.
+                                // Heuristic detection can't distinguish Bash/Grep/Glob/etc (all have {stdout,stderr}).
+                                const historyName = lookupToolNameFromHistory(session.messages, toolUseId);
                                 const detectedName = extractToolName(toolResult);
-                                const resolvedName = detectedName !== 'unknown'
-                                    ? detectedName
-                                    : (lookupToolNameFromHistory(session.messages, toolUseId) || detectedName);
+                                const resolvedName = historyName || detectedName;
                                 onOutput({
                                     type: 'tool_result',
                                     data: toolResult,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@exreve/exk",
-  "version": "1.0.48",
+  "version": "1.0.50",
   "description": "exk - Control Claude CLI with voice and programmable interfaces",
   "type": "module",
   "bin": {
@@ -61,4 +61,4 @@
   "engines": {
     "node": ">=20.0.0"
   }
-}
+}