@exreve/exk 1.0.13 → 1.0.15

package/dist/agentSession.js

@@ -51,12 +51,35 @@ function extractToolName(toolResult) {
     if (toolResult.type === 'text' && toolResult.file)
         return 'Read';
     if (toolResult.file_path || toolResult.filePath) {
+        // Has old_string/new_string → Edit; has content/create → Write; else Read
+        if (toolResult.old_string !== undefined && toolResult.new_string !== undefined)
+            return 'Edit';
         return (toolResult.content !== undefined || toolResult.type === 'create') ? 'Write' : 'Read';
     }
     if (toolResult.stdout !== undefined || toolResult.stderr !== undefined)
         return 'Bash';
+    // SDK 0.2.x: content-only results from nested tool calls (no stdout/stderr wrapper)
+    if (toolResult.content && typeof toolResult.content === 'string' && toolResult.type === 'text')
+        return 'Bash';
     return 'unknown';
 }
+// Look up tool name from the most recent assistant message's tool_use blocks by tool_use_id
+function lookupToolNameFromHistory(messages, toolUseId) {
+    if (!toolUseId)
+        return null;
+    for (let i = messages.length - 1; i >= 0; i--) {
+        const msg = messages[i];
+        if (msg.role !== 'assistant')
+            continue;
+        const content = typeof msg.content === 'string' ? null : msg.content;
+        if (!Array.isArray(content))
+            continue;
+        const toolUse = content.find((c) => c.type === 'tool_use' && c.id === toolUseId);
+        if (toolUse?.name)
+            return toolUse.name;
+    }
+    return null;
+}
 // AI config - loaded from server after registration, stored in ~/.talk-to-code/ai-config.json
 // (Do not read ANTHROPIC_* / CLAUDE_MODEL from the host environment — only this file + code default model.)
 const AI_CONFIG_PATH = path.join(os.homedir(), '.talk-to-code', 'ai-config.json');
@@ -251,6 +274,13 @@ export class AgentSessionManager {
         if (!session.isProcessingQueue) {
             this.processPromptQueue(sessionId);
         }
+        else if (session.isProcessingQueue && !session.activeQueryStream && !this.emergencyStopInProgress.has(sessionId)) {
+            // Safety: isProcessingQueue is true but there's no active stream and no emergency stop
+            // This means the queue got stuck (e.g. from a previous abort return that bypassed cleanup)
+            console.warn(`[agentSession] Queue stuck detected for session ${sessionId}, resetting isProcessingQueue`);
+            session.isProcessingQueue = false;
+            this.processPromptQueue(sessionId);
+        }
     }
     async processPromptQueue(sessionId) {
         const session = this.sessions.get(sessionId);
@@ -647,19 +677,62 @@ export class AgentSessionManager {
                         }
                         else if (message.type === 'user') {
                             const msg = message;
+                            // SDK 0.2.x: tool results can appear in two places:
+                            // 1. msg.tool_use_result (top-level field, present in 0.1.x and some 0.2.x messages)
+                            // 2. msg.message.content array with type='tool_result' blocks (common in 0.2.x subagent calls)
+                            let toolResult = null;
+                            let toolUseId = msg.parent_tool_use_id;
+                            // Check top-level tool_use_result first
                             if (msg.tool_use_result) {
-                                const toolResult = msg.tool_use_result;
-                                let toolUseId = msg.parent_tool_use_id;
-                                if (!toolUseId && Array.isArray(msg.message.content)) {
-                                    const toolResultContent = msg.message.content.find((c) => c.type === 'tool_result' && c.tool_use_id);
-                                    toolUseId = toolResultContent?.tool_use_id || null;
+                                toolResult = msg.tool_use_result;
+                            }
+                            // Check message.content for tool_result blocks (SDK 0.2.x nested calls)
+                            if (!toolResult && Array.isArray(msg.message?.content)) {
+                                const contentBlocks = msg.message.content;
+                                const toolResultBlock = contentBlocks.find((c) => c.type === 'tool_result');
+                                if (toolResultBlock) {
+                                    // Extract tool use ID from the content block
+                                    if (toolResultBlock.tool_use_id) {
+                                        toolUseId = toolResultBlock.tool_use_id;
+                                    }
+                                    // The result content can be a string or array of content blocks
+                                    if (typeof toolResultBlock.content === 'string') {
+                                        try {
+                                            toolResult = JSON.parse(toolResultBlock.content);
+                                        }
+                                        catch {
+                                            toolResult = { content: toolResultBlock.content, type: 'text' };
+                                        }
+                                    }
+                                    else if (Array.isArray(toolResultBlock.content)) {
+                                        // Extract text from content blocks
+                                        const textParts = toolResultBlock.content
+                                            .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 {
+                                        toolResult = toolResultBlock;
+                                    }
                                 }
+                            }
+                            if (toolResult) {
+                                const detectedName = extractToolName(toolResult);
+                                const resolvedName = detectedName !== 'unknown'
+                                    ? detectedName
+                                    : (lookupToolNameFromHistory(session.messages, toolUseId) || detectedName);
                                 onOutput({
                                     type: 'tool_result',
                                     data: toolResult,
                                     timestamp: Date.now(),
                                     metadata: {
-                                        toolName: extractToolName(toolResult),
+                                        toolName: resolvedName,
                                         toolResult: toolResult,
                                         toolUseId: toolUseId || undefined,
                                         parentToolUseId: msg.parent_tool_use_id,
@@ -785,7 +858,9 @@ export class AgentSessionManager {
                         onComplete(null);
                         session.activeQueryStream = undefined;
                         session.currentPromptId = undefined;
-                        return;
+                        // Use break instead of return to ensure isProcessingQueue gets reset
+                        // after the while loop at the end of processPromptQueue
+                        break;
                     }
                     // Re-throw non-abort errors
                     throw streamError;
@@ -972,24 +1047,46 @@ export class AgentSessionManager {
             if (!session) {
                 return { success: false, message: 'Session not found' };
             }
-            // 1. Abort all controllers (session level + all prompt-level)
+            // 1. Abort session-level controller only (not all sessions' controllers)
             session.abortController.abort();
-            for (const controller of this.promptAbortControllers.values()) {
-                controller.abort();
+            // Abort only controllers belonging to THIS session
+            // Find and abort controllers for prompts in this session's queue and current prompt
+            if (session.currentPromptId) {
+                const ctrl = this.promptAbortControllers.get(session.currentPromptId);
+                if (ctrl)
+                    ctrl.abort();
+            }
+            for (const queued of session.promptQueue) {
+                if (queued.abortController)
+                    queued.abortController.abort();
+                if (queued.promptId) {
+                    const ctrl = this.promptAbortControllers.get(queued.promptId);
+                    if (ctrl)
+                        ctrl.abort();
+                }
             }
             // 2. Kill the entire process tree
             await this.killProcessTree(sessionId);
-            // 3. Clear the prompt queue
+            // 3. Collect prompt IDs from queue BEFORE clearing it
             const queueSize = session.promptQueue.length;
+            const queuedPromptIds = session.promptQueue
+                .map(p => p.promptId)
+                .filter((id) => !!id);
+            const currentPromptId = session.currentPromptId;
+            // 4. Clear the prompt queue
             session.promptQueue = [];
-            // 4. Clear active stream
+            // 5. Clear active stream
             session.activeQueryStream = undefined;
-            // 5. Reset processing state
+            // 6. Reset processing state
             session.isProcessingQueue = false;
-            // 6. Clear current prompt tracking
-            const currentPromptId = session.currentPromptId;
-            // 7. Clean up abort controllers map
-            this.promptAbortControllers.clear();
+            // 7. Clean up abort controllers map (only for this session's prompts, not ALL sessions)
+            if (currentPromptId) {
+                this.promptAbortControllers.delete(currentPromptId);
+            }
+            for (const pid of queuedPromptIds) {
+                this.promptAbortControllers.delete(pid);
+            }
+            session.currentPromptId = undefined;
             // 8. Remove from emergency stop tracking
             this.emergencyStopInProgress.delete(sessionId);
             // 9. Resolve any pending choice request with null (cancelled)

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@exreve/exk",
-  "version": "1.0.13",
+  "version": "1.0.15",
   "description": "exk - Control Claude CLI with voice and programmable interfaces",
   "type": "module",
   "bin": {