snow-ai 0.3.22 → 0.3.24

package/dist/api/gemini.d.ts

@@ -7,7 +7,7 @@ export interface GeminiOptions {
     includeBuiltinSystemPrompt?: boolean;
 }
 export interface GeminiStreamChunk {
-    type: 'content' | 'tool_calls' | 'tool_call_delta' | 'done' | 'usage';
+    type: 'content' | 'tool_calls' | 'tool_call_delta' | 'done' | 'usage' | 'reasoning_started' | 'reasoning_delta';
     content?: string;
     tool_calls?: Array<{
         id: string;
@@ -19,6 +19,10 @@ export interface GeminiStreamChunk {
     }>;
     delta?: string;
     usage?: UsageInfo;
+    thinking?: {
+        type: 'thinking';
+        thinking: string;
+    };
 }
 export declare function resetGeminiClient(): void;
 /**

package/dist/api/gemini.js

@@ -17,6 +17,7 @@ function getGeminiConfig() {
                 ? config.baseUrl
                 : 'https://generativelanguage.googleapis.com/v1beta',
             customHeaders,
+            geminiThinking: config.geminiThinking,
         };
     }
     return geminiConfig;
@@ -230,10 +231,16 @@ export async function* createStreamingGeminiCompletion(options, abortSignal, onR
             systemInstruction: systemInstruction
                 ? { parts: [{ text: systemInstruction }] }
                 : undefined,
-            generationConfig: {
-                temperature: options.temperature ?? 0.7,
-            },
         };
+        // Add thinking configuration if enabled
+        // Only include generationConfig when thinking is enabled
+        if (config.geminiThinking?.enabled) {
+            requestBody.generationConfig = {
+                thinkingConfig: {
+                    thinkingBudget: config.geminiThinking.budget,
+                },
+            };
+        }
         // Add tools if provided
         const geminiTools = convertToolsToGemini(options.tools);
         if (geminiTools) {
@@ -263,6 +270,7 @@ export async function* createStreamingGeminiCompletion(options, abortSignal, onR
             throw new Error('No response body from Gemini API');
         }
         let contentBuffer = '';
+        let thinkingTextBuffer = ''; // Accumulate thinking text content
         let toolCallsBuffer = [];
         let hasToolCalls = false;
         let toolCallIndex = 0;
@@ -310,8 +318,17 @@ export async function* createStreamingGeminiCompletion(options, abortSignal, onR
                             const candidate = chunk.candidates[0];
                             if (candidate.content && candidate.content.parts) {
                                 for (const part of candidate.content.parts) {
-                                    // Process text content
-                                    if (part.text) {
+                                    // Process thought content (Gemini thinking)
+                                    // When part.thought === true, the text field contains thinking content
+                                    if (part.thought === true && part.text) {
+                                        thinkingTextBuffer += part.text;
+                                        yield {
+                                            type: 'reasoning_delta',
+                                            delta: part.text,
+                                        };
+                                    }
+                                    // Process regular text content (when thought is not true)
+                                    else if (part.text) {
                                         contentBuffer += part.text;
                                         yield {
                                             type: 'content',
@@ -374,9 +391,17 @@ export async function* createStreamingGeminiCompletion(options, abortSignal, onR
                 usage: usageData,
             };
         }
+        // Return complete thinking block if thinking content exists
+        const thinkingBlock = thinkingTextBuffer
+            ? {
+                type: 'thinking',
+                thinking: thinkingTextBuffer,
+            }
+            : undefined;
         // Signal completion
         yield {
             type: 'done',
+            thinking: thinkingBlock,
         };
     }, {
         abortSignal,

package/dist/api/responses.js

@@ -79,6 +79,19 @@ function getOpenAIConfig() {
     }
     return openaiConfig;
 }
+function getResponsesReasoningConfig() {
+    const config = getOpenAiConfig();
+    const reasoningConfig = config.responsesReasoning;
+    // 如果 reasoning 未启用，返回 null
+    if (!reasoningConfig?.enabled) {
+        return null;
+    }
+    // 返回配置，summary 永远默认为 'auto'
+    return {
+        effort: reasoningConfig.effort || 'high',
+        summary: 'auto',
+    };
+}
 export function resetOpenAIClient() {
     openaiConfig = null;
 }
@@ -237,6 +250,8 @@ export async function* createStreamingResponse(options, abortSignal, onRetry) {
     const config = getOpenAIConfig();
     // 提取系统提示词和转换后的消息
     const { input: requestInput, systemInstructions } = convertToResponseInput(options.messages, options.includeBuiltinSystemPrompt !== false);
+    // 获取配置的 reasoning 设置
+    const configuredReasoning = getResponsesReasoningConfig();
     // 使用重试包装生成器
     yield* withRetryGenerator(async function* () {
         const requestPayload = {
@@ -246,9 +261,9 @@ export async function* createStreamingResponse(options, abortSignal, onRetry) {
             tools: convertToolsForResponses(options.tools),
             tool_choice: options.tool_choice,
             parallel_tool_calls: false,
-            // Only add reasoning if not explicitly disabled (null means don't pass it)
-            ...(options.reasoning !== null && {
-                reasoning: options.reasoning || { effort: 'high', summary: 'auto' },
+            // 只有当 reasoning 启用时才添加 reasoning 字段
+            ...(configuredReasoning && {
+                reasoning: configuredReasoning,
             }),
             store: false,
             stream: true,

package/dist/hooks/useConversation.d.ts

@@ -12,11 +12,6 @@ export type ConversationHandlerOptions = {
     saveMessage: (message: any) => Promise<void>;
     setMessages: React.Dispatch<React.SetStateAction<Message[]>>;
     setStreamTokenCount: React.Dispatch<React.SetStateAction<number>>;
-    setCurrentTodos: React.Dispatch<React.SetStateAction<Array<{
-        id: string;
-        content: string;
-        status: 'pending' | 'completed';
-    }>>>;
     requestToolConfirmation: (toolCall: ToolCall, batchToolNames?: string, allTools?: ToolCall[]) => Promise<string>;
     isToolAutoApproved: (toolName: string) => boolean;
     addMultipleToAlwaysApproved: (toolNames: string[]) => void;

package/dist/hooks/useConversation.js

@@ -20,7 +20,7 @@ import { shouldAutoCompress, performAutoCompression, } from '../utils/autoCompre
 export async function handleConversationWithTools(options) {
     const { userContent, imageContents, controller, 
     // messages, // No longer used - we load from session instead to get complete history with tool calls
-    saveMessage, setMessages, setStreamTokenCount, setCurrentTodos, requestToolConfirmation, isToolAutoApproved, addMultipleToAlwaysApproved, yoloMode, setContextUsage, setIsReasoning, setRetryStatus, } = options;
+    saveMessage, setMessages, setStreamTokenCount, requestToolConfirmation, isToolAutoApproved, addMultipleToAlwaysApproved, yoloMode, setContextUsage, setIsReasoning, setRetryStatus, } = options;
     // Create a wrapper function for adding single tool to always-approved list
     const addToAlwaysApproved = (toolName) => {
         addMultipleToAlwaysApproved([toolName]);
@@ -33,10 +33,6 @@ export async function handleConversationWithTools(options) {
     const todoService = getTodoService();
     // Get existing TODO list
     const existingTodoList = await todoService.getTodoList(currentSession.id);
-    // Update UI state
-    if (existingTodoList) {
-        setCurrentTodos(existingTodoList.todos);
-    }
     // Collect all MCP tools
     const mcpTools = await collectAllMCPTools();
     // Build conversation history with TODO context as pinned user message
@@ -124,6 +120,7 @@ export async function handleConversationWithTools(options) {
             let receivedToolCalls;
             let receivedReasoning;
             let receivedThinking; // Accumulate thinking content from all platforms
+            let hasStartedReasoning = false; // Track if reasoning has started (for Gemini thinking)
             // Stream AI response - choose API based on config
             let toolCallAccumulator = ''; // Accumulate tool call deltas for token counting
             let reasoningAccumulator = ''; // Accumulate reasoning summary deltas for token counting (Responses API only)
@@ -194,6 +191,23 @@ export async function handleConversationWithTools(options) {
                     // Reasoning started (Responses API only) - set reasoning state
                     setIsReasoning?.(true);
                 }
+                else if (chunk.type === 'reasoning_delta' && chunk.delta) {
+                    // Handle reasoning delta from Gemini thinking
+                    // When reasoning_delta is received, set reasoning state if not already set
+                    if (!hasStartedReasoning) {
+                        setIsReasoning?.(true);
+                        hasStartedReasoning = true;
+                    }
+                    // Note: reasoning content is NOT sent back to AI, only counted for display
+                    reasoningAccumulator += chunk.delta;
+                    try {
+                        const tokens = encoder.encode(streamedContent + toolCallAccumulator + reasoningAccumulator);
+                        setStreamTokenCount(tokens.length);
+                    }
+                    catch (e) {
+                        // Ignore encoding errors
+                    }
+                }
                 else if (chunk.type === 'content' && chunk.content) {
                     // Accumulate content and update token count
                     // When content starts, reasoning is done
@@ -220,18 +234,6 @@ export async function handleConversationWithTools(options) {
                         // Ignore encoding errors
                     }
                 }
-                else if (chunk.type === 'reasoning_delta' && chunk.delta) {
-                    // Accumulate reasoning summary deltas for token counting (Responses API only)
-                    // Note: reasoning content is NOT sent back to AI, only counted for display
-                    reasoningAccumulator += chunk.delta;
-                    try {
-                        const tokens = encoder.encode(streamedContent + toolCallAccumulator + reasoningAccumulator);
-                        setStreamTokenCount(tokens.length);
-                    }
-                    catch (e) {
-                        // Ignore encoding errors
-                    }
-                }
                 else if (chunk.type === 'tool_calls' && chunk.tool_calls) {
                     receivedToolCalls = chunk.tool_calls;
                 }
@@ -358,8 +360,28 @@ export async function handleConversationWithTools(options) {
                 const autoApprovedTools = [];
                 for (const toolCall of receivedToolCalls) {
                     // Check both global approved list and session-approved list
-                    if (isToolAutoApproved(toolCall.function.name) ||
-                        sessionApprovedTools.has(toolCall.function.name)) {
+                    const isApproved = isToolAutoApproved(toolCall.function.name) ||
+                        sessionApprovedTools.has(toolCall.function.name);
+                    // Check if this is a sensitive command (terminal-execute with sensitive pattern)
+                    let isSensitiveCommand = false;
+                    if (toolCall.function.name === 'terminal-execute') {
+                        try {
+                            const args = JSON.parse(toolCall.function.arguments);
+                            const { isSensitiveCommand: checkSensitiveCommand } = await import('../utils/sensitiveCommandManager.js').then(m => ({
+                                isSensitiveCommand: m.isSensitiveCommand,
+                            }));
+                            const sensitiveCheck = checkSensitiveCommand(args.command);
+                            isSensitiveCommand = sensitiveCheck.isSensitive;
+                        }
+                        catch {
+                            // If parsing fails, treat as normal command
+                        }
+                    }
+                    // If sensitive command, always require confirmation regardless of approval status
+                    if (isSensitiveCommand) {
+                        toolsNeedingConfirmation.push(toolCall);
+                    }
+                    else if (isApproved) {
                         autoApprovedTools.push(toolCall);
                     }
                     else {
@@ -368,24 +390,79 @@ export async function handleConversationWithTools(options) {
                 }
                 // Request confirmation only once for all tools needing confirmation
                 let approvedTools = [...autoApprovedTools];
-                // In YOLO mode, auto-approve all tools
+                // In YOLO mode, auto-approve all tools EXCEPT sensitive commands
                 if (yoloMode) {
-                    approvedTools.push(...toolsNeedingConfirmation);
+                    // Filter out sensitive commands from auto-approval
+                    const nonSensitiveTools = [];
+                    const sensitiveTools = [];
+                    for (const toolCall of toolsNeedingConfirmation) {
+                        if (toolCall.function.name === 'terminal-execute') {
+                            try {
+                                const args = JSON.parse(toolCall.function.arguments);
+                                const { isSensitiveCommand: checkSensitiveCommand } = await import('../utils/sensitiveCommandManager.js').then(m => ({
+                                    isSensitiveCommand: m.isSensitiveCommand,
+                                }));
+                                const sensitiveCheck = checkSensitiveCommand(args.command);
+                                if (sensitiveCheck.isSensitive) {
+                                    sensitiveTools.push(toolCall);
+                                }
+                                else {
+                                    nonSensitiveTools.push(toolCall);
+                                }
+                            }
+                            catch {
+                                nonSensitiveTools.push(toolCall);
+                            }
+                        }
+                        else {
+                            nonSensitiveTools.push(toolCall);
+                        }
+                    }
+                    approvedTools.push(...nonSensitiveTools);
+                    // If there are sensitive tools, still need confirmation even in YOLO mode
+                    if (sensitiveTools.length > 0) {
+                        const firstTool = sensitiveTools[0];
+                        const allTools = sensitiveTools.length > 1 ? sensitiveTools : undefined;
+                        const confirmation = await requestToolConfirmation(firstTool, undefined, allTools);
+                        if (confirmation === 'reject') {
+                            setMessages(prev => prev.filter(msg => !msg.toolPending));
+                            for (const toolCall of sensitiveTools) {
+                                const rejectionMessage = {
+                                    role: 'tool',
+                                    tool_call_id: toolCall.id,
+                                    content: 'Error: Tool execution rejected by user',
+                                };
+                                conversationMessages.push(rejectionMessage);
+                                saveMessage(rejectionMessage).catch(error => {
+                                    console.error('Failed to save tool rejection message:', error);
+                                });
+                            }
+                            setMessages(prev => [
+                                ...prev,
+                                {
+                                    role: 'assistant',
+                                    content: 'Tool call rejected, session ended',
+                                    streaming: false,
+                                },
+                            ]);
+                            if (options.setIsStreaming) {
+                                options.setIsStreaming(false);
+                            }
+                            freeEncoder();
+                            return { usage: accumulatedUsage };
+                        }
+                        // Approved, add sensitive tools to approved list
+                        approvedTools.push(...sensitiveTools);
+                    }
                 }
                 else if (toolsNeedingConfirmation.length > 0) {
-                    const firstTool = toolsNeedingConfirmation[0]; // Safe: length > 0 guarantees this exists
-                    // Use regular CLI confirmation
-                    // Pass all tools for proper display in confirmation UI
+                    const firstTool = toolsNeedingConfirmation[0];
                     const allTools = toolsNeedingConfirmation.length > 1
                         ? toolsNeedingConfirmation
                         : undefined;
-                    // Use first tool for confirmation UI, but apply result to all
                     const confirmation = await requestToolConfirmation(firstTool, undefined, allTools);
                     if (confirmation === 'reject') {
-                        // Remove pending tool messages
                         setMessages(prev => prev.filter(msg => !msg.toolPending));
-                        // User rejected - need to save tool rejection messages to maintain conversation structure
-                        // Add tool rejection responses for ALL tools that were rejected
                         for (const toolCall of toolsNeedingConfirmation) {
                             const rejectionMessage = {
                                 role: 'tool',
@@ -397,7 +474,6 @@ export async function handleConversationWithTools(options) {
                                 console.error('Failed to save tool rejection message:', error);
                             });
                         }
-                        // User rejected - end conversation
                         setMessages(prev => [
                             ...prev,
                             {
@@ -406,12 +482,11 @@ export async function handleConversationWithTools(options) {
                                 streaming: false,
                             },
                         ]);
-                        // End streaming immediately
                         if (options.setIsStreaming) {
                             options.setIsStreaming(false);
                         }
                         freeEncoder();
-                        return { usage: accumulatedUsage }; // Exit the conversation loop
+                        return { usage: accumulatedUsage };
                     }
                     // If approved_always, add ALL these tools to both global and session-approved sets
                     if (confirmation === 'approve_always') {
@@ -642,18 +717,6 @@ export async function handleConversationWithTools(options) {
                         // 即使压缩失败也继续处理工具结果
                     }
                 }
-                // Check if there are TODO related tool calls, if yes refresh TODO list
-                const hasTodoTools = approvedTools.some(t => t.function.name.startsWith('todo-'));
-                const hasTodoUpdateTools = approvedTools.some(t => t.function.name === 'todo-update');
-                if (hasTodoTools) {
-                    const session = sessionManager.getCurrentSession();
-                    if (session) {
-                        const updatedTodoList = await todoService.getTodoList(session.id);
-                        if (updatedTodoList) {
-                            setCurrentTodos(updatedTodoList.todos);
-                        }
-                    }
-                }
                 // Remove only streaming sub-agent content messages (not tool-related messages)
                 // Keep sub-agent tool call and tool result messages for display
                 setMessages(prev => prev.filter(m => m.role !== 'subagent' ||
@@ -757,18 +820,6 @@ export async function handleConversationWithTools(options) {
                         });
                     }
                 }
-                // After all tool results are processed, show TODO panel if there were todo-update calls
-                if (hasTodoUpdateTools) {
-                    setMessages(prev => [
-                        ...prev,
-                        {
-                            role: 'assistant',
-                            content: '',
-                            streaming: false,
-                            showTodoTree: true,
-                        },
-                    ]);
-                }
                 // Check if there are pending user messages to insert
                 if (options.getPendingMessages && options.clearPendingMessages) {
                     const pendingMessages = options.getPendingMessages();
@@ -811,7 +862,9 @@ export async function handleConversationWithTools(options) {
                         // Clear pending messages
                         options.clearPendingMessages();
                         // Combine multiple pending messages into one
-                        const combinedMessage = pendingMessages.map(m => m.text).join('\n\n');
+                        const combinedMessage = pendingMessages
+                            .map(m => m.text)
+                            .join('\n\n');
                         // Collect all images from pending messages
                         const allPendingImages = pendingMessages
                             .flatMap(m => m.images || [])

package/dist/hooks/useFilePicker.d.ts

@@ -11,7 +11,7 @@ export declare function useFilePicker(buffer: TextBuffer, triggerUpdate: () => v
     setAtSymbolPosition: (_pos: number) => void;
     filteredFileCount: number;
     searchMode: "content" | "file";
-    updateFilePickerState: (text: string, cursorPos: number) => void;
+    updateFilePickerState: (_text: string, cursorPos: number) => void;
     handleFileSelect: (filePath: string) => Promise<void>;
     handleFilteredCountChange: (count: number) => void;
     fileListRef: import("react").RefObject<FileListRef>;

package/dist/hooks/useFilePicker.js

@@ -51,15 +51,19 @@ export function useFilePicker(buffer, triggerUpdate) {
     });
     const fileListRef = useRef(null);
     // Update file picker state
-    const updateFilePickerState = useCallback((text, cursorPos) => {
-        if (!text.includes('@')) {
+    const updateFilePickerState = useCallback((_text, cursorPos) => {
+        // Use display text (with placeholders) instead of full text (expanded)
+        // to ensure cursor position matches text content
+        // Note: _text parameter is ignored, we use buffer.text instead
+        const displayText = buffer.text;
+        if (!displayText.includes('@')) {
             if (state.showFilePicker) {
                 dispatch({ type: 'HIDE' });
             }
             return;
         }
         // Find the last '@' or '@@' symbol before the cursor
-        const beforeCursor = text.slice(0, cursorPos);
+        const beforeCursor = displayText.slice(0, cursorPos);
         // Look for @@ first (content search), then @ (file search)
         let searchMode = 'file';
         let position = -1;
@@ -130,6 +134,7 @@ export function useFilePicker(buffer, triggerUpdate) {
             }
         }
     }, [
+        buffer,
         state.showFilePicker,
         state.fileQuery,
         state.atSymbolPosition,
@@ -138,13 +143,14 @@ export function useFilePicker(buffer, triggerUpdate) {
     // Handle file selection
     const handleFileSelect = useCallback(async (filePath) => {
         if (state.atSymbolPosition !== -1) {
-            const text = buffer.getFullText();
+            // Use display text (with placeholders) for position calculations
+            const displayText = buffer.text;
             const cursorPos = buffer.getCursorPosition();
             // Replace query with selected file path
             // For content search (@@), the filePath already includes line number
             // For file search (@), just the file path
-            const beforeAt = text.slice(0, state.atSymbolPosition);
-            const afterCursor = text.slice(cursorPos);
+            const beforeAt = displayText.slice(0, state.atSymbolPosition);
+            const afterCursor = displayText.slice(cursorPos);
             // Construct the replacement based on search mode
             const prefix = state.searchMode === 'content' ? '@@' : '@';
             const newText = beforeAt + prefix + filePath + ' ' + afterCursor;
@@ -156,7 +162,7 @@ export function useFilePicker(buffer, triggerUpdate) {
             const targetPos = state.atSymbolPosition + insertedLength;
             // Reset cursor to beginning, then move to correct position
             for (let i = 0; i < targetPos; i++) {
-                if (i < buffer.getFullText().length) {
+                if (i < buffer.text.length) {
                     buffer.moveRight();
                 }
             }

package/dist/hooks/useHistoryNavigation.js

@@ -34,11 +34,18 @@ export function useHistoryNavigation(buffer, triggerUpdate, chatHistory, onHisto
             .map((msg, index) => ({ ...msg, originalIndex: index }))
             .filter(msg => msg.role === 'user' && msg.content.trim());
         // Keep original order (oldest first, newest last) and map with display numbers
-        return userMessages.map((msg, index) => ({
-            label: `${index + 1}. ${msg.content.slice(0, 50)}${msg.content.length > 50 ? '...' : ''}`,
-            value: msg.originalIndex.toString(),
-            infoText: msg.content,
-        }));
+        return userMessages.map((msg, index) => {
+            // Remove all newlines, control characters and extra whitespace to ensure single line display
+            const cleanContent = msg.content
+                .replace(/[\r\n\t\v\f\u0000-\u001F\u007F-\u009F]+/g, ' ')
+                .replace(/\s+/g, ' ')
+                .trim();
+            return {
+                label: `${index + 1}. ${cleanContent.slice(0, 50)}${cleanContent.length > 50 ? '...' : ''}`,
+                value: msg.originalIndex.toString(),
+                infoText: msg.content,
+            };
+        });
     }, [chatHistory]);
     // Handle history selection
     const handleHistorySelect = useCallback((value) => {
@@ -71,7 +78,7 @@ export function useHistoryNavigation(buffer, triggerUpdate, chatHistory, onHisto
             triggerUpdate();
         }
         return true;
-    }, [currentHistoryIndex, buffer]);
+    }, [currentHistoryIndex]); // 移除 buffer 避免循环依赖
     // Terminal-style history navigation: navigate down (newer)
     const navigateHistoryDown = useCallback(() => {
         if (currentHistoryIndex === -1)
@@ -93,7 +100,7 @@ export function useHistoryNavigation(buffer, triggerUpdate, chatHistory, onHisto
         }
         triggerUpdate();
         return true;
-    }, [currentHistoryIndex, buffer]);
+    }, [currentHistoryIndex]); // 移除 buffer 避免循环依赖
     // Reset history navigation state
     const resetHistoryNavigation = useCallback(() => {
         setCurrentHistoryIndex(-1);

package/dist/hooks/useInputBuffer.d.ts

@@ -2,5 +2,5 @@ import { TextBuffer, Viewport } from '../utils/textBuffer.js';
 export declare function useInputBuffer(viewport: Viewport): {
     buffer: TextBuffer;
     triggerUpdate: () => void;
-    forceUpdate: import("react").Dispatch<import("react").SetStateAction<{}>>;
+    forceUpdate: () => void;
 };

package/dist/hooks/useInputBuffer.js

@@ -1,19 +1,35 @@
 import { useState, useCallback, useEffect, useRef } from 'react';
 import { TextBuffer } from '../utils/textBuffer.js';
 export function useInputBuffer(viewport) {
-    const [, forceUpdate] = useState({});
+    const [, setForceUpdateState] = useState({});
     const lastUpdateTime = useRef(0);
-    // Force re-render when buffer changes
-    const triggerUpdate = useCallback(() => {
+    const bufferRef = useRef(null);
+    // Stable forceUpdate function using useRef
+    const forceUpdateRef = useRef(() => {
+        setForceUpdateState({});
+    });
+    // Stable triggerUpdate function using useRef
+    const triggerUpdateRef = useRef(() => {
         const now = Date.now();
         lastUpdateTime.current = now;
-        forceUpdate({});
+        forceUpdateRef.current();
+    });
+    // Initialize buffer once
+    if (!bufferRef.current) {
+        bufferRef.current = new TextBuffer(viewport, triggerUpdateRef.current);
+    }
+    const buffer = bufferRef.current;
+    // Expose stable callback functions
+    const forceUpdate = useCallback(() => {
+        forceUpdateRef.current();
+    }, []);
+    const triggerUpdate = useCallback(() => {
+        triggerUpdateRef.current();
     }, []);
-    const [buffer] = useState(() => new TextBuffer(viewport, triggerUpdate));
     // Update buffer viewport when viewport changes
     useEffect(() => {
         buffer.updateViewport(viewport);
-        triggerUpdate();
+        forceUpdateRef.current();
     }, [viewport.width, viewport.height, buffer]);
     // Cleanup buffer on unmount
     useEffect(() => {

package/dist/hooks/useStreamingState.js

@@ -45,7 +45,7 @@ export function useStreamingState() {
     }, [timerStartTime]);
     // Initialize remaining seconds when retry starts
     useEffect(() => {
-        if (!retryStatus || !retryStatus.isRetrying)
+        if (!retryStatus?.isRetrying)
             return;
         if (retryStatus.remainingSeconds !== undefined)
             return;
@@ -56,7 +56,7 @@ export function useStreamingState() {
                 remainingSeconds: Math.ceil(prev.nextDelay / 1000),
             }
             : null);
-    }, [retryStatus?.isRetrying, retryStatus?.nextDelay]);
+    }, [retryStatus?.isRetrying]); // Only depend on isRetrying flag
     // Countdown timer for retry delays
     useEffect(() => {
         if (!retryStatus || !retryStatus.isRetrying)

package/dist/hooks/useVSCodeState.js

@@ -1,26 +1,43 @@
-import { useState, useEffect } from 'react';
+import { useState, useEffect, useRef } from 'react';
 import { vscodeConnection } from '../utils/vscodeConnection.js';
 export function useVSCodeState() {
     const [vscodeConnected, setVscodeConnected] = useState(false);
     const [vscodeConnectionStatus, setVscodeConnectionStatus] = useState('disconnected');
     const [editorContext, setEditorContext] = useState({});
+    // Use ref to track last status without causing re-renders
+    const lastStatusRef = useRef('disconnected');
+    // Use ref to track last editor context to avoid unnecessary updates
+    const lastEditorContextRef = useRef({});
     // Monitor VSCode connection status and editor context
     useEffect(() => {
         const checkConnectionInterval = setInterval(() => {
             const isConnected = vscodeConnection.isConnected();
             setVscodeConnected(isConnected);
             // Update connection status based on actual connection state
-            if (isConnected && vscodeConnectionStatus !== 'connected') {
+            // Use ref to avoid reading from state
+            if (isConnected && lastStatusRef.current !== 'connected') {
+                lastStatusRef.current = 'connected';
                 setVscodeConnectionStatus('connected');
             }
-            else if (!isConnected && vscodeConnectionStatus === 'connected') {
+            else if (!isConnected && lastStatusRef.current === 'connected') {
+                lastStatusRef.current = 'disconnected';
                 setVscodeConnectionStatus('disconnected');
             }
         }, 1000);
         const unsubscribe = vscodeConnection.onContextUpdate(context => {
-            setEditorContext(context);
+            // Only update state if context has actually changed
+            const hasChanged = context.activeFile !== lastEditorContextRef.current.activeFile ||
+                context.selectedText !== lastEditorContextRef.current.selectedText ||
+                context.cursorPosition?.line !== lastEditorContextRef.current.cursorPosition?.line ||
+                context.cursorPosition?.character !== lastEditorContextRef.current.cursorPosition?.character ||
+                context.workspaceFolder !== lastEditorContextRef.current.workspaceFolder;
+            if (hasChanged) {
+                lastEditorContextRef.current = context;
+                setEditorContext(context);
+            }
             // When we receive context, it means connection is successful
-            if (vscodeConnectionStatus !== 'connected') {
+            if (lastStatusRef.current !== 'connected') {
+                lastStatusRef.current = 'connected';
                 setVscodeConnectionStatus('connected');
             }
         });
@@ -28,7 +45,7 @@ export function useVSCodeState() {
             clearInterval(checkConnectionInterval);
             unsubscribe();
         };
-    }, [vscodeConnectionStatus]);
+    }, []); // Remove vscodeConnectionStatus from dependencies
     // Separate effect for handling connecting timeout
     useEffect(() => {
         if (vscodeConnectionStatus !== 'connecting') {