snow-ai 0.4.15 → 0.4.17

package/dist/agents/summaryAgent.js

@@ -1,260 +0,0 @@
-import { getOpenAiConfig } 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';
-/**
- * Summary Agent Service
- *
- * Generates concise summaries for conversations after the first user-assistant exchange.
- * This service operates in the background without blocking the main conversation flow.
- *
- * Features:
- * - Uses basicModel for efficient, low-cost summarization
- * - Follows the same API routing as main flow (chat, responses, gemini, anthropic)
- * - Generates title (max 50 chars) and summary (max 150 chars)
- * - Only runs once after the first complete conversation exchange
- * - Silent execution with error handling to prevent main flow disruption
- */
-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) {
-                logger.warn('Summary agent: Basic model not configured, using advanced model as fallback');
-                // Fallback to advanced model if basic model is not configured
-                if (!config.advancedModel) {
-                    logger.warn('Summary agent: No model configured');
-                    return false;
-                }
-                this.modelName = config.advancedModel;
-            }
-            else {
-                this.modelName = config.basicModel;
-            }
-            this.requestMethod = config.requestMethod;
-            this.initialized = true;
-            return true;
-        }
-        catch (error) {
-            logger.warn('Summary agent: Failed to initialize:', error);
-            return false;
-        }
-    }
-    /**
-     * Check if summary agent is available
-     */
-    async isAvailable() {
-        if (!this.initialized) {
-            return await this.initialize();
-        }
-        return true;
-    }
-    /**
-     * Call the model with streaming API and assemble complete response
-     * Uses the same routing logic as main flow for consistency
-     *
-     * @param messages - Chat messages
-     * @param abortSignal - Optional abort signal to cancel the request
-     */
-    async callModel(messages, abortSignal) {
-        let streamGenerator;
-        // Route to appropriate streaming API based on request method
-        switch (this.requestMethod) {
-            case 'anthropic':
-                streamGenerator = createStreamingAnthropicCompletion({
-                    model: this.modelName,
-                    messages,
-                    max_tokens: 500, // Limited tokens for summary generation
-                    includeBuiltinSystemPrompt: false, // 不需要内置系统提示词
-                    disableThinking: true, // Agents 不使用 Extended Thinking
-                }, abortSignal);
-                break;
-            case 'gemini':
-                streamGenerator = createStreamingGeminiCompletion({
-                    model: this.modelName,
-                    messages,
-                    includeBuiltinSystemPrompt: false, // 不需要内置系统提示词
-                }, abortSignal);
-                break;
-            case 'responses':
-                streamGenerator = createStreamingResponse({
-                    model: this.modelName,
-                    messages,
-                    stream: true,
-                    includeBuiltinSystemPrompt: false, // 不需要内置系统提示词
-                }, abortSignal);
-                break;
-            case 'chat':
-            default:
-                streamGenerator = createStreamingChatCompletion({
-                    model: this.modelName,
-                    messages,
-                    stream: true,
-                    includeBuiltinSystemPrompt: false, // 不需要内置系统提示词
-                }, abortSignal);
-                break;
-        }
-        // Assemble complete content from streaming response
-        let completeContent = '';
-        try {
-            for await (const chunk of streamGenerator) {
-                // 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
-                    if (chunk.choices && chunk.choices[0]?.delta?.content) {
-                        completeContent += chunk.choices[0].delta.content;
-                    }
-                }
-                else {
-                    // Responses, Gemini, and Anthropic APIs use unified format
-                    if (chunk.type === 'content' && chunk.content) {
-                        completeContent += chunk.content;
-                    }
-                }
-            }
-        }
-        catch (streamError) {
-            logger.error('Summary agent: Streaming error:', streamError);
-            throw streamError;
-        }
-        return completeContent;
-    }
-    /**
-     * Generate title and summary for a conversation
-     *
-     * @param userMessage - User's first message content
-     * @param assistantMessage - Assistant's first response content
-     * @param abortSignal - Optional abort signal to cancel generation
-     * @returns Object containing title and summary, or null if generation fails
-     */
-    async generateSummary(userMessage, assistantMessage, abortSignal) {
-        const available = await this.isAvailable();
-        if (!available) {
-            logger.warn('Summary agent: Not available, using fallback summary');
-            return this.generateFallbackSummary(userMessage, assistantMessage);
-        }
-        try {
-            const summaryPrompt = `You are a conversation summarization assistant. Based on the first exchange between the user and AI assistant below, generate a concise title and summary.
-
-IMPORTANT: Generate the title and summary in the SAME LANGUAGE as the user's message. If the user writes in Chinese, respond in Chinese. If in English, respond in English.
-
-User message:
-${userMessage}
-
-AI assistant reply:
-${assistantMessage}
-
-Requirements:
-1. Generate a short title (max 50 characters) that captures the conversation topic
-2. Generate a summary (max 150 characters) that briefly describes the core content
-3. Title should be concise and clear, avoid complete sentences
-4. Summary should contain key information while staying brief
-5. Use the SAME LANGUAGE as the user's message
-
-Output in the following JSON format (JSON only, no other content):
-{
-  "title": "Conversation title",
-  "summary": "Conversation summary"
-}`;
-            const messages = [
-                {
-                    role: 'user',
-                    content: summaryPrompt,
-                },
-            ];
-            const response = await this.callModel(messages, abortSignal);
-            if (!response || response.trim().length === 0) {
-                logger.warn('Summary agent: Empty response, using fallback');
-                return this.generateFallbackSummary(userMessage, assistantMessage);
-            }
-            // Parse JSON response
-            try {
-                // Extract JSON from markdown code blocks if present
-                let jsonStr = response.trim();
-                const jsonMatch = jsonStr.match(/```(?:json)?\s*\n?([\s\S]*?)\n?```/);
-                if (jsonMatch) {
-                    jsonStr = jsonMatch[1].trim();
-                }
-                const parsed = JSON.parse(jsonStr);
-                if (!parsed.title || !parsed.summary) {
-                    logger.warn('Summary agent: Invalid JSON structure, using fallback');
-                    return this.generateFallbackSummary(userMessage, assistantMessage);
-                }
-                // Ensure title and summary are within length limits
-                const title = this.truncateString(parsed.title, 50);
-                const summary = this.truncateString(parsed.summary, 150);
-                logger.info('Summary agent: Successfully generated summary', {
-                    title,
-                    summary,
-                });
-                return { title, summary };
-            }
-            catch (parseError) {
-                logger.warn('Summary agent: Failed to parse JSON response, using fallback', parseError);
-                return this.generateFallbackSummary(userMessage, assistantMessage);
-            }
-        }
-        catch (error) {
-            logger.error('Summary agent: Failed to generate summary', error);
-            return this.generateFallbackSummary(userMessage, assistantMessage);
-        }
-    }
-    /**
-     * Generate fallback summary when AI generation fails
-     * Simply truncates the user message for title and summary
-     */
-    generateFallbackSummary(userMessage, _assistantMessage) {
-        // Clean newlines and extra spaces
-        const cleanedUser = userMessage
-            .replace(/[\r\n]+/g, ' ')
-            .replace(/\s+/g, ' ')
-            .trim();
-        // Use first 50 chars as title
-        const title = this.truncateString(cleanedUser, 50);
-        // Use first 150 chars as summary
-        const summary = this.truncateString(cleanedUser, 150);
-        return { title, summary };
-    }
-    /**
-     * Truncate string to specified length, adding ellipsis if truncated
-     */
-    truncateString(str, maxLength) {
-        if (str.length <= maxLength) {
-            return str;
-        }
-        return str.slice(0, maxLength - 3) + '...';
-    }
-}
-// Export singleton instance
-export const summaryAgent = new SummaryAgent();

package/dist/api/anthropic.d.ts

@@ -1,44 +0,0 @@
-import type { ChatMessage, ChatCompletionTool, UsageInfo } from './types.js';
-export interface AnthropicOptions {
-    model: string;
-    messages: ChatMessage[];
-    temperature?: number;
-    max_tokens?: number;
-    tools?: ChatCompletionTool[];
-    sessionId?: string;
-    includeBuiltinSystemPrompt?: boolean;
-    disableThinking?: boolean;
-}
-export interface AnthropicStreamChunk {
-    type: 'content' | 'tool_calls' | 'tool_call_delta' | 'done' | 'usage' | 'reasoning_started' | 'reasoning_delta';
-    content?: string;
-    tool_calls?: Array<{
-        id: string;
-        type: 'function';
-        function: {
-            name: string;
-            arguments: string;
-        };
-    }>;
-    delta?: string;
-    usage?: UsageInfo;
-    thinking?: {
-        type: 'thinking';
-        thinking: string;
-        signature?: string;
-    };
-}
-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;
-export declare function createStreamingAnthropicCompletion(options: AnthropicOptions, abortSignal?: AbortSignal, onRetry?: (error: Error, attempt: number, nextDelay: number) => void): AsyncGenerator<AnthropicStreamChunk, void, unknown>;