snow-ai 0.4.16 → 0.4.17

package/dist/api/anthropic.js

@@ -1,598 +0,0 @@
-import { createHash, randomUUID } from 'crypto';
-import { getOpenAiConfig, getCustomSystemPrompt, getCustomHeaders, } from '../utils/apiConfig.js';
-import { getSystemPrompt } from './systemPrompt.js';
-import { withRetryGenerator, parseJsonWithFix } from '../utils/retryUtils.js';
-import { logger } from '../utils/logger.js';
-import { addProxyToFetchOptions } from '../utils/proxyUtils.js';
-import { saveUsageToFile } from '../utils/usageLogger.js';
-import { isDevMode, getDevUserId } from '../utils/devMode.js';
-let anthropicConfig = null;
-// Persistent userId that remains the same until application restart
-let persistentUserId = null;
-function getAnthropicConfig() {
-    if (!anthropicConfig) {
-        const config = getOpenAiConfig();
-        if (!config.apiKey) {
-            throw new Error('Anthropic API configuration is incomplete. Please configure API key first.');
-        }
-        const customHeaders = getCustomHeaders();
-        anthropicConfig = {
-            apiKey: config.apiKey,
-            baseUrl: config.baseUrl && config.baseUrl !== 'https://api.openai.com/v1'
-                ? config.baseUrl
-                : 'https://api.anthropic.com/v1',
-            customHeaders,
-            anthropicBeta: config.anthropicBeta,
-            thinking: config.thinking,
-        };
-    }
-    return anthropicConfig;
-}
-export function resetAnthropicClient() {
-    anthropicConfig = null;
-    persistentUserId = null; // Reset userId on client reset
-}
-/**
- * Generate a persistent user_id that remains the same until application restart
- * Format: user_<hash>_account__session_<uuid>
- * This matches Anthropic's expected format for tracking and caching
- *
- * In dev mode (--dev flag), uses a persistent userId from ~/.snow/dev-user-id
- * instead of generating a new one each session
- */
-function getPersistentUserId() {
-    // Check if dev mode is enabled
-    if (isDevMode()) {
-        return getDevUserId();
-    }
-    // Normal mode: generate userId per session
-    if (!persistentUserId) {
-        const sessionId = randomUUID();
-        const hash = createHash('sha256')
-            .update(`anthropic_user_${sessionId}`)
-            .digest('hex');
-        persistentUserId = `user_${hash}_account__session_${sessionId}`;
-    }
-    return persistentUserId;
-}
-/**
- * Convert OpenAI-style tools to Anthropic tool format
- * Adds cache_control to the last tool for prompt caching
- */
-function convertToolsToAnthropic(tools) {
-    if (!tools || tools.length === 0) {
-        return undefined;
-    }
-    const convertedTools = tools
-        .filter(tool => tool.type === 'function' && 'function' in tool)
-        .map(tool => {
-        if (tool.type === 'function' && 'function' in tool) {
-            return {
-                name: tool.function.name,
-                description: tool.function.description || '',
-                input_schema: tool.function.parameters,
-            };
-        }
-        throw new Error('Invalid tool format');
-    });
-    if (convertedTools.length > 0) {
-        const lastTool = convertedTools[convertedTools.length - 1];
-        lastTool.cache_control = { type: 'ephemeral' };
-    }
-    return convertedTools;
-}
-/**
- * Convert our ChatMessage format to Anthropic's message format
- * Adds cache_control to system prompt and last user message for prompt caching
- * @param messages - The messages to convert
- * @param includeBuiltinSystemPrompt - Whether to include builtin system prompt (default true)
- */
-function convertToAnthropicMessages(messages, includeBuiltinSystemPrompt = true) {
-    const customSystemPrompt = getCustomSystemPrompt();
-    let systemContent;
-    const anthropicMessages = [];
-    for (const msg of messages) {
-        if (msg.role === 'system') {
-            systemContent = msg.content;
-            continue;
-        }
-        if (msg.role === 'tool' && msg.tool_call_id) {
-            // Build tool_result content - can be text or array with images
-            let toolResultContent;
-            if (msg.images && msg.images.length > 0) {
-                // Multimodal tool result with images
-                const contentArray = [];
-                // Add text content first
-                if (msg.content) {
-                    contentArray.push({
-                        type: 'text',
-                        text: msg.content,
-                    });
-                }
-                // Add images
-                for (const image of msg.images) {
-                    contentArray.push({
-                        type: 'image',
-                        source: {
-                            type: 'base64',
-                            media_type: image.mimeType,
-                            data: image.data,
-                        },
-                    });
-                }
-                toolResultContent = contentArray;
-            }
-            else {
-                // Text-only tool result
-                toolResultContent = msg.content;
-            }
-            anthropicMessages.push({
-                role: 'user',
-                content: [
-                    {
-                        type: 'tool_result',
-                        tool_use_id: msg.tool_call_id,
-                        content: toolResultContent,
-                    },
-                ],
-            });
-            continue;
-        }
-        if (msg.role === 'user' && msg.images && msg.images.length > 0) {
-            const content = [];
-            if (msg.content) {
-                content.push({
-                    type: 'text',
-                    text: msg.content,
-                });
-            }
-            for (const image of msg.images) {
-                const base64Match = image.data.match(/^data:([^;]+);base64,(.+)$/);
-                if (base64Match) {
-                    content.push({
-                        type: 'image',
-                        source: {
-                            type: 'base64',
-                            media_type: base64Match[1] || image.mimeType,
-                            data: base64Match[2] || '',
-                        },
-                    });
-                }
-            }
-            anthropicMessages.push({
-                role: 'user',
-                content,
-            });
-            continue;
-        }
-        if (msg.role === 'assistant' &&
-            msg.tool_calls &&
-            msg.tool_calls.length > 0) {
-            const content = [];
-            // When thinking is enabled, thinking block must come first
-            if (msg.thinking) {
-                // Use the complete thinking block object (includes signature)
-                content.push(msg.thinking);
-            }
-            if (msg.content) {
-                content.push({
-                    type: 'text',
-                    text: msg.content,
-                });
-            }
-            for (const toolCall of msg.tool_calls) {
-                content.push({
-                    type: 'tool_use',
-                    id: toolCall.id,
-                    name: toolCall.function.name,
-                    input: JSON.parse(toolCall.function.arguments),
-                });
-            }
-            anthropicMessages.push({
-                role: 'assistant',
-                content,
-            });
-            continue;
-        }
-        if (msg.role === 'user' || msg.role === 'assistant') {
-            // For assistant messages with thinking, convert to structured format
-            if (msg.role === 'assistant' && msg.thinking) {
-                const content = [];
-                // Thinking block must come first - use complete block object (includes signature)
-                content.push(msg.thinking);
-                // Then text content
-                if (msg.content) {
-                    content.push({
-                        type: 'text',
-                        text: msg.content,
-                    });
-                }
-                anthropicMessages.push({
-                    role: 'assistant',
-                    content,
-                });
-            }
-            else {
-                anthropicMessages.push({
-                    role: msg.role,
-                    content: msg.content,
-                });
-            }
-        }
-    }
-    // 如果配置了自定义系统提示词（最高优先级，始终添加）
-    if (customSystemPrompt) {
-        systemContent = customSystemPrompt;
-        if (includeBuiltinSystemPrompt) {
-            // 将默认系统提示词作为第一条用户消息
-            anthropicMessages.unshift({
-                role: 'user',
-                content: [
-                    {
-                        type: 'text',
-                        text: getSystemPrompt(),
-                        cache_control: { type: 'ephemeral' },
-                    },
-                ],
-            });
-        }
-    }
-    else if (!systemContent && includeBuiltinSystemPrompt) {
-        // 没有自定义系统提示词，但需要添加默认系统提示词
-        systemContent = getSystemPrompt();
-    }
-    let lastUserMessageIndex = -1;
-    for (let i = anthropicMessages.length - 1; i >= 0; i--) {
-        if (anthropicMessages[i]?.role === 'user') {
-            if (customSystemPrompt && i === 0) {
-                continue;
-            }
-            lastUserMessageIndex = i;
-            break;
-        }
-    }
-    if (lastUserMessageIndex >= 0) {
-        const lastMessage = anthropicMessages[lastUserMessageIndex];
-        if (lastMessage && lastMessage.role === 'user') {
-            if (typeof lastMessage.content === 'string') {
-                lastMessage.content = [
-                    {
-                        type: 'text',
-                        text: lastMessage.content,
-                        cache_control: { type: 'ephemeral' },
-                    },
-                ];
-            }
-            else if (Array.isArray(lastMessage.content)) {
-                const lastContentIndex = lastMessage.content.length - 1;
-                if (lastContentIndex >= 0) {
-                    const lastContent = lastMessage.content[lastContentIndex];
-                    lastContent.cache_control = { type: 'ephemeral' };
-                }
-            }
-        }
-    }
-    const system = systemContent
-        ? [
-            {
-                type: 'text',
-                text: systemContent,
-                cache_control: { type: 'ephemeral' },
-            },
-        ]
-        : undefined;
-    return { system, messages: anthropicMessages };
-}
-/**
- * Parse Server-Sent Events (SSE) stream
- */
-async function* parseSSEStream(reader) {
-    const decoder = new TextDecoder();
-    let buffer = '';
-    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; // 正常结束
-            }
-            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;
-    }
-}
-export async function* createStreamingAnthropicCompletion(options, abortSignal, onRetry) {
-    yield* withRetryGenerator(async function* () {
-        const config = getAnthropicConfig();
-        const { system, messages } = convertToAnthropicMessages(options.messages, options.includeBuiltinSystemPrompt !== false);
-        // Use persistent userId that remains the same until application restart
-        const userId = getPersistentUserId();
-        const requestBody = {
-            model: options.model,
-            max_tokens: options.max_tokens || 4096,
-            system,
-            messages,
-            tools: convertToolsToAnthropic(options.tools),
-            metadata: {
-                user_id: userId,
-            },
-            stream: true,
-        };
-        // Add thinking configuration if enabled and not explicitly disabled
-        // When thinking is enabled, temperature must be 1
-        // Note: agents and other internal tools should set disableThinking=true
-        if (config.thinking && !options.disableThinking) {
-            requestBody.thinking = config.thinking;
-            requestBody.temperature = 1;
-        }
-        // Prepare headers
-        const headers = {
-            'Content-Type': 'application/json',
-            'x-api-key': config.apiKey,
-            Authorization: `Bearer ${config.apiKey}`,
-            'anthropic-version': '2023-06-01',
-            'x-snow': 'true',
-            ...config.customHeaders,
-        };
-        // Add beta parameter if configured
-        // if (config.anthropicBeta) {
-        // 	headers['anthropic-beta'] = 'prompt-caching-2024-07-31';
-        // }
-        const url = config.anthropicBeta
-            ? `${config.baseUrl}/messages?beta=true`
-            : `${config.baseUrl}/messages`;
-        const fetchOptions = addProxyToFetchOptions(url, {
-            method: 'POST',
-            headers,
-            body: JSON.stringify(requestBody),
-            signal: abortSignal,
-        });
-        const response = await fetch(url, fetchOptions);
-        if (!response.ok) {
-            const errorText = await response.text();
-            throw new Error(`Anthropic API error: ${response.status} ${response.statusText} - ${errorText}`);
-        }
-        if (!response.body) {
-            throw new Error('No response body from Anthropic API');
-        }
-        let contentBuffer = '';
-        let thinkingTextBuffer = ''; // Accumulate thinking text content
-        let thinkingSignature = ''; // Accumulate thinking signature
-        let toolCallsBuffer = new Map();
-        let hasToolCalls = false;
-        let usageData;
-        let blockIndexToId = new Map();
-        let blockIndexToType = new Map(); // Track block types (text, thinking, tool_use)
-        let completedToolBlocks = new Set(); // Track which tool blocks have finished streaming
-        for await (const event of parseSSEStream(response.body.getReader())) {
-            if (abortSignal?.aborted) {
-                return;
-            }
-            if (event.type === 'content_block_start') {
-                const block = event.content_block;
-                const blockIndex = event.index;
-                // Track block type for later reference
-                blockIndexToType.set(blockIndex, block.type);
-                if (block.type === 'tool_use') {
-                    hasToolCalls = true;
-                    blockIndexToId.set(blockIndex, block.id);
-                    toolCallsBuffer.set(block.id, {
-                        id: block.id,
-                        type: 'function',
-                        function: {
-                            name: block.name,
-                            arguments: '',
-                        },
-                    });
-                    yield {
-                        type: 'tool_call_delta',
-                        delta: block.name,
-                    };
-                }
-                // Handle thinking block start (Extended Thinking feature)
-                else if (block.type === 'thinking') {
-                    // Thinking block started - emit reasoning_started event
-                    yield {
-                        type: 'reasoning_started',
-                    };
-                }
-            }
-            else if (event.type === 'content_block_delta') {
-                const delta = event.delta;
-                if (delta.type === 'text_delta') {
-                    const text = delta.text;
-                    contentBuffer += text;
-                    yield {
-                        type: 'content',
-                        content: text,
-                    };
-                }
-                // Handle thinking_delta (Extended Thinking feature)
-                // Emit reasoning_delta event for thinking content
-                if (delta.type === 'thinking_delta') {
-                    const thinkingText = delta.thinking;
-                    thinkingTextBuffer += thinkingText; // Accumulate thinking text
-                    yield {
-                        type: 'reasoning_delta',
-                        delta: thinkingText,
-                    };
-                }
-                // Handle signature_delta (Extended Thinking feature)
-                // Signature is required for thinking blocks
-                if (delta.type === 'signature_delta') {
-                    thinkingSignature += delta.signature; // Accumulate signature
-                }
-                if (delta.type === 'input_json_delta') {
-                    const jsonDelta = delta.partial_json;
-                    const blockIndex = event.index;
-                    const toolId = blockIndexToId.get(blockIndex);
-                    if (toolId) {
-                        const toolCall = toolCallsBuffer.get(toolId);
-                        if (toolCall) {
-                            // Filter out any XML-like tags that might be mixed in the JSON delta
-                            // This can happen when the model output contains XML that gets interpreted as JSON
-                            const cleanedDelta = jsonDelta.replace(/<\/?parameter[^>]*>/g, '');
-                            if (cleanedDelta) {
-                                toolCall.function.arguments += cleanedDelta;
-                                yield {
-                                    type: 'tool_call_delta',
-                                    delta: cleanedDelta,
-                                };
-                            }
-                        }
-                    }
-                }
-            }
-            else if (event.type === 'content_block_stop') {
-                // Mark this block as completed
-                const blockIndex = event.index;
-                const toolId = blockIndexToId.get(blockIndex);
-                if (toolId) {
-                    completedToolBlocks.add(toolId);
-                }
-            }
-            else if (event.type === 'message_start') {
-                if (event.message.usage) {
-                    usageData = {
-                        prompt_tokens: event.message.usage.input_tokens || 0,
-                        completion_tokens: event.message.usage.output_tokens || 0,
-                        total_tokens: (event.message.usage.input_tokens || 0) +
-                            (event.message.usage.output_tokens || 0),
-                        cache_creation_input_tokens: event.message.usage
-                            .cache_creation_input_tokens,
-                        cache_read_input_tokens: event.message.usage
-                            .cache_read_input_tokens,
-                    };
-                }
-            }
-            else if (event.type === 'message_delta') {
-                if (event.usage) {
-                    if (!usageData) {
-                        usageData = {
-                            prompt_tokens: 0,
-                            completion_tokens: 0,
-                            total_tokens: 0,
-                        };
-                    }
-                    // Update prompt_tokens if present in message_delta
-                    if (event.usage.input_tokens !== undefined) {
-                        usageData.prompt_tokens = event.usage.input_tokens;
-                    }
-                    usageData.completion_tokens = event.usage.output_tokens || 0;
-                    usageData.total_tokens =
-                        usageData.prompt_tokens + usageData.completion_tokens;
-                    if (event.usage.cache_creation_input_tokens !== undefined) {
-                        usageData.cache_creation_input_tokens = event.usage.cache_creation_input_tokens;
-                    }
-                    if (event.usage.cache_read_input_tokens !== undefined) {
-                        usageData.cache_read_input_tokens = event.usage.cache_read_input_tokens;
-                    }
-                }
-            }
-        }
-        if (hasToolCalls && toolCallsBuffer.size > 0) {
-            const toolCalls = Array.from(toolCallsBuffer.values());
-            for (const toolCall of toolCalls) {
-                // Normalize the arguments
-                let args = toolCall.function.arguments.trim();
-                // If arguments is empty, use empty object
-                if (!args) {
-                    args = '{}';
-                }
-                // Try to parse the JSON using the unified parseJsonWithFix utility
-                if (completedToolBlocks.has(toolCall.id)) {
-                    // Tool block was completed, parse with fix and logging
-                    const parseResult = parseJsonWithFix(args, {
-                        toolName: toolCall.function.name,
-                        fallbackValue: {},
-                        logWarning: true,
-                        logError: true,
-                    });
-                    // Use the parsed data or fallback value
-                    toolCall.function.arguments = JSON.stringify(parseResult.data);
-                }
-                else {
-                    // Tool block wasn't completed, likely interrupted stream
-                    // Try to parse without logging errors (incomplete data is expected)
-                    const parseResult = parseJsonWithFix(args, {
-                        toolName: toolCall.function.name,
-                        fallbackValue: {},
-                        logWarning: false,
-                        logError: false,
-                    });
-                    if (!parseResult.success) {
-                        logger.warn(`Warning: Tool call ${toolCall.function.name} (${toolCall.id}) was incomplete. Using fallback data.`);
-                    }
-                    toolCall.function.arguments = JSON.stringify(parseResult.data);
-                }
-            }
-            yield {
-                type: 'tool_calls',
-                tool_calls: toolCalls,
-            };
-        }
-        if (usageData) {
-            // Save usage to file system at API layer
-            saveUsageToFile(options.model, usageData);
-            yield {
-                type: 'usage',
-                usage: usageData,
-            };
-        }
-        // Return complete thinking block with signature if thinking content exists
-        const thinkingBlock = thinkingTextBuffer
-            ? {
-                type: 'thinking',
-                thinking: thinkingTextBuffer,
-                signature: thinkingSignature || undefined,
-            }
-            : undefined;
-        yield {
-            type: 'done',
-            thinking: thinkingBlock,
-        };
-    }, {
-        abortSignal,
-        onRetry,
-    });
-}

package/dist/api/chat.d.ts

@@ -1,73 +0,0 @@
-import type { ChatMessage, ChatCompletionTool, ToolCall, UsageInfo, ImageContent } from './types.js';
-export type { ChatMessage, ChatCompletionTool, ToolCall, UsageInfo, ImageContent, };
-export interface ChatCompletionOptions {
-    model: string;
-    messages: ChatMessage[];
-    stream?: boolean;
-    temperature?: number;
-    max_tokens?: number;
-    tools?: ChatCompletionTool[];
-    tool_choice?: 'auto' | 'none' | 'required' | {
-        type: 'function';
-        function: {
-            name: string;
-        };
-    };
-    includeBuiltinSystemPrompt?: boolean;
-}
-export interface ChatCompletionChunk {
-    id: string;
-    object: 'chat.completion.chunk';
-    created: number;
-    model: string;
-    choices: Array<{
-        index: number;
-        delta: {
-            role?: string;
-            content?: string;
-            tool_calls?: Array<{
-                index?: number;
-                id?: string;
-                type?: 'function';
-                function?: {
-                    name?: string;
-                    arguments?: string;
-                };
-            }>;
-        };
-        finish_reason?: string | null;
-    }>;
-}
-export interface ChatCompletionMessageParam {
-    role: 'system' | 'user' | 'assistant' | 'tool';
-    content: string | Array<{
-        type: 'text' | 'image_url';
-        text?: string;
-        image_url?: {
-            url: string;
-        };
-    }>;
-    tool_call_id?: string;
-    tool_calls?: ToolCall[];
-}
-export declare function resetOpenAIClient(): void;
-export interface StreamChunk {
-    type: 'content' | 'tool_calls' | 'tool_call_delta' | 'reasoning_delta' | 'reasoning_started' | 'done' | 'usage';
-    content?: string;
-    tool_calls?: Array<{
-        id: string;
-        type: 'function';
-        function: {
-            name: string;
-            arguments: string;
-        };
-    }>;
-    delta?: string;
-    usage?: UsageInfo;
-}
-/**
- * Simple streaming chat completion - only handles OpenAI interaction
- * Tool execution should be handled by the caller
- */
-export declare function createStreamingChatCompletion(options: ChatCompletionOptions, abortSignal?: AbortSignal, onRetry?: (error: Error, attempt: number, nextDelay: number) => void): AsyncGenerator<StreamChunk, void, unknown>;
-export declare function validateChatOptions(options: ChatCompletionOptions): string[];