snow-ai 0.2.15 → 0.2.17

package/dist/api/anthropic.d.ts

@@ -33,4 +33,4 @@ export declare function resetAnthropicClient(): void;
 /**
  * Create streaming chat completion using Anthropic API
  */
-export declare function createStreamingAnthropicCompletion(options: AnthropicOptions, abortSignal?: AbortSignal): AsyncGenerator<AnthropicStreamChunk, void, unknown>;
+export declare function createStreamingAnthropicCompletion(options: AnthropicOptions, abortSignal?: AbortSignal, onRetry?: (error: Error, attempt: number, nextDelay: number) => void): AsyncGenerator<AnthropicStreamChunk, void, unknown>;

package/dist/api/anthropic.js

@@ -1,7 +1,8 @@
 import Anthropic from '@anthropic-ai/sdk';
 import { createHash, randomUUID } from 'crypto';
-import { getOpenAiConfig, getCustomSystemPrompt } from '../utils/apiConfig.js';
+import { getOpenAiConfig, getCustomSystemPrompt, getCustomHeaders } from '../utils/apiConfig.js';
 import { SYSTEM_PROMPT } from './systemPrompt.js';
+import { withRetryGenerator } from '../utils/retryUtils.js';
 let anthropicClient = null;
 function getAnthropicClient() {
     if (!anthropicClient) {
@@ -12,17 +13,26 @@ function getAnthropicClient() {
         const clientConfig = {
             apiKey: config.apiKey,
         };
-        // Support custom baseUrl for proxy servers
         if (config.baseUrl && config.baseUrl !== 'https://api.openai.com/v1') {
             clientConfig.baseURL = config.baseUrl;
         }
-        // If Anthropic Beta is enabled, add default query parameter
-        if (config.anthropicBeta) {
-            clientConfig.defaultQuery = { beta: 'true' };
-        }
-        // Add Authorization header for enhanced compatibility
+        const customHeaders = getCustomHeaders();
         clientConfig.defaultHeaders = {
             'Authorization': `Bearer ${config.apiKey}`,
+            //'anthropic-version': '2024-09-24',
+            ...customHeaders
+        };
+        // if (config.anthropicBeta) {
+        // 	clientConfig.defaultHeaders['anthropic-beta'] = 'prompt-caching-2024-07-31';
+        // }
+        // Intercept fetch to add beta parameter to URL
+        const originalFetch = clientConfig.fetch || globalThis.fetch;
+        clientConfig.fetch = async (url, init) => {
+            let finalUrl = url;
+            if (config.anthropicBeta && typeof url === 'string' && !url.includes('?beta=')) {
+                finalUrl = url + (url.includes('?') ? '&beta=true' : '?beta=true');
+            }
+            return originalFetch(finalUrl, init);
         };
         anthropicClient = new Anthropic(clientConfig);
     }
@@ -63,7 +73,6 @@ 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' };
@@ -73,23 +82,17 @@ function convertToolsToAnthropic(tools) {
 /**
  * Convert our ChatMessage format to Anthropic's message format
  * Adds cache_control to system prompt and last user message for prompt caching
- * Logic:
- * 1. If custom system prompt exists: use custom as system, prepend default as first user message
- * 2. If no custom system prompt: use default as system
  */
 function convertToAnthropicMessages(messages) {
     const customSystemPrompt = getCustomSystemPrompt();
     let systemContent;
     const anthropicMessages = [];
     for (const msg of messages) {
-        // Extract system message
         if (msg.role === 'system') {
             systemContent = msg.content;
             continue;
         }
-        // Handle tool result messages
         if (msg.role === 'tool' && msg.tool_call_id) {
-            // Anthropic expects tool results as user messages with tool_result content
             anthropicMessages.push({
                 role: 'user',
                 content: [{
@@ -100,19 +103,15 @@ function convertToAnthropicMessages(messages) {
             });
             continue;
         }
-        // Handle user messages with images
         if (msg.role === 'user' && msg.images && msg.images.length > 0) {
             const content = [];
-            // Add text content
             if (msg.content) {
                 content.push({
                     type: 'text',
                     text: msg.content
                 });
             }
-            // Add images
             for (const image of msg.images) {
-                // Extract base64 data and mime type
                 const base64Match = image.data.match(/^data:([^;]+);base64,(.+)$/);
                 if (base64Match) {
                     content.push({
@@ -131,17 +130,14 @@ function convertToAnthropicMessages(messages) {
             });
             continue;
         }
-        // Handle assistant messages with tool calls
         if (msg.role === 'assistant' && msg.tool_calls && msg.tool_calls.length > 0) {
             const content = [];
-            // Add text content if present
             if (msg.content) {
                 content.push({
                     type: 'text',
                     text: msg.content
                 });
             }
-            // Add tool uses
             for (const toolCall of msg.tool_calls) {
                 content.push({
                     type: 'tool_use',
@@ -156,7 +152,6 @@ function convertToAnthropicMessages(messages) {
             });
             continue;
         }
-        // Handle regular text messages
         if (msg.role === 'user' || msg.role === 'assistant') {
             anthropicMessages.push({
                 role: msg.role,
@@ -164,25 +159,33 @@ function convertToAnthropicMessages(messages) {
             });
         }
     }
-    // 如果配置了自定义系统提示词
     if (customSystemPrompt) {
-        // 自定义系统提示词作为 system，默认系统提示词作为第一条用户消息
         systemContent = customSystemPrompt;
         anthropicMessages.unshift({
             role: 'user',
-            content: SYSTEM_PROMPT
+            content: [{
+                    type: 'text',
+                    text: SYSTEM_PROMPT,
+                    cache_control: { type: 'ephemeral' }
+                }]
         });
     }
     else if (!systemContent) {
-        // 没有自定义系统提示词，默认系统提示词作为 system
         systemContent = SYSTEM_PROMPT;
     }
-    // Add cache_control to last user message for prompt caching
-    if (anthropicMessages.length > 0) {
-        const lastMessageIndex = anthropicMessages.length - 1;
-        const lastMessage = anthropicMessages[lastMessageIndex];
+    let lastUserMessageIndex = -1;
+    for (let i = anthropicMessages.length - 1; i >= 0; i--) {
+        if (anthropicMessages[i]?.role === 'user') {
+            if (customSystemPrompt && i === 0) {
+                continue;
+            }
+            lastUserMessageIndex = i;
+            break;
+        }
+    }
+    if (lastUserMessageIndex >= 0) {
+        const lastMessage = anthropicMessages[lastUserMessageIndex];
         if (lastMessage && lastMessage.role === 'user') {
-            // Convert content to array format if it's a string
             if (typeof lastMessage.content === 'string') {
                 lastMessage.content = [{
                         type: 'text',
@@ -191,7 +194,6 @@ function convertToAnthropicMessages(messages) {
                     }];
             }
             else if (Array.isArray(lastMessage.content)) {
-                // Add cache_control to last content block
                 const lastContentIndex = lastMessage.content.length - 1;
                 if (lastContentIndex >= 0) {
                     const lastContent = lastMessage.content[lastContentIndex];
@@ -200,7 +202,6 @@ function convertToAnthropicMessages(messages) {
             }
         }
     }
-    // Format system prompt with cache_control (only if we have a system prompt)
     const system = systemContent ? [{
             type: 'text',
             text: systemContent,
@@ -211,14 +212,13 @@ function convertToAnthropicMessages(messages) {
 /**
  * Create streaming chat completion using Anthropic API
  */
-export async function* createStreamingAnthropicCompletion(options, abortSignal) {
+export async function* createStreamingAnthropicCompletion(options, abortSignal, onRetry) {
     const client = getAnthropicClient();
-    try {
+    yield* withRetryGenerator(async function* () {
         const { system, messages } = convertToAnthropicMessages(options.messages);
-        // Generate user_id with session tracking if sessionId is provided
         const sessionId = options.sessionId || randomUUID();
         const userId = generateUserId(sessionId);
-        // Prepare request body for logging
+        const customHeaders = getCustomHeaders();
         const requestBody = {
             model: options.model,
             max_tokens: options.max_tokens || 4096,
@@ -231,33 +231,32 @@ export async function* createStreamingAnthropicCompletion(options, abortSignal)
             },
             stream: true
         };
-        // Create streaming request
-        const stream = await client.messages.create(requestBody);
+        const stream = await client.messages.create(requestBody, {
+            headers: customHeaders
+        });
         let contentBuffer = '';
         let toolCallsBuffer = new Map();
         let hasToolCalls = false;
         let usageData;
-        let currentToolUseId = null; // Track current tool use block ID
+        let blockIndexToId = new Map();
         for await (const event of stream) {
             if (abortSignal?.aborted) {
                 return;
             }
-            // Handle different event types
             if (event.type === 'content_block_start') {
                 const block = event.content_block;
-                // Handle tool use blocks
                 if (block.type === 'tool_use') {
                     hasToolCalls = true;
-                    currentToolUseId = block.id; // Store current tool use ID
+                    const blockIndex = event.index;
+                    blockIndexToId.set(blockIndex, block.id);
                     toolCallsBuffer.set(block.id, {
                         id: block.id,
                         type: 'function',
                         function: {
                             name: block.name,
-                            arguments: '{}' // Initialize with empty object instead of empty string
+                            arguments: '{}'
                         }
                     });
-                    // Yield delta for token counting
                     yield {
                         type: 'tool_call_delta',
                         delta: block.name
@@ -266,7 +265,6 @@ export async function* createStreamingAnthropicCompletion(options, abortSignal)
             }
             else if (event.type === 'content_block_delta') {
                 const delta = event.delta;
-                // Handle text content
                 if (delta.type === 'text_delta') {
                     const text = delta.text;
                     contentBuffer += text;
@@ -275,21 +273,19 @@ export async function* createStreamingAnthropicCompletion(options, abortSignal)
                         content: text
                     };
                 }
-                // Handle tool input deltas
                 if (delta.type === 'input_json_delta') {
                     const jsonDelta = delta.partial_json;
-                    // Use currentToolUseId instead of event.index
-                    if (currentToolUseId) {
-                        const toolCall = toolCallsBuffer.get(currentToolUseId);
+                    const blockIndex = event.index;
+                    const toolId = blockIndexToId.get(blockIndex);
+                    if (toolId) {
+                        const toolCall = toolCallsBuffer.get(toolId);
                         if (toolCall) {
-                            // If this is the first delta and arguments is still '{}', replace it
                             if (toolCall.function.arguments === '{}') {
                                 toolCall.function.arguments = jsonDelta;
                             }
                             else {
                                 toolCall.function.arguments += jsonDelta;
                             }
-                            // Yield delta for token counting
                             yield {
                                 type: 'tool_call_delta',
                                 delta: jsonDelta
@@ -298,12 +294,7 @@ export async function* createStreamingAnthropicCompletion(options, abortSignal)
                     }
                 }
             }
-            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 (including cache metrics)
                 if (event.message.usage) {
                     usageData = {
                         prompt_tokens: event.message.usage.input_tokens || 0,
@@ -315,7 +306,6 @@ export async function* createStreamingAnthropicCompletion(options, abortSignal)
                 }
             }
             else if (event.type === 'message_delta') {
-                // Update usage data with final token counts (including cache metrics)
                 if (event.usage) {
                     if (!usageData) {
                         usageData = {
@@ -326,7 +316,6 @@ 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;
                     }
@@ -336,17 +325,12 @@ export async function* createStreamingAnthropicCompletion(options, abortSignal)
                 }
             }
         }
-        // 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
-                    // Empty string should be treated as empty object
                     const args = toolCall.function.arguments.trim() || '{}';
                     JSON.parse(args);
-                    // Update with normalized version
                     toolCall.function.arguments = args;
                 }
                 catch (e) {
@@ -359,25 +343,17 @@ export async function* createStreamingAnthropicCompletion(options, abortSignal)
                 tool_calls: toolCalls
             };
         }
-        // Yield usage information if available
         if (usageData) {
             yield {
                 type: 'usage',
                 usage: usageData
             };
         }
-        // Signal completion
         yield {
             type: 'done'
         };
-    }
-    catch (error) {
-        if (abortSignal?.aborted) {
-            return;
-        }
-        if (error instanceof Error) {
-            throw new Error(`Anthropic streaming completion failed: ${error.message}`);
-        }
-        throw new Error('Anthropic streaming completion failed: Unknown error');
-    }
+    }, {
+        abortSignal,
+        onRetry
+    });
 }

package/dist/api/chat.d.ts

@@ -60,11 +60,11 @@ export declare function resetOpenAIClient(): void;
 /**
  * Create chat completion with automatic function calling support
  */
-export declare function createChatCompletionWithTools(options: ChatCompletionOptions, maxToolRounds?: number): Promise<{
+export declare function createChatCompletionWithTools(options: ChatCompletionOptions, maxToolRounds?: number, abortSignal?: AbortSignal, onRetry?: (error: Error, attempt: number, nextDelay: number) => void): Promise<{
     content: string;
     toolCalls: ToolCall[];
 }>;
-export declare function createChatCompletion(options: ChatCompletionOptions): Promise<string>;
+export declare function createChatCompletion(options: ChatCompletionOptions, abortSignal?: AbortSignal, onRetry?: (error: Error, attempt: number, nextDelay: number) => void): Promise<string>;
 export interface UsageInfo {
     prompt_tokens: number;
     completion_tokens: number;
@@ -74,7 +74,7 @@ export interface UsageInfo {
     cached_tokens?: number;
 }
 export interface StreamChunk {
-    type: 'content' | 'tool_calls' | 'tool_call_delta' | 'reasoning_delta' | 'done' | 'usage';
+    type: 'content' | 'tool_calls' | 'tool_call_delta' | 'reasoning_delta' | 'reasoning_started' | 'done' | 'usage';
     content?: string;
     tool_calls?: Array<{
         id: string;
@@ -91,5 +91,5 @@ export interface StreamChunk {
  * Simple streaming chat completion - only handles OpenAI interaction
  * Tool execution should be handled by the caller
  */
-export declare function createStreamingChatCompletion(options: ChatCompletionOptions, abortSignal?: AbortSignal): AsyncGenerator<StreamChunk, void, unknown>;
+export declare function createStreamingChatCompletion(options: ChatCompletionOptions, abortSignal?: AbortSignal, onRetry?: (error: Error, attempt: number, nextDelay: number) => void): AsyncGenerator<StreamChunk, void, unknown>;
 export declare function validateChatOptions(options: ChatCompletionOptions): string[];

package/dist/api/chat.js

@@ -1,7 +1,8 @@
 import OpenAI from 'openai';
-import { getOpenAiConfig, getCustomSystemPrompt } from '../utils/apiConfig.js';
+import { getOpenAiConfig, getCustomSystemPrompt, getCustomHeaders } from '../utils/apiConfig.js';
 import { executeMCPTool } from '../utils/mcpToolsManager.js';
 import { SYSTEM_PROMPT } from './systemPrompt.js';
+import { withRetry, withRetryGenerator } from '../utils/retryUtils.js';
 /**
  * Convert our ChatMessage format to OpenAI's ChatCompletionMessageParam format
  * Automatically prepends system prompt if not present
@@ -96,9 +97,14 @@ function getOpenAIClient() {
         if (!config.apiKey || !config.baseUrl) {
             throw new Error('OpenAI API configuration is incomplete. Please configure API settings first.');
         }
+        // Get custom headers
+        const customHeaders = getCustomHeaders();
         openaiClient = new OpenAI({
             apiKey: config.apiKey,
             baseURL: config.baseUrl,
+            defaultHeaders: {
+                ...customHeaders
+            }
         });
     }
     return openaiClient;
@@ -109,14 +115,14 @@ export function resetOpenAIClient() {
 /**
  * Create chat completion with automatic function calling support
  */
-export async function createChatCompletionWithTools(options, maxToolRounds = 5) {
+export async function createChatCompletionWithTools(options, maxToolRounds = 5, abortSignal, onRetry) {
     const client = getOpenAIClient();
     let messages = [...options.messages];
     let allToolCalls = [];
     let rounds = 0;
     try {
         while (rounds < maxToolRounds) {
-            const response = await client.chat.completions.create({
+            const response = await withRetry(() => client.chat.completions.create({
                 model: options.model,
                 messages: convertToOpenAIMessages(messages),
                 stream: false,
@@ -124,6 +130,9 @@ export async function createChatCompletionWithTools(options, maxToolRounds = 5)
                 max_tokens: options.max_tokens,
                 tools: options.tools,
                 tool_choice: options.tool_choice,
+            }), {
+                abortSignal,
+                onRetry
             });
             const message = response.choices[0]?.message;
             if (!message) {
@@ -179,12 +188,12 @@ export async function createChatCompletionWithTools(options, maxToolRounds = 5)
         throw new Error('Chat completion with tools failed: Unknown error');
     }
 }
-export async function createChatCompletion(options) {
+export async function createChatCompletion(options, abortSignal, onRetry) {
     const client = getOpenAIClient();
     let messages = [...options.messages];
     try {
         while (true) {
-            const response = await client.chat.completions.create({
+            const response = await withRetry(() => client.chat.completions.create({
                 model: options.model,
                 messages: convertToOpenAIMessages(messages),
                 stream: false,
@@ -192,6 +201,9 @@ export async function createChatCompletion(options) {
                 max_tokens: options.max_tokens,
                 tools: options.tools,
                 tool_choice: options.tool_choice,
+            }), {
+                abortSignal,
+                onRetry
             });
             const message = response.choices[0]?.message;
             if (!message) {
@@ -246,9 +258,10 @@ export async function createChatCompletion(options) {
  * Simple streaming chat completion - only handles OpenAI interaction
  * Tool execution should be handled by the caller
  */
-export async function* createStreamingChatCompletion(options, abortSignal) {
+export async function* createStreamingChatCompletion(options, abortSignal, onRetry) {
     const client = getOpenAIClient();
-    try {
+    // 使用重试包装生成器
+    yield* withRetryGenerator(async function* () {
         const stream = await client.chat.completions.create({
             model: options.model,
             messages: convertToOpenAIMessages(options.messages),
@@ -265,6 +278,7 @@ export async function* createStreamingChatCompletion(options, abortSignal) {
         let toolCallsBuffer = {};
         let hasToolCalls = false;
         let usageData;
+        let reasoningStarted = false; // Track if reasoning has started
         for await (const chunk of stream) {
             if (abortSignal?.aborted) {
                 return;
@@ -298,6 +312,13 @@ export async function* createStreamingChatCompletion(options, abortSignal) {
             // Note: reasoning_content is NOT included in the response, only counted for tokens
             const reasoningContent = choice.delta?.reasoning_content;
             if (reasoningContent) {
+                // Emit reasoning_started event on first reasoning content
+                if (!reasoningStarted) {
+                    reasoningStarted = true;
+                    yield {
+                        type: 'reasoning_started'
+                    };
+                }
                 yield {
                     type: 'reasoning_delta',
                     delta: reasoningContent
@@ -363,16 +384,10 @@ export async function* createStreamingChatCompletion(options, abortSignal) {
         yield {
             type: 'done'
         };
-    }
-    catch (error) {
-        if (error instanceof Error && error.name === 'AbortError') {
-            return;
-        }
-        if (error instanceof Error) {
-            throw new Error(`Streaming chat completion failed: ${error.message}`);
-        }
-        throw new Error('Streaming chat completion failed: Unknown error');
-    }
+    }, {
+        abortSignal,
+        onRetry
+    });
 }
 export function validateChatOptions(options) {
     const errors = [];

package/dist/api/gemini.d.ts

@@ -32,4 +32,4 @@ export declare function resetGeminiClient(): void;
 /**
  * Create streaming chat completion using Gemini API
  */
-export declare function createStreamingGeminiCompletion(options: GeminiOptions, abortSignal?: AbortSignal): AsyncGenerator<GeminiStreamChunk, void, unknown>;
+export declare function createStreamingGeminiCompletion(options: GeminiOptions, abortSignal?: AbortSignal, onRetry?: (error: Error, attempt: number, nextDelay: number) => void): AsyncGenerator<GeminiStreamChunk, void, unknown>;

package/dist/api/gemini.js

@@ -1,6 +1,7 @@
 import { GoogleGenAI } from '@google/genai';
-import { getOpenAiConfig, getCustomSystemPrompt } from '../utils/apiConfig.js';
+import { getOpenAiConfig, getCustomSystemPrompt, getCustomHeaders } from '../utils/apiConfig.js';
 import { SYSTEM_PROMPT } from './systemPrompt.js';
+import { withRetryGenerator } from '../utils/retryUtils.js';
 let geminiClient = null;
 function getGeminiClient() {
     if (!geminiClient) {
@@ -12,12 +13,23 @@ function getGeminiClient() {
         const clientConfig = {
             apiKey: config.apiKey
         };
+        // Get custom headers
+        const customHeaders = getCustomHeaders();
         // 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
+                    ...customHeaders
+                }
+            };
+        }
+        else if (Object.keys(customHeaders).length > 0) {
+            // If using default base URL but have custom headers
+            clientConfig.httpOptions = {
+                headers: {
+                    ...customHeaders
                 }
             };
         }
@@ -200,9 +212,10 @@ function convertToGeminiMessages(messages) {
 /**
  * Create streaming chat completion using Gemini API
  */
-export async function* createStreamingGeminiCompletion(options, abortSignal) {
+export async function* createStreamingGeminiCompletion(options, abortSignal, onRetry) {
     const client = getGeminiClient();
-    try {
+    // 使用重试包装生成器
+    yield* withRetryGenerator(async function* () {
         const { systemInstruction, contents } = convertToGeminiMessages(options.messages);
         // Build request config
         const requestConfig = {
@@ -297,14 +310,8 @@ export async function* createStreamingGeminiCompletion(options, abortSignal) {
         yield {
             type: 'done'
         };
-    }
-    catch (error) {
-        if (abortSignal?.aborted) {
-            return;
-        }
-        if (error instanceof Error) {
-            throw new Error(`Gemini streaming completion failed: ${error.message}`);
-        }
-        throw new Error('Gemini streaming completion failed: Unknown error');
-    }
+    }, {
+        abortSignal,
+        onRetry
+    });
 }

package/dist/api/models.d.ts

@@ -8,5 +8,8 @@ export interface ModelsResponse {
     object: string;
     data: Model[];
 }
+/**
+ * Fetch available models based on configured request method
+ */
 export declare function fetchAvailableModels(): Promise<Model[]>;
 export declare function filterModels(models: Model[], searchTerm: string): Model[];