snow-ai 0.3.1 → 0.3.3

package/dist/agents/summaryAgent.d.ts

@@ -0,0 +1,31 @@
+export declare class SummaryAgent {
+    private modelName;
+    private requestMethod;
+    private initialized;
+    /**
+     * Initialize the summary agent with current configuration
+     * @returns true if initialized successfully, false otherwise
+     */
+    private initialize;
+    /**
+     * Check if summary agent is available
+     */
+    isAvailable(): Promise<boolean>;
+    /**
+     * Call the basic model with the same routing as main flow
+     * Uses streaming APIs and intercepts to assemble complete response
+     * This ensures 100% consistency with main flow routing
+     * @param messages - Chat messages
+     * @param abortSignal - Optional abort signal to cancel the request
+     */
+    private callBasicModel;
+    /**
+     * Generate a concise summary from the first user message
+     *
+     * @param userMessage - The first user message in the conversation
+     * @param abortSignal - Optional abort signal to cancel generation
+     * @returns A concise summary (10-20 words) suitable for session title
+     */
+    generateSummary(userMessage: string, abortSignal?: AbortSignal): Promise<string>;
+}
+export declare const summaryAgent: SummaryAgent;

package/dist/agents/summaryAgent.js

@@ -0,0 +1,256 @@
+import { getOpenAiConfig, getCustomSystemPrompt } from '../utils/apiConfig.js';
+import { logger } from '../utils/logger.js';
+import { createStreamingChatCompletion } from '../api/chat.js';
+import { createStreamingResponse } from '../api/responses.js';
+import { createStreamingGeminiCompletion } from '../api/gemini.js';
+import { createStreamingAnthropicCompletion } from '../api/anthropic.js';
+export class SummaryAgent {
+    constructor() {
+        Object.defineProperty(this, "modelName", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: ''
+        });
+        Object.defineProperty(this, "requestMethod", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: 'chat'
+        });
+        Object.defineProperty(this, "initialized", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: false
+        });
+    }
+    /**
+     * Initialize the summary agent with current configuration
+     * @returns true if initialized successfully, false otherwise
+     */
+    async initialize() {
+        try {
+            const config = getOpenAiConfig();
+            // Check if basic model is configured
+            if (!config.basicModel) {
+                return false;
+            }
+            this.modelName = config.basicModel;
+            this.requestMethod = config.requestMethod; // Follow main flow's request method
+            this.initialized = true;
+            return true;
+        }
+        catch (error) {
+            logger.warn('Failed to initialize summary agent:', error);
+            return false;
+        }
+    }
+    /**
+     * Check if summary agent is available
+     */
+    async isAvailable() {
+        if (!this.initialized) {
+            return await this.initialize();
+        }
+        return true;
+    }
+    /**
+     * Call the basic model with the same routing as main flow
+     * Uses streaming APIs and intercepts to assemble complete response
+     * This ensures 100% consistency with main flow routing
+     * @param messages - Chat messages
+     * @param abortSignal - Optional abort signal to cancel the request
+     */
+    async callBasicModel(messages, abortSignal) {
+        const config = getOpenAiConfig();
+        if (!config.basicModel) {
+            throw new Error('Basic model not configured');
+        }
+        // Get custom system prompt if configured
+        const customSystemPrompt = getCustomSystemPrompt();
+        // If custom system prompt exists, prepend it to messages
+        // This ensures summary agent respects user's custom system configuration
+        let processedMessages = messages;
+        if (customSystemPrompt) {
+            processedMessages = [
+                {
+                    role: 'system',
+                    content: customSystemPrompt,
+                },
+                ...messages,
+            ];
+        }
+        // Temporarily override advancedModel with basicModel
+        const originalAdvancedModel = config.advancedModel;
+        try {
+            // Override config to use basicModel
+            config.advancedModel = config.basicModel;
+            let streamGenerator;
+            // Route to appropriate streaming API based on request method (follows main flow exactly)
+            switch (this.requestMethod) {
+                case 'anthropic':
+                    streamGenerator = createStreamingAnthropicCompletion({
+                        model: this.modelName,
+                        messages: processedMessages,
+                        max_tokens: 1024, // Summaries are short
+                    }, abortSignal);
+                    break;
+                case 'gemini':
+                    streamGenerator = createStreamingGeminiCompletion({
+                        model: this.modelName,
+                        messages: processedMessages,
+                    }, abortSignal);
+                    break;
+                case 'responses':
+                    streamGenerator = createStreamingResponse({
+                        model: this.modelName,
+                        messages: processedMessages,
+                        stream: true,
+                    }, abortSignal);
+                    break;
+                case 'chat':
+                default:
+                    streamGenerator = createStreamingChatCompletion({
+                        model: this.modelName,
+                        messages: processedMessages,
+                        stream: true,
+                    }, abortSignal);
+                    break;
+            }
+            // Intercept streaming response and assemble complete content
+            let completeContent = '';
+            let chunkCount = 0;
+            try {
+                for await (const chunk of streamGenerator) {
+                    chunkCount++;
+                    // Check abort signal
+                    if (abortSignal?.aborted) {
+                        throw new Error('Request aborted');
+                    }
+                    // Handle different chunk formats based on request method
+                    if (this.requestMethod === 'chat') {
+                        // Chat API uses standard OpenAI format: {choices: [{delta: {content}}]}
+                        if (chunk.choices && chunk.choices[0]?.delta?.content) {
+                            completeContent += chunk.choices[0].delta.content;
+                        }
+                    }
+                    else {
+                        // Responses, Gemini, and Anthropic APIs all use: {type: 'content', content: string}
+                        if (chunk.type === 'content' && chunk.content) {
+                            completeContent += chunk.content;
+                        }
+                    }
+                }
+            }
+            catch (streamError) {
+                // Log streaming error with details
+                if (streamError instanceof Error) {
+                    logger.error('Summary agent: Streaming error:', {
+                        error: streamError.message,
+                        stack: streamError.stack,
+                        name: streamError.name,
+                        chunkCount,
+                        contentLength: completeContent.length,
+                    });
+                }
+                else {
+                    logger.error('Summary agent: Unknown streaming error:', {
+                        error: streamError,
+                        chunkCount,
+                        contentLength: completeContent.length,
+                    });
+                }
+                throw streamError;
+            }
+            return completeContent;
+        }
+        catch (error) {
+            // Log detailed error from API call setup or streaming
+            if (error instanceof Error) {
+                logger.error('Summary agent: API call failed:', {
+                    error: error.message,
+                    stack: error.stack,
+                    name: error.name,
+                    requestMethod: this.requestMethod,
+                    modelName: this.modelName,
+                });
+            }
+            else {
+                logger.error('Summary agent: Unknown API error:', {
+                    error,
+                    requestMethod: this.requestMethod,
+                    modelName: this.modelName,
+                });
+            }
+            throw error;
+        }
+        finally {
+            // Restore original config
+            config.advancedModel = originalAdvancedModel;
+        }
+    }
+    /**
+     * Generate a concise summary from the first user message
+     *
+     * @param userMessage - The first user message in the conversation
+     * @param abortSignal - Optional abort signal to cancel generation
+     * @returns A concise summary (10-20 words) suitable for session title
+     */
+    async generateSummary(userMessage, abortSignal) {
+        const available = await this.isAvailable();
+        if (!available) {
+            // If summary agent is not available, return a truncated version of the message
+            return userMessage.slice(0, 50) + (userMessage.length > 50 ? '...' : '');
+        }
+        try {
+            const summaryPrompt = `Generate a concise summary (10-20 words) for the following user message. The summary should capture the main topic or intent.
+
+User Message: ${userMessage}
+
+Instructions:
+1. Keep it under 20 words
+2. Focus on the main topic or question
+3. Use clear, simple language
+4. Do not include quotes or special formatting
+5. Make it suitable as a conversation title
+
+Summary:`;
+            const messages = [
+                {
+                    role: 'user',
+                    content: summaryPrompt,
+                },
+            ];
+            const summary = await this.callBasicModel(messages, abortSignal);
+            if (!summary || summary.trim().length === 0) {
+                logger.warn('Summary agent returned empty response, using truncated message');
+                return (userMessage.slice(0, 50) + (userMessage.length > 50 ? '...' : ''));
+            }
+            // Clean up the summary (remove quotes, trim whitespace)
+            const cleanedSummary = summary
+                .trim()
+                .replace(/^["']|["']$/g, '') // Remove leading/trailing quotes
+                .replace(/\n/g, ' ') // Replace newlines with spaces
+                .slice(0, 100); // Limit to 100 characters max
+            return cleanedSummary;
+        }
+        catch (error) {
+            // Log detailed error information
+            if (error instanceof Error) {
+                logger.warn('Summary agent generation failed, using truncated message:', {
+                    error: error.message,
+                    stack: error.stack,
+                    name: error.name,
+                });
+            }
+            else {
+                logger.warn('Summary agent generation failed with unknown error:', error);
+            }
+            // Fallback to truncated message
+            return userMessage.slice(0, 50) + (userMessage.length > 50 ? '...' : '');
+        }
+    }
+}
+// Export singleton instance
+export const summaryAgent = new SummaryAgent();

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;