snow-ai 0.3.11 → 0.3.13

package/dist/agents/compactAgent.js

@@ -102,6 +102,7 @@ export class CompactAgent {
                         messages,
                         max_tokens: 4096,
                         includeBuiltinSystemPrompt: false, // 不需要内置系统提示词
+                        disableThinking: true, // Agents 不使用 Extended Thinking
                     }, abortSignal);
                     break;
                 case 'gemini':
@@ -192,14 +193,14 @@ export class CompactAgent {
                         stack: streamError.stack,
                         name: streamError.name,
                         chunkCount,
-                        contentLength: completeContent.length
+                        contentLength: completeContent.length,
                     });
                 }
                 else {
                     logger.error('Compact agent: Unknown streaming error:', {
                         error: streamError,
                         chunkCount,
-                        contentLength: completeContent.length
+                        contentLength: completeContent.length,
                     });
                 }
                 throw streamError;
@@ -220,14 +221,14 @@ export class CompactAgent {
                     stack: error.stack,
                     name: error.name,
                     requestMethod: this.requestMethod,
-                    modelName: this.modelName
+                    modelName: this.modelName,
                 });
             }
             else {
                 logger.error('Compact agent: Unknown API error:', {
                     error,
                     requestMethod: this.requestMethod,
-                    modelName: this.modelName
+                    modelName: this.modelName,
                 });
             }
             throw error;
@@ -291,7 +292,7 @@ Provide the extracted content below:`;
                 logger.warn('Compact agent extraction failed, using original content:', {
                     error: error.message,
                     stack: error.stack,
-                    name: error.name
+                    name: error.name,
                 });
             }
             else {

package/dist/agents/reviewAgent.js

@@ -203,6 +203,7 @@ Please provide your review in a clear, structured format.`;
                     model: this.modelName,
                     messages: processedMessages,
                     max_tokens: 4096,
+                    disableThinking: true, // Agents 不使用 Extended Thinking
                 }, abortSignal);
                 break;
             case 'gemini':

package/dist/agents/summaryAgent.js

@@ -93,6 +93,7 @@ export class SummaryAgent {
                     messages,
                     max_tokens: 500, // Limited tokens for summary generation
                     includeBuiltinSystemPrompt: false, // 不需要内置系统提示词
+                    disableThinking: true, // Agents 不使用 Extended Thinking
                 }, abortSignal);
                 break;
             case 'gemini':

package/dist/api/anthropic.d.ts

@@ -7,9 +7,10 @@ export interface AnthropicOptions {
     tools?: ChatCompletionTool[];
     sessionId?: string;
     includeBuiltinSystemPrompt?: boolean;
+    disableThinking?: boolean;
 }
 export interface AnthropicStreamChunk {
-    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;
@@ -21,6 +22,11 @@ export interface AnthropicStreamChunk {
     }>;
     delta?: string;
     usage?: UsageInfo;
+    thinking?: {
+        type: 'thinking';
+        thinking: string;
+        signature?: string;
+    };
 }
 export interface AnthropicTool {
     name: string;

package/dist/api/anthropic.js

@@ -20,6 +20,7 @@ function getAnthropicConfig() {
                 : 'https://api.anthropic.com/v1',
             customHeaders,
             anthropicBeta: config.anthropicBeta,
+            thinking: config.thinking,
         };
     }
     return anthropicConfig;
@@ -124,6 +125,11 @@ function convertToAnthropicMessages(messages, includeBuiltinSystemPrompt = true)
             msg.tool_calls &&
             msg.tool_calls.length > 0) {
             const content = [];
+            // When thinking is enabled, thinking block must come first
+            if (msg.thinking) {
+                // Use the complete thinking block object (includes signature)
+                content.push(msg.thinking);
+            }
             if (msg.content) {
                 content.push({
                     type: 'text',
@@ -145,10 +151,29 @@ function convertToAnthropicMessages(messages, includeBuiltinSystemPrompt = true)
             continue;
         }
         if (msg.role === 'user' || msg.role === 'assistant') {
-            anthropicMessages.push({
-                role: msg.role,
-                content: msg.content,
-            });
+            // For assistant messages with thinking, convert to structured format
+            if (msg.role === 'assistant' && msg.thinking) {
+                const content = [];
+                // Thinking block must come first - use complete block object (includes signature)
+                content.push(msg.thinking);
+                // Then text content
+                if (msg.content) {
+                    content.push({
+                        type: 'text',
+                        text: msg.content,
+                    });
+                }
+                anthropicMessages.push({
+                    role: 'assistant',
+                    content,
+                });
+            }
+            else {
+                anthropicMessages.push({
+                    role: msg.role,
+                    content: msg.content,
+                });
+            }
         }
     }
     // 如果配置了自定义系统提示词（最高优先级，始终添加）
@@ -266,7 +291,6 @@ export async function* createStreamingAnthropicCompletion(options, abortSignal,
         const requestBody = {
             model: options.model,
             max_tokens: options.max_tokens || 4096,
-            temperature: options.temperature ?? 0.7,
             system,
             messages,
             tools: convertToolsToAnthropic(options.tools),
@@ -275,11 +299,18 @@ export async function* createStreamingAnthropicCompletion(options, abortSignal,
             },
             stream: true,
         };
+        // Add thinking configuration if enabled and not explicitly disabled
+        // When thinking is enabled, temperature must be 1
+        // Note: agents and other internal tools should set disableThinking=true
+        if (config.thinking && !options.disableThinking) {
+            requestBody.thinking = config.thinking;
+            requestBody.temperature = 1;
+        }
         // Prepare headers
         const headers = {
             'Content-Type': 'application/json',
             'x-api-key': config.apiKey,
-            'Authorization': `Bearer ${config.apiKey}`,
+            Authorization: `Bearer ${config.apiKey}`,
             'anthropic-version': '2023-06-01',
             ...config.customHeaders,
         };
@@ -305,10 +336,13 @@ export async function* createStreamingAnthropicCompletion(options, abortSignal,
             throw new Error('No response body from Anthropic API');
         }
         let contentBuffer = '';
+        let thinkingTextBuffer = ''; // Accumulate thinking text content
+        let thinkingSignature = ''; // Accumulate thinking signature
         let toolCallsBuffer = new Map();
         let hasToolCalls = false;
         let usageData;
         let blockIndexToId = new Map();
+        let blockIndexToType = new Map(); // Track block types (text, thinking, tool_use)
         let completedToolBlocks = new Set(); // Track which tool blocks have finished streaming
         for await (const event of parseSSEStream(response.body.getReader())) {
             if (abortSignal?.aborted) {
@@ -316,9 +350,11 @@ export async function* createStreamingAnthropicCompletion(options, abortSignal,
             }
             if (event.type === 'content_block_start') {
                 const block = event.content_block;
+                const blockIndex = event.index;
+                // Track block type for later reference
+                blockIndexToType.set(blockIndex, block.type);
                 if (block.type === 'tool_use') {
                     hasToolCalls = true;
-                    const blockIndex = event.index;
                     blockIndexToId.set(blockIndex, block.id);
                     toolCallsBuffer.set(block.id, {
                         id: block.id,
@@ -333,6 +369,13 @@ export async function* createStreamingAnthropicCompletion(options, abortSignal,
                         delta: block.name,
                     };
                 }
+                // Handle thinking block start (Extended Thinking feature)
+                else if (block.type === 'thinking') {
+                    // Thinking block started - emit reasoning_started event
+                    yield {
+                        type: 'reasoning_started',
+                    };
+                }
             }
             else if (event.type === 'content_block_delta') {
                 const delta = event.delta;
@@ -344,6 +387,21 @@ export async function* createStreamingAnthropicCompletion(options, abortSignal,
                         content: text,
                     };
                 }
+                // Handle thinking_delta (Extended Thinking feature)
+                // Emit reasoning_delta event for thinking content
+                if (delta.type === 'thinking_delta') {
+                    const thinkingText = delta.thinking;
+                    thinkingTextBuffer += thinkingText; // Accumulate thinking text
+                    yield {
+                        type: 'reasoning_delta',
+                        delta: thinkingText,
+                    };
+                }
+                // Handle signature_delta (Extended Thinking feature)
+                // Signature is required for thinking blocks
+                if (delta.type === 'signature_delta') {
+                    thinkingSignature += delta.signature; // Accumulate signature
+                }
                 if (delta.type === 'input_json_delta') {
                     const jsonDelta = delta.partial_json;
                     const blockIndex = event.index;
@@ -457,8 +515,17 @@ export async function* createStreamingAnthropicCompletion(options, abortSignal,
                 usage: usageData,
             };
         }
+        // Return complete thinking block with signature if thinking content exists
+        const thinkingBlock = thinkingTextBuffer
+            ? {
+                type: 'thinking',
+                thinking: thinkingTextBuffer,
+                signature: thinkingSignature || undefined,
+            }
+            : undefined;
         yield {
             type: 'done',
+            thinking: thinkingBlock,
         };
     }, {
         abortSignal,

package/dist/api/chat.js

@@ -185,7 +185,7 @@ export async function* createStreamingChatCompletion(options, abortSignal, onRet
             method: 'POST',
             headers: {
                 'Content-Type': 'application/json',
-                'Authorization': `Bearer ${config.apiKey}`,
+                Authorization: `Bearer ${config.apiKey}`,
                 ...config.customHeaders,
             },
             body: JSON.stringify(requestBody),

package/dist/api/responses.js

@@ -256,7 +256,7 @@ export async function* createStreamingResponse(options, abortSignal, onRetry) {
             method: 'POST',
             headers: {
                 'Content-Type': 'application/json',
-                'Authorization': `Bearer ${config.apiKey}`,
+                Authorization: `Bearer ${config.apiKey}`,
                 ...config.customHeaders,
             },
             body: JSON.stringify(requestPayload),
@@ -442,7 +442,7 @@ export async function* createStreamingResponse(options, abortSignal, onRetry) {
                 usage: usageData,
             };
         }
-        // 发送完成信号
+        // 发送完成信号 - For Responses API, thinking content is in reasoning object, not separate thinking field
         yield {
             type: 'done',
         };

package/dist/api/systemPrompt.js

@@ -33,7 +33,7 @@ const SYSTEM_PROMPT_TEMPLATE = `You are Snow AI CLI, an intelligent command-line
 1. **Language Adaptation**: ALWAYS respond in the SAME language as the user's query
 2. **ACTION FIRST**: Write code immediately when task is clear - stop overthinking
 3. **Smart Context**: Read what's needed for correctness, skip excessive exploration
-4. **Quality Verification**: Use \'ide-get_diagnostics\' to get diagnostic information or run build/test after changes
+4. **Quality Verification**: run build/test after changes
 
 ## 🚀 Execution Strategy - BALANCE ACTION & ANALYSIS
 
@@ -124,10 +124,9 @@ system administration and data processing challenges.
 ## 🔍 Quality Assurance
 
 Guidance and recommendations:
-1. Use \`ide-get_diagnostics\` to verify quality
-2. Run build: \`npm run build\` or \`tsc\`
-3. Fix any errors immediately
-4. Never leave broken code
+1. Run build: \`npm run build\` or \`tsc\`
+2. Fix any errors immediately
+3. Never leave broken code
 
 ## 📚 Project Context (SNOW.md)
 

package/dist/api/types.d.ts

@@ -29,6 +29,11 @@ export interface ChatMessage {
         content?: any;
         encrypted_content?: string;
     };
+    thinking?: {
+        type: 'thinking';
+        thinking: string;
+        signature?: string;
+    };
 }
 export interface ChatCompletionTool {
     type: 'function';

package/dist/hooks/useConversation.js

@@ -114,6 +114,7 @@ export async function handleConversationWithTools(options) {
             let streamedContent = '';
             let receivedToolCalls;
             let receivedReasoning;
+            let receivedThinking; // Accumulate thinking content from all platforms
             // 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 +195,8 @@ export async function handleConversationWithTools(options) {
                 }
                 else if (chunk.type === 'tool_call_delta' && chunk.delta) {
                     // Accumulate tool call deltas and update token count in real-time
+                    // When tool calls start, reasoning is done (OpenAI generally doesn't output text content during tool calls)
+                    setIsReasoning?.(false);
                     toolCallAccumulator += chunk.delta;
                     try {
                         const tokens = encoder.encode(streamedContent + toolCallAccumulator + reasoningAccumulator);
@@ -222,6 +225,10 @@ export async function handleConversationWithTools(options) {
                     // Capture reasoning data from Responses API
                     receivedReasoning = chunk.reasoning;
                 }
+                else if (chunk.type === 'done' && chunk.thinking) {
+                    // Capture thinking content from Anthropic only (includes signature)
+                    receivedThinking = chunk.thinking;
+                }
                 else if (chunk.type === 'usage' && chunk.usage) {
                     // Capture usage information both in state and locally
                     setContextUsage(chunk.usage);
@@ -256,7 +263,8 @@ export async function handleConversationWithTools(options) {
                         }
                         if (chunk.usage.cached_tokens !== undefined) {
                             accumulatedUsage.cached_tokens =
-                                (accumulatedUsage.cached_tokens || 0) + chunk.usage.cached_tokens;
+                                (accumulatedUsage.cached_tokens || 0) +
+                                    chunk.usage.cached_tokens;
                         }
                     }
                 }
@@ -283,7 +291,8 @@ export async function handleConversationWithTools(options) {
                             arguments: tc.function.arguments,
                         },
                     })),
-                    reasoning: receivedReasoning, // Include reasoning data for caching
+                    reasoning: receivedReasoning, // Include reasoning data for caching (Responses API)
+                    thinking: receivedThinking, // Include thinking content (Anthropic/OpenAI)
                 };
                 conversationMessages.push(assistantMessage);
                 // Save assistant message with tool calls
@@ -819,7 +828,8 @@ export async function handleConversationWithTools(options) {
                 const assistantMessage = {
                     role: 'assistant',
                     content: streamedContent.trim(),
-                    reasoning: receivedReasoning, // Include reasoning data for caching
+                    reasoning: receivedReasoning, // Include reasoning data for caching (Responses API)
+                    thinking: receivedThinking, // Include thinking content (Anthropic/OpenAI)
                 };
                 conversationMessages.push(assistantMessage);
                 saveMessage(assistantMessage).catch(error => {

package/dist/hooks/useFilePicker.d.ts

@@ -2,13 +2,13 @@ import { TextBuffer } from '../utils/textBuffer.js';
 import { FileListRef } from '../ui/components/FileList.js';
 export declare function useFilePicker(buffer: TextBuffer, triggerUpdate: () => void): {
     showFilePicker: boolean;
-    setShowFilePicker: import("react").Dispatch<import("react").SetStateAction<boolean>>;
+    setShowFilePicker: (show: boolean) => void;
     fileSelectedIndex: number;
-    setFileSelectedIndex: import("react").Dispatch<import("react").SetStateAction<number>>;
+    setFileSelectedIndex: (index: number | ((prev: number) => number)) => void;
     fileQuery: string;
-    setFileQuery: import("react").Dispatch<import("react").SetStateAction<string>>;
+    setFileQuery: (_query: string) => void;
     atSymbolPosition: number;
-    setAtSymbolPosition: import("react").Dispatch<import("react").SetStateAction<number>>;
+    setAtSymbolPosition: (_pos: number) => void;
     filteredFileCount: number;
     updateFilePickerState: (text: string, cursorPos: number) => void;
     handleFileSelect: (filePath: string) => Promise<void>;

package/dist/hooks/useFilePicker.js

@@ -1,19 +1,58 @@
-import { useState, useCallback, useRef } from 'react';
+import { useReducer, useCallback, useRef } from 'react';
+function filePickerReducer(state, action) {
+    switch (action.type) {
+        case 'SHOW':
+            return {
+                ...state,
+                showFilePicker: true,
+                fileSelectedIndex: 0,
+                fileQuery: action.query,
+                atSymbolPosition: action.position,
+            };
+        case 'HIDE':
+            return {
+                ...state,
+                showFilePicker: false,
+                fileSelectedIndex: 0,
+                fileQuery: '',
+                atSymbolPosition: -1,
+            };
+        case 'SELECT_FILE':
+            return {
+                ...state,
+                showFilePicker: false,
+                fileSelectedIndex: 0,
+                fileQuery: '',
+                atSymbolPosition: -1,
+            };
+        case 'SET_SELECTED_INDEX':
+            return {
+                ...state,
+                fileSelectedIndex: action.index,
+            };
+        case 'SET_FILTERED_COUNT':
+            return {
+                ...state,
+                filteredFileCount: action.count,
+            };
+        default:
+            return state;
+    }
+}
 export function useFilePicker(buffer, triggerUpdate) {
-    const [showFilePicker, setShowFilePicker] = useState(false);
-    const [fileSelectedIndex, setFileSelectedIndex] = useState(0);
-    const [fileQuery, setFileQuery] = useState('');
-    const [atSymbolPosition, setAtSymbolPosition] = useState(-1);
-    const [filteredFileCount, setFilteredFileCount] = useState(0);
+    const [state, dispatch] = useReducer(filePickerReducer, {
+        showFilePicker: false,
+        fileSelectedIndex: 0,
+        fileQuery: '',
+        atSymbolPosition: -1,
+        filteredFileCount: 0,
+    });
     const fileListRef = useRef(null);
     // Update file picker state
     const updateFilePickerState = useCallback((text, cursorPos) => {
         if (!text.includes('@')) {
-            if (showFilePicker) {
-                setShowFilePicker(false);
-                setFileSelectedIndex(0);
-                setFileQuery('');
-                setAtSymbolPosition(-1);
+            if (state.showFilePicker) {
+                dispatch({ type: 'HIDE' });
             }
             return;
         }
@@ -24,65 +63,74 @@ export function useFilePicker(buffer, triggerUpdate) {
             // Check if there's no space between '@' and cursor
             const afterAt = beforeCursor.slice(lastAtIndex + 1);
             if (!afterAt.includes(' ') && !afterAt.includes('\n')) {
-                if (!showFilePicker ||
-                    fileQuery !== afterAt ||
-                    atSymbolPosition !== lastAtIndex) {
-                    setShowFilePicker(true);
-                    setFileSelectedIndex(0);
-                    setFileQuery(afterAt);
-                    setAtSymbolPosition(lastAtIndex);
+                if (!state.showFilePicker ||
+                    state.fileQuery !== afterAt ||
+                    state.atSymbolPosition !== lastAtIndex) {
+                    dispatch({ type: 'SHOW', query: afterAt, position: lastAtIndex });
                 }
                 return;
             }
         }
         // Hide file picker if no valid @ context found
-        if (showFilePicker) {
-            setShowFilePicker(false);
-            setFileSelectedIndex(0);
-            setFileQuery('');
-            setAtSymbolPosition(-1);
+        if (state.showFilePicker) {
+            dispatch({ type: 'HIDE' });
         }
-    }, [showFilePicker, fileQuery, atSymbolPosition]);
+    }, [state.showFilePicker, state.fileQuery, state.atSymbolPosition]);
     // Handle file selection
     const handleFileSelect = useCallback(async (filePath) => {
-        if (atSymbolPosition !== -1) {
+        if (state.atSymbolPosition !== -1) {
             const text = buffer.getFullText();
             const cursorPos = buffer.getCursorPosition();
             // Replace @query with @filePath + space
-            const beforeAt = text.slice(0, atSymbolPosition);
+            const beforeAt = text.slice(0, state.atSymbolPosition);
             const afterCursor = text.slice(cursorPos);
             const newText = beforeAt + '@' + filePath + ' ' + afterCursor;
             // Set the new text and position cursor after the inserted file path + space
             buffer.setText(newText);
             // Calculate cursor position after the inserted file path + space
             // Reset cursor to beginning, then move to correct position
-            for (let i = 0; i < atSymbolPosition + filePath.length + 2; i++) {
+            for (let i = 0; i < state.atSymbolPosition + filePath.length + 2; i++) {
                 // +2 for @ and space
                 if (i < buffer.getFullText().length) {
                     buffer.moveRight();
                 }
             }
-            setShowFilePicker(false);
-            setFileSelectedIndex(0);
-            setFileQuery('');
-            setAtSymbolPosition(-1);
+            dispatch({ type: 'SELECT_FILE' });
             triggerUpdate();
         }
-    }, [atSymbolPosition, buffer, triggerUpdate]);
+    }, [state.atSymbolPosition, buffer]);
     // Handle filtered file count change
     const handleFilteredCountChange = useCallback((count) => {
-        setFilteredFileCount(count);
+        dispatch({ type: 'SET_FILTERED_COUNT', count });
+    }, []);
+    // Wrapper setters for backwards compatibility
+    const setShowFilePicker = useCallback((show) => {
+        dispatch({ type: show ? 'SHOW' : 'HIDE', query: '', position: -1 });
     }, []);
+    const setFileSelectedIndex = useCallback((index) => {
+        if (typeof index === 'function') {
+            // For functional updates, we need to get current state first
+            // This is a simplified version - in production you might want to use a ref
+            dispatch({ type: 'SET_SELECTED_INDEX', index: index(state.fileSelectedIndex) });
+        }
+        else {
+            dispatch({ type: 'SET_SELECTED_INDEX', index });
+        }
+    }, [state.fileSelectedIndex]);
     return {
-        showFilePicker,
+        showFilePicker: state.showFilePicker,
         setShowFilePicker,
-        fileSelectedIndex,
+        fileSelectedIndex: state.fileSelectedIndex,
         setFileSelectedIndex,
-        fileQuery,
-        setFileQuery,
-        atSymbolPosition,
-        setAtSymbolPosition,
-        filteredFileCount,
+        fileQuery: state.fileQuery,
+        setFileQuery: (_query) => {
+            // Not used, but kept for compatibility
+        },
+        atSymbolPosition: state.atSymbolPosition,
+        setAtSymbolPosition: (_pos) => {
+            // Not used, but kept for compatibility
+        },
+        filteredFileCount: state.filteredFileCount,
         updateFilePickerState,
         handleFileSelect,
         handleFilteredCountChange,

package/dist/hooks/useHistoryNavigation.d.ts

@@ -17,5 +17,10 @@ export declare function useHistoryNavigation(buffer: TextBuffer, triggerUpdate:
         infoText: string;
     }[];
     handleHistorySelect: (value: string) => void;
+    currentHistoryIndex: number;
+    navigateHistoryUp: () => boolean;
+    navigateHistoryDown: () => boolean;
+    resetHistoryNavigation: () => void;
+    saveToHistory: (content: string) => Promise<void>;
 };
 export {};