snow-ai 0.4.5 → 0.4.7

package/dist/api/anthropic.js

@@ -97,13 +97,42 @@ function convertToAnthropicMessages(messages, includeBuiltinSystemPrompt = true)
             continue;
         }
         if (msg.role === 'tool' && msg.tool_call_id) {
+            // Build tool_result content - can be text or array with images
+            let toolResultContent;
+            if (msg.images && msg.images.length > 0) {
+                // Multimodal tool result with images
+                const contentArray = [];
+                // Add text content first
+                if (msg.content) {
+                    contentArray.push({
+                        type: 'text',
+                        text: msg.content,
+                    });
+                }
+                // Add images
+                for (const image of msg.images) {
+                    contentArray.push({
+                        type: 'image',
+                        source: {
+                            type: 'base64',
+                            media_type: image.mimeType,
+                            data: image.data,
+                        },
+                    });
+                }
+                toolResultContent = contentArray;
+            }
+            else {
+                // Text-only tool result
+                toolResultContent = msg.content;
+            }
             anthropicMessages.push({
                 role: 'user',
                 content: [
                     {
                         type: 'tool_result',
                         tool_use_id: msg.tool_call_id,
-                        content: msg.content,
+                        content: toolResultContent,
                     },
                 ],
             });

package/dist/api/chat.js

@@ -50,6 +50,31 @@ function convertToOpenAIMessages(messages, includeBuiltinSystemPrompt = true) {
             };
         }
         if (msg.role === 'tool' && msg.tool_call_id) {
+            // Handle multimodal tool results with images
+            if (msg.images && msg.images.length > 0) {
+                const content = [];
+                // Add text content
+                if (msg.content) {
+                    content.push({
+                        type: 'text',
+                        text: msg.content,
+                    });
+                }
+                // Add images as base64 data URLs
+                for (const image of msg.images) {
+                    content.push({
+                        type: 'image_url',
+                        image_url: {
+                            url: `data:${image.mimeType};base64,${image.data}`,
+                        },
+                    });
+                }
+                return {
+                    role: 'tool',
+                    content,
+                    tool_call_id: msg.tool_call_id,
+                };
+            }
             return {
                 role: 'tool',
                 content: msg.content,

package/dist/api/gemini.js

@@ -91,6 +91,18 @@ function convertToGeminiMessages(messages, includeBuiltinSystemPrompt = true) {
             // Tool response must be a valid object for Gemini API
             // If content is a JSON string, parse it; otherwise wrap it in an object
             let responseData;
+            const imageParts = [];
+            // Handle images from tool result
+            if (msg.images && msg.images.length > 0) {
+                for (const image of msg.images) {
+                    imageParts.push({
+                        inlineData: {
+                            mimeType: image.mimeType,
+                            data: image.data,
+                        },
+                    });
+                }
+            }
             if (!msg.content) {
                 responseData = {};
             }
@@ -132,16 +144,22 @@ function convertToGeminiMessages(messages, includeBuiltinSystemPrompt = true) {
                     responseData = { content: contentToParse };
                 }
             }
+            // Build parts array with functionResponse and optional images
+            const parts = [
+                {
+                    functionResponse: {
+                        name: functionName,
+                        response: responseData,
+                    },
+                },
+            ];
+            // Add images as inline data parts
+            if (imageParts.length > 0) {
+                parts.push(...imageParts);
+            }
             contents.push({
                 role: 'user',
-                parts: [
-                    {
-                        functionResponse: {
-                            name: functionName,
-                            response: responseData,
-                        },
-                    },
-                ],
+                parts,
             });
             continue;
         }

package/dist/api/responses.js

@@ -163,11 +163,38 @@ function convertToResponseInput(messages, includeBuiltinSystemPrompt = true) {
         }
         // Tool 消息：转换为 function_call_output
         if (msg.role === 'tool' && msg.tool_call_id) {
-            result.push({
-                type: 'function_call_output',
-                call_id: msg.tool_call_id,
-                output: msg.content,
-            });
+            // Handle multimodal tool results with images
+            if (msg.images && msg.images.length > 0) {
+                // For Responses API, we need to include images in a structured way
+                // The output can be an array of content items
+                const outputContent = [];
+                // Add text content
+                if (msg.content) {
+                    outputContent.push({
+                        type: 'input_text',
+                        text: msg.content,
+                    });
+                }
+                // Add images as base64 data URLs (Responses API format)
+                for (const image of msg.images) {
+                    outputContent.push({
+                        type: 'input_image',
+                        image_url: `data:${image.mimeType};base64,${image.data}`,
+                    });
+                }
+                result.push({
+                    type: 'function_call_output',
+                    call_id: msg.tool_call_id,
+                    output: outputContent,
+                });
+            }
+            else {
+                result.push({
+                    type: 'function_call_output',
+                    call_id: msg.tool_call_id,
+                    output: msg.content,
+                });
+            }
             continue;
         }
     }

package/dist/api/systemPrompt.js

@@ -78,88 +78,48 @@ const SYSTEM_PROMPT_TEMPLATE = `You are Snow AI CLI, an intelligent command-line
 
 ## Execution Strategy - BALANCE ACTION & ANALYSIS
 
-## Rigorous coding habits
-- In any programming language or business logic, which is usually accompanied by many-to-many references to files, you also need to think about the impact of the modification and whether it will conflict with the user's original business.
-- Using the optimal solution principle, you cannot choose risk scenarios such as hardcoding, logic simplification, etc., unless the user asks you to do so.
-- Avoid duplication, users may have encapsulated some reusable functions, and you should try to find them instead of creating a new function right away.
-- Compilable principle, you should not have low-level errors such as syntax errors, use tools to check for syntax errors, non-compilable code is meaningless.
+### Rigorous Coding Habits
+- **Location Code**: Must First use a search tool to locate the line number of the code, then use \`filesystem-read\` to read the code content
+- **Boundary verification**: MUST use \`filesystem-read\` to identify complete code boundaries before ANY edit. Never guess line numbers or code structure
+- **Impact analysis**: Consider modification impact and conflicts with existing business logic
+- **Optimal solution**: Avoid hardcoding/shortcuts unless explicitly requested
+- **Avoid duplication**: Search for existing reusable functions before creating new ones
+- **Compilable code**: No syntax errors - always verify complete syntactic units
 
 ### Smart Action Mode
 **Principle: Understand enough to code correctly, but don't over-investigate**
 
-**Examples:**
-- "Fix timeout in parser.ts" → Read file + check imports if needed → Fix → Done
-- "Add validation to form" → Read form component + related validation utils → Add code → Done
-- "Refactor error handling" → Read error handler + callers → Refactor → Done
+**Examples:** "Fix timeout in parser.ts" → Read file + check imports → Fix → Done
 
 PLACEHOLDER_FOR_WORKFLOW_SECTION
 
-**Golden Rule: Read what you need to write correct code, nothing more.**
+### TODO Management - USE ACTIVELY
+
+**STRONGLY RECOMMENDED: Create TODO for ALL multi-step tasks (3+ steps)** - Prevents missing steps, ensures systematic execution
+
+**When to use:** Multi-file changes, features, refactoring, bug fixes touching 2+ files
+**Skip only:** Single-file trivial edits (1-2 lines)
+
+**CRITICAL - PARALLEL CALLS ONLY:** ALWAYS call TODO tools WITH action tools in same function call block
+- CORRECT: todo-create + filesystem-read | todo-update + filesystem-edit
+- FORBIDDEN: NEVER call TODO tools alone then wait for result
+
+**Lifecycle:** New task → todo-create + initial action | Major change → delete + recreate | Minor → todo-add/update
 
-### TODO Management - STRONGLY RECOMMENDED for Better Results
-
-**DEFAULT BEHAVIOR: Use TODO for ALL multi-step tasks (3+ steps)**
-
-**WHY TODO IS ESSENTIAL:**
-- **Track progress** - Never lose your place in complex work
-- **Ensure completeness** - Verify all steps are done
-- **Stay focused** - Clear roadmap prevents confusion
-- **Build confidence** - Users see structured progress
-- **Better quality** - Systematic approach reduces errors
-
-**WHEN TO USE TODO (Default for most tasks):**
-- **ANY multi-file modification** (always use)
-- **ANY feature implementation** (always use)
-- **ANY refactoring task** (always use)
-- **Bug fixes touching 2+ files** (recommended)
-- **User requests with multiple requirements** (always use)
-- **Unfamiliar codebase changes** (recommended)
-- **SKIP ONLY for**: Single-file trivial edits (1-2 lines)
-
-**USAGE RULES (Critical):**
-1. **PARALLEL CALLS ONLY**: ALWAYS call TODO tools with action tools in the SAME function call block
-2. **Immediate updates**: Mark completed while performing work (not after)
-3. **Right sizing**: 3-7 main tasks, add subtasks if needed
-4. **Lifecycle Management**:
-   - New task = Create TODO at start
-   - Major requirement change = Delete old + create new
-   - Minor adjustment = Use todo-add or todo-update
-   - **CRITICAL**: Keep using TODO throughout the entire conversation!
-
-**CORRECT PATTERNS (Do this):**
-- todo-create + filesystem-read → Plan while gathering info
-- todo-update(completed) + filesystem-edit → Update as you work
-- todo-get + filesystem-read → Check status while reading
-- todo-add + filesystem-edit → Add new task while working
-
-**FORBIDDEN PATTERNS (NEVER do this - WILL FAIL):**
-- todo-create alone, wait for result, then work → VIOLATION! Call together!
-- todo-update alone, wait, then continue → VIOLATION! Update while working!
-- todo-get alone just to check → VIOLATION! Call with other tools!
-- Skipping TODO for multi-file tasks → VIOLATION! Always use TODO!
-- **Abandoning TODO mid-conversation** → VIOLATION! Keep using throughout dialogue!
-
-**BEST PRACTICE: Start every non-trivial task with todo-create + initial action in parallel!**
+**Best practice:** Start every non-trivial task with todo-create in parallel with first action
 
 ## Available Tools
 
 **Filesystem (SUPPORTS BATCH OPERATIONS):**
-- Read first and then modify to avoid grammatical errors caused by boundary judgment errors**
 
-**BATCH EDITING WORKFLOW - HIGH EFFICIENCY:**
-When modifying multiple files (extremely common in real projects):
-1. Use filesystem-read with array of files to read them ALL at once
-2. Use filesystem-edit or filesystem-edit_search with array config to modify ALL at once
-3. This saves multiple round trips and dramatically improves efficiency
+**CRITICAL: BOUNDARY-FIRST EDITING**
 
-**BATCH EXAMPLES:**
-- Read multiple: \`filesystem-read(filePath=["a.ts", "b.ts", "c.ts"])\`
-- Edit multiple with same change: \`filesystem-edit_search(filePath=["a.ts", "b.ts"], searchContent="old", replaceContent="new")\`
-- Edit multiple with different changes: \`filesystem-edit_search(filePath=[{path:"a.ts", searchContent:"old1", replaceContent:"new1"}, {path:"b.ts", searchContent:"old2", replaceContent:"new2"}])\`
-- Per-file line ranges: \`filesystem-edit(filePath=[{path:"a.ts", startLine:10, endLine:20, newContent:"..."}, {path:"b.ts", startLine:50, endLine:60, newContent:"..."}])\`
+**MANDATORY WORKFLOW:**
+1. **READ & VERIFY** - Use \`filesystem-read\` to identify COMPLETE units (functions: opening to closing brace, markup: full tags, check indentation)
+2. **COPY COMPLETE CODE** - Remove line numbers, preserve all content
+3. **EDIT** - \`filesystem-edit_search\` (fuzzy match, safer) or \`filesystem-edit\` (line-based, for add/delete)
 
-**CRITICAL EFFICIENCY RULE:**
-When you need to modify 2+ files, ALWAYS use batch operations instead of calling tools multiple times. This is faster, cleaner, and more reliable.
+**BATCH OPERATIONS:** Modify 2+ files? Use batch: \`filesystem-read(filePath=["a.ts","b.ts"])\` or \`filesystem-edit_search(filePath=[{path:"a.ts",...},{path:"b.ts",...}])\`
 
 **Code Search:**
 PLACEHOLDER_FOR_CODE_SEARCH_SECTION
@@ -333,7 +293,7 @@ What type of task?
 ## Quality Assurance
 
 Guidance and recommendations:
-1. Run build: \`npm run build\` or \`tsc\`
+1. Run build
 2. Fix any errors immediately
 3. Never leave broken code
 
@@ -365,20 +325,16 @@ function isCodebaseEnabled() {
 function getWorkflowSection(hasCodebase) {
     if (hasCodebase) {
         return `**Your workflow:**
-1. **START WITH SEMANTIC SEARCH** - Use \\\`codebase-search\\\` as your PRIMARY exploration tool
-   - ALWAYS try \\\`codebase-search\\\` FIRST for ANY code understanding task
-   - Examples: "authentication logic", "error handling", "user validation", "database queries"
-   - Dramatically faster than reading multiple files manually
-   - Returns relevant code snippets with context - read results to understand the codebase
-2. Read the primary file(s) mentioned (or files found by codebase search)
+1. **START WITH \`codebase-search\`** - Your PRIMARY tool for code exploration (use for 90% of understanding tasks)
+   - Query by intent: "authentication logic", "error handling", "validation patterns"
+   - Returns relevant code with full context - dramatically faster than manual file reading
+2. Read specific files found by codebase-search or mentioned by user
 3. Check dependencies/imports that directly impact the change
-4. For precise symbol lookup AFTER understanding context, use \\\`ace-search_symbols\\\`, \\\`ace-find_definition\\\`, or \\\`ace-find_references\\\`
-5. Read related files ONLY if they're critical to understanding the task
-6. Write/modify code with proper context
-7. Verify with build
-8. NO excessive exploration beyond what's needed
-9. NO reading entire modules "for reference"
-10. NO over-planning multi-step workflows for simple tasks`;
+4. Use ACE tools ONLY when needed: \`ace-find_definition\` (exact symbol), \`ace-find_references\` (usage tracking)
+5. Write/modify code with proper context
+6. Verify with build
+
+**Key principle:** codebase-search first, ACE tools for precision only`;
     }
     else {
         return `**Your workflow:**
@@ -406,28 +362,22 @@ When dealing with 2+ files, ALWAYS prefer batch operations:
  */
 function getCodeSearchSection(hasCodebase) {
     if (hasCodebase) {
-        // When codebase tool is available, prioritize it
+        // When codebase tool is available, prioritize it heavily
         return `**Code Search Strategy:**
 
-**Priority Order (use in this sequence):**
-
-1. **Semantic Search First** (\`codebase-search\`):
-   - **ALWAYS START HERE** for code understanding and exploration tasks
-   - Query by MEANING: "how is auth handled", "error patterns", "validation logic", "where is X implemented"
-   - Returns semantically relevant code with context
-   - **CRITICAL**: Primary tool for code understanding - do NOT skip this!
-   - Example: "find authentication logic" → use codebase-search first
-
-2. **Precise Lookup Second** (ACE tools - AFTER understanding context):
-   - \`ace-semantic_search\` - Symbol search with context (fuzzy matching + symbol type filtering)
-   - \`ace-find_definition\` - Go to single definition of a known symbol
-   - \`ace-find_references\` - Find all usages of a known symbol
-   - Use for: Known exact symbol names, reference tracking after exploration
-
-3. **Literal Text Search Last** (\`ace-text_search\`):
-   - ONLY for literal string matching (TODOs, log messages, error strings, constants)
-   - NOT for code understanding or exploration
-   - Use AFTER semantic search when you need exact string patterns`;
+**PRIMARY TOOL - \`codebase-search\` (Semantic Search):**
+- **USE THIS FIRST for 90% of code exploration tasks**
+- Query by MEANING and intent: "authentication logic", "error handling patterns", "validation flow"
+- Returns relevant code with full context across entire codebase
+- **Why it's superior**: Understands semantic relationships, not just exact matches
+- Examples: "how users are authenticated", "where database queries happen", "error handling approach"
+
+**Fallback tools (use ONLY when codebase-search insufficient):**
+- \`ace-find_definition\` - Jump to exact symbol definition (when you know the exact name)
+- \`ace-find_references\` - Find all usages of a known symbol (for impact analysis)
+- \`ace-text_search\` - Literal string search (TODOs, log messages, exact error strings)
+
+**Golden rule:** Try codebase-search first, use ACE tools only for precise symbol lookup`;
     }
     else {
         // When codebase tool is NOT available, only show ACE

package/dist/hooks/useAgentPicker.d.ts

@@ -6,5 +6,9 @@ export declare function useAgentPicker(buffer: TextBuffer, triggerUpdate: () =>
     agentSelectedIndex: number;
     setAgentSelectedIndex: import("react").Dispatch<import("react").SetStateAction<number>>;
     agents: SubAgent[];
+    agentQuery: string;
+    hashSymbolPosition: number;
+    updateAgentPickerState: (_text: string, cursorPos: number) => void;
+    getFilteredAgents: () => SubAgent[];
     handleAgentSelect: (agent: SubAgent) => void;
 };

package/dist/hooks/useAgentPicker.js

@@ -4,6 +4,8 @@ export function useAgentPicker(buffer, triggerUpdate) {
     const [showAgentPicker, setShowAgentPicker] = useState(false);
     const [agentSelectedIndex, setAgentSelectedIndex] = useState(0);
     const [agents, setAgents] = useState([]);
+    const [agentQuery, setAgentQuery] = useState('');
+    const [hashSymbolPosition, setHashSymbolPosition] = useState(-1);
     // Load agents when picker is shown
     useEffect(() => {
         if (showAgentPicker) {
@@ -12,21 +14,106 @@ export function useAgentPicker(buffer, triggerUpdate) {
             setAgentSelectedIndex(0);
         }
     }, [showAgentPicker]);
+    // Update agent picker state based on # symbol
+    const updateAgentPickerState = useCallback((_text, cursorPos) => {
+        // Use display text (with placeholders) instead of full text (expanded)
+        const displayText = buffer.text;
+        // Find the last '#' symbol before the cursor
+        const beforeCursor = displayText.slice(0, cursorPos);
+        let position = -1;
+        let query = '';
+        // Search backwards from cursor to find #
+        for (let i = beforeCursor.length - 1; i >= 0; i--) {
+            if (beforeCursor[i] === '#') {
+                position = i;
+                const afterHash = beforeCursor.slice(i + 1);
+                // Only activate if no space/newline after #
+                if (!afterHash.includes(' ') && !afterHash.includes('\n')) {
+                    query = afterHash;
+                    break;
+                }
+                else {
+                    // Has space after #, not valid
+                    position = -1;
+                    break;
+                }
+            }
+        }
+        if (position !== -1) {
+            // Found valid # context
+            if (!showAgentPicker ||
+                agentQuery !== query ||
+                hashSymbolPosition !== position) {
+                setShowAgentPicker(true);
+                setAgentQuery(query);
+                setHashSymbolPosition(position);
+                setAgentSelectedIndex(0);
+            }
+        }
+        else {
+            // Hide agent picker if no valid # context found and it was triggered by #
+            if (showAgentPicker && hashSymbolPosition !== -1) {
+                setShowAgentPicker(false);
+                setHashSymbolPosition(-1);
+                setAgentQuery('');
+            }
+        }
+    }, [buffer, showAgentPicker, agentQuery, hashSymbolPosition]);
+    // Get filtered agents based on query
+    const getFilteredAgents = useCallback(() => {
+        if (!agentQuery) {
+            return agents;
+        }
+        const query = agentQuery.toLowerCase();
+        return agents.filter(agent => agent.id.toLowerCase().includes(query) ||
+            agent.name.toLowerCase().includes(query) ||
+            agent.description.toLowerCase().includes(query));
+    }, [agents, agentQuery]);
     // Handle agent selection
     const handleAgentSelect = useCallback((agent) => {
-        // Clear buffer and insert agent reference
-        buffer.setText('');
-        buffer.insert(`#${agent.id} `);
+        if (hashSymbolPosition !== -1) {
+            // Triggered by # symbol - replace inline
+            const displayText = buffer.text;
+            const cursorPos = buffer.getCursorPosition();
+            // Replace query with selected agent ID
+            const beforeHash = displayText.slice(0, hashSymbolPosition);
+            const afterCursor = displayText.slice(cursorPos);
+            // Construct the replacement: #agent_id
+            const newText = beforeHash + '#' + agent.id + ' ' + afterCursor;
+            // Set the new text and position cursor after the inserted agent ID + space
+            buffer.setText(newText);
+            // Calculate cursor position after the inserted text
+            // # length (1) + agent ID length + space (1)
+            const insertedLength = 1 + agent.id.length + 1;
+            const targetPos = hashSymbolPosition + insertedLength;
+            // Reset cursor to beginning, then move to correct position
+            for (let i = 0; i < targetPos; i++) {
+                if (i < buffer.text.length) {
+                    buffer.moveRight();
+                }
+            }
+            setHashSymbolPosition(-1);
+            setAgentQuery('');
+        }
+        else {
+            // Triggered by command - clear buffer and insert
+            buffer.setText('');
+            buffer.insert(`#${agent.id} `);
+        }
         setShowAgentPicker(false);
         setAgentSelectedIndex(0);
         triggerUpdate();
-    }, [buffer, triggerUpdate]);
+    }, [hashSymbolPosition, buffer, triggerUpdate]);
     return {
         showAgentPicker,
         setShowAgentPicker,
         agentSelectedIndex,
         setAgentSelectedIndex,
         agents,
+        agentQuery,
+        hashSymbolPosition,
+        updateAgentPickerState,
+        getFilteredAgents,
         handleAgentSelect,
     };
 }

package/dist/hooks/useFilePicker.d.ts

@@ -10,7 +10,7 @@ export declare function useFilePicker(buffer: TextBuffer, triggerUpdate: () => v
     atSymbolPosition: number;
     setAtSymbolPosition: (_pos: number) => void;
     filteredFileCount: number;
-    searchMode: "content" | "file";
+    searchMode: "file" | "content";
     updateFilePickerState: (_text: string, cursorPos: number) => void;
     handleFileSelect: (filePath: string) => Promise<void>;
     handleFilteredCountChange: (count: number) => void;

package/dist/hooks/useKeyboardInput.d.ts

@@ -57,7 +57,8 @@ type KeyboardInputOptions = {
     setShowAgentPicker: (show: boolean) => void;
     agentSelectedIndex: number;
     setAgentSelectedIndex: (index: number | ((prev: number) => number)) => void;
-    agents: SubAgent[];
+    updateAgentPickerState: (text: string, cursorPos: number) => void;
+    getFilteredAgents: () => SubAgent[];
     handleAgentSelect: (agent: SubAgent) => void;
     showTodoPicker: boolean;
     setShowTodoPicker: (show: boolean) => void;

package/dist/hooks/useKeyboardInput.js

@@ -2,7 +2,7 @@ import { useRef, useEffect } from 'react';
 import { useInput } from 'ink';
 import { executeCommand } from '../utils/commandExecutor.js';
 export function useKeyboardInput(options) {
-    const { buffer, disabled, triggerUpdate, forceUpdate, showCommands, setShowCommands, commandSelectedIndex, setCommandSelectedIndex, getFilteredCommands, updateCommandPanelState, onCommand, showFilePicker, setShowFilePicker, fileSelectedIndex, setFileSelectedIndex, setFileQuery, setAtSymbolPosition, filteredFileCount, updateFilePickerState, handleFileSelect, fileListRef, showHistoryMenu, setShowHistoryMenu, historySelectedIndex, setHistorySelectedIndex, escapeKeyCount, setEscapeKeyCount, escapeKeyTimer, getUserMessages, handleHistorySelect, currentHistoryIndex, navigateHistoryUp, navigateHistoryDown, resetHistoryNavigation, saveToHistory, pasteFromClipboard, onSubmit, ensureFocus, showAgentPicker, setShowAgentPicker, agentSelectedIndex, setAgentSelectedIndex, agents, handleAgentSelect, showTodoPicker, setShowTodoPicker, todoSelectedIndex, setTodoSelectedIndex, todos, selectedTodos, toggleTodoSelection, confirmTodoSelection, todoSearchQuery, setTodoSearchQuery, } = options;
+    const { buffer, disabled, triggerUpdate, forceUpdate, showCommands, setShowCommands, commandSelectedIndex, setCommandSelectedIndex, getFilteredCommands, updateCommandPanelState, onCommand, showFilePicker, setShowFilePicker, fileSelectedIndex, setFileSelectedIndex, setFileQuery, setAtSymbolPosition, filteredFileCount, updateFilePickerState, handleFileSelect, fileListRef, showHistoryMenu, setShowHistoryMenu, historySelectedIndex, setHistorySelectedIndex, escapeKeyCount, setEscapeKeyCount, escapeKeyTimer, getUserMessages, handleHistorySelect, currentHistoryIndex, navigateHistoryUp, navigateHistoryDown, resetHistoryNavigation, saveToHistory, pasteFromClipboard, onSubmit, ensureFocus, showAgentPicker, setShowAgentPicker, agentSelectedIndex, setAgentSelectedIndex, updateAgentPickerState, getFilteredAgents, handleAgentSelect, showTodoPicker, setShowTodoPicker, todoSelectedIndex, setTodoSelectedIndex, todos, selectedTodos, toggleTodoSelection, confirmTodoSelection, todoSearchQuery, setTodoSearchQuery, } = options;
     // Mark variables as used (they are used in useInput closure below)
     void todoSelectedIndex;
     void selectedTodos;
@@ -24,6 +24,7 @@ export function useKeyboardInput(options) {
         const text = buffer.getFullText();
         const cursorPos = buffer.getCursorPosition();
         updateFilePickerState(text, cursorPos);
+        updateAgentPickerState(text, cursorPos);
         updateCommandPanelState(text);
         forceUpdate({});
     };
@@ -165,6 +166,7 @@ export function useKeyboardInput(options) {
         }
         // Handle agent picker navigation
         if (showAgentPicker) {
+            const filteredAgents = getFilteredAgents();
             // Up arrow in agent picker
             if (key.upArrow) {
                 setAgentSelectedIndex(prev => Math.max(0, prev - 1));
@@ -172,14 +174,14 @@ export function useKeyboardInput(options) {
             }
             // Down arrow in agent picker
             if (key.downArrow) {
-                const maxIndex = Math.max(0, agents.length - 1);
+                const maxIndex = Math.max(0, filteredAgents.length - 1);
                 setAgentSelectedIndex(prev => Math.min(maxIndex, prev + 1));
                 return;
             }
             // Enter - select agent
             if (key.return) {
-                if (agents.length > 0 && agentSelectedIndex < agents.length) {
-                    const selectedAgent = agents[agentSelectedIndex];
+                if (filteredAgents.length > 0 && agentSelectedIndex < filteredAgents.length) {
+                    const selectedAgent = filteredAgents[agentSelectedIndex];
                     if (selectedAgent) {
                         handleAgentSelect(selectedAgent);
                         setShowAgentPicker(false);
@@ -188,8 +190,9 @@ export function useKeyboardInput(options) {
                 }
                 return;
             }
-            // For any other key in agent picker, just return to prevent interference
-            return;
+            // Allow typing to filter - don't block regular input
+            // The input will be processed below and updateAgentPickerState will be called
+            // which will update the filter automatically
         }
         // Handle history menu navigation
         if (showHistoryMenu) {
@@ -395,6 +398,7 @@ export function useKeyboardInput(options) {
             const text = buffer.getFullText();
             const cursorPos = buffer.getCursorPosition();
             updateFilePickerState(text, cursorPos);
+            updateAgentPickerState(text, cursorPos);
             triggerUpdate();
             return;
         }
@@ -419,6 +423,7 @@ export function useKeyboardInput(options) {
             const text = buffer.getFullText();
             const cursorPos = buffer.getCursorPosition();
             updateFilePickerState(text, cursorPos);
+            updateAgentPickerState(text, cursorPos);
             triggerUpdate();
             return;
         }
@@ -452,6 +457,7 @@ export function useKeyboardInput(options) {
                 const navigated = navigateHistoryUp();
                 if (navigated) {
                     updateFilePickerState(buffer.getFullText(), buffer.getCursorPosition());
+                    updateAgentPickerState(buffer.getFullText(), buffer.getCursorPosition());
                     triggerUpdate();
                     return;
                 }
@@ -459,6 +465,7 @@ export function useKeyboardInput(options) {
             // Normal cursor movement
             buffer.moveUp();
             updateFilePickerState(buffer.getFullText(), buffer.getCursorPosition());
+            updateAgentPickerState(buffer.getFullText(), buffer.getCursorPosition());
             triggerUpdate();
             return;
         }
@@ -492,6 +499,7 @@ export function useKeyboardInput(options) {
                 const navigated = navigateHistoryDown();
                 if (navigated) {
                     updateFilePickerState(buffer.getFullText(), buffer.getCursorPosition());
+                    updateAgentPickerState(buffer.getFullText(), buffer.getCursorPosition());
                     triggerUpdate();
                     return;
                 }
@@ -499,6 +507,7 @@ export function useKeyboardInput(options) {
             // Normal cursor movement
             buffer.moveDown();
             updateFilePickerState(buffer.getFullText(), buffer.getCursorPosition());
+            updateAgentPickerState(buffer.getFullText(), buffer.getCursorPosition());
             triggerUpdate();
             return;
         }
@@ -522,6 +531,7 @@ export function useKeyboardInput(options) {
                 const cursorPos = buffer.getCursorPosition();
                 updateCommandPanelState(text);
                 updateFilePickerState(text, cursorPos);
+                updateAgentPickerState(text, cursorPos);
                 triggerUpdate();
             }
             else {
@@ -551,6 +561,7 @@ export function useKeyboardInput(options) {
                     const cursorPos = buffer.getCursorPosition();
                     updateCommandPanelState(text);
                     updateFilePickerState(text, cursorPos);
+                    updateAgentPickerState(text, cursorPos);
                     triggerUpdate();
                 }
                 // Set timer to process accumulated input
@@ -587,6 +598,7 @@ export function useKeyboardInput(options) {
                         const cursorPos = buffer.getCursorPosition();
                         updateCommandPanelState(text);
                         updateFilePickerState(text, cursorPos);
+                        updateAgentPickerState(text, cursorPos);
                         triggerUpdate();
                     }
                 }, timeoutDelay); // Extended delay for large pastes to ensure complete accumulation