snow-ai 0.4.3 → 0.4.4

package/dist/api/anthropic.d.ts

@@ -41,7 +41,4 @@ export interface AnthropicMessageParam {
     content: string | Array<any>;
 }
 export declare function resetAnthropicClient(): void;
-/**
- * Create streaming chat completion using Anthropic API
- */
 export declare function createStreamingAnthropicCompletion(options: AnthropicOptions, abortSignal?: AbortSignal, onRetry?: (error: Error, attempt: number, nextDelay: number) => void): AsyncGenerator<AnthropicStreamChunk, void, unknown>;

package/dist/api/anthropic.js

@@ -251,43 +251,58 @@ function convertToAnthropicMessages(messages, includeBuiltinSystemPrompt = true)
 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]' || trimmed === 'data:[DONE]') {
-                return;
-            }
-            // Handle both "event: " and "event:" formats
-            if (trimmed.startsWith('event:')) {
-                // Event type, will be followed by data
-                continue;
+    try {
+        while (true) {
+            const { done, value } = await reader.read();
+            if (done) {
+                // ✅ 关键修复：检查buffer是否有残留数据
+                if (buffer.trim()) {
+                    // 连接异常中断，抛出明确错误
+                    throw new Error(`Stream terminated unexpectedly with incomplete data: ${buffer.substring(0, 100)}...`);
+                }
+                break; // 正常结束
             }
-            // Handle both "data: " and "data:" formats
-            if (trimmed.startsWith('data:')) {
-                const data = trimmed.startsWith('data: ')
-                    ? trimmed.slice(6)
-                    : trimmed.slice(5);
-                try {
-                    yield JSON.parse(data);
+            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]' || trimmed === 'data:[DONE]') {
+                    return;
                 }
-                catch (e) {
-                    logger.error('Failed to parse SSE data:', data);
+                // Handle both "event: " and "event:" formats
+                if (trimmed.startsWith('event:')) {
+                    // Event type, will be followed by data
+                    continue;
+                }
+                // Handle both "data: " and "data:" formats
+                if (trimmed.startsWith('data:')) {
+                    const data = trimmed.startsWith('data: ')
+                        ? trimmed.slice(6)
+                        : trimmed.slice(5);
+                    const parseResult = parseJsonWithFix(data, {
+                        toolName: 'SSE stream',
+                        logWarning: false,
+                        logError: true,
+                    });
+                    if (parseResult.success) {
+                        yield parseResult.data;
+                    }
                 }
             }
         }
     }
+    catch (error) {
+        const { logger } = await import('../utils/logger.js');
+        logger.error('SSE stream parsing error:', {
+            error: error instanceof Error ? error.message : 'Unknown error',
+            remainingBuffer: buffer.substring(0, 200),
+        });
+        throw error;
+    }
 }
-/**
- * Create streaming chat completion using Anthropic API
- */
 export async function* createStreamingAnthropicCompletion(options, abortSignal, onRetry) {
     yield* withRetryGenerator(async function* () {
         const config = getAnthropicConfig();

package/dist/api/chat.js

@@ -126,41 +126,57 @@ export function resetOpenAIClient() {
 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]' || trimmed === 'data:[DONE]') {
-                return;
-            }
-            // Handle both "event: " and "event:" formats
-            if (trimmed.startsWith('event:')) {
-                // Event type, will be followed by data
-                continue;
+    try {
+        while (true) {
+            const { done, value } = await reader.read();
+            if (done) {
+                // ✅ 关键修复：检查buffer是否有残留数据
+                if (buffer.trim()) {
+                    // 连接异常中断，抛出明确错误
+                    throw new Error(`Stream terminated unexpectedly with incomplete data: ${buffer.substring(0, 100)}...`);
+                }
+                break; // 正常结束
             }
-            // Handle both "data: " and "data:" formats
-            if (trimmed.startsWith('data:')) {
-                const data = trimmed.startsWith('data: ')
-                    ? trimmed.slice(6)
-                    : trimmed.slice(5);
-                const parseResult = parseJsonWithFix(data, {
-                    toolName: 'SSE stream',
-                    logWarning: false,
-                    logError: true,
-                });
-                if (parseResult.success) {
-                    yield parseResult.data;
+            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]' || trimmed === 'data:[DONE]') {
+                    return;
+                }
+                // Handle both "event: " and "event:" formats
+                if (trimmed.startsWith('event:')) {
+                    // Event type, will be followed by data
+                    continue;
+                }
+                // Handle both "data: " and "data:" formats
+                if (trimmed.startsWith('data:')) {
+                    const data = trimmed.startsWith('data: ')
+                        ? trimmed.slice(6)
+                        : trimmed.slice(5);
+                    const parseResult = parseJsonWithFix(data, {
+                        toolName: 'SSE stream',
+                        logWarning: false,
+                        logError: true,
+                    });
+                    if (parseResult.success) {
+                        yield parseResult.data;
+                    }
                 }
             }
         }
     }
+    catch (error) {
+        const { logger } = await import('../utils/logger.js');
+        logger.error('SSE stream parsing error:', {
+            error: error instanceof Error ? error.message : 'Unknown error',
+            remainingBuffer: buffer.substring(0, 200),
+        });
+        throw error;
+    }
 }
 /**
  * Simple streaming chat completion - only handles OpenAI interaction

package/dist/api/gemini.js

@@ -280,97 +280,113 @@ export async function* createStreamingGeminiCompletion(options, abortSignal, onR
         const reader = response.body.getReader();
         const decoder = new TextDecoder();
         let buffer = '';
-        while (true) {
-            const { done, value } = await reader.read();
-            if (done)
-                break;
-            if (abortSignal?.aborted) {
-                return;
-            }
-            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]' || trimmed === 'data:[DONE]') {
-                    break;
+        try {
+            while (true) {
+                const { done, value } = await reader.read();
+                if (done) {
+                    // ✅ 关键修复：检查buffer是否有残留数据
+                    if (buffer.trim()) {
+                        // 连接异常中断，抛出明确错误
+                        throw new Error(`Stream terminated unexpectedly with incomplete data: ${buffer.substring(0, 100)}...`);
+                    }
+                    break; // 正常结束
                 }
-                // Handle both "event: " and "event:" formats
-                if (trimmed.startsWith('event:')) {
-                    // Event type, will be followed by data
-                    continue;
+                if (abortSignal?.aborted) {
+                    return;
                 }
-                // Handle both "data: " and "data:" formats
-                if (trimmed.startsWith('data:')) {
-                    const data = trimmed.startsWith('data: ')
-                        ? trimmed.slice(6)
-                        : trimmed.slice(5);
-                    const parseResult = parseJsonWithFix(data, {
-                        toolName: 'Gemini SSE stream',
-                        logWarning: false,
-                        logError: true,
-                    });
-                    if (parseResult.success) {
-                        const chunk = parseResult.data;
-                        // Process candidates
-                        if (chunk.candidates && chunk.candidates.length > 0) {
-                            const candidate = chunk.candidates[0];
-                            if (candidate.content && candidate.content.parts) {
-                                for (const part of candidate.content.parts) {
-                                    // Process thought content (Gemini thinking)
-                                    // When part.thought === true, the text field contains thinking content
-                                    if (part.thought === true && part.text) {
-                                        thinkingTextBuffer += part.text;
-                                        yield {
-                                            type: 'reasoning_delta',
-                                            delta: part.text,
-                                        };
-                                    }
-                                    // Process regular text content (when thought is not true)
-                                    else if (part.text) {
-                                        contentBuffer += part.text;
-                                        yield {
-                                            type: 'content',
-                                            content: part.text,
-                                        };
-                                    }
-                                    // Process function calls
-                                    if (part.functionCall) {
-                                        hasToolCalls = true;
-                                        const fc = part.functionCall;
-                                        const toolCall = {
-                                            id: `call_${toolCallIndex++}`,
-                                            type: 'function',
-                                            function: {
-                                                name: fc.name,
-                                                arguments: JSON.stringify(fc.args || {}),
-                                            },
-                                        };
-                                        toolCallsBuffer.push(toolCall);
-                                        // Yield delta for token counting
-                                        const deltaText = fc.name + JSON.stringify(fc.args || {});
-                                        yield {
-                                            type: 'tool_call_delta',
-                                            delta: deltaText,
-                                        };
+                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]' || trimmed === 'data:[DONE]') {
+                        break;
+                    }
+                    // Handle both "event: " and "event:" formats
+                    if (trimmed.startsWith('event:')) {
+                        // Event type, will be followed by data
+                        continue;
+                    }
+                    // Handle both "data: " and "data:" formats
+                    if (trimmed.startsWith('data:')) {
+                        const data = trimmed.startsWith('data: ')
+                            ? trimmed.slice(6)
+                            : trimmed.slice(5);
+                        const parseResult = parseJsonWithFix(data, {
+                            toolName: 'Gemini SSE stream',
+                            logWarning: false,
+                            logError: true,
+                        });
+                        if (parseResult.success) {
+                            const chunk = parseResult.data;
+                            // Process candidates
+                            if (chunk.candidates && chunk.candidates.length > 0) {
+                                const candidate = chunk.candidates[0];
+                                if (candidate.content && candidate.content.parts) {
+                                    for (const part of candidate.content.parts) {
+                                        // Process thought content (Gemini thinking)
+                                        // When part.thought === true, the text field contains thinking content
+                                        if (part.thought === true && part.text) {
+                                            thinkingTextBuffer += part.text;
+                                            yield {
+                                                type: 'reasoning_delta',
+                                                delta: part.text,
+                                            };
+                                        }
+                                        // Process regular text content (when thought is not true)
+                                        else if (part.text) {
+                                            contentBuffer += part.text;
+                                            yield {
+                                                type: 'content',
+                                                content: part.text,
+                                            };
+                                        }
+                                        // Process function calls
+                                        if (part.functionCall) {
+                                            hasToolCalls = true;
+                                            const fc = part.functionCall;
+                                            const toolCall = {
+                                                id: `call_${toolCallIndex++}`,
+                                                type: 'function',
+                                                function: {
+                                                    name: fc.name,
+                                                    arguments: JSON.stringify(fc.args || {}),
+                                                },
+                                            };
+                                            toolCallsBuffer.push(toolCall);
+                                            // Yield delta for token counting
+                                            const deltaText = fc.name + JSON.stringify(fc.args || {});
+                                            yield {
+                                                type: 'tool_call_delta',
+                                                delta: deltaText,
+                                            };
+                                        }
                                     }
                                 }
                             }
-                        }
-                        // Track usage info
-                        if (chunk.usageMetadata) {
-                            totalTokens = {
-                                prompt: chunk.usageMetadata.promptTokenCount || 0,
-                                completion: chunk.usageMetadata.candidatesTokenCount || 0,
-                                total: chunk.usageMetadata.totalTokenCount || 0,
-                            };
+                            // Track usage info
+                            if (chunk.usageMetadata) {
+                                totalTokens = {
+                                    prompt: chunk.usageMetadata.promptTokenCount || 0,
+                                    completion: chunk.usageMetadata.candidatesTokenCount || 0,
+                                    total: chunk.usageMetadata.totalTokenCount || 0,
+                                };
+                            }
                         }
                     }
                 }
             }
         }
+        catch (error) {
+            const { logger } = await import('../utils/logger.js');
+            logger.error('Gemini SSE stream parsing error:', {
+                error: error instanceof Error ? error.message : 'Unknown error',
+                remainingBuffer: buffer.substring(0, 200),
+            });
+            throw error;
+        }
         // Yield tool calls if any
         if (hasToolCalls && toolCallsBuffer.length > 0) {
             yield {

package/dist/api/responses.js

@@ -207,41 +207,57 @@ function convertToResponseInput(messages, includeBuiltinSystemPrompt = true) {
 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]' || trimmed === 'data:[DONE]') {
-                return;
-            }
-            // Handle both "event: " and "event:" formats
-            if (trimmed.startsWith('event:')) {
-                // Event type, will be followed by data
-                continue;
+    try {
+        while (true) {
+            const { done, value } = await reader.read();
+            if (done) {
+                // ✅ 关键修复：检查buffer是否有残留数据
+                if (buffer.trim()) {
+                    // 连接异常中断，抛出明确错误
+                    throw new Error(`Stream terminated unexpectedly with incomplete data: ${buffer.substring(0, 100)}...`);
+                }
+                break; // 正常结束
             }
-            // Handle both "data: " and "data:" formats
-            if (trimmed.startsWith('data:')) {
-                const data = trimmed.startsWith('data: ')
-                    ? trimmed.slice(6)
-                    : trimmed.slice(5);
-                const parseResult = parseJsonWithFix(data, {
-                    toolName: 'Responses API SSE stream',
-                    logWarning: false,
-                    logError: true,
-                });
-                if (parseResult.success) {
-                    yield parseResult.data;
+            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]' || trimmed === 'data:[DONE]') {
+                    return;
+                }
+                // Handle both "event: " and "event:" formats
+                if (trimmed.startsWith('event:')) {
+                    // Event type, will be followed by data
+                    continue;
+                }
+                // Handle both "data: " and "data:" formats
+                if (trimmed.startsWith('data:')) {
+                    const data = trimmed.startsWith('data: ')
+                        ? trimmed.slice(6)
+                        : trimmed.slice(5);
+                    const parseResult = parseJsonWithFix(data, {
+                        toolName: 'Responses API SSE stream',
+                        logWarning: false,
+                        logError: true,
+                    });
+                    if (parseResult.success) {
+                        yield parseResult.data;
+                    }
                 }
             }
         }
     }
+    catch (error) {
+        const { logger } = await import('../utils/logger.js');
+        logger.error('Responses API SSE stream parsing error:', {
+            error: error instanceof Error ? error.message : 'Unknown error',
+            remainingBuffer: buffer.substring(0, 200),
+        });
+        throw error;
+    }
 }
 /**
  * 使用 Responses API 创建流式响应（带自动工具调用）

package/dist/hooks/useConversation.js

@@ -1041,9 +1041,12 @@ export async function handleConversationWithTools(options) {
         freeEncoder();
     }
     catch (error) {
-        freeEncoder();
         throw error;
     }
+    finally {
+        // ✅ 确保总是释放encoder资源，避免资源泄漏
+        freeEncoder();
+    }
     // Return the accumulated usage data
     return { usage: accumulatedUsage };
 }

package/package.json

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