snow-ai 0.3.0 → 0.3.2

package/dist/api/anthropic.d.ts

@@ -1,5 +1,4 @@
-import type { ChatMessage } from './chat.js';
-import type { ChatCompletionTool } from 'openai/resources/chat/completions';
+import type { ChatMessage, ChatCompletionTool, UsageInfo } from './types.js';
 export interface AnthropicOptions {
     model: string;
     messages: ChatMessage[];
@@ -8,13 +7,6 @@ export interface AnthropicOptions {
     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;
@@ -29,6 +21,18 @@ export interface AnthropicStreamChunk {
     delta?: string;
     usage?: UsageInfo;
 }
+export interface AnthropicTool {
+    name: string;
+    description: string;
+    input_schema: any;
+    cache_control?: {
+        type: 'ephemeral';
+    };
+}
+export interface AnthropicMessageParam {
+    role: 'user' | 'assistant';
+    content: string | Array<any>;
+}
 export declare function resetAnthropicClient(): void;
 /**
  * Create streaming chat completion using Anthropic API

package/dist/api/anthropic.js

@@ -1,45 +1,28 @@
-import Anthropic from '@anthropic-ai/sdk';
 import { createHash, randomUUID } from 'crypto';
 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) {
+let anthropicConfig = null;
+function getAnthropicConfig() {
+    if (!anthropicConfig) {
         const config = getOpenAiConfig();
         if (!config.apiKey) {
             throw new Error('Anthropic API configuration is incomplete. Please configure API key first.');
         }
-        const clientConfig = {
-            apiKey: config.apiKey,
-        };
-        if (config.baseUrl && config.baseUrl !== 'https://api.openai.com/v1') {
-            clientConfig.baseURL = config.baseUrl;
-        }
         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);
+        anthropicConfig = {
+            apiKey: config.apiKey,
+            baseUrl: config.baseUrl && config.baseUrl !== 'https://api.openai.com/v1'
+                ? config.baseUrl
+                : 'https://api.anthropic.com/v1',
+            customHeaders,
+            anthropicBeta: config.anthropicBeta
         };
-        anthropicClient = new Anthropic(clientConfig);
     }
-    return anthropicClient;
+    return anthropicConfig;
 }
 export function resetAnthropicClient() {
-    anthropicClient = null;
+    anthropicConfig = null;
 }
 /**
  * Generate a user_id in the format: user_<hash>_account__session_<uuid>
@@ -209,16 +192,51 @@ function convertToAnthropicMessages(messages) {
         }] : undefined;
     return { system, messages: anthropicMessages };
 }
+/**
+ * Parse Server-Sent Events (SSE) stream
+ */
+async function* parseSSEStream(reader) {
+    const decoder = new TextDecoder();
+    let buffer = '';
+    while (true) {
+        const { done, value } = await reader.read();
+        if (done)
+            break;
+        buffer += decoder.decode(value, { stream: true });
+        const lines = buffer.split('\n');
+        buffer = lines.pop() || '';
+        for (const line of lines) {
+            const trimmed = line.trim();
+            if (!trimmed || trimmed.startsWith(':'))
+                continue;
+            if (trimmed === 'data: [DONE]') {
+                return;
+            }
+            if (trimmed.startsWith('event: ')) {
+                // Event type, will be followed by data
+                continue;
+            }
+            if (trimmed.startsWith('data: ')) {
+                const data = trimmed.slice(6);
+                try {
+                    yield JSON.parse(data);
+                }
+                catch (e) {
+                    console.error('Failed to parse SSE data:', data);
+                }
+            }
+        }
+    }
+}
 /**
  * Create streaming chat completion using Anthropic API
  */
 export async function* createStreamingAnthropicCompletion(options, abortSignal, onRetry) {
-    const client = getAnthropicClient();
     yield* withRetryGenerator(async function* () {
+        const config = getAnthropicConfig();
         const { system, messages } = convertToAnthropicMessages(options.messages);
         const sessionId = options.sessionId || randomUUID();
         const userId = generateUserId(sessionId);
-        const customHeaders = getCustomHeaders();
         const requestBody = {
             model: options.model,
             max_tokens: options.max_tokens || 4096,
@@ -231,15 +249,40 @@ export async function* createStreamingAnthropicCompletion(options, abortSignal,
             },
             stream: true
         };
-        const stream = await client.messages.create(requestBody, {
-            headers: customHeaders
+        // Prepare headers
+        const headers = {
+            'Content-Type': 'application/json',
+            'x-api-key': config.apiKey,
+            'authorization': `Bearer ${config.apiKey}`,
+            'anthropic-version': '2023-06-01',
+            ...config.customHeaders
+        };
+        // Add beta parameter if configured
+        // if (config.anthropicBeta) {
+        // 	headers['anthropic-beta'] = 'prompt-caching-2024-07-31';
+        // }
+        const url = config.anthropicBeta
+            ? `${config.baseUrl}/messages?beta=true`
+            : `${config.baseUrl}/messages`;
+        const response = await fetch(url, {
+            method: 'POST',
+            headers,
+            body: JSON.stringify(requestBody),
+            signal: abortSignal
         });
+        if (!response.ok) {
+            const errorText = await response.text();
+            throw new Error(`Anthropic API error: ${response.status} ${response.statusText} - ${errorText}`);
+        }
+        if (!response.body) {
+            throw new Error('No response body from Anthropic API');
+        }
         let contentBuffer = '';
         let toolCallsBuffer = new Map();
         let hasToolCalls = false;
         let usageData;
         let blockIndexToId = new Map();
-        for await (const event of stream) {
+        for await (const event of parseSSEStream(response.body.getReader())) {
             if (abortSignal?.aborted) {
                 return;
             }

package/dist/api/chat.d.ts

@@ -1,24 +1,5 @@
-import type { ChatCompletionTool } from 'openai/resources/chat/completions';
-export interface ImageContent {
-    type: 'image';
-    data: string;
-    mimeType: string;
-}
-export interface ChatMessage {
-    role: 'system' | 'user' | 'assistant' | 'tool';
-    content: string;
-    tool_call_id?: string;
-    tool_calls?: ToolCall[];
-    images?: ImageContent[];
-}
-export interface ToolCall {
-    id: string;
-    type: 'function';
-    function: {
-        name: string;
-        arguments: string;
-    };
-}
+import type { ChatMessage, ChatCompletionTool, ToolCall, UsageInfo, ImageContent } from './types.js';
+export type { ChatMessage, ChatCompletionTool, ToolCall, UsageInfo, ImageContent };
 export interface ChatCompletionOptions {
     model: string;
     messages: ChatMessage[];
@@ -56,15 +37,19 @@ export interface ChatCompletionChunk {
         finish_reason?: string | null;
     }>;
 }
-export declare function resetOpenAIClient(): void;
-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 ChatCompletionMessageParam {
+    role: 'system' | 'user' | 'assistant' | 'tool';
+    content: string | Array<{
+        type: 'text' | 'image_url';
+        text?: string;
+        image_url?: {
+            url: string;
+        };
+    }>;
+    tool_call_id?: string;
+    tool_calls?: ToolCall[];
 }
+export declare function resetOpenAIClient(): void;
 export interface StreamChunk {
     type: 'content' | 'tool_calls' | 'tool_call_delta' | 'reasoning_delta' | 'reasoning_started' | 'done' | 'usage';
     content?: string;

package/dist/api/chat.js

@@ -1,4 +1,3 @@
-import OpenAI from 'openai';
 import { getOpenAiConfig, getCustomSystemPrompt, getCustomHeaders } from '../utils/apiConfig.js';
 import { SYSTEM_PROMPT } from './systemPrompt.js';
 import { withRetryGenerator } from '../utils/retryUtils.js';
@@ -89,54 +88,98 @@ function convertToOpenAIMessages(messages, includeSystemPrompt = true) {
     }
     return result;
 }
-let openaiClient = null;
-function getOpenAIClient() {
-    if (!openaiClient) {
+let openaiConfig = null;
+function getOpenAIConfig() {
+    if (!openaiConfig) {
         const config = getOpenAiConfig();
         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({
+        openaiConfig = {
             apiKey: config.apiKey,
-            baseURL: config.baseUrl,
-            defaultHeaders: {
-                ...customHeaders
-            }
-        });
+            baseUrl: config.baseUrl,
+            customHeaders
+        };
     }
-    return openaiClient;
+    return openaiConfig;
 }
 export function resetOpenAIClient() {
-    openaiClient = null;
+    openaiConfig = null;
+}
+/**
+ * Parse Server-Sent Events (SSE) stream
+ */
+async function* parseSSEStream(reader) {
+    const decoder = new TextDecoder();
+    let buffer = '';
+    while (true) {
+        const { done, value } = await reader.read();
+        if (done)
+            break;
+        buffer += decoder.decode(value, { stream: true });
+        const lines = buffer.split('\n');
+        buffer = lines.pop() || '';
+        for (const line of lines) {
+            const trimmed = line.trim();
+            if (!trimmed || trimmed.startsWith(':'))
+                continue;
+            if (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);
+                }
+            }
+        }
+    }
 }
 /**
  * Simple streaming chat completion - only handles OpenAI interaction
  * Tool execution should be handled by the caller
  */
 export async function* createStreamingChatCompletion(options, abortSignal, onRetry) {
-    const client = getOpenAIClient();
+    const config = getOpenAIConfig();
     // 使用重试包装生成器
     yield* withRetryGenerator(async function* () {
-        const stream = await client.chat.completions.create({
+        const requestBody = {
             model: options.model,
             messages: convertToOpenAIMessages(options.messages),
             stream: true,
-            stream_options: { include_usage: true }, // Request usage data in stream
+            stream_options: { include_usage: true },
             temperature: options.temperature || 0.7,
             max_tokens: options.max_tokens,
             tools: options.tools,
             tool_choice: options.tool_choice,
-        }, {
-            signal: abortSignal,
+        };
+        const response = await fetch(`${config.baseUrl}/chat/completions`, {
+            method: 'POST',
+            headers: {
+                'Content-Type': 'application/json',
+                'Authorization': `Bearer ${config.apiKey}`,
+                ...config.customHeaders
+            },
+            body: JSON.stringify(requestBody),
+            signal: abortSignal
         });
+        if (!response.ok) {
+            const errorText = await response.text();
+            throw new Error(`OpenAI API error: ${response.status} ${response.statusText} - ${errorText}`);
+        }
+        if (!response.body) {
+            throw new Error('No response body from OpenAI API');
+        }
         let contentBuffer = '';
         let toolCallsBuffer = {};
         let hasToolCalls = false;
         let usageData;
         let reasoningStarted = false; // Track if reasoning has started
-        for await (const chunk of stream) {
+        for await (const chunk of parseSSEStream(response.body.getReader())) {
             if (abortSignal?.aborted) {
                 return;
             }

package/dist/api/gemini.d.ts

@@ -1,19 +1,10 @@
-import type { ChatMessage } from './chat.js';
-import type { ChatCompletionTool } from 'openai/resources/chat/completions';
+import type { ChatMessage, ChatCompletionTool, UsageInfo } from './types.js';
 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;

package/dist/api/gemini.js

@@ -1,44 +1,26 @@
-import { GoogleGenAI } from '@google/genai';
 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) {
+let geminiConfig = null;
+function getGeminiConfig() {
+    if (!geminiConfig) {
         const config = getOpenAiConfig();
         if (!config.apiKey) {
             throw new Error('Gemini API configuration is incomplete. Please configure API key first.');
         }
-        // Create client configuration
-        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
-                }
-            };
-        }
-        geminiClient = new GoogleGenAI(clientConfig);
+        geminiConfig = {
+            apiKey: config.apiKey,
+            baseUrl: config.baseUrl && config.baseUrl !== 'https://api.openai.com/v1'
+                ? config.baseUrl
+                : 'https://generativelanguage.googleapis.com/v1beta',
+            customHeaders
+        };
     }
-    return geminiClient;
+    return geminiConfig;
 }
 export function resetGeminiClient() {
-    geminiClient = null;
+    geminiConfig = null;
 }
 /**
  * Convert OpenAI-style tools to Gemini function declarations
@@ -213,81 +195,121 @@ function convertToGeminiMessages(messages) {
  * Create streaming chat completion using Gemini API
  */
 export async function* createStreamingGeminiCompletion(options, abortSignal, onRetry) {
-    const client = getGeminiClient();
+    const config = getGeminiConfig();
     // 使用重试包装生成器
     yield* withRetryGenerator(async function* () {
         const { systemInstruction, contents } = convertToGeminiMessages(options.messages);
-        // Build request config
-        const requestConfig = {
-            model: options.model,
+        // Build request payload
+        const requestBody = {
             contents,
-            config: {
-                systemInstruction,
+            systemInstruction: systemInstruction ? { parts: [{ text: systemInstruction }] } : undefined,
+            generationConfig: {
                 temperature: options.temperature ?? 0.7,
             }
         };
         // Add tools if provided
         const geminiTools = convertToolsToGemini(options.tools);
         if (geminiTools) {
-            requestConfig.config.tools = geminiTools;
+            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 url = `${config.baseUrl}/${modelName}:streamGenerateContent?key=${config.apiKey}&alt=sse`;
+        const response = await fetch(url, {
+            method: 'POST',
+            headers: {
+                'Content-Type': 'application/json',
+                'authorization': `Bearer ${config.apiKey}`,
+                ...config.customHeaders
+            },
+            body: JSON.stringify(requestBody),
+            signal: abortSignal
+        });
+        if (!response.ok) {
+            const errorText = await response.text();
+            throw new Error(`Gemini API error: ${response.status} ${response.statusText} - ${errorText}`);
+        }
+        if (!response.body) {
+            throw new Error('No response body from Gemini API');
         }
-        // Stream the response
-        const stream = await client.models.generateContentStream(requestConfig);
         let contentBuffer = '';
         let toolCallsBuffer = [];
         let hasToolCalls = false;
         let toolCallIndex = 0;
         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) {
+        // Parse SSE stream
+        const reader = response.body.getReader();
+        const decoder = new TextDecoder();
+        let buffer = '';
+        while (true) {
+            const { done, value } = await reader.read();
+            if (done)
+                break;
             if (abortSignal?.aborted) {
-                console.warn = originalWarn; // Restore console.warn
                 return;
             }
-            // Process text content
-            if (chunk.text) {
-                contentBuffer += chunk.text;
-                yield {
-                    type: 'content',
-                    content: chunk.text
-                };
-            }
-            // Process function calls using the official API
-            if (chunk.functionCalls && chunk.functionCalls.length > 0) {
-                hasToolCalls = true;
-                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)
+            buffer += decoder.decode(value, { stream: true });
+            const lines = buffer.split('\n');
+            buffer = lines.pop() || '';
+            for (const line of lines) {
+                const trimmed = line.trim();
+                if (!trimmed || trimmed.startsWith(':'))
+                    continue;
+                if (trimmed.startsWith('data: ')) {
+                    const data = trimmed.slice(6);
+                    try {
+                        const chunk = JSON.parse(data);
+                        // Process candidates
+                        if (chunk.candidates && chunk.candidates.length > 0) {
+                            const candidate = chunk.candidates[0];
+                            if (candidate.content && candidate.content.parts) {
+                                for (const part of candidate.content.parts) {
+                                    // Process text content
+                                    if (part.text) {
+                                        contentBuffer += part.text;
+                                        yield {
+                                            type: 'content',
+                                            content: part.text
+                                        };
+                                    }
+                                    // Process function calls
+                                    if (part.functionCall) {
+                                        hasToolCalls = true;
+                                        const fc = part.functionCall;
+                                        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
+                                        };
+                                    }
+                                }
+                            }
                         }
-                    };
-                    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
+                            };
+                        }
+                    }
+                    catch (e) {
+                        console.error('Failed to parse Gemini SSE data:', data);
+                    }
                 }
             }
-            // 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 {