snow-ai 0.3.6 → 0.3.7

package/dist/api/chat.d.ts

@@ -1,5 +1,5 @@
 import type { ChatMessage, ChatCompletionTool, ToolCall, UsageInfo, ImageContent } from './types.js';
-export type { ChatMessage, ChatCompletionTool, ToolCall, UsageInfo, ImageContent };
+export type { ChatMessage, ChatCompletionTool, ToolCall, UsageInfo, ImageContent, };
 export interface ChatCompletionOptions {
     model: string;
     messages: ChatMessage[];

package/dist/api/chat.js

@@ -1,6 +1,8 @@
-import { getOpenAiConfig, getCustomSystemPrompt, getCustomHeaders } from '../utils/apiConfig.js';
-import { SYSTEM_PROMPT } from './systemPrompt.js';
-import { withRetryGenerator } from '../utils/retryUtils.js';
+import { getOpenAiConfig, getCustomSystemPrompt, getCustomHeaders, } from '../utils/apiConfig.js';
+import { getSystemPrompt } from './systemPrompt.js';
+import { withRetryGenerator, parseJsonWithFix } from '../utils/retryUtils.js';
+import { addProxyToFetchOptions } from '../utils/proxyUtils.js';
+import { saveUsageToFile } from '../utils/usageLogger.js';
 /**
  * Convert our ChatMessage format to OpenAI's ChatCompletionMessageParam format
  * Automatically prepends system prompt if not present
@@ -18,7 +20,7 @@ function convertToOpenAIMessages(messages, includeSystemPrompt = true) {
             if (msg.content) {
                 contentParts.push({
                     type: 'text',
-                    text: msg.content
+                    text: msg.content,
                 });
             }
             // 添加图片内容
@@ -26,30 +28,30 @@ function convertToOpenAIMessages(messages, includeSystemPrompt = true) {
                 contentParts.push({
                     type: 'image_url',
                     image_url: {
-                        url: image.data // Base64 data URL
-                    }
+                        url: image.data, // Base64 data URL
+                    },
                 });
             }
             return {
                 role: 'user',
-                content: contentParts
+                content: contentParts,
             };
         }
         const baseMessage = {
             role: msg.role,
-            content: msg.content
+            content: msg.content,
         };
         if (msg.role === 'assistant' && msg.tool_calls) {
             return {
                 ...baseMessage,
-                tool_calls: msg.tool_calls
+                tool_calls: msg.tool_calls,
             };
         }
         if (msg.role === 'tool' && msg.tool_call_id) {
             return {
                 role: 'tool',
                 content: msg.content,
-                tool_call_id: msg.tool_call_id
+                tool_call_id: msg.tool_call_id,
             };
         }
         return baseMessage;
@@ -66,13 +68,13 @@ function convertToOpenAIMessages(messages, includeSystemPrompt = true) {
             result = [
                 {
                     role: 'system',
-                    content: customSystemPrompt
+                    content: customSystemPrompt,
                 },
                 {
                     role: 'user',
-                    content: SYSTEM_PROMPT
+                    content: getSystemPrompt(),
                 },
-                ...result
+                ...result,
             ];
         }
         else {
@@ -80,9 +82,9 @@ function convertToOpenAIMessages(messages, includeSystemPrompt = true) {
             result = [
                 {
                     role: 'system',
-                    content: SYSTEM_PROMPT
+                    content: getSystemPrompt(),
                 },
-                ...result
+                ...result,
             ];
         }
     }
@@ -99,7 +101,7 @@ function getOpenAIConfig() {
         openaiConfig = {
             apiKey: config.apiKey,
             baseUrl: config.baseUrl,
-            customHeaders
+            customHeaders,
         };
     }
     return openaiConfig;
@@ -124,16 +126,26 @@ async function* parseSSEStream(reader) {
             const trimmed = line.trim();
             if (!trimmed || trimmed.startsWith(':'))
                 continue;
-            if (trimmed === 'data: [DONE]') {
+            if (trimmed === 'data: [DONE]' || trimmed === 'data:[DONE]') {
                 return;
             }
-            if (trimmed.startsWith('data: ')) {
-                const data = trimmed.slice(6);
-                try {
-                    yield JSON.parse(data);
-                }
-                catch (e) {
-                    console.error('Failed to parse SSE data:', data);
+            // Handle both "event: " and "event:" formats
+            if (trimmed.startsWith('event:')) {
+                // Event type, will be followed by data
+                continue;
+            }
+            // Handle both "data: " and "data:" formats
+            if (trimmed.startsWith('data:')) {
+                const data = trimmed.startsWith('data: ')
+                    ? trimmed.slice(6)
+                    : trimmed.slice(5);
+                const parseResult = parseJsonWithFix(data, {
+                    toolName: 'SSE stream',
+                    logWarning: false,
+                    logError: true,
+                });
+                if (parseResult.success) {
+                    yield parseResult.data;
                 }
             }
         }
@@ -157,16 +169,18 @@ export async function* createStreamingChatCompletion(options, abortSignal, onRet
             tools: options.tools,
             tool_choice: options.tool_choice,
         };
-        const response = await fetch(`${config.baseUrl}/chat/completions`, {
+        const url = `${config.baseUrl}/chat/completions`;
+        const fetchOptions = addProxyToFetchOptions(url, {
             method: 'POST',
             headers: {
                 'Content-Type': 'application/json',
                 'Authorization': `Bearer ${config.apiKey}`,
-                ...config.customHeaders
+                ...config.customHeaders,
             },
             body: JSON.stringify(requestBody),
-            signal: abortSignal
+            signal: abortSignal,
         });
+        const response = await fetch(url, fetchOptions);
         if (!response.ok) {
             const errorText = await response.text();
             throw new Error(`OpenAI API error: ${response.status} ${response.statusText} - ${errorText}`);
@@ -191,7 +205,7 @@ export async function* createStreamingChatCompletion(options, abortSignal, onRet
                     completion_tokens: usageValue.completion_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
+                    cached_tokens: usageValue.prompt_tokens_details?.cached_tokens,
                 };
             }
             // Skip content processing if no choices (but usage is already captured above)
@@ -205,7 +219,7 @@ export async function* createStreamingChatCompletion(options, abortSignal, onRet
                 contentBuffer += content;
                 yield {
                     type: 'content',
-                    content
+                    content,
                 };
             }
             // Stream reasoning content (for o1 models, etc.)
@@ -216,12 +230,12 @@ export async function* createStreamingChatCompletion(options, abortSignal, onRet
                 if (!reasoningStarted) {
                     reasoningStarted = true;
                     yield {
-                        type: 'reasoning_started'
+                        type: 'reasoning_started',
                     };
                 }
                 yield {
                     type: 'reasoning_delta',
-                    delta: reasoningContent
+                    delta: reasoningContent,
                 };
             }
             // Accumulate tool calls and stream deltas
@@ -236,8 +250,8 @@ export async function* createStreamingChatCompletion(options, abortSignal, onRet
                             type: 'function',
                             function: {
                                 name: '',
-                                arguments: ''
-                            }
+                                arguments: '',
+                            },
                         };
                     }
                     if (deltaCall.id) {
@@ -250,14 +264,15 @@ export async function* createStreamingChatCompletion(options, abortSignal, onRet
                         deltaText += deltaCall.function.name;
                     }
                     if (deltaCall.function?.arguments) {
-                        toolCallsBuffer[index].function.arguments += deltaCall.function.arguments;
+                        toolCallsBuffer[index].function.arguments +=
+                            deltaCall.function.arguments;
                         deltaText += deltaCall.function.arguments;
                     }
                     // Stream the delta to frontend for real-time token counting
                     if (deltaText) {
                         yield {
                             type: 'tool_call_delta',
-                            delta: deltaText
+                            delta: deltaText,
                         };
                     }
                 }
@@ -270,23 +285,25 @@ export async function* createStreamingChatCompletion(options, abortSignal, onRet
         if (hasToolCalls) {
             yield {
                 type: 'tool_calls',
-                tool_calls: Object.values(toolCallsBuffer)
+                tool_calls: Object.values(toolCallsBuffer),
             };
         }
         // Yield usage information if available
         if (usageData) {
+            // Save usage to file system at API layer
+            saveUsageToFile(options.model, usageData);
             yield {
                 type: 'usage',
-                usage: usageData
+                usage: usageData,
             };
         }
         // Signal completion
         yield {
-            type: 'done'
+            type: 'done',
         };
     }, {
         abortSignal,
-        onRetry
+        onRetry,
     });
 }
 export function validateChatOptions(options) {
@@ -298,7 +315,8 @@ export function validateChatOptions(options) {
         errors.push('At least one message is required');
     }
     for (const message of options.messages || []) {
-        if (!message.role || !['system', 'user', 'assistant', 'tool'].includes(message.role)) {
+        if (!message.role ||
+            !['system', 'user', 'assistant', 'tool'].includes(message.role)) {
             errors.push('Invalid message role');
         }
         // Tool messages must have tool_call_id
@@ -306,7 +324,8 @@ export function validateChatOptions(options) {
             errors.push('Tool messages must have tool_call_id');
         }
         // Content can be empty for tool calls
-        if (message.role !== 'tool' && (!message.content || message.content.trim().length === 0)) {
+        if (message.role !== 'tool' &&
+            (!message.content || message.content.trim().length === 0)) {
             errors.push('Message content cannot be empty (except for tool messages)');
         }
     }

package/dist/api/gemini.js

@@ -1,6 +1,8 @@
-import { getOpenAiConfig, getCustomSystemPrompt, getCustomHeaders } from '../utils/apiConfig.js';
-import { SYSTEM_PROMPT } from './systemPrompt.js';
-import { withRetryGenerator } from '../utils/retryUtils.js';
+import { getOpenAiConfig, getCustomSystemPrompt, getCustomHeaders, } from '../utils/apiConfig.js';
+import { getSystemPrompt } from './systemPrompt.js';
+import { withRetryGenerator, parseJsonWithFix } from '../utils/retryUtils.js';
+import { addProxyToFetchOptions } from '../utils/proxyUtils.js';
+import { saveUsageToFile } from '../utils/usageLogger.js';
 let geminiConfig = null;
 function getGeminiConfig() {
     if (!geminiConfig) {
@@ -14,7 +16,7 @@ function getGeminiConfig() {
             baseUrl: config.baseUrl && config.baseUrl !== 'https://api.openai.com/v1'
                 ? config.baseUrl
                 : 'https://generativelanguage.googleapis.com/v1beta',
-            customHeaders
+            customHeaders,
         };
     }
     return geminiConfig;
@@ -41,8 +43,8 @@ function convertToolsToGemini(tools) {
                 parametersJsonSchema: {
                     type: 'object',
                     properties: params.properties || {},
-                    required: params.required || []
-                }
+                    required: params.required || [],
+                },
             };
         }
         throw new Error('Invalid tool format');
@@ -93,21 +95,28 @@ function convertToGeminiMessages(messages) {
                 let contentToParse = msg.content;
                 // Sometimes the content is double-encoded as JSON
                 // First, try to parse it once
-                try {
-                    const firstParse = JSON.parse(contentToParse);
+                const firstParseResult = parseJsonWithFix(contentToParse, {
+                    toolName: 'Gemini tool response (first parse)',
+                    logWarning: false,
+                    logError: false,
+                });
+                if (firstParseResult.success &&
+                    typeof firstParseResult.data === 'string') {
                     // 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
+                    contentToParse = firstParseResult.data;
                 }
                 // Now parse or wrap the final content
-                try {
-                    const parsed = JSON.parse(contentToParse);
+                const finalParseResult = parseJsonWithFix(contentToParse, {
+                    toolName: 'Gemini tool response (final parse)',
+                    logWarning: false,
+                    logError: false,
+                });
+                if (finalParseResult.success) {
+                    const parsed = finalParseResult.data;
                     // If parsed result is an object (not array, not null), use it directly
-                    if (typeof parsed === 'object' && parsed !== null && !Array.isArray(parsed)) {
+                    if (typeof parsed === 'object' &&
+                        parsed !== null &&
+                        !Array.isArray(parsed)) {
                         responseData = parsed;
                     }
                     else {
@@ -115,24 +124,28 @@ function convertToGeminiMessages(messages) {
                         responseData = { content: parsed };
                     }
                 }
-                catch {
+                else {
                     // Not valid JSON, wrap the raw string
                     responseData = { content: contentToParse };
                 }
             }
             contents.push({
                 role: 'user',
-                parts: [{
+                parts: [
+                    {
                         functionResponse: {
                             name: functionName,
-                            response: responseData
-                        }
-                    }]
+                            response: responseData,
+                        },
+                    },
+                ],
             });
             continue;
         }
         // Handle tool calls in assistant messages
-        if (msg.role === 'assistant' && msg.tool_calls && msg.tool_calls.length > 0) {
+        if (msg.role === 'assistant' &&
+            msg.tool_calls &&
+            msg.tool_calls.length > 0) {
             const parts = [];
             // Add text content if exists
             if (msg.content) {
@@ -140,16 +153,22 @@ function convertToGeminiMessages(messages) {
             }
             // Add function calls
             for (const toolCall of msg.tool_calls) {
+                const argsParseResult = parseJsonWithFix(toolCall.function.arguments, {
+                    toolName: `Gemini function call: ${toolCall.function.name}`,
+                    fallbackValue: {},
+                    logWarning: true,
+                    logError: true,
+                });
                 parts.push({
                     functionCall: {
                         name: toolCall.function.name,
-                        args: JSON.parse(toolCall.function.arguments)
-                    }
+                        args: argsParseResult.data,
+                    },
                 });
             }
             contents.push({
                 role: 'model',
-                parts
+                parts,
             });
             continue;
         }
@@ -167,8 +186,8 @@ function convertToGeminiMessages(messages) {
                     parts.push({
                         inlineData: {
                             mimeType: base64Match[1] || image.mimeType,
-                            data: base64Match[2] || ''
-                        }
+                            data: base64Match[2] || '',
+                        },
                     });
                 }
             }
@@ -183,11 +202,11 @@ function convertToGeminiMessages(messages) {
         // Prepend default system prompt as first user message
         contents.unshift({
             role: 'user',
-            parts: [{ text: SYSTEM_PROMPT }]
+            parts: [{ text: getSystemPrompt() }],
         });
     }
     else if (!systemInstruction) {
-        systemInstruction = SYSTEM_PROMPT;
+        systemInstruction = getSystemPrompt();
     }
     return { systemInstruction, contents };
 }
@@ -202,10 +221,12 @@ export async function* createStreamingGeminiCompletion(options, abortSignal, onR
         // Build request payload
         const requestBody = {
             contents,
-            systemInstruction: systemInstruction ? { parts: [{ text: systemInstruction }] } : undefined,
+            systemInstruction: systemInstruction
+                ? { parts: [{ text: systemInstruction }] }
+                : undefined,
             generationConfig: {
                 temperature: options.temperature ?? 0.7,
-            }
+            },
         };
         // Add tools if provided
         const geminiTools = convertToolsToGemini(options.tools);
@@ -213,18 +234,21 @@ export async function* createStreamingGeminiCompletion(options, abortSignal, onR
             requestBody.tools = geminiTools;
         }
         // Extract model name from options.model (e.g., "gemini-pro" or "models/gemini-pro")
-        const modelName = options.model.startsWith('models/') ? options.model : `models/${options.model}`;
+        const modelName = options.model.startsWith('models/')
+            ? options.model
+            : `models/${options.model}`;
         const url = `${config.baseUrl}/${modelName}:streamGenerateContent?key=${config.apiKey}&alt=sse`;
-        const response = await fetch(url, {
+        const fetchOptions = addProxyToFetchOptions(url, {
             method: 'POST',
             headers: {
                 'Content-Type': 'application/json',
-                'authorization': `Bearer ${config.apiKey}`,
-                ...config.customHeaders
+                'Authorization': `Bearer ${config.apiKey}`,
+                ...config.customHeaders,
             },
             body: JSON.stringify(requestBody),
-            signal: abortSignal
+            signal: abortSignal,
         });
+        const response = await fetch(url, fetchOptions);
         if (!response.ok) {
             const errorText = await response.text();
             throw new Error(`Gemini API error: ${response.status} ${response.statusText} - ${errorText}`);
@@ -255,10 +279,26 @@ export async function* createStreamingGeminiCompletion(options, abortSignal, onR
                 const trimmed = line.trim();
                 if (!trimmed || trimmed.startsWith(':'))
                     continue;
-                if (trimmed.startsWith('data: ')) {
-                    const data = trimmed.slice(6);
-                    try {
-                        const chunk = JSON.parse(data);
+                if (trimmed === 'data: [DONE]' || trimmed === 'data:[DONE]') {
+                    break;
+                }
+                // Handle both "event: " and "event:" formats
+                if (trimmed.startsWith('event:')) {
+                    // Event type, will be followed by data
+                    continue;
+                }
+                // Handle both "data: " and "data:" formats
+                if (trimmed.startsWith('data:')) {
+                    const data = trimmed.startsWith('data: ')
+                        ? trimmed.slice(6)
+                        : trimmed.slice(5);
+                    const parseResult = parseJsonWithFix(data, {
+                        toolName: 'Gemini SSE stream',
+                        logWarning: false,
+                        logError: true,
+                    });
+                    if (parseResult.success) {
+                        const chunk = parseResult.data;
                         // Process candidates
                         if (chunk.candidates && chunk.candidates.length > 0) {
                             const candidate = chunk.candidates[0];
@@ -269,7 +309,7 @@ export async function* createStreamingGeminiCompletion(options, abortSignal, onR
                                         contentBuffer += part.text;
                                         yield {
                                             type: 'content',
-                                            content: part.text
+                                            content: part.text,
                                         };
                                     }
                                     // Process function calls
@@ -281,15 +321,15 @@ export async function* createStreamingGeminiCompletion(options, abortSignal, onR
                                             type: 'function',
                                             function: {
                                                 name: fc.name,
-                                                arguments: JSON.stringify(fc.args || {})
-                                            }
+                                                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
+                                            delta: deltaText,
                                         };
                                     }
                                 }
@@ -300,13 +340,10 @@ export async function* createStreamingGeminiCompletion(options, abortSignal, onR
                             totalTokens = {
                                 prompt: chunk.usageMetadata.promptTokenCount || 0,
                                 completion: chunk.usageMetadata.candidatesTokenCount || 0,
-                                total: chunk.usageMetadata.totalTokenCount || 0
+                                total: chunk.usageMetadata.totalTokenCount || 0,
                             };
                         }
                     }
-                    catch (e) {
-                        console.error('Failed to parse Gemini SSE data:', data);
-                    }
                 }
             }
         }
@@ -314,26 +351,29 @@ export async function* createStreamingGeminiCompletion(options, abortSignal, onR
         if (hasToolCalls && toolCallsBuffer.length > 0) {
             yield {
                 type: 'tool_calls',
-                tool_calls: toolCallsBuffer
+                tool_calls: toolCallsBuffer,
             };
         }
         // Yield usage info
         if (totalTokens.total > 0) {
+            const usageData = {
+                prompt_tokens: totalTokens.prompt,
+                completion_tokens: totalTokens.completion,
+                total_tokens: totalTokens.total,
+            };
+            // Save usage to file system at API layer
+            saveUsageToFile(options.model, usageData);
             yield {
                 type: 'usage',
-                usage: {
-                    prompt_tokens: totalTokens.prompt,
-                    completion_tokens: totalTokens.completion,
-                    total_tokens: totalTokens.total
-                }
+                usage: usageData,
             };
         }
         // Signal completion
         yield {
-            type: 'done'
+            type: 'done',
         };
     }, {
         abortSignal,
-        onRetry
+        onRetry,
     });
 }

package/dist/api/responses.d.ts

@@ -16,11 +16,19 @@ export interface ResponseOptions {
     include?: string[];
 }
 export interface ResponseStreamChunk {
-    type: 'content' | 'tool_calls' | 'tool_call_delta' | 'reasoning_delta' | 'reasoning_started' | 'done' | 'usage';
+    type: 'content' | 'tool_calls' | 'tool_call_delta' | 'reasoning_delta' | 'reasoning_started' | 'reasoning_data' | 'done' | 'usage';
     content?: string;
     tool_calls?: ToolCall[];
     delta?: string;
     usage?: UsageInfo;
+    reasoning?: {
+        summary?: Array<{
+            type: 'summary_text';
+            text: string;
+        }>;
+        content?: any;
+        encrypted_content?: string;
+    };
 }
 export declare function resetOpenAIClient(): void;
 /**