snow-ai 0.3.1 → 0.3.2

package/dist/api/models.js

@@ -3,7 +3,7 @@ import { getOpenAiConfig, getCustomHeaders } from '../utils/apiConfig.js';
  * Fetch models from OpenAI-compatible API
  */
 async function fetchOpenAIModels(baseUrl, apiKey, customHeaders) {
-    const url = `${baseUrl.replace(/\/$/, '')}/models`;
+    const url = `${baseUrl}/models`;
     const headers = {
         'Content-Type': 'application/json',
         ...customHeaders,
@@ -26,7 +26,7 @@ async function fetchOpenAIModels(baseUrl, apiKey, customHeaders) {
  */
 async function fetchGeminiModels(baseUrl, apiKey) {
     // Gemini uses API key as query parameter
-    const url = `${baseUrl.replace(/\/$/, '')}/models?key=${apiKey}`;
+    const url = `${baseUrl}/models?key=${apiKey}`;
     const response = await fetch(url, {
         method: 'GET',
         headers: {
@@ -50,10 +50,9 @@ async function fetchGeminiModels(baseUrl, apiKey) {
  * Supports both Anthropic native format and OpenAI-compatible format for backward compatibility
  */
 async function fetchAnthropicModels(baseUrl, apiKey, customHeaders) {
-    const url = `${baseUrl.replace(/\/$/, '')}/models`;
+    const url = `${baseUrl}/models`;
     const headers = {
         'Content-Type': 'application/json',
-        'anthropic-version': '2023-06-01',
         ...customHeaders,
     };
     if (apiKey) {
@@ -106,19 +105,19 @@ export async function fetchAvailableModels() {
                 if (!config.apiKey) {
                     throw new Error('API key is required for Gemini API');
                 }
-                models = await fetchGeminiModels(config.baseUrl.replace(/\/$/, '') + '/v1beta', config.apiKey);
+                models = await fetchGeminiModels(config.baseUrl.replace(/\/$/, ''), config.apiKey);
                 break;
             case 'anthropic':
                 if (!config.apiKey) {
                     throw new Error('API key is required for Anthropic API');
                 }
-                models = await fetchAnthropicModels(config.baseUrl.replace(/\/$/, '') + '/v1', config.apiKey, customHeaders);
+                models = await fetchAnthropicModels(config.baseUrl.replace(/\/$/, ''), config.apiKey, customHeaders);
                 break;
             case 'chat':
             case 'responses':
             default:
                 // OpenAI-compatible API
-                models = await fetchOpenAIModels(config.baseUrl, config.apiKey, customHeaders);
+                models = await fetchOpenAIModels(config.baseUrl.replace(/\/$/, ''), config.apiKey, customHeaders);
                 break;
         }
         // Sort models alphabetically by id for better UX

package/dist/api/responses.d.ts

@@ -1,18 +1,11 @@
-import type { ChatMessage, ToolCall } from './chat.js';
+import type { ChatMessage, ToolCall, ChatCompletionTool, UsageInfo } from './types.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>;
-        };
-    }>;
+    tools?: ChatCompletionTool[];
     tool_choice?: 'auto' | 'none' | 'required';
     reasoning?: {
         summary?: 'auto' | 'none';
@@ -22,14 +15,6 @@ export interface ResponseOptions {
     store?: boolean;
     include?: string[];
 }
-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 ResponseStreamChunk {
     type: 'content' | 'tool_calls' | 'tool_call_delta' | 'reasoning_delta' | 'reasoning_started' | 'done' | 'usage';
     content?: string;

package/dist/api/responses.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';
@@ -52,27 +51,24 @@ function convertToolsForResponses(tools) {
         strict: false
     }));
 }
-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;
 }
 function convertToResponseInput(messages) {
     const customSystemPrompt = getCustomSystemPrompt();
@@ -177,11 +173,43 @@ function convertToResponseInput(messages) {
     }
     return { input: result, systemInstructions };
 }
+/**
+ * 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);
+                }
+            }
+        }
+    }
+}
 /**
  * 使用 Responses API 创建流式响应（带自动工具调用）
  */
 export async function* createStreamingResponse(options, abortSignal, onRetry) {
-    const client = getOpenAIClient();
+    const config = getOpenAIConfig();
     // 提取系统提示词和转换后的消息
     const { input: requestInput, systemInstructions } = convertToResponseInput(options.messages);
     // 使用重试包装生成器
@@ -198,15 +226,29 @@ export async function* createStreamingResponse(options, abortSignal, onRetry) {
             include: options.include || ['reasoning.encrypted_content'],
             prompt_cache_key: options.prompt_cache_key,
         };
-        const stream = await client.responses.create(requestPayload, {
-            signal: abortSignal,
+        const response = await fetch(`${config.baseUrl}/responses`, {
+            method: 'POST',
+            headers: {
+                'Content-Type': 'application/json',
+                'Authorization': `Bearer ${config.apiKey}`,
+                ...config.customHeaders
+            },
+            body: JSON.stringify(requestPayload),
+            signal: abortSignal
         });
+        if (!response.ok) {
+            const errorText = await response.text();
+            throw new Error(`OpenAI Responses API error: ${response.status} ${response.statusText} - ${errorText}`);
+        }
+        if (!response.body) {
+            throw new Error('No response body from OpenAI Responses API');
+        }
         let contentBuffer = '';
         let toolCallsBuffer = {};
         let hasToolCalls = false;
         let currentFunctionCallId = null;
         let usageData;
-        for await (const chunk of stream) {
+        for await (const chunk of parseSSEStream(response.body.getReader())) {
             if (abortSignal?.aborted) {
                 return;
             }

package/dist/api/types.d.ts

@@ -0,0 +1,39 @@
+/**
+ * Shared API types for all AI providers
+ */
+export interface ImageContent {
+    type: 'image';
+    data: string;
+    mimeType: string;
+}
+export interface ToolCall {
+    id: string;
+    type: 'function';
+    function: {
+        name: string;
+        arguments: string;
+    };
+}
+export interface ChatMessage {
+    role: 'system' | 'user' | 'assistant' | 'tool';
+    content: string;
+    tool_call_id?: string;
+    tool_calls?: ToolCall[];
+    images?: ImageContent[];
+}
+export interface ChatCompletionTool {
+    type: 'function';
+    function: {
+        name: string;
+        description?: string;
+        parameters?: Record<string, any>;
+    };
+}
+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;
+}

package/dist/api/types.js

@@ -0,0 +1,4 @@
+/**
+ * Shared API types for all AI providers
+ */
+export {};

package/dist/ui/pages/ConfigScreen.js

@@ -66,6 +66,7 @@ export default function ConfigScreen({ onBack, onSave, inlineMode = false, }) {
     const [searchTerm, setSearchTerm] = useState('');
     const [manualInputMode, setManualInputMode] = useState(false);
     const [manualInputValue, setManualInputValue] = useState('');
+    const [, forceUpdate] = useState(0);
     const requestMethodOptions = [
         {
             label: 'Chat Completions - Modern chat API (GPT-4, GPT-3.5-turbo)',
@@ -392,6 +393,8 @@ export default function ConfigScreen({ onBack, onSave, inlineMode = false, }) {
             key.escape) {
             setIsEditing(false);
             setSearchTerm('');
+            // Force re-render to clear Select component artifacts
+            forceUpdate(prev => prev + 1);
             return;
         }
         // Handle editing mode
@@ -620,26 +623,58 @@ export default function ConfigScreen({ onBack, onSave, inlineMode = false, }) {
                 activeProfile && (React.createElement(Text, { color: "cyan", dimColor: true },
                     "Active Profile: ",
                     activeProfile))))),
-        React.createElement(Box, { flexDirection: "column" },
+        isEditing &&
+            (currentField === 'profile' ||
+                currentField === 'requestMethod' ||
+                currentField === 'advancedModel' ||
+                currentField === 'basicModel' ||
+                currentField === 'compactModelName') ? (React.createElement(Box, { flexDirection: "column" },
+            React.createElement(Text, { color: "green" },
+                "\u276F ",
+                currentField === 'profile' && 'Profile',
+                currentField === 'requestMethod' && 'Request Method',
+                currentField === 'advancedModel' && 'Advanced Model',
+                currentField === 'basicModel' && 'Basic Model',
+                currentField === 'compactModelName' && 'Compact Model',
+                ":"),
+            React.createElement(Box, { marginLeft: 3, marginTop: 1 },
+                currentField === 'profile' && (React.createElement(Select, { options: [
+                        ...profiles.map(p => ({
+                            label: `${p.displayName}${p.isActive ? ' (Active)' : ''}`,
+                            value: p.name,
+                        })),
+                        {
+                            label: chalk.green('+ New Profile'),
+                            value: '__CREATE_NEW__',
+                        },
+                        {
+                            label: chalk.red('🆇 Delete Profile'),
+                            value: '__DELETE__',
+                        },
+                    ], defaultValue: activeProfile, onChange: handleProfileChange })),
+                currentField === 'requestMethod' && (React.createElement(Select, { options: requestMethodOptions, defaultValue: requestMethod, onChange: value => {
+                        setRequestMethod(value);
+                        setIsEditing(false);
+                    } })),
+                (currentField === 'advancedModel' ||
+                    currentField === 'basicModel' ||
+                    currentField === 'compactModelName') && (React.createElement(Box, { flexDirection: "column" },
+                    searchTerm && React.createElement(Text, { color: "cyan" },
+                        "Filter: ",
+                        searchTerm),
+                    React.createElement(Select, { options: getCurrentOptions(), defaultValue: getCurrentValue(), onChange: handleModelChange })))),
+            React.createElement(Box, { marginTop: 1 },
+                React.createElement(Alert, { variant: "info" },
+                    (currentField === 'advancedModel' ||
+                        currentField === 'basicModel' ||
+                        currentField === 'compactModelName') &&
+                        'Type to filter, ↑↓ to select, Enter to confirm, Esc to cancel',
+                    (currentField === 'profile' || currentField === 'requestMethod') &&
+                        '↑↓ to select, Enter to confirm, Esc to cancel')))) : (React.createElement(Box, { flexDirection: "column" },
             React.createElement(Box, { flexDirection: "column" },
                 React.createElement(Text, { color: currentField === 'profile' ? 'green' : 'white' },
                     currentField === 'profile' ? '❯ ' : '  ',
                     "Profile:"),
-                currentField === 'profile' && isEditing && (React.createElement(Box, { marginLeft: 3 },
-                    React.createElement(Select, { options: [
-                            ...profiles.map(p => ({
-                                label: `${p.displayName}${p.isActive ? ' (Active)' : ''}`,
-                                value: p.name,
-                            })),
-                            {
-                                label: chalk.green('+ New Profile'),
-                                value: '__CREATE_NEW__',
-                            },
-                            {
-                                label: chalk.red('🆇 Delete Profile'),
-                                value: '__DELETE__',
-                            },
-                        ], defaultValue: activeProfile, onChange: handleProfileChange }))),
                 (!isEditing || currentField !== 'profile') && (React.createElement(Box, { marginLeft: 3 },
                     React.createElement(Text, { color: "gray" }, profiles.find(p => p.name === activeProfile)?.displayName ||
                         activeProfile)))),
@@ -663,11 +698,6 @@ export default function ConfigScreen({ onBack, onSave, inlineMode = false, }) {
                 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);
-                        } }))),
                 (!isEditing || currentField !== 'requestMethod') && (React.createElement(Box, { marginLeft: 3 },
                     React.createElement(Text, { color: "gray" }, requestMethodOptions.find(opt => opt.value === requestMethod)
                         ?.label || 'Not set')))),
@@ -683,36 +713,18 @@ export default function ConfigScreen({ onBack, onSave, inlineMode = false, }) {
                 React.createElement(Text, { color: currentField === 'advancedModel' ? 'green' : 'white' },
                     currentField === 'advancedModel' ? '❯ ' : '  ',
                     "Advanced Model:"),
-                currentField === 'advancedModel' && isEditing && (React.createElement(Box, { marginLeft: 3 },
-                    React.createElement(Box, { flexDirection: "column" },
-                        searchTerm && React.createElement(Text, { color: "cyan" },
-                            "Filter: ",
-                            searchTerm),
-                        React.createElement(Select, { options: getCurrentOptions(), defaultValue: getCurrentValue(), onChange: handleModelChange })))),
                 (!isEditing || currentField !== 'advancedModel') && (React.createElement(Box, { marginLeft: 3 },
                     React.createElement(Text, { color: "gray" }, advancedModel || 'Not set')))),
             React.createElement(Box, { flexDirection: "column" },
                 React.createElement(Text, { color: currentField === 'basicModel' ? 'green' : 'white' },
                     currentField === 'basicModel' ? '❯ ' : '  ',
                     "Basic Model:"),
-                currentField === 'basicModel' && isEditing && (React.createElement(Box, { marginLeft: 3 },
-                    React.createElement(Box, { flexDirection: "column" },
-                        searchTerm && React.createElement(Text, { color: "cyan" },
-                            "Filter: ",
-                            searchTerm),
-                        React.createElement(Select, { options: getCurrentOptions(), defaultValue: getCurrentValue(), onChange: handleModelChange })))),
                 (!isEditing || currentField !== 'basicModel') && (React.createElement(Box, { marginLeft: 3 },
                     React.createElement(Text, { color: "gray" }, basicModel || 'Not set')))),
             React.createElement(Box, { flexDirection: "column" },
                 React.createElement(Text, { color: currentField === 'compactModelName' ? 'green' : 'white' },
                     currentField === 'compactModelName' ? '❯ ' : '  ',
                     "Compact Model:"),
-                currentField === 'compactModelName' && isEditing && (React.createElement(Box, { marginLeft: 3 },
-                    React.createElement(Box, { flexDirection: "column" },
-                        searchTerm && React.createElement(Text, { color: "cyan" },
-                            "Filter: ",
-                            searchTerm),
-                        React.createElement(Select, { options: getCurrentOptions(), defaultValue: getCurrentValue(), onChange: handleModelChange })))),
                 (!isEditing || currentField !== 'compactModelName') && (React.createElement(Box, { marginLeft: 3 },
                     React.createElement(Text, { color: "gray" }, compactModelName || 'Not set')))),
             React.createElement(Box, { flexDirection: "column" },
@@ -734,20 +746,21 @@ export default function ConfigScreen({ onBack, onSave, inlineMode = false, }) {
                         "Enter value: ",
                         maxTokens))),
                 (!isEditing || currentField !== 'maxTokens') && (React.createElement(Box, { marginLeft: 3 },
-                    React.createElement(Text, { color: "gray" }, maxTokens))))),
+                    React.createElement(Text, { color: "gray" }, maxTokens)))))),
         errors.length > 0 && (React.createElement(Box, { flexDirection: "column", marginTop: 1 },
             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", marginTop: 1 }, isEditing ? (React.createElement(React.Fragment, null,
-            React.createElement(Alert, { variant: "info" },
-                "Editing mode:",
-                ' ',
+        !(isEditing &&
+            (currentField === 'profile' ||
+                currentField === 'requestMethod' ||
                 currentField === 'advancedModel' ||
-                    currentField === 'basicModel' ||
-                    currentField === 'compactModelName'
-                    ? 'Type to filter, ↑↓ to select, Enter to confirm'
-                    : 'Press Enter to save and exit editing'))) : (React.createElement(React.Fragment, null,
-            React.createElement(Alert, { variant: "info" }, "Use \u2191\u2193 to navigate, Enter to edit, M for manual input, Ctrl+S or Esc to save"))))));
+                currentField === 'basicModel' ||
+                currentField === 'compactModelName')) && (React.createElement(Box, { flexDirection: "column", marginTop: 1 }, isEditing ? (React.createElement(Alert, { variant: "info" },
+            "Editing mode:",
+            ' ',
+            currentField === 'maxContextTokens' || currentField === 'maxTokens'
+                ? 'Type to edit, Enter to save'
+                : 'Press Enter to save and exit editing')) : (React.createElement(Alert, { variant: "info" }, "Use \u2191\u2193 to navigate, Enter to edit, M for manual input, Ctrl+S or Esc to save"))))));
 }

package/dist/ui/pages/WelcomeScreen.js

@@ -92,7 +92,7 @@ export default function WelcomeScreen({ version = '1.0.0', onMenuSelect, }) {
     }, [terminalWidth, stdout]);
     return (React.createElement(Box, { flexDirection: "column", width: terminalWidth },
         React.createElement(Static, { key: remountKey, items: [
-                React.createElement(Box, { key: "welcome-header", flexDirection: "row", paddingLeft: 2, paddingTop: 1, paddingBottom: 1, width: terminalWidth },
+                React.createElement(Box, { key: "welcome-header", flexDirection: "row", paddingLeft: 2, paddingTop: 1, paddingBottom: 0, width: terminalWidth },
                     React.createElement(Box, { flexDirection: "column", justifyContent: "center" },
                         React.createElement(Text, { bold: true },
                             React.createElement(Gradient, { name: "rainbow" }, "\u2746 SNOW AI CLI")),

package/dist/utils/contextCompressor.d.ts

@@ -1,4 +1,4 @@
-import type { ChatMessage } from '../api/chat.js';
+import type { ChatMessage } from '../api/types.js';
 export interface CompressionResult {
     summary: string;
     usage: {