snow-ai 0.1.12 → 0.2.2

package/dist/api/chat.d.ts

@@ -1,6 +1,23 @@
+import type { ChatCompletionTool } from 'openai/resources/chat/completions';
+export interface ImageContent {
+    type: 'image';
+    data: string;
+    mimeType: string;
+}
 export interface ChatMessage {
-    role: 'system' | 'user' | 'assistant';
+    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;
+    };
 }
 export interface ChatCompletionOptions {
     model: string;
@@ -8,6 +25,13 @@ export interface ChatCompletionOptions {
     stream?: boolean;
     temperature?: number;
     max_tokens?: number;
+    tools?: ChatCompletionTool[];
+    tool_choice?: 'auto' | 'none' | 'required' | {
+        type: 'function';
+        function: {
+            name: string;
+        };
+    };
 }
 export interface ChatCompletionChunk {
     id: string;
@@ -19,11 +43,50 @@ export interface ChatCompletionChunk {
         delta: {
             role?: string;
             content?: string;
+            tool_calls?: Array<{
+                index?: number;
+                id?: string;
+                type?: 'function';
+                function?: {
+                    name?: string;
+                    arguments?: string;
+                };
+            }>;
         };
         finish_reason?: string | null;
     }>;
 }
 export declare function resetOpenAIClient(): void;
+/**
+ * Create chat completion with automatic function calling support
+ */
+export declare function createChatCompletionWithTools(options: ChatCompletionOptions, maxToolRounds?: number): Promise<{
+    content: string;
+    toolCalls: ToolCall[];
+}>;
 export declare function createChatCompletion(options: ChatCompletionOptions): Promise<string>;
-export declare function createStreamingChatCompletion(options: ChatCompletionOptions, abortSignal?: AbortSignal): AsyncGenerator<string, void, unknown>;
+export interface UsageInfo {
+    prompt_tokens: number;
+    completion_tokens: number;
+    total_tokens: number;
+}
+export interface StreamChunk {
+    type: 'content' | 'tool_calls' | 'tool_call_delta' | 'reasoning_delta' | 'done' | 'usage';
+    content?: string;
+    tool_calls?: Array<{
+        id: string;
+        type: 'function';
+        function: {
+            name: string;
+            arguments: string;
+        };
+    }>;
+    delta?: string;
+    usage?: UsageInfo;
+}
+/**
+ * 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 validateChatOptions(options: ChatCompletionOptions): string[];

package/dist/api/chat.js

@@ -1,5 +1,68 @@
 import OpenAI from 'openai';
 import { getOpenAiConfig } 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
+ */
+function convertToOpenAIMessages(messages, includeSystemPrompt = true) {
+    let result = messages.map(msg => {
+        // 如果消息包含图片，使用 content 数组格式
+        if (msg.role === 'user' && msg.images && msg.images.length > 0) {
+            const contentParts = [];
+            // 添加文本内容
+            if (msg.content) {
+                contentParts.push({
+                    type: 'text',
+                    text: msg.content
+                });
+            }
+            // 添加图片内容
+            for (const image of msg.images) {
+                contentParts.push({
+                    type: 'image_url',
+                    image_url: {
+                        url: image.data // Base64 data URL
+                    }
+                });
+            }
+            return {
+                role: 'user',
+                content: contentParts
+            };
+        }
+        const baseMessage = {
+            role: msg.role,
+            content: msg.content
+        };
+        if (msg.role === 'assistant' && msg.tool_calls) {
+            return {
+                ...baseMessage,
+                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
+            };
+        }
+        return baseMessage;
+    });
+    // 如果需要系统提示词且第一条消息不是 system 消息，则添加
+    if (includeSystemPrompt && (result.length === 0 || result[0]?.role !== 'system')) {
+        result = [
+            {
+                role: 'system',
+                content: SYSTEM_PROMPT
+            },
+            ...result
+        ];
+    }
+    return result;
+}
 let openaiClient = null;
 function getOpenAIClient() {
     if (!openaiClient) {
@@ -17,17 +80,134 @@ function getOpenAIClient() {
 export function resetOpenAIClient() {
     openaiClient = null;
 }
+/**
+ * Create chat completion with automatic function calling support
+ */
+export async function createChatCompletionWithTools(options, maxToolRounds = 5) {
+    const client = getOpenAIClient();
+    let messages = [...options.messages];
+    let allToolCalls = [];
+    let rounds = 0;
+    try {
+        while (rounds < maxToolRounds) {
+            const response = await client.chat.completions.create({
+                model: options.model,
+                messages: convertToOpenAIMessages(messages),
+                stream: false,
+                temperature: options.temperature || 0.7,
+                max_tokens: options.max_tokens,
+                tools: options.tools,
+                tool_choice: options.tool_choice,
+            });
+            const message = response.choices[0]?.message;
+            if (!message) {
+                throw new Error('No response from AI');
+            }
+            // Add assistant message to conversation
+            messages.push({
+                role: 'assistant',
+                content: message.content || '',
+                tool_calls: message.tool_calls
+            });
+            // Check if AI wants to call tools
+            if (message.tool_calls && message.tool_calls.length > 0) {
+                allToolCalls.push(...message.tool_calls);
+                // Execute each tool call
+                for (const toolCall of message.tool_calls) {
+                    if (toolCall.type === 'function') {
+                        try {
+                            const args = JSON.parse(toolCall.function.arguments);
+                            const result = await executeMCPTool(toolCall.function.name, args);
+                            // Add tool result to conversation
+                            messages.push({
+                                role: 'tool',
+                                content: JSON.stringify(result),
+                                tool_call_id: toolCall.id
+                            });
+                        }
+                        catch (error) {
+                            // Add error result to conversation
+                            messages.push({
+                                role: 'tool',
+                                content: `Error: ${error instanceof Error ? error.message : 'Tool execution failed'}`,
+                                tool_call_id: toolCall.id
+                            });
+                        }
+                    }
+                }
+                rounds++;
+                continue;
+            }
+            // No tool calls, return the content
+            return {
+                content: message.content || '',
+                toolCalls: allToolCalls
+            };
+        }
+        throw new Error(`Maximum tool calling rounds (${maxToolRounds}) exceeded`);
+    }
+    catch (error) {
+        if (error instanceof Error) {
+            throw new Error(`Chat completion with tools failed: ${error.message}`);
+        }
+        throw new Error('Chat completion with tools failed: Unknown error');
+    }
+}
 export async function createChatCompletion(options) {
     const client = getOpenAIClient();
+    let messages = [...options.messages];
     try {
-        const response = await client.chat.completions.create({
-            model: options.model,
-            messages: options.messages,
-            stream: false,
-            temperature: options.temperature || 0.7,
-            max_tokens: options.max_tokens,
-        });
-        return response.choices[0]?.message?.content || '';
+        while (true) {
+            const response = await client.chat.completions.create({
+                model: options.model,
+                messages: convertToOpenAIMessages(messages),
+                stream: false,
+                temperature: options.temperature || 0.7,
+                max_tokens: options.max_tokens,
+                tools: options.tools,
+                tool_choice: options.tool_choice,
+            });
+            const message = response.choices[0]?.message;
+            if (!message) {
+                throw new Error('No response from AI');
+            }
+            // Add assistant message to conversation
+            messages.push({
+                role: 'assistant',
+                content: message.content || '',
+                tool_calls: message.tool_calls
+            });
+            // Check if AI wants to call tools
+            if (message.tool_calls && message.tool_calls.length > 0) {
+                // Execute each tool call
+                for (const toolCall of message.tool_calls) {
+                    if (toolCall.type === 'function') {
+                        try {
+                            const args = JSON.parse(toolCall.function.arguments);
+                            const result = await executeMCPTool(toolCall.function.name, args);
+                            // Add tool result to conversation
+                            messages.push({
+                                role: 'tool',
+                                content: JSON.stringify(result),
+                                tool_call_id: toolCall.id
+                            });
+                        }
+                        catch (error) {
+                            // Add error result to conversation
+                            messages.push({
+                                role: 'tool',
+                                content: `Error: ${error instanceof Error ? error.message : 'Tool execution failed'}`,
+                                tool_call_id: toolCall.id
+                            });
+                        }
+                    }
+                }
+                // Continue the conversation with tool results
+                continue;
+            }
+            // No tool calls, return the content
+            return message.content || '';
+        }
     }
     catch (error) {
         if (error instanceof Error) {
@@ -36,31 +216,129 @@ export async function createChatCompletion(options) {
         throw new Error('Chat completion failed: Unknown error');
     }
 }
+/**
+ * Simple streaming chat completion - only handles OpenAI interaction
+ * Tool execution should be handled by the caller
+ */
 export async function* createStreamingChatCompletion(options, abortSignal) {
     const client = getOpenAIClient();
     try {
         const stream = await client.chat.completions.create({
             model: options.model,
-            messages: options.messages,
+            messages: convertToOpenAIMessages(options.messages),
             stream: true,
+            stream_options: { include_usage: true }, // Request usage data in stream
             temperature: options.temperature || 0.7,
             max_tokens: options.max_tokens,
+            tools: options.tools,
+            tool_choice: options.tool_choice,
         }, {
             signal: abortSignal,
         });
+        let contentBuffer = '';
+        let toolCallsBuffer = {};
+        let hasToolCalls = false;
+        let usageData;
         for await (const chunk of stream) {
             if (abortSignal?.aborted) {
-                break;
+                return;
+            }
+            // Capture usage information if available (usually in the last chunk)
+            const usageValue = chunk.usage;
+            if (usageValue !== null && usageValue !== undefined) {
+                usageData = {
+                    prompt_tokens: usageValue.prompt_tokens || 0,
+                    completion_tokens: usageValue.completion_tokens || 0,
+                    total_tokens: usageValue.total_tokens || 0
+                };
             }
-            const content = chunk.choices[0]?.delta?.content;
+            // Skip content processing if no choices (but usage is already captured above)
+            const choice = chunk.choices[0];
+            if (!choice) {
+                continue;
+            }
+            // Stream content chunks
+            const content = choice.delta?.content;
             if (content) {
-                yield content;
+                contentBuffer += content;
+                yield {
+                    type: 'content',
+                    content
+                };
+            }
+            // Stream reasoning content (for o1 models, etc.)
+            // Note: reasoning_content is NOT included in the response, only counted for tokens
+            const reasoningContent = choice.delta?.reasoning_content;
+            if (reasoningContent) {
+                yield {
+                    type: 'reasoning_delta',
+                    delta: reasoningContent
+                };
+            }
+            // Accumulate tool calls and stream deltas
+            const deltaToolCalls = choice.delta?.tool_calls;
+            if (deltaToolCalls) {
+                hasToolCalls = true;
+                for (const deltaCall of deltaToolCalls) {
+                    const index = deltaCall.index ?? 0;
+                    if (!toolCallsBuffer[index]) {
+                        toolCallsBuffer[index] = {
+                            id: '',
+                            type: 'function',
+                            function: {
+                                name: '',
+                                arguments: ''
+                            }
+                        };
+                    }
+                    if (deltaCall.id) {
+                        toolCallsBuffer[index].id = deltaCall.id;
+                    }
+                    // Yield tool call deltas for token counting
+                    let deltaText = '';
+                    if (deltaCall.function?.name) {
+                        toolCallsBuffer[index].function.name += deltaCall.function.name;
+                        deltaText += deltaCall.function.name;
+                    }
+                    if (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
+                        };
+                    }
+                }
+            }
+            if (choice.finish_reason) {
+                break;
             }
         }
+        // If there are tool calls, yield them
+        if (hasToolCalls) {
+            yield {
+                type: 'tool_calls',
+                tool_calls: Object.values(toolCallsBuffer)
+            };
+        }
+        // Yield usage information if available
+        if (usageData) {
+            yield {
+                type: 'usage',
+                usage: usageData
+            };
+        }
+        // Signal completion
+        yield {
+            type: 'done'
+        };
     }
     catch (error) {
         if (error instanceof Error && error.name === 'AbortError') {
-            return; // Silently handle abort
+            return;
         }
         if (error instanceof Error) {
             throw new Error(`Streaming chat completion failed: ${error.message}`);
@@ -77,11 +355,16 @@ export function validateChatOptions(options) {
         errors.push('At least one message is required');
     }
     for (const message of options.messages || []) {
-        if (!message.role || !['system', 'user', 'assistant'].includes(message.role)) {
+        if (!message.role || !['system', 'user', 'assistant', 'tool'].includes(message.role)) {
             errors.push('Invalid message role');
         }
-        if (!message.content || message.content.trim().length === 0) {
-            errors.push('Message content cannot be empty');
+        // Tool messages must have tool_call_id
+        if (message.role === 'tool' && !message.tool_call_id) {
+            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)) {
+            errors.push('Message content cannot be empty (except for tool messages)');
         }
     }
     return errors;

package/dist/api/responses.d.ts

@@ -0,0 +1,52 @@
+import type { ChatMessage, ToolCall } from './chat.js';
+export interface ResponseOptions {
+    model: string;
+    messages: ChatMessage[];
+    stream?: boolean;
+    temperature?: number;
+    max_tokens?: number;
+    tools?: Array<{
+        type: 'function';
+        function: {
+            name: string;
+            description?: string;
+            parameters?: Record<string, any>;
+        };
+    }>;
+    tool_choice?: 'auto' | 'none' | 'required';
+    reasoning?: {
+        summary?: 'auto' | 'none';
+        effort?: 'low' | 'medium' | 'high';
+    };
+    prompt_cache_key?: string;
+    store?: boolean;
+    include?: string[];
+}
+export interface UsageInfo {
+    prompt_tokens: number;
+    completion_tokens: number;
+    total_tokens: number;
+}
+export interface ResponseStreamChunk {
+    type: 'content' | 'tool_calls' | 'tool_call_delta' | 'reasoning_delta' | 'done' | 'usage';
+    content?: string;
+    tool_calls?: ToolCall[];
+    delta?: string;
+    usage?: UsageInfo;
+}
+export declare function resetOpenAIClient(): void;
+/**
+ * 使用 Responses API 创建响应（非流式，带自动工具调用）
+ */
+export declare function createResponse(options: ResponseOptions): Promise<string>;
+/**
+ * 使用 Responses API 创建流式响应（带自动工具调用）
+ */
+export declare function createStreamingResponse(options: ResponseOptions, abortSignal?: AbortSignal): AsyncGenerator<ResponseStreamChunk, void, unknown>;
+/**
+ * 使用 Responses API 创建响应（限制工具调用轮数）
+ */
+export declare function createResponseWithTools(options: ResponseOptions, maxToolRounds?: number): Promise<{
+    content: string;
+    toolCalls: ToolCall[];
+}>;