snow-ai 0.2.11 → 0.2.12

package/dist/api/anthropic.d.ts

@@ -12,6 +12,8 @@ export interface UsageInfo {
     prompt_tokens: number;
     completion_tokens: number;
     total_tokens: number;
+    cache_creation_input_tokens?: number;
+    cache_read_input_tokens?: number;
 }
 export interface AnthropicStreamChunk {
     type: 'content' | 'tool_calls' | 'tool_call_delta' | 'done' | 'usage';

package/dist/api/anthropic.js

@@ -1,6 +1,6 @@
 import Anthropic from '@anthropic-ai/sdk';
 import { createHash, randomUUID } from 'crypto';
-import { getOpenAiConfig } from '../utils/apiConfig.js';
+import { getOpenAiConfig, getCustomSystemPrompt } from '../utils/apiConfig.js';
 import { SYSTEM_PROMPT } from './systemPrompt.js';
 let anthropicClient = null;
 function getAnthropicClient() {
@@ -45,12 +45,13 @@ function generateUserId(sessionId) {
 }
 /**
  * Convert OpenAI-style tools to Anthropic tool format
+ * Adds cache_control to the last tool for prompt caching
  */
 function convertToolsToAnthropic(tools) {
     if (!tools || tools.length === 0) {
         return undefined;
     }
-    return tools
+    const convertedTools = tools
         .filter(tool => tool.type === 'function' && 'function' in tool)
         .map(tool => {
         if (tool.type === 'function' && 'function' in tool) {
@@ -62,6 +63,12 @@ function convertToolsToAnthropic(tools) {
         }
         throw new Error('Invalid tool format');
     });
+    // Add cache_control to the last tool for prompt caching
+    if (convertedTools.length > 0) {
+        const lastTool = convertedTools[convertedTools.length - 1];
+        lastTool.cache_control = { type: 'ephemeral' };
+    }
+    return convertedTools;
 }
 /**
  * Convert our ChatMessage format to Anthropic's message format
@@ -71,8 +78,7 @@ function convertToolsToAnthropic(tools) {
  * 2. If no custom system prompt: use default as system
  */
 function convertToAnthropicMessages(messages) {
-    const config = getOpenAiConfig();
-    const customSystemPrompt = config.systemPrompt;
+    const customSystemPrompt = getCustomSystemPrompt();
     let systemContent;
     const anthropicMessages = [];
     for (const msg of messages) {
@@ -231,6 +237,7 @@ export async function* createStreamingAnthropicCompletion(options, abortSignal)
         let toolCallsBuffer = new Map();
         let hasToolCalls = false;
         let usageData;
+        let currentToolUseId = null; // Track current tool use block ID
         for await (const event of stream) {
             if (abortSignal?.aborted) {
                 return;
@@ -241,6 +248,7 @@ export async function* createStreamingAnthropicCompletion(options, abortSignal)
                 // Handle tool use blocks
                 if (block.type === 'tool_use') {
                     hasToolCalls = true;
+                    currentToolUseId = block.id; // Store current tool use ID
                     toolCallsBuffer.set(block.id, {
                         id: block.id,
                         type: 'function',
@@ -270,29 +278,38 @@ export async function* createStreamingAnthropicCompletion(options, abortSignal)
                 // Handle tool input deltas
                 if (delta.type === 'input_json_delta') {
                     const jsonDelta = delta.partial_json;
-                    const toolCall = toolCallsBuffer.get(event.index.toString());
-                    if (toolCall) {
-                        toolCall.function.arguments += jsonDelta;
-                        // Yield delta for token counting
-                        yield {
-                            type: 'tool_call_delta',
-                            delta: jsonDelta
-                        };
+                    // Use currentToolUseId instead of event.index
+                    if (currentToolUseId) {
+                        const toolCall = toolCallsBuffer.get(currentToolUseId);
+                        if (toolCall) {
+                            toolCall.function.arguments += jsonDelta;
+                            // Yield delta for token counting
+                            yield {
+                                type: 'tool_call_delta',
+                                delta: jsonDelta
+                            };
+                        }
                     }
                 }
             }
+            else if (event.type === 'content_block_stop') {
+                // Reset current tool use ID when block ends
+                currentToolUseId = null;
+            }
             else if (event.type === 'message_start') {
-                // Capture initial usage data
+                // Capture initial usage data (including cache metrics)
                 if (event.message.usage) {
                     usageData = {
                         prompt_tokens: event.message.usage.input_tokens || 0,
                         completion_tokens: event.message.usage.output_tokens || 0,
-                        total_tokens: (event.message.usage.input_tokens || 0) + (event.message.usage.output_tokens || 0)
+                        total_tokens: (event.message.usage.input_tokens || 0) + (event.message.usage.output_tokens || 0),
+                        cache_creation_input_tokens: event.message.usage.cache_creation_input_tokens,
+                        cache_read_input_tokens: event.message.usage.cache_read_input_tokens
                     };
                 }
             }
             else if (event.type === 'message_delta') {
-                // Update usage data with final token counts
+                // Update usage data with final token counts (including cache metrics)
                 if (event.usage) {
                     if (!usageData) {
                         usageData = {
@@ -303,14 +320,32 @@ export async function* createStreamingAnthropicCompletion(options, abortSignal)
                     }
                     usageData.completion_tokens = event.usage.output_tokens || 0;
                     usageData.total_tokens = usageData.prompt_tokens + usageData.completion_tokens;
+                    // Update cache metrics if present
+                    if (event.usage.cache_creation_input_tokens !== undefined) {
+                        usageData.cache_creation_input_tokens = event.usage.cache_creation_input_tokens;
+                    }
+                    if (event.usage.cache_read_input_tokens !== undefined) {
+                        usageData.cache_read_input_tokens = event.usage.cache_read_input_tokens;
+                    }
                 }
             }
         }
-        // Yield tool calls if any
+        // Yield tool calls if any (only after stream completes)
         if (hasToolCalls && toolCallsBuffer.size > 0) {
+            // Validate that all tool call arguments are complete valid JSON
+            const toolCalls = Array.from(toolCallsBuffer.values());
+            for (const toolCall of toolCalls) {
+                try {
+                    // Validate JSON completeness
+                    JSON.parse(toolCall.function.arguments);
+                }
+                catch (e) {
+                    throw new Error(`Incomplete tool call JSON for ${toolCall.function.name}: ${toolCall.function.arguments}`);
+                }
+            }
             yield {
                 type: 'tool_calls',
-                tool_calls: Array.from(toolCallsBuffer.values())
+                tool_calls: toolCalls
             };
         }
         // Yield usage information if available

package/dist/api/chat.d.ts

@@ -69,6 +69,9 @@ export interface UsageInfo {
     prompt_tokens: number;
     completion_tokens: number;
     total_tokens: number;
+    cache_creation_input_tokens?: number;
+    cache_read_input_tokens?: number;
+    cached_tokens?: number;
 }
 export interface StreamChunk {
     type: 'content' | 'tool_calls' | 'tool_call_delta' | 'reasoning_delta' | 'done' | 'usage';

package/dist/api/chat.js

@@ -1,5 +1,5 @@
 import OpenAI from 'openai';
-import { getOpenAiConfig } from '../utils/apiConfig.js';
+import { getOpenAiConfig, getCustomSystemPrompt } from '../utils/apiConfig.js';
 import { executeMCPTool } from '../utils/mcpToolsManager.js';
 import { SYSTEM_PROMPT } from './systemPrompt.js';
 /**
@@ -10,8 +10,7 @@ import { SYSTEM_PROMPT } from './systemPrompt.js';
  * 2. If no custom system prompt: use default as system
  */
 function convertToOpenAIMessages(messages, includeSystemPrompt = true) {
-    const config = getOpenAiConfig();
-    const customSystemPrompt = config.systemPrompt;
+    const customSystemPrompt = getCustomSystemPrompt();
     let result = messages.map(msg => {
         // 如果消息包含图片，使用 content 数组格式
         if (msg.role === 'user' && msg.images && msg.images.length > 0) {
@@ -276,7 +275,9 @@ export async function* createStreamingChatCompletion(options, abortSignal) {
                 usageData = {
                     prompt_tokens: usageValue.prompt_tokens || 0,
                     completion_tokens: usageValue.completion_tokens || 0,
-                    total_tokens: usageValue.total_tokens || 0
+                    total_tokens: usageValue.total_tokens || 0,
+                    // OpenAI Chat API: cached_tokens in prompt_tokens_details
+                    cached_tokens: usageValue.prompt_tokens_details?.cached_tokens
                 };
             }
             // Skip content processing if no choices (but usage is already captured above)

package/dist/api/gemini.d.ts

@@ -10,6 +10,9 @@ export interface UsageInfo {
     prompt_tokens: number;
     completion_tokens: number;
     total_tokens: number;
+    cache_creation_input_tokens?: number;
+    cache_read_input_tokens?: number;
+    cached_tokens?: number;
 }
 export interface GeminiStreamChunk {
     type: 'content' | 'tool_calls' | 'tool_call_delta' | 'done' | 'usage';

package/dist/api/gemini.js

@@ -1,5 +1,5 @@
-import { GoogleGenerativeAI } from '@google/generative-ai';
-import { getOpenAiConfig } from '../utils/apiConfig.js';
+import { GoogleGenAI } from '@google/genai';
+import { getOpenAiConfig, getCustomSystemPrompt } from '../utils/apiConfig.js';
 import { SYSTEM_PROMPT } from './systemPrompt.js';
 let geminiClient = null;
 function getGeminiClient() {
@@ -8,7 +8,20 @@ function getGeminiClient() {
         if (!config.apiKey) {
             throw new Error('Gemini API configuration is incomplete. Please configure API key first.');
         }
-        geminiClient = new GoogleGenerativeAI(config.apiKey);
+        // Create client configuration
+        const clientConfig = {
+            apiKey: config.apiKey
+        };
+        // Support custom baseUrl and headers for proxy servers
+        if (config.baseUrl && config.baseUrl !== 'https://api.openai.com/v1') {
+            clientConfig.httpOptions = {
+                baseUrl: config.baseUrl,
+                headers: {
+                    'x-goog-api-key': config.apiKey, // Gemini API requires this header
+                }
+            };
+        }
+        geminiClient = new GoogleGenAI(clientConfig);
     }
     return geminiClient;
 }
@@ -26,10 +39,16 @@ function convertToolsToGemini(tools) {
         .filter(tool => tool.type === 'function' && 'function' in tool)
         .map(tool => {
         if (tool.type === 'function' && 'function' in tool) {
+            // Convert OpenAI parameters schema to Gemini format
+            const params = tool.function.parameters;
             return {
                 name: tool.function.name,
                 description: tool.function.description || '',
-                parameters: tool.function.parameters
+                parametersJsonSchema: {
+                    type: 'object',
+                    properties: params.properties || {},
+                    required: params.required || []
+                }
             };
         }
         throw new Error('Invalid tool format');
@@ -37,40 +56,110 @@ function convertToolsToGemini(tools) {
     return [{ functionDeclarations }];
 }
 /**
- * Convert our ChatMessage format to Gemini's Content format
- * Logic:
- * 1. If custom system prompt exists: use custom as systemInstruction, prepend default as first user message
- * 2. If no custom system prompt: use default as systemInstruction
+ * Convert our ChatMessage format to Gemini's format
  */
 function convertToGeminiMessages(messages) {
-    const config = getOpenAiConfig();
-    const customSystemPrompt = config.systemPrompt;
+    const customSystemPrompt = getCustomSystemPrompt();
     let systemInstruction;
     const contents = [];
-    for (const msg of messages) {
+    for (let i = 0; i < messages.length; i++) {
+        const msg = messages[i];
+        if (!msg)
+            continue;
         // Extract system message as systemInstruction
         if (msg.role === 'system') {
             systemInstruction = msg.content;
             continue;
         }
-        // Skip tool messages for now (Gemini handles them differently)
+        // Handle tool results
         if (msg.role === 'tool') {
-            // Tool results in Gemini are represented as function response parts
-            const parts = [{
-                    functionResponse: {
-                        name: 'function_name', // This should be mapped from tool_call_id
-                        response: {
-                            content: msg.content
+            // Find the corresponding function call to get the function name
+            // Look backwards in contents to find the matching tool call
+            let functionName = 'unknown_function';
+            for (let j = contents.length - 1; j >= 0; j--) {
+                const contentMsg = contents[j];
+                if (contentMsg.role === 'model' && contentMsg.parts) {
+                    for (const part of contentMsg.parts) {
+                        if (part.functionCall) {
+                            functionName = part.functionCall.name;
+                            break;
                         }
                     }
-                }];
+                    if (functionName !== 'unknown_function')
+                        break;
+                }
+            }
+            // 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;
+            if (!msg.content) {
+                responseData = {};
+            }
+            else {
+                let contentToParse = msg.content;
+                // Sometimes the content is double-encoded as JSON
+                // First, try to parse it once
+                try {
+                    const firstParse = JSON.parse(contentToParse);
+                    // If it's a string, it might be double-encoded, try parsing again
+                    if (typeof firstParse === 'string') {
+                        contentToParse = firstParse;
+                    }
+                }
+                catch {
+                    // Not JSON, use as-is
+                }
+                // Now parse or wrap the final content
+                try {
+                    const parsed = JSON.parse(contentToParse);
+                    // If parsed result is an object (not array, not null), use it directly
+                    if (typeof parsed === 'object' && parsed !== null && !Array.isArray(parsed)) {
+                        responseData = parsed;
+                    }
+                    else {
+                        // If it's a primitive, array, or null, wrap it
+                        responseData = { content: parsed };
+                    }
+                }
+                catch {
+                    // Not valid JSON, wrap the raw string
+                    responseData = { content: contentToParse };
+                }
+            }
             contents.push({
-                role: 'function',
+                role: 'user',
+                parts: [{
+                        functionResponse: {
+                            name: functionName,
+                            response: responseData
+                        }
+                    }]
+            });
+            continue;
+        }
+        // Handle tool calls in assistant messages
+        if (msg.role === 'assistant' && msg.tool_calls && msg.tool_calls.length > 0) {
+            const parts = [];
+            // Add text content if exists
+            if (msg.content) {
+                parts.push({ text: msg.content });
+            }
+            // Add function calls
+            for (const toolCall of msg.tool_calls) {
+                parts.push({
+                    functionCall: {
+                        name: toolCall.function.name,
+                        args: JSON.parse(toolCall.function.arguments)
+                    }
+                });
+            }
+            contents.push({
+                role: 'model',
                 parts
             });
             continue;
         }
-        // Convert user/assistant messages
+        // Build message parts
         const parts = [];
         // Add text content
         if (msg.content) {
@@ -79,7 +168,6 @@ function convertToGeminiMessages(messages) {
         // Add images for user messages
         if (msg.role === 'user' && msg.images && msg.images.length > 0) {
             for (const image of msg.images) {
-                // Extract base64 data and mime type
                 const base64Match = image.data.match(/^data:([^;]+);base64,(.+)$/);
                 if (base64Match) {
                     parts.push({
@@ -91,35 +179,20 @@ function convertToGeminiMessages(messages) {
                 }
             }
         }
-        // Handle tool calls in assistant messages
-        if (msg.role === 'assistant' && msg.tool_calls && msg.tool_calls.length > 0) {
-            for (const toolCall of msg.tool_calls) {
-                parts.push({
-                    functionCall: {
-                        name: toolCall.function.name,
-                        args: JSON.parse(toolCall.function.arguments)
-                    }
-                });
-            }
-        }
-        // Map role (Gemini uses 'user' and 'model' instead of 'user' and 'assistant')
+        // Add to contents
         const role = msg.role === 'assistant' ? 'model' : 'user';
-        contents.push({
-            role,
-            parts
-        });
+        contents.push({ role, parts });
     }
-    // 如果配置了自定义系统提示词
+    // Handle system instruction
     if (customSystemPrompt) {
-        // 自定义系统提示词作为 systemInstruction，默认系统提示词作为第一条用户消息
         systemInstruction = customSystemPrompt;
+        // Prepend default system prompt as first user message
         contents.unshift({
             role: 'user',
             parts: [{ text: SYSTEM_PROMPT }]
         });
     }
     else if (!systemInstruction) {
-        // 没有自定义系统提示词，默认系统提示词作为 systemInstruction
         systemInstruction = SYSTEM_PROMPT;
     }
     return { systemInstruction, contents };
@@ -129,83 +202,79 @@ function convertToGeminiMessages(messages) {
  */
 export async function* createStreamingGeminiCompletion(options, abortSignal) {
     const client = getGeminiClient();
-    const config = getOpenAiConfig();
     try {
         const { systemInstruction, contents } = convertToGeminiMessages(options.messages);
-        // Initialize the model with optional custom baseUrl
-        // Note: For Gemini API, baseUrl should be in format: https://your-proxy.com/v1beta
-        // Default is: https://generativelanguage.googleapis.com/v1beta
-        const modelConfig = {
+        // Build request config
+        const requestConfig = {
             model: options.model,
-            systemInstruction,
-            tools: convertToolsToGemini(options.tools),
-            generationConfig: {
+            contents,
+            config: {
+                systemInstruction,
                 temperature: options.temperature ?? 0.7,
             }
         };
-        // Support custom baseUrl for proxy servers
-        const requestOptions = {};
-        if (config.baseUrl && config.baseUrl !== 'https://api.openai.com/v1') {
-            // Only set custom baseUrl if it's not the default OpenAI URL
-            requestOptions.baseUrl = config.baseUrl;
-        }
-        const model = client.getGenerativeModel(modelConfig, requestOptions);
-        // Start chat session
-        const chat = model.startChat({
-            history: contents.slice(0, -1), // All messages except the last one
-        });
-        // Get the last user message
-        const lastMessage = contents[contents.length - 1];
-        if (!lastMessage) {
-            throw new Error('No user message found');
+        // Add tools if provided
+        const geminiTools = convertToolsToGemini(options.tools);
+        if (geminiTools) {
+            requestConfig.config.tools = geminiTools;
         }
         // Stream the response
-        const result = await chat.sendMessageStream(lastMessage.parts);
+        const stream = await client.models.generateContentStream(requestConfig);
         let contentBuffer = '';
         let toolCallsBuffer = [];
         let hasToolCalls = false;
         let toolCallIndex = 0;
-        for await (const chunk of result.stream) {
+        let totalTokens = { prompt: 0, completion: 0, total: 0 };
+        // Save original console.warn to suppress SDK warnings
+        const originalWarn = console.warn;
+        console.warn = () => { }; // Suppress "there are non-text parts" warnings
+        for await (const chunk of stream) {
             if (abortSignal?.aborted) {
+                console.warn = originalWarn; // Restore console.warn
                 return;
             }
-            const candidate = chunk.candidates?.[0];
-            if (!candidate)
-                continue;
             // Process text content
-            const text = chunk.text();
-            if (text) {
-                contentBuffer += text;
+            if (chunk.text) {
+                contentBuffer += chunk.text;
                 yield {
                     type: 'content',
-                    content: text
+                    content: chunk.text
                 };
             }
-            // Process function calls (tool calls)
-            const functionCalls = candidate.content?.parts?.filter(part => 'functionCall' in part);
-            if (functionCalls && functionCalls.length > 0) {
+            // Process function calls using the official API
+            if (chunk.functionCalls && chunk.functionCalls.length > 0) {
                 hasToolCalls = true;
-                for (const fc of functionCalls) {
-                    if ('functionCall' in fc && fc.functionCall) {
-                        const toolCall = {
-                            id: `call_${toolCallIndex++}`,
-                            type: 'function',
-                            function: {
-                                name: fc.functionCall.name,
-                                arguments: JSON.stringify(fc.functionCall.args)
-                            }
-                        };
-                        toolCallsBuffer.push(toolCall);
-                        // Yield delta for token counting
-                        const deltaText = fc.functionCall.name + JSON.stringify(fc.functionCall.args);
-                        yield {
-                            type: 'tool_call_delta',
-                            delta: deltaText
-                        };
-                    }
+                for (const fc of chunk.functionCalls) {
+                    if (!fc.name)
+                        continue;
+                    const toolCall = {
+                        id: `call_${toolCallIndex++}`,
+                        type: 'function',
+                        function: {
+                            name: fc.name,
+                            arguments: JSON.stringify(fc.args)
+                        }
+                    };
+                    toolCallsBuffer.push(toolCall);
+                    // Yield delta for token counting
+                    const deltaText = fc.name + JSON.stringify(fc.args);
+                    yield {
+                        type: 'tool_call_delta',
+                        delta: deltaText
+                    };
                 }
             }
+            // Track usage info
+            if (chunk.usageMetadata) {
+                totalTokens = {
+                    prompt: chunk.usageMetadata.promptTokenCount || 0,
+                    completion: chunk.usageMetadata.candidatesTokenCount || 0,
+                    total: chunk.usageMetadata.totalTokenCount || 0
+                };
+            }
         }
+        // Restore console.warn
+        console.warn = originalWarn;
         // Yield tool calls if any
         if (hasToolCalls && toolCallsBuffer.length > 0) {
             yield {
@@ -213,16 +282,14 @@ export async function* createStreamingGeminiCompletion(options, abortSignal) {
                 tool_calls: toolCallsBuffer
             };
         }
-        // Get final response for usage info
-        const finalResponse = await result.response;
-        const usageMetadata = finalResponse.usageMetadata;
-        if (usageMetadata) {
+        // Yield usage info
+        if (totalTokens.total > 0) {
             yield {
                 type: 'usage',
                 usage: {
-                    prompt_tokens: usageMetadata.promptTokenCount || 0,
-                    completion_tokens: usageMetadata.candidatesTokenCount || 0,
-                    total_tokens: usageMetadata.totalTokenCount || 0
+                    prompt_tokens: totalTokens.prompt,
+                    completion_tokens: totalTokens.completion,
+                    total_tokens: totalTokens.total
                 }
             };
         }

package/dist/api/responses.d.ts

@@ -26,6 +26,9 @@ export interface UsageInfo {
     prompt_tokens: number;
     completion_tokens: number;
     total_tokens: number;
+    cache_creation_input_tokens?: number;
+    cache_read_input_tokens?: number;
+    cached_tokens?: number;
 }
 export interface ResponseStreamChunk {
     type: 'content' | 'tool_calls' | 'tool_call_delta' | 'reasoning_delta' | 'done' | 'usage';

package/dist/api/responses.js

@@ -1,5 +1,5 @@
 import OpenAI from 'openai';
-import { getOpenAiConfig } from '../utils/apiConfig.js';
+import { getOpenAiConfig, getCustomSystemPrompt } from '../utils/apiConfig.js';
 import { executeMCPTool } from '../utils/mcpToolsManager.js';
 import { SYSTEM_PROMPT } from './systemPrompt.js';
 /**
@@ -83,8 +83,7 @@ export function resetOpenAIClient() {
  * 2. If no custom system prompt: use default as instructions
  */
 function convertToResponseInput(messages) {
-    const config = getOpenAiConfig();
-    const customSystemPrompt = config.systemPrompt;
+    const customSystemPrompt = getCustomSystemPrompt();
     const result = [];
     for (const msg of messages) {
         if (!msg)
@@ -410,7 +409,9 @@ export async function* createStreamingResponse(options, abortSignal) {
                     usageData = {
                         prompt_tokens: chunk.response.usage.input_tokens || 0,
                         completion_tokens: chunk.response.usage.output_tokens || 0,
-                        total_tokens: chunk.response.usage.total_tokens || 0
+                        total_tokens: chunk.response.usage.total_tokens || 0,
+                        // OpenAI Responses API: cached_tokens in input_tokens_details (note: tokenS)
+                        cached_tokens: chunk.response.usage.input_tokens_details?.cached_tokens
                     };
                 }
                 break;

package/dist/ui/components/ChatInput.d.ts

@@ -16,6 +16,9 @@ type Props = {
     contextUsage?: {
         inputTokens: number;
         maxContextTokens: number;
+        cacheCreationTokens?: number;
+        cacheReadTokens?: number;
+        cachedTokens?: number;
     };
     snapshotFileCount?: Map<number, number>;
 };

package/dist/ui/components/ChatInput.js

@@ -647,7 +647,15 @@ end try'`;
                 React.createElement(Text, { color: "yellow", dimColor: true }, "\u2741  YOLO MODE ACTIVE - All tools will be auto-approved without confirmation"))),
             contextUsage && (React.createElement(Box, { marginTop: 1, paddingX: 1 },
                 React.createElement(Text, { color: "gray", dimColor: true }, (() => {
-                    const percentage = Math.min(100, (contextUsage.inputTokens / contextUsage.maxContextTokens) * 100);
+                    // Determine which caching system is being used
+                    const isAnthropic = (contextUsage.cacheCreationTokens || 0) > 0 || (contextUsage.cacheReadTokens || 0) > 0;
+                    const isOpenAI = (contextUsage.cachedTokens || 0) > 0;
+                    // For Anthropic: Total = inputTokens + cacheCreationTokens
+                    // For OpenAI: Total = inputTokens (cachedTokens are already included in inputTokens)
+                    const totalInputTokens = isAnthropic
+                        ? contextUsage.inputTokens + (contextUsage.cacheCreationTokens || 0)
+                        : contextUsage.inputTokens;
+                    const percentage = Math.min(100, (totalInputTokens / contextUsage.maxContextTokens) * 100);
                     let color;
                     if (percentage < 50)
                         color = 'green';
@@ -662,13 +670,32 @@ end try'`;
                             return `${(num / 1000).toFixed(1)}k`;
                         return num.toString();
                     };
+                    const hasCacheMetrics = isAnthropic || isOpenAI;
                     return (React.createElement(React.Fragment, null,
                         React.createElement(Text, { color: color },
                             percentage.toFixed(1),
                             "%"),
                         React.createElement(Text, null, " \u00B7 "),
-                        React.createElement(Text, { color: color }, formatNumber(contextUsage.inputTokens)),
-                        React.createElement(Text, null, " tokens")));
+                        React.createElement(Text, { color: color }, formatNumber(totalInputTokens)),
+                        React.createElement(Text, null, " tokens"),
+                        hasCacheMetrics && (React.createElement(React.Fragment, null,
+                            React.createElement(Text, null, " \u00B7 "),
+                            isAnthropic && (React.createElement(React.Fragment, null,
+                                (contextUsage.cacheReadTokens || 0) > 0 && (React.createElement(React.Fragment, null,
+                                    React.createElement(Text, { color: "cyan" },
+                                        "\u21AF ",
+                                        formatNumber(contextUsage.cacheReadTokens || 0),
+                                        " cached"))),
+                                (contextUsage.cacheCreationTokens || 0) > 0 && (React.createElement(React.Fragment, null,
+                                    (contextUsage.cacheReadTokens || 0) > 0 && React.createElement(Text, null, " \u00B7 "),
+                                    React.createElement(Text, { color: "magenta" },
+                                        "\u25C6 ",
+                                        formatNumber(contextUsage.cacheCreationTokens || 0),
+                                        " new cache"))))),
+                            isOpenAI && (React.createElement(Text, { color: "cyan" },
+                                "\u21AF ",
+                                formatNumber(contextUsage.cachedTokens || 0),
+                                " cached"))))));
                 })()))),
             React.createElement(Box, { marginTop: 1 },
                 React.createElement(Text, { color: "gray", dimColor: true }, showCommands && getFilteredCommands().length > 0

package/dist/ui/pages/ChatScreen.js

@@ -728,7 +728,10 @@ export default function ChatScreen({}) {
         !pendingToolConfirmation && !isCompressing && !showSessionPanel && !showMcpPanel && !pendingRollback && (React.createElement(React.Fragment, null,
             React.createElement(ChatInput, { onSubmit: handleMessageSubmit, onCommand: handleCommandExecution, placeholder: "Ask me anything about coding...", disabled: !!pendingToolConfirmation, chatHistory: messages, onHistorySelect: handleHistorySelect, yoloMode: yoloMode, contextUsage: contextUsage ? {
                     inputTokens: contextUsage.prompt_tokens,
-                    maxContextTokens: getOpenAiConfig().maxContextTokens || 4000
+                    maxContextTokens: getOpenAiConfig().maxContextTokens || 4000,
+                    cacheCreationTokens: contextUsage.cache_creation_input_tokens,
+                    cacheReadTokens: contextUsage.cache_read_input_tokens,
+                    cachedTokens: contextUsage.cached_tokens
                 } : undefined, snapshotFileCount: snapshotFileCount }),
             vscodeConnectionStatus !== 'disconnected' && (React.createElement(Box, { marginTop: 1 },
                 React.createElement(Text, { color: vscodeConnectionStatus === 'connecting' ? 'yellow' :

package/dist/ui/pages/SystemPromptConfigScreen.js

@@ -4,7 +4,6 @@ import { spawn } from 'child_process';
 import { writeFileSync, readFileSync, existsSync, mkdirSync } from 'fs';
 import { join } from 'path';
 import { homedir, platform } from 'os';
-import { getOpenAiConfig, updateOpenAiConfig, } from '../../utils/apiConfig.js';
 import { SYSTEM_PROMPT } from '../../api/systemPrompt.js';
 const CONFIG_DIR = join(homedir(), '.snow');
 const SYSTEM_PROMPT_FILE = join(CONFIG_DIR, 'system-prompt.txt');
@@ -24,9 +23,17 @@ export default function SystemPromptConfigScreen({ onBack }) {
     useEffect(() => {
         const openEditor = async () => {
             ensureConfigDirectory();
-            // 读取当前配置的自定义系统提示词，如果为空则使用默认系统提示词
-            const config = getOpenAiConfig();
-            const currentPrompt = config.systemPrompt || SYSTEM_PROMPT;
+            // 读取系统提示词文件，如果不存在则使用默认系统提示词
+            let currentPrompt = SYSTEM_PROMPT;
+            if (existsSync(SYSTEM_PROMPT_FILE)) {
+                try {
+                    currentPrompt = readFileSync(SYSTEM_PROMPT_FILE, 'utf8');
+                }
+                catch {
+                    // 读取失败，使用默认
+                    currentPrompt = SYSTEM_PROMPT;
+                }
+            }
             // 写入临时文件供编辑
             writeFileSync(SYSTEM_PROMPT_FILE, currentPrompt, 'utf8');
             const editor = getSystemEditor();
@@ -39,22 +46,28 @@ export default function SystemPromptConfigScreen({ onBack }) {
                 if (existsSync(SYSTEM_PROMPT_FILE)) {
                     try {
                         const editedContent = readFileSync(SYSTEM_PROMPT_FILE, 'utf8');
-                        // 如果编辑后的内容为空或与默认提示词相同，则保存为空（使用默认）
-                        // 否则保存自定义提示词
                         const trimmedContent = editedContent.trim();
                         if (trimmedContent === '' || trimmedContent === SYSTEM_PROMPT.trim()) {
-                            // 保存为空，表示使用默认提示词
-                            updateOpenAiConfig({ systemPrompt: undefined });
-                            console.log('System prompt reset to default. Please use `snow` to restart!');
+                            // 内容为空或与默认相同，删除文件，使用默认提示词
+                            try {
+                                const fs = require('fs');
+                                fs.unlinkSync(SYSTEM_PROMPT_FILE);
+                                console.log('System prompt reset to default. Please use `snow` to restart!');
+                            }
+                            catch {
+                                // 删除失败，保存空内容
+                                writeFileSync(SYSTEM_PROMPT_FILE, '', 'utf8');
+                                console.log('System prompt reset to default. Please use `snow` to restart!');
+                            }
                         }
                         else {
-                            // 保存自定义提示词
-                            updateOpenAiConfig({ systemPrompt: editedContent });
+                            // 保存自定义提示词到文件
+                            writeFileSync(SYSTEM_PROMPT_FILE, editedContent, 'utf8');
                             console.log('Custom system prompt saved successfully! Please use `snow` to restart!');
                         }
                     }
                     catch (error) {
-                        console.error('Failed to read edited content:', error instanceof Error ? error.message : 'Unknown error');
+                        console.error('Failed to save system prompt:', error instanceof Error ? error.message : 'Unknown error');
                     }
                 }
                 process.exit(0);

package/dist/utils/apiConfig.d.ts

@@ -14,7 +14,6 @@ export interface ApiConfig {
     maxTokens?: number;
     compactModel?: CompactModelConfig;
     anthropicBeta?: boolean;
-    systemPrompt?: string;
 }
 export interface MCPServer {
     url?: string;
@@ -37,3 +36,9 @@ export declare function validateApiConfig(config: Partial<ApiConfig>): string[];
 export declare function updateMCPConfig(mcpConfig: MCPConfig): void;
 export declare function getMCPConfig(): MCPConfig;
 export declare function validateMCPConfig(config: Partial<MCPConfig>): string[];
+/**
+ * 读取自定义系统提示词
+ * 如果 system-prompt.txt 文件存在且不为空，返回其内容
+ * 否则返回 undefined (使用默认系统提示词)
+ */
+export declare function getCustomSystemPrompt(): string | undefined;

package/dist/utils/apiConfig.js

@@ -17,6 +17,7 @@ const DEFAULT_MCP_CONFIG = {
     mcpServers: {},
 };
 const CONFIG_DIR = join(homedir(), '.snow');
+const SYSTEM_PROMPT_FILE = join(CONFIG_DIR, 'system-prompt.txt');
 function normalizeRequestMethod(method) {
     if (method === 'chat' || method === 'responses' || method === 'gemini' || method === 'anthropic') {
         return method;
@@ -192,3 +193,26 @@ export function validateMCPConfig(config) {
     }
     return errors;
 }
+/**
+ * 读取自定义系统提示词
+ * 如果 system-prompt.txt 文件存在且不为空，返回其内容
+ * 否则返回 undefined (使用默认系统提示词)
+ */
+export function getCustomSystemPrompt() {
+    ensureConfigDirectory();
+    if (!existsSync(SYSTEM_PROMPT_FILE)) {
+        return undefined;
+    }
+    try {
+        const content = readFileSync(SYSTEM_PROMPT_FILE, 'utf8');
+        // 只有当文件完全为空时才返回 undefined
+        if (content.length === 0) {
+            return undefined;
+        }
+        // 返回原始内容，不做任何处理
+        return content;
+    }
+    catch {
+        return undefined;
+    }
+}

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "snow-ai",
-	"version": "0.2.11",
+	"version": "0.2.12",
 	"description": "Intelligent Command Line Assistant powered by AI",
 	"license": "MIT",
 	"bin": {
@@ -40,7 +40,7 @@
 	],
 	"dependencies": {
 		"@anthropic-ai/sdk": "^0.65.0",
-		"@google/generative-ai": "^0.24.1",
+		"@google/genai": "^1.23.0",
 		"@inkjs/ui": "^2.0.0",
 		"@modelcontextprotocol/sdk": "^1.17.3",
 		"chalk-template": "^1.1.2",

package/readme.md

@@ -1,6 +1,7 @@
 # snow-ai
 
-> This readme is automatically generated by [create-ink-app](https://github.com/vadimdemedes/create-ink-app)
+English | [中文](readme_zh.md)
+
 
 ## Install
 
@@ -21,15 +22,17 @@ $ snow --update
 ## Config example  `./User/.snow/config.json`
 ```json
 {
-  "openai": {
-    "baseUrl": "https://api.openai.com/v1",
+  "snowcfg": {
+    "baseUrl": "https://api.openai.com/v1",//Gemini：https://generativelanguage.googleapis.com Anthropic：https://api.anthropic.com
     "apiKey": "your-api-key",
     "requestMethod": "responses",
     "advancedModel": "gpt-5-codex",
     "basicModel": "gpt-5-codex",
-    "maxContextTokens": 200000,
+    "maxContextTokens": 32000, //The maximum context length of the model
+    "maxTokens": 4096, // The maximum generation length of the model
+    "anthropicBeta": false,
     "compactModel": {
-      "baseUrl": "https://api.openai.com/v1",
+      "baseUrl": "https://api.opeai.com/v1",
       "apiKey": "your-api-key",
       "modelName": "gpt-4.1-mini"
     }
@@ -56,7 +59,24 @@ $ npm uninstall --global snow-ai
 * **Agent**
 
 ![alt text](image-1.png)
+* In the middle of the conversation: click ESC to stop AI generation
+
+* When mounting: double-click ESC, view the dialogue recorder, select rollback, including file checkpoints
 
 * **Commands**
 
-![alt text](image-2.png)
+![alt text](image-2.png)
+  - /clear —— Create a new session
+
+  - /resume - The recovery history has
+
+  - /mcp - Check the status of MCP service
+
+  - /yolo - Unattended mode, all tools automatically agree to execute
+
+  - /init - Initialize the project and generate the SNOW.md description document
+
+  - /ide - Connect to VSCode, you need to install the plug-in
+
+  - /compact - compress the context into a sentence
+