snow-ai 0.2.24 → 0.2.25

package/dist/utils/contextCompressor.js

@@ -1,5 +1,342 @@
 import OpenAI from 'openai';
-import { getOpenAiConfig } from './apiConfig.js';
+import { GoogleGenAI } from '@google/genai';
+import Anthropic from '@anthropic-ai/sdk';
+import { getOpenAiConfig, getCustomHeaders, getCustomSystemPrompt } from './apiConfig.js';
+import { SYSTEM_PROMPT } from '../api/systemPrompt.js';
+/**
+ * Compression request prompt - asks AI to summarize conversation with focus on task continuity
+ */
+const COMPRESSION_PROMPT = 'Please provide a concise summary of our conversation so far. Focus on: 1) The current task or goal we are working on, 2) Key decisions and approaches we have agreed upon, 3) Important context needed to continue, 4) Any pending or unfinished work. Keep it brief but ensure I can seamlessly continue assisting with the task.';
+/**
+ * Compress context using OpenAI Chat Completions API
+ */
+async function compressWithChatCompletions(baseUrl, apiKey, modelName, conversationMessages, systemPrompt) {
+    const client = new OpenAI({
+        apiKey,
+        baseURL: baseUrl,
+    });
+    const customHeaders = getCustomHeaders();
+    // Build messages with system prompt support
+    const messages = [];
+    if (systemPrompt) {
+        // If custom system prompt exists: custom as system, default as first user message
+        messages.push({ role: 'system', content: systemPrompt });
+        messages.push({ role: 'user', content: SYSTEM_PROMPT });
+    }
+    else {
+        // No custom system prompt: default as system
+        messages.push({ role: 'system', content: SYSTEM_PROMPT });
+    }
+    // Add all conversation history (exclude system messages)
+    for (const msg of conversationMessages) {
+        if (msg.role !== 'system' && msg.role !== 'tool') {
+            messages.push({
+                role: msg.role,
+                content: msg.content,
+            });
+        }
+    }
+    // Add compression request as final user message
+    messages.push({
+        role: 'user',
+        content: COMPRESSION_PROMPT,
+    });
+    // Build request payload (no tools for compression)
+    const requestPayload = {
+        model: modelName,
+        messages,
+        stream: true,
+        stream_options: { include_usage: true },
+    };
+    // Log request payload
+    console.log('[ContextCompressor] Chat Completions Request:', JSON.stringify(requestPayload, null, 2));
+    // Use streaming to avoid timeout
+    const stream = (await client.chat.completions.create(requestPayload, {
+        headers: customHeaders,
+    }));
+    let summary = '';
+    let usage = {
+        prompt_tokens: 0,
+        completion_tokens: 0,
+        total_tokens: 0,
+    };
+    for await (const chunk of stream) {
+        const delta = chunk.choices[0]?.delta;
+        if (delta?.content) {
+            summary += delta.content;
+        }
+        // Collect usage info (usually in the last chunk)
+        if (chunk.usage) {
+            usage = {
+                prompt_tokens: chunk.usage.prompt_tokens || 0,
+                completion_tokens: chunk.usage.completion_tokens || 0,
+                total_tokens: chunk.usage.total_tokens || 0,
+            };
+        }
+    }
+    if (!summary) {
+        throw new Error('Failed to generate summary from compact model');
+    }
+    return {
+        summary,
+        usage,
+    };
+}
+/**
+ * Compress context using OpenAI Responses API
+ */
+async function compressWithResponses(baseUrl, apiKey, modelName, conversationMessages, systemPrompt) {
+    const client = new OpenAI({
+        apiKey,
+        baseURL: baseUrl,
+    });
+    const customHeaders = getCustomHeaders();
+    // Build instructions
+    const instructions = systemPrompt || SYSTEM_PROMPT;
+    // Build input array with conversation history
+    const input = [];
+    // If custom system prompt exists, add default as first user message
+    if (systemPrompt) {
+        input.push({
+            type: 'message',
+            role: 'user',
+            content: [{ type: 'input_text', text: SYSTEM_PROMPT }],
+        });
+    }
+    // Add all conversation history (exclude system messages)
+    for (const msg of conversationMessages) {
+        if (msg.role !== 'system' && msg.role !== 'tool') {
+            input.push({
+                type: 'message',
+                role: msg.role,
+                content: [{
+                        type: msg.role === 'user' ? 'input_text' : 'output_text',
+                        text: msg.content,
+                    }],
+            });
+        }
+    }
+    // Add compression request as final user message
+    input.push({
+        type: 'message',
+        role: 'user',
+        content: [{
+                type: 'input_text',
+                text: COMPRESSION_PROMPT,
+            }],
+    });
+    // Build request payload (no tools for compression)
+    const requestPayload = {
+        model: modelName,
+        instructions,
+        input,
+        stream: true,
+    };
+    // Log request payload
+    console.log('[ContextCompressor] Responses API Request:', JSON.stringify(requestPayload, null, 2));
+    // Use streaming to avoid timeout
+    const stream = await client.responses.create(requestPayload, {
+        headers: customHeaders,
+    });
+    let summary = '';
+    let usage = {
+        prompt_tokens: 0,
+        completion_tokens: 0,
+        total_tokens: 0,
+    };
+    for await (const chunk of stream) {
+        const eventType = chunk.type;
+        // Handle text content delta
+        if (eventType === 'response.output_text.delta') {
+            const delta = chunk.delta;
+            if (delta) {
+                summary += delta;
+            }
+        }
+        // Handle usage info
+        if (eventType === 'response.done') {
+            const response = chunk.response;
+            if (response?.usage) {
+                usage = {
+                    prompt_tokens: response.usage.input_tokens || 0,
+                    completion_tokens: response.usage.output_tokens || 0,
+                    total_tokens: (response.usage.input_tokens || 0) + (response.usage.output_tokens || 0),
+                };
+            }
+        }
+    }
+    if (!summary) {
+        throw new Error('Failed to generate summary from compact model (Responses API)');
+    }
+    return {
+        summary,
+        usage,
+    };
+}
+/**
+ * Compress context using Gemini API
+ */
+async function compressWithGemini(baseUrl, apiKey, modelName, conversationMessages, systemPrompt) {
+    const clientConfig = {
+        apiKey,
+    };
+    const customHeaders = getCustomHeaders();
+    // Support custom baseUrl and headers for proxy servers
+    if (baseUrl && baseUrl !== 'https://api.openai.com/v1') {
+        clientConfig.httpOptions = {
+            baseUrl,
+            headers: {
+                'x-goog-api-key': apiKey,
+                ...customHeaders,
+            },
+        };
+    }
+    else if (Object.keys(customHeaders).length > 0) {
+        clientConfig.httpOptions = {
+            headers: customHeaders,
+        };
+    }
+    const client = new GoogleGenAI(clientConfig);
+    // Build system instruction
+    const systemInstruction = systemPrompt || SYSTEM_PROMPT;
+    // Build contents array with conversation history
+    const contents = [];
+    // If custom system prompt exists, add default as first user message
+    if (systemPrompt) {
+        contents.push({
+            role: 'user',
+            parts: [{ text: SYSTEM_PROMPT }],
+        });
+    }
+    // Add all conversation history (exclude system messages)
+    for (const msg of conversationMessages) {
+        if (msg.role !== 'system' && msg.role !== 'tool') {
+            contents.push({
+                role: msg.role === 'assistant' ? 'model' : 'user',
+                parts: [{ text: msg.content }],
+            });
+        }
+    }
+    // Add compression request as final user message
+    contents.push({
+        role: 'user',
+        parts: [{
+                text: COMPRESSION_PROMPT,
+            }],
+    });
+    const requestConfig = {
+        model: modelName,
+        systemInstruction,
+        contents,
+    };
+    // Log request payload
+    console.log('[ContextCompressor] Gemini Request:', JSON.stringify(requestConfig, null, 2));
+    // Use streaming to avoid timeout
+    const stream = await client.models.generateContentStream(requestConfig);
+    let summary = '';
+    let usage = {
+        prompt_tokens: 0,
+        completion_tokens: 0,
+        total_tokens: 0,
+    };
+    for await (const chunk of stream) {
+        if (chunk.text) {
+            summary += chunk.text;
+        }
+        // Collect usage info
+        if (chunk.usageMetadata) {
+            usage = {
+                prompt_tokens: chunk.usageMetadata.promptTokenCount || 0,
+                completion_tokens: chunk.usageMetadata.candidatesTokenCount || 0,
+                total_tokens: chunk.usageMetadata.totalTokenCount || 0,
+            };
+        }
+    }
+    if (!summary) {
+        throw new Error('Failed to generate summary from Gemini model');
+    }
+    return {
+        summary,
+        usage,
+    };
+}
+/**
+ * Compress context using Anthropic API
+ */
+async function compressWithAnthropic(baseUrl, apiKey, modelName, conversationMessages, systemPrompt) {
+    const clientConfig = {
+        apiKey,
+    };
+    if (baseUrl && baseUrl !== 'https://api.openai.com/v1') {
+        clientConfig.baseURL = baseUrl;
+    }
+    const customHeaders = getCustomHeaders();
+    clientConfig.defaultHeaders = {
+        'Authorization': `Bearer ${apiKey}`,
+        ...customHeaders,
+    };
+    const client = new Anthropic(clientConfig);
+    // Build messages array with conversation history
+    const messages = [];
+    // If custom system prompt exists, add default as first user message
+    if (systemPrompt) {
+        messages.push({ role: 'user', content: SYSTEM_PROMPT });
+    }
+    // Add all conversation history (exclude system messages)
+    for (const msg of conversationMessages) {
+        if (msg.role !== 'system' && msg.role !== 'tool') {
+            messages.push({
+                role: msg.role,
+                content: msg.content,
+            });
+        }
+    }
+    // Add compression request as final user message
+    messages.push({
+        role: 'user',
+        content: COMPRESSION_PROMPT,
+    });
+    // Anthropic uses system parameter separately
+    const systemParam = systemPrompt || SYSTEM_PROMPT;
+    // Build request payload (no tools for compression)
+    const requestPayload = {
+        model: modelName,
+        max_tokens: 4096,
+        system: systemParam,
+        messages,
+    };
+    // Log request payload
+    console.log('[ContextCompressor] Anthropic Request:', JSON.stringify(requestPayload, null, 2));
+    // Use streaming to avoid timeout
+    const stream = await client.messages.stream(requestPayload);
+    let summary = '';
+    let usage = {
+        prompt_tokens: 0,
+        completion_tokens: 0,
+        total_tokens: 0,
+    };
+    for await (const event of stream) {
+        if (event.type === 'content_block_delta' && event.delta.type === 'text_delta') {
+            summary += event.delta.text;
+        }
+        // Collect usage info from message_stop event
+        if (event.type === 'message_stop') {
+            const finalMessage = await stream.finalMessage();
+            usage = {
+                prompt_tokens: finalMessage.usage.input_tokens,
+                completion_tokens: finalMessage.usage.output_tokens,
+                total_tokens: finalMessage.usage.input_tokens + finalMessage.usage.output_tokens,
+            };
+        }
+    }
+    if (!summary) {
+        throw new Error('Failed to generate summary from Anthropic model');
+    }
+    return {
+        summary,
+        usage,
+    };
+}
 /**
  * Compress conversation history using the compact model
  * @param messages - Array of messages to compress
@@ -8,57 +345,34 @@ import { getOpenAiConfig } from './apiConfig.js';
 export async function compressContext(messages) {
     const config = getOpenAiConfig();
     // Check if compact model is configured
-    if (!config.compactModel || !config.compactModel.baseUrl || !config.compactModel.apiKey || !config.compactModel.modelName) {
-        throw new Error('Compact model not configured. Please configure it in Model Settings.');
+    if (!config.compactModel || !config.compactModel.modelName) {
+        throw new Error('Compact model not configured. Please configure it in API & Model Settings.');
     }
-    // Create OpenAI client with compact model config
-    const client = new OpenAI({
-        apiKey: config.compactModel.apiKey,
-        baseURL: config.compactModel.baseUrl,
-    });
-    // Filter out system messages and create a conversation text
-    const conversationText = messages
-        .filter(msg => msg.role !== 'system')
-        .map(msg => {
-        const role = msg.role === 'user' ? 'User' : msg.role === 'assistant' ? 'Assistant' : 'Tool';
-        return `${role}: ${msg.content}`;
-    })
-        .join('\n\n');
-    // Create compression prompt
-    const compressionPrompt = `Please summarize the following conversation history in a concise way, preserving all important context, decisions, and key information. The summary should be detailed enough to continue the conversation seamlessly.
-
-Conversation:
-${conversationText}
-
-Summary:`;
+    // Use shared API credentials
+    const baseUrl = config.baseUrl;
+    const apiKey = config.apiKey;
+    const modelName = config.compactModel.modelName;
+    const requestMethod = config.requestMethod;
+    if (!baseUrl || !apiKey) {
+        throw new Error('API configuration incomplete. Please configure Base URL and API Key.');
+    }
+    // Get custom system prompt if configured
+    const customSystemPrompt = getCustomSystemPrompt();
     try {
-        const response = await client.chat.completions.create({
-            model: config.compactModel.modelName,
-            messages: [
-                {
-                    role: 'user',
-                    content: compressionPrompt,
-                },
-            ]
-        });
-        const summary = response.choices[0]?.message?.content;
-        if (!summary) {
-            throw new Error('Failed to generate summary from compact model');
+        // Choose compression method based on request method
+        switch (requestMethod) {
+            case 'gemini':
+                return await compressWithGemini(baseUrl, apiKey, modelName, messages, customSystemPrompt || null);
+            case 'anthropic':
+                return await compressWithAnthropic(baseUrl, apiKey, modelName, messages, customSystemPrompt || null);
+            case 'responses':
+                // OpenAI Responses API
+                return await compressWithResponses(baseUrl, apiKey, modelName, messages, customSystemPrompt || null);
+            case 'chat':
+            default:
+                // OpenAI Chat Completions API
+                return await compressWithChatCompletions(baseUrl, apiKey, modelName, messages, customSystemPrompt || null);
         }
-        // Extract usage information
-        const usage = response.usage || {
-            prompt_tokens: 0,
-            completion_tokens: 0,
-            total_tokens: 0
-        };
-        return {
-            summary,
-            usage: {
-                prompt_tokens: usage.prompt_tokens,
-                completion_tokens: usage.completion_tokens,
-                total_tokens: usage.total_tokens
-            }
-        };
     }
     catch (error) {
         if (error instanceof Error) {

package/dist/utils/retryUtils.js

@@ -64,6 +64,12 @@ function isRetriableError(error) {
         errorMessage.includes('unavailable')) {
         return true;
     }
+    // Connection terminated by server
+    if (errorMessage.includes('terminated') ||
+        errorMessage.includes('connection reset') ||
+        errorMessage.includes('socket hang up')) {
+        return true;
+    }
     return false;
 }
 /**

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "snow-ai",
-	"version": "0.2.24",
+	"version": "0.2.25",
 	"description": "Intelligent Command Line Assistant powered by AI",
 	"license": "MIT",
 	"bin": {

package/dist/ui/pages/ApiConfigScreen.js

@@ -1,161 +0,0 @@
-import React, { useState, useEffect } from 'react';
-import { Box, Text, useInput } from 'ink';
-import Gradient from 'ink-gradient';
-import { Select, Alert } from '@inkjs/ui';
-import TextInput from 'ink-text-input';
-import { getOpenAiConfig, updateOpenAiConfig, validateApiConfig, } from '../../utils/apiConfig.js';
-export default function ApiConfigScreen({ onBack, onSave, inlineMode = false }) {
-    const [baseUrl, setBaseUrl] = useState('');
-    const [apiKey, setApiKey] = useState('');
-    const [requestMethod, setRequestMethod] = useState('chat');
-    const [anthropicBeta, setAnthropicBeta] = useState(false);
-    const [currentField, setCurrentField] = useState('baseUrl');
-    const [errors, setErrors] = useState([]);
-    const [isEditing, setIsEditing] = useState(false);
-    const requestMethodOptions = [
-        {
-            label: 'Chat Completions - Modern chat API (GPT-4, GPT-3.5-turbo)',
-            value: 'chat',
-        },
-        {
-            label: 'Responses - New responses API (2025, with built-in tools)',
-            value: 'responses',
-        },
-        {
-            label: 'Gemini - Google Gemini API',
-            value: 'gemini',
-        },
-        {
-            label: 'Anthropic - Claude API',
-            value: 'anthropic',
-        },
-    ];
-    useEffect(() => {
-        const config = getOpenAiConfig();
-        setBaseUrl(config.baseUrl);
-        setApiKey(config.apiKey);
-        setRequestMethod(config.requestMethod || 'chat');
-        setAnthropicBeta(config.anthropicBeta || false);
-    }, []);
-    useInput((input, key) => {
-        // Allow Escape key to exit Select component without changes
-        if (isEditing && currentField === 'requestMethod' && key.escape) {
-            setIsEditing(false);
-            return;
-        }
-        // Don't handle other input when Select component is active
-        if (isEditing && currentField === 'requestMethod') {
-            return;
-        }
-        // Handle save/exit globally
-        if (input === 's' && (key.ctrl || key.meta)) {
-            const validationErrors = validateApiConfig({ baseUrl, apiKey, requestMethod });
-            if (validationErrors.length === 0) {
-                updateOpenAiConfig({ baseUrl, apiKey, requestMethod, anthropicBeta });
-                setErrors([]);
-                onSave();
-            }
-            else {
-                setErrors(validationErrors);
-            }
-        }
-        else if (key.escape) {
-            const validationErrors = validateApiConfig({ baseUrl, apiKey, requestMethod });
-            if (validationErrors.length === 0) {
-                updateOpenAiConfig({ baseUrl, apiKey, requestMethod, anthropicBeta });
-                setErrors([]);
-            }
-            onBack();
-        }
-        else if (key.return) {
-            if (isEditing) {
-                // Exit edit mode, return to navigation
-                setIsEditing(false);
-            }
-            else {
-                // Enter edit mode for current field (toggle for checkbox)
-                if (currentField === 'anthropicBeta') {
-                    setAnthropicBeta(!anthropicBeta);
-                }
-                else {
-                    setIsEditing(true);
-                }
-            }
-        }
-        else if (!isEditing && key.upArrow) {
-            if (currentField === 'apiKey') {
-                setCurrentField('baseUrl');
-            }
-            else if (currentField === 'requestMethod') {
-                setCurrentField('apiKey');
-            }
-            else if (currentField === 'anthropicBeta') {
-                setCurrentField('requestMethod');
-            }
-        }
-        else if (!isEditing && key.downArrow) {
-            if (currentField === 'baseUrl') {
-                setCurrentField('apiKey');
-            }
-            else if (currentField === 'apiKey') {
-                setCurrentField('requestMethod');
-            }
-            else if (currentField === 'requestMethod') {
-                setCurrentField('anthropicBeta');
-            }
-        }
-    });
-    return (React.createElement(Box, { flexDirection: "column", padding: 1 },
-        !inlineMode && (React.createElement(Box, { marginBottom: 2, borderStyle: "double", borderColor: "cyan", paddingX: 2, paddingY: 1 },
-            React.createElement(Box, { flexDirection: "column" },
-                React.createElement(Gradient, { name: "rainbow" }, "OpenAI API Configuration"),
-                React.createElement(Text, { color: "gray", dimColor: true }, "Configure your OpenAI API settings")))),
-        React.createElement(Box, { flexDirection: "column", marginBottom: 2 },
-            React.createElement(Box, { marginBottom: 1 },
-                React.createElement(Box, { flexDirection: "column" },
-                    React.createElement(Text, { color: currentField === 'baseUrl' ? 'green' : 'white' },
-                        currentField === 'baseUrl' ? '❯ ' : '  ',
-                        "Base URL:"),
-                    currentField === 'baseUrl' && isEditing && (React.createElement(Box, { marginLeft: 3 },
-                        React.createElement(TextInput, { value: baseUrl, onChange: setBaseUrl, placeholder: "https://api.openai.com/v1" }))),
-                    (!isEditing || currentField !== 'baseUrl') && (React.createElement(Box, { marginLeft: 3 },
-                        React.createElement(Text, { color: "gray" }, baseUrl || 'Not set'))))),
-            React.createElement(Box, { marginBottom: 1 },
-                React.createElement(Box, { flexDirection: "column" },
-                    React.createElement(Text, { color: currentField === 'apiKey' ? 'green' : 'white' },
-                        currentField === 'apiKey' ? '❯ ' : '  ',
-                        "API Key:"),
-                    currentField === 'apiKey' && isEditing && (React.createElement(Box, { marginLeft: 3 },
-                        React.createElement(TextInput, { value: apiKey, onChange: setApiKey, placeholder: "sk-...", mask: "*" }))),
-                    (!isEditing || currentField !== 'apiKey') && (React.createElement(Box, { marginLeft: 3 },
-                        React.createElement(Text, { color: "gray" }, apiKey ? '*'.repeat(Math.min(apiKey.length, 20)) : 'Not set'))))),
-            React.createElement(Box, { marginBottom: 1 },
-                React.createElement(Box, { flexDirection: "column" },
-                    React.createElement(Text, { color: currentField === 'requestMethod' ? 'green' : 'white' },
-                        currentField === 'requestMethod' ? '❯ ' : '  ',
-                        "Request Method:"),
-                    currentField === 'requestMethod' && isEditing && (React.createElement(Box, { marginLeft: 3 },
-                        React.createElement(Select, { options: requestMethodOptions, defaultValue: requestMethod, onChange: (value) => {
-                                setRequestMethod(value);
-                                setIsEditing(false); // Auto exit edit mode after selection
-                            } }))),
-                    (!isEditing || currentField !== 'requestMethod') && (React.createElement(Box, { marginLeft: 3 },
-                        React.createElement(Text, { color: "gray" }, requestMethodOptions.find(opt => opt.value === requestMethod)?.label || 'Not set'))))),
-            React.createElement(Box, { marginBottom: 1 },
-                React.createElement(Box, { flexDirection: "column" },
-                    React.createElement(Text, { color: currentField === 'anthropicBeta' ? 'green' : 'white' },
-                        currentField === 'anthropicBeta' ? '❯ ' : '  ',
-                        "Anthropic Beta (for Claude API):"),
-                    React.createElement(Box, { marginLeft: 3 },
-                        React.createElement(Text, { color: "gray" },
-                            anthropicBeta ? '☑ Enabled' : '☐ Disabled',
-                            " (Press Enter to toggle)"))))),
-        errors.length > 0 && (React.createElement(Box, { flexDirection: "column", marginBottom: 2 },
-            React.createElement(Text, { color: "red", bold: true }, "Errors:"),
-            errors.map((error, index) => (React.createElement(Text, { key: index, color: "red" },
-                "\u2022 ",
-                error))))),
-        React.createElement(Box, { flexDirection: "column" }, isEditing ? (React.createElement(React.Fragment, null,
-            React.createElement(Alert, { variant: "info" }, "Editing mode: Press Enter to save and exit editing (Make your changes and press Enter when done)"))) : (React.createElement(React.Fragment, null,
-            React.createElement(Alert, { variant: "info" }, "Use \u2191\u2193 to navigate between fields, press Enter to edit, and press Ctrl+S or Esc to save and return"))))));
-}

package/dist/ui/pages/ModelConfigScreen.d.ts

@@ -1,8 +0,0 @@
-import React from 'react';
-type Props = {
-    onBack: () => void;
-    onSave: () => void;
-    inlineMode?: boolean;
-};
-export default function ModelConfigScreen({ onBack, onSave, inlineMode, }: Props): React.JSX.Element;
-export {};