snow-ai 0.2.10 → 0.2.12

package/dist/api/anthropic.d.ts

@@ -0,0 +1,36 @@
+import type { ChatMessage } from './chat.js';
+import type { ChatCompletionTool } from 'openai/resources/chat/completions';
+export interface AnthropicOptions {
+    model: string;
+    messages: ChatMessage[];
+    temperature?: number;
+    max_tokens?: number;
+    tools?: ChatCompletionTool[];
+    sessionId?: string;
+}
+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';
+    content?: string;
+    tool_calls?: Array<{
+        id: string;
+        type: 'function';
+        function: {
+            name: string;
+            arguments: string;
+        };
+    }>;
+    delta?: string;
+    usage?: UsageInfo;
+}
+export declare function resetAnthropicClient(): void;
+/**
+ * Create streaming chat completion using Anthropic API
+ */
+export declare function createStreamingAnthropicCompletion(options: AnthropicOptions, abortSignal?: AbortSignal): AsyncGenerator<AnthropicStreamChunk, void, unknown>;

package/dist/api/anthropic.js

@@ -0,0 +1,372 @@
+import Anthropic from '@anthropic-ai/sdk';
+import { createHash, randomUUID } from 'crypto';
+import { getOpenAiConfig, getCustomSystemPrompt } from '../utils/apiConfig.js';
+import { SYSTEM_PROMPT } from './systemPrompt.js';
+let anthropicClient = null;
+function getAnthropicClient() {
+    if (!anthropicClient) {
+        const config = getOpenAiConfig();
+        if (!config.apiKey) {
+            throw new Error('Anthropic API configuration is incomplete. Please configure API key first.');
+        }
+        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
+        clientConfig.defaultHeaders = {
+            'Authorization': `Bearer ${config.apiKey}`,
+        };
+        anthropicClient = new Anthropic(clientConfig);
+    }
+    return anthropicClient;
+}
+export function resetAnthropicClient() {
+    anthropicClient = null;
+}
+/**
+ * Generate a user_id in the format: user_<hash>_account__session_<uuid>
+ * This matches Anthropic's expected format for tracking and caching
+ * The hash is based on sessionId only to keep it consistent within the same session
+ */
+function generateUserId(sessionId) {
+    // Generate a 64-character hash (consistent for the same session)
+    const hash = createHash('sha256')
+        .update(`anthropic_user_${sessionId}`)
+        .digest('hex');
+    return `user_${hash}_account__session_${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;
+    }
+    const convertedTools = tools
+        .filter(tool => tool.type === 'function' && 'function' in tool)
+        .map(tool => {
+        if (tool.type === 'function' && 'function' in tool) {
+            return {
+                name: tool.function.name,
+                description: tool.function.description || '',
+                input_schema: tool.function.parameters
+            };
+        }
+        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
+ * 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: [{
+                        type: 'tool_result',
+                        tool_use_id: msg.tool_call_id,
+                        content: msg.content
+                    }]
+            });
+            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({
+                        type: 'image',
+                        source: {
+                            type: 'base64',
+                            media_type: base64Match[1] || image.mimeType,
+                            data: base64Match[2] || ''
+                        }
+                    });
+                }
+            }
+            anthropicMessages.push({
+                role: 'user',
+                content
+            });
+            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',
+                    id: toolCall.id,
+                    name: toolCall.function.name,
+                    input: JSON.parse(toolCall.function.arguments)
+                });
+            }
+            anthropicMessages.push({
+                role: 'assistant',
+                content
+            });
+            continue;
+        }
+        // Handle regular text messages
+        if (msg.role === 'user' || msg.role === 'assistant') {
+            anthropicMessages.push({
+                role: msg.role,
+                content: msg.content
+            });
+        }
+    }
+    // 如果配置了自定义系统提示词
+    if (customSystemPrompt) {
+        // 自定义系统提示词作为 system，默认系统提示词作为第一条用户消息
+        systemContent = customSystemPrompt;
+        anthropicMessages.unshift({
+            role: 'user',
+            content: SYSTEM_PROMPT
+        });
+    }
+    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];
+        if (lastMessage && lastMessage.role === 'user') {
+            // Convert content to array format if it's a string
+            if (typeof lastMessage.content === 'string') {
+                lastMessage.content = [{
+                        type: 'text',
+                        text: lastMessage.content,
+                        cache_control: { type: 'ephemeral' }
+                    }];
+            }
+            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];
+                    lastContent.cache_control = { type: 'ephemeral' };
+                }
+            }
+        }
+    }
+    // Format system prompt with cache_control (only if we have a system prompt)
+    const system = systemContent ? [{
+            type: 'text',
+            text: systemContent,
+            cache_control: { type: 'ephemeral' }
+        }] : undefined;
+    return { system, messages: anthropicMessages };
+}
+/**
+ * Create streaming chat completion using Anthropic API
+ */
+export async function* createStreamingAnthropicCompletion(options, abortSignal) {
+    const client = getAnthropicClient();
+    try {
+        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 requestBody = {
+            model: options.model,
+            max_tokens: options.max_tokens || 4096,
+            temperature: options.temperature ?? 0.7,
+            system,
+            messages,
+            tools: convertToolsToAnthropic(options.tools),
+            metadata: {
+                user_id: userId
+            },
+            stream: true
+        };
+        // Create streaming request
+        const stream = await client.messages.create(requestBody);
+        let contentBuffer = '';
+        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;
+            }
+            // 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
+                    toolCallsBuffer.set(block.id, {
+                        id: block.id,
+                        type: 'function',
+                        function: {
+                            name: block.name,
+                            arguments: ''
+                        }
+                    });
+                    // Yield delta for token counting
+                    yield {
+                        type: 'tool_call_delta',
+                        delta: block.name
+                    };
+                }
+            }
+            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;
+                    yield {
+                        type: 'content',
+                        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);
+                        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 (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),
+                        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 (including cache metrics)
+                if (event.usage) {
+                    if (!usageData) {
+                        usageData = {
+                            prompt_tokens: 0,
+                            completion_tokens: 0,
+                            total_tokens: 0
+                        };
+                    }
+                    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 (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: 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');
+    }
+}

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,12 +1,16 @@
 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';
 /**
  * Convert our ChatMessage format to OpenAI's ChatCompletionMessageParam format
  * Automatically prepends system prompt if not present
+ * 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 convertToOpenAIMessages(messages, includeSystemPrompt = true) {
+    const customSystemPrompt = getCustomSystemPrompt();
     let result = messages.map(msg => {
         // 如果消息包含图片，使用 content 数组格式
         if (msg.role === 'user' && msg.images && msg.images.length > 0) {
@@ -51,15 +55,37 @@ function convertToOpenAIMessages(messages, includeSystemPrompt = true) {
         }
         return baseMessage;
     });
-    // 如果需要系统提示词且第一条消息不是 system 消息，则添加
-    if (includeSystemPrompt && (result.length === 0 || result[0]?.role !== 'system')) {
-        result = [
-            {
-                role: 'system',
-                content: SYSTEM_PROMPT
-            },
-            ...result
-        ];
+    // 如果需要系统提示词
+    if (includeSystemPrompt) {
+        // 如果第一条消息已经是 system 消息，跳过
+        if (result.length > 0 && result[0]?.role === 'system') {
+            return result;
+        }
+        // 如果配置了自定义系统提示词
+        if (customSystemPrompt) {
+            // 自定义系统提示词作为 system 消息，默认系统提示词作为第一条 user 消息
+            result = [
+                {
+                    role: 'system',
+                    content: customSystemPrompt
+                },
+                {
+                    role: 'user',
+                    content: SYSTEM_PROMPT
+                },
+                ...result
+            ];
+        }
+        else {
+            // 没有自定义系统提示词，默认系统提示词作为 system 消息
+            result = [
+                {
+                    role: 'system',
+                    content: SYSTEM_PROMPT
+                },
+                ...result
+            ];
+        }
     }
     return result;
 }
@@ -249,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

@@ -0,0 +1,35 @@
+import type { ChatMessage } from './chat.js';
+import type { ChatCompletionTool } from 'openai/resources/chat/completions';
+export interface GeminiOptions {
+    model: string;
+    messages: ChatMessage[];
+    temperature?: number;
+    tools?: ChatCompletionTool[];
+}
+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';
+    content?: string;
+    tool_calls?: Array<{
+        id: string;
+        type: 'function';
+        function: {
+            name: string;
+            arguments: string;
+        };
+    }>;
+    delta?: string;
+    usage?: UsageInfo;
+}
+export declare function resetGeminiClient(): void;
+/**
+ * Create streaming chat completion using Gemini API
+ */
+export declare function createStreamingGeminiCompletion(options: GeminiOptions, abortSignal?: AbortSignal): AsyncGenerator<GeminiStreamChunk, void, unknown>;