snow-ai 0.4.15 → 0.4.17

package/dist/agents/codebaseReviewAgent.js

@@ -1,301 +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';
-/**
- * Codebase Review Agent Service
- *
- * Reviews codebase search results to filter out irrelevant items.
- * Uses basicModel for efficient, low-cost relevance checking.
- * Can also suggest better search keywords if results are not relevant.
- */
-export class CodebaseReviewAgent {
-    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
-        });
-        Object.defineProperty(this, "MAX_RETRIES", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: 3
-        });
-    }
-    /**
-     * Initialize the review agent with current configuration
-     */
-    async initialize() {
-        try {
-            const config = getOpenAiConfig();
-            if (!config.basicModel) {
-                logger.warn('Codebase review agent: Basic model not configured, using advanced model as fallback');
-                if (!config.advancedModel) {
-                    logger.warn('Codebase review 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('Codebase review agent: Failed to initialize:', error);
-            return false;
-        }
-    }
-    /**
-     * Check if review agent is available
-     */
-    async isAvailable() {
-        if (!this.initialized) {
-            return await this.initialize();
-        }
-        return true;
-    }
-    /**
-     * Call the model with streaming API and assemble complete response
-     */
-    async callModel(messages, abortSignal) {
-        let streamGenerator;
-        switch (this.requestMethod) {
-            case 'anthropic':
-                streamGenerator = createStreamingAnthropicCompletion({
-                    model: this.modelName,
-                    messages,
-                    includeBuiltinSystemPrompt: false,
-                    disableThinking: true,
-                }, 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;
-        }
-        let completeContent = '';
-        try {
-            for await (const chunk of streamGenerator) {
-                if (abortSignal?.aborted) {
-                    throw new Error('Request aborted');
-                }
-                if (this.requestMethod === 'chat') {
-                    if (chunk.choices && chunk.choices[0]?.delta?.content) {
-                        completeContent += chunk.choices[0].delta.content;
-                    }
-                }
-                else {
-                    if (chunk.type === 'content' && chunk.content) {
-                        completeContent += chunk.content;
-                    }
-                }
-            }
-        }
-        catch (streamError) {
-            logger.error('Codebase review agent: Streaming error:', streamError);
-            throw streamError;
-        }
-        return completeContent;
-    }
-    /**
-     * Try to parse JSON response with retry logic
-     */
-    tryParseJSON(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);
-            // Validate structure
-            if (!Array.isArray(parsed.relevantIndices)) {
-                logger.warn('Codebase review agent: Invalid JSON structure - missing relevantIndices array');
-                return null;
-            }
-            return parsed;
-        }
-        catch (error) {
-            logger.warn('Codebase review agent: JSON parse error:', error);
-            return null;
-        }
-    }
-    /**
-     * Review search results with retry mechanism
-     */
-    async reviewWithRetry(query, results, abortSignal) {
-        const reviewPrompt = `You are a code search result reviewer. Your task is to analyze search results and determine which ones are truly relevant to the user's query.
-
-Search Query: "${query}"
-
-Search Results (${results.length} items):
-${results
-            .map((r, idx) => `\n[Result ${idx + 1}]
-File: ${r.filePath}
-Lines: ${r.startLine}-${r.endLine}
-Similarity Score: ${r.similarityScore}%
-Code:
-\`\`\`
-${r.content}
-\`\`\``)
-            .join('\n---')}
-
-Your Tasks:
-1. Identify which results are RELEVANT to the search query
-2. Mark irrelevant results for removal
-3. If most results are irrelevant, suggest better search keywords
-
-Output in JSON format:
-{
-  "relevantIndices": [1, 3, 5],
-  "removedIndices": [2, 4],
-  "suggestions": ["keyword1", "keyword2"]
-}
-
-Guidelines:
-- Be strict but fair: code doesn't need to match exactly, but should be semantically related
-- Consider file paths, code content, and context
-- If a result is marginally relevant, keep it
-- Only suggest new keywords if >50% of results are irrelevant
-- Return ONLY valid JSON, no other text or explanation`;
-        const messages = [
-            {
-                role: 'user',
-                content: reviewPrompt,
-            },
-        ];
-        // Retry loop
-        for (let attempt = 1; attempt <= this.MAX_RETRIES; attempt++) {
-            try {
-                logger.info(`Codebase review agent: Attempt ${attempt}/${this.MAX_RETRIES}`);
-                const response = await this.callModel(messages, abortSignal);
-                if (!response || response.trim().length === 0) {
-                    logger.warn(`Codebase review agent: Empty response on attempt ${attempt}`);
-                    if (attempt < this.MAX_RETRIES) {
-                        await this.sleep(500 * attempt); // Exponential backoff
-                        continue;
-                    }
-                    return null;
-                }
-                // Try to parse JSON
-                const parsed = this.tryParseJSON(response);
-                if (parsed) {
-                    logger.info(`Codebase review agent: Successfully parsed on attempt ${attempt}`);
-                    return { parsed, attempt };
-                }
-                // If parse failed and we have retries left
-                if (attempt < this.MAX_RETRIES) {
-                    logger.warn(`Codebase review agent: Parse failed on attempt ${attempt}, retrying...`);
-                    await this.sleep(500 * attempt); // Exponential backoff
-                    continue;
-                }
-                return null;
-            }
-            catch (error) {
-                logger.error(`Codebase review agent: Error on attempt ${attempt}:`, error);
-                if (attempt < this.MAX_RETRIES) {
-                    await this.sleep(500 * attempt); // Exponential backoff
-                    continue;
-                }
-                return null;
-            }
-        }
-        return null;
-    }
-    /**
-     * Sleep utility for retry backoff
-     */
-    sleep(ms) {
-        return new Promise(resolve => setTimeout(resolve, ms));
-    }
-    /**
-     * Review search results and filter out irrelevant ones
-     * With retry mechanism and graceful degradation
-     *
-     * @param query - Original search query
-     * @param results - Search results to review
-     * @param abortSignal - Optional abort signal
-     * @returns Object with filtered results and optional suggestions
-     */
-    async reviewResults(query, results, abortSignal) {
-        const available = await this.isAvailable();
-        if (!available) {
-            logger.warn('Codebase review agent: Not available, returning original results');
-            return {
-                filteredResults: results,
-                removedCount: 0,
-                reviewFailed: true,
-            };
-        }
-        // Attempt review with retry
-        const reviewResult = await this.reviewWithRetry(query, results, abortSignal);
-        // If all retries failed, gracefully degrade
-        if (!reviewResult) {
-            logger.warn('Codebase review agent: All retry attempts failed, returning original results');
-            return {
-                filteredResults: results,
-                removedCount: 0,
-                reviewFailed: true,
-            };
-        }
-        // Success - filter results
-        const { parsed, attempt } = reviewResult;
-        const filteredResults = results.filter((_, idx) => parsed.relevantIndices.includes(idx + 1));
-        const removedCount = results.length - filteredResults.length;
-        logger.info('Codebase review agent: Review completed', {
-            originalCount: results.length,
-            filteredCount: filteredResults.length,
-            removedCount,
-            attempts: attempt,
-            hasSuggestions: !!parsed.suggestions?.length,
-        });
-        return {
-            filteredResults,
-            removedCount,
-            suggestions: parsed.suggestions || undefined,
-            reviewFailed: false,
-        };
-    }
-}
-// Export singleton instance
-export const codebaseReviewAgent = new CodebaseReviewAgent();

package/dist/agents/compactAgent.d.ts

@@ -1,55 +0,0 @@
-/**
- * Compact Agent Service
- *
- * Provides lightweight AI agent capabilities using the basic model.
- * This service operates independently from the main conversation flow
- * but follows the EXACT same configuration and routing as the main flow:
- * - API endpoint (baseUrl)
- * - Authentication (apiKey)
- * - Custom headers
- * - Request method (chat, responses, gemini, anthropic)
- * - Uses basicModel instead of advancedModel
- *
- * All requests go through streaming APIs and are intercepted to assemble
- * the complete response, ensuring complete consistency with main flow.
- *
- * Use cases:
- * - Content preprocessing for web pages
- * - Information extraction from large documents
- * - Quick analysis tasks that don't require the main model
- */
-export declare class CompactAgent {
-    private modelName;
-    private requestMethod;
-    private initialized;
-    /**
-     * Initialize the compact agent with current configuration
-     * @returns true if initialized successfully, false otherwise
-     */
-    private initialize;
-    /**
-     * Check if compact agent is available
-     */
-    isAvailable(): Promise<boolean>;
-    /**
-     * Call the compact 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
-     * @param onTokenUpdate - Optional callback to update token count during streaming
-     */
-    private callCompactModel;
-    /**
-     * Extract key information from web page content based on user query
-     *
-     * @param content - Full web page content
-     * @param userQuery - User's original question/query
-     * @param url - URL of the web page (for context)
-     * @param abortSignal - Optional abort signal to cancel extraction
-     * @param onTokenUpdate - Optional callback to update token count during streaming
-     * @returns Extracted key information relevant to the query
-     */
-    extractWebPageContent(content: string, userQuery: string, url: string, abortSignal?: AbortSignal, onTokenUpdate?: (tokenCount: number) => void): Promise<string>;
-}
-export declare const compactAgent: CompactAgent;

package/dist/agents/compactAgent.js

@@ -1,306 +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';
-/**
- * Compact Agent Service
- *
- * Provides lightweight AI agent capabilities using the basic model.
- * This service operates independently from the main conversation flow
- * but follows the EXACT same configuration and routing as the main flow:
- * - API endpoint (baseUrl)
- * - Authentication (apiKey)
- * - Custom headers
- * - Request method (chat, responses, gemini, anthropic)
- * - Uses basicModel instead of advancedModel
- *
- * All requests go through streaming APIs and are intercepted to assemble
- * the complete response, ensuring complete consistency with main flow.
- *
- * Use cases:
- * - Content preprocessing for web pages
- * - Information extraction from large documents
- * - Quick analysis tasks that don't require the main model
- */
-export class CompactAgent {
-    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 compact 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 compact agent:', error);
-            return false;
-        }
-    }
-    /**
-     * Check if compact agent is available
-     */
-    async isAvailable() {
-        if (!this.initialized) {
-            return await this.initialize();
-        }
-        return true;
-    }
-    /**
-     * Call the compact 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
-     * @param onTokenUpdate - Optional callback to update token count during streaming
-     */
-    async callCompactModel(messages, abortSignal, onTokenUpdate) {
-        const config = getOpenAiConfig();
-        if (!config.basicModel) {
-            throw new Error('Basic model not configured');
-        }
-        // 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,
-                        max_tokens: 4096,
-                        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;
-            }
-            // Intercept streaming response and assemble complete content
-            let completeContent = '';
-            let chunkCount = 0;
-            // Initialize token encoder for token counting
-            let encoder;
-            try {
-                const { encoding_for_model } = await import('tiktoken');
-                encoder = encoding_for_model('gpt-5');
-            }
-            catch (e) {
-                const { encoding_for_model } = await import('tiktoken');
-                encoder = encoding_for_model('gpt-5');
-            }
-            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;
-                            // Update token count if callback provided
-                            if (onTokenUpdate && encoder) {
-                                try {
-                                    const tokens = encoder.encode(completeContent);
-                                    onTokenUpdate(tokens.length);
-                                }
-                                catch (e) {
-                                    // Ignore encoding errors
-                                }
-                            }
-                        }
-                    }
-                    else {
-                        // Responses, Gemini, and Anthropic APIs all use: {type: 'content', content: string}
-                        if (chunk.type === 'content' && chunk.content) {
-                            completeContent += chunk.content;
-                            // Update token count if callback provided
-                            if (onTokenUpdate && encoder) {
-                                try {
-                                    const tokens = encoder.encode(completeContent);
-                                    onTokenUpdate(tokens.length);
-                                }
-                                catch (e) {
-                                    // Ignore encoding errors
-                                }
-                            }
-                        }
-                    }
-                }
-            }
-            catch (streamError) {
-                // Log streaming error with details
-                if (streamError instanceof Error) {
-                    logger.error('Compact agent: Streaming error:', {
-                        error: streamError.message,
-                        stack: streamError.stack,
-                        name: streamError.name,
-                        chunkCount,
-                        contentLength: completeContent.length,
-                    });
-                }
-                else {
-                    logger.error('Compact agent: Unknown streaming error:', {
-                        error: streamError,
-                        chunkCount,
-                        contentLength: completeContent.length,
-                    });
-                }
-                throw streamError;
-            }
-            finally {
-                // Free encoder
-                if (encoder) {
-                    encoder.free();
-                }
-            }
-            return completeContent;
-        }
-        catch (error) {
-            // Log detailed error from API call setup or streaming
-            if (error instanceof Error) {
-                logger.error('Compact agent: API call failed:', {
-                    error: error.message,
-                    stack: error.stack,
-                    name: error.name,
-                    requestMethod: this.requestMethod,
-                    modelName: this.modelName,
-                });
-            }
-            else {
-                logger.error('Compact agent: Unknown API error:', {
-                    error,
-                    requestMethod: this.requestMethod,
-                    modelName: this.modelName,
-                });
-            }
-            throw error;
-        }
-        finally {
-            // Restore original config
-            config.advancedModel = originalAdvancedModel;
-        }
-    }
-    /**
-     * Extract key information from web page content based on user query
-     *
-     * @param content - Full web page content
-     * @param userQuery - User's original question/query
-     * @param url - URL of the web page (for context)
-     * @param abortSignal - Optional abort signal to cancel extraction
-     * @param onTokenUpdate - Optional callback to update token count during streaming
-     * @returns Extracted key information relevant to the query
-     */
-    async extractWebPageContent(content, userQuery, url, abortSignal, onTokenUpdate) {
-        const available = await this.isAvailable();
-        if (!available) {
-            // If compact agent is not available, return original content
-            return content;
-        }
-        try {
-            const extractionPrompt = `You are a content extraction assistant. Your task is to extract and summarize the most relevant information from a web page based on the user's query.
-
-User's Query: ${userQuery}
-
-Web Page URL: ${url}
-
-Web Page Content:
-${content}
-
-Instructions:
-1. Extract ONLY the information that is directly relevant to the user's query
-2. Preserve important details, facts, code examples, and key points
-3. Remove navigation, ads, irrelevant sections, and boilerplate text
-4. Organize the information in a clear, structured format
-5. If there are multiple relevant sections, separate them clearly
-6. Keep technical terms and specific details intact
-
-Provide the extracted content below:`;
-            const messages = [
-                {
-                    role: 'user',
-                    content: extractionPrompt,
-                },
-            ];
-            const extractedContent = await this.callCompactModel(messages, abortSignal, onTokenUpdate);
-            if (!extractedContent || extractedContent.trim().length === 0) {
-                logger.warn('Compact agent returned empty response, using original content');
-                return content;
-            }
-            return extractedContent;
-        }
-        catch (error) {
-            // Log detailed error information
-            if (error instanceof Error) {
-                logger.warn('Compact agent extraction failed, using original content:', {
-                    error: error.message,
-                    stack: error.stack,
-                    name: error.name,
-                });
-            }
-            else {
-                logger.warn('Compact agent extraction failed with unknown error:', error);
-            }
-            return content;
-        }
-    }
-}
-// Export singleton instance
-export const compactAgent = new CompactAgent();