@myassis/gateway 1.0.0

package/dist/services/llm/LLMClient.js

@@ -0,0 +1,724 @@
+import { persistStore } from "@/stores";
+import { getLogger } from '@pocketclaw/shared';
+import fs from 'fs/promises';
+const logger = getLogger('LLMClient');
+/**
+ * LLM 调用器类
+ * 提供 Chat 和 streamChat 两种调用方式
+ */
+export class LLMClient {
+    models;
+    messages;
+    tools;
+    preferredModelId;
+    signal;
+    timeoutMs = 60000;
+    constructor(models, messages, signal, tools) {
+        this.models = models;
+        this.messages = messages;
+        this.tools = tools;
+        this.signal = signal;
+    }
+    getActionName(params) {
+        const args = parseAruments(params);
+        return args?.action;
+    }
+    /**
+     * 设置首选模型
+     */
+    setPreferredModel(modelId) {
+        this.preferredModelId = modelId;
+    }
+    /**
+     * 非流式 Chat 调用
+     * 返回完整的 content、reasoningContent 和 toolCalls
+     */
+    async Chat() {
+        const selector = this.createSelector();
+        let lastError;
+        selector.resetTriedModels();
+        while (true) {
+            if (this.signal.aborted) {
+                throw Error('aborted');
+            }
+            const model = selector.getNext();
+            if (!model)
+                break;
+            const controller = new AbortController();
+            const timer = setTimeout(() => controller.abort(), this.timeoutMs);
+            try {
+                const request = await this.buildRequest(model, false);
+                // 组合外部 signal 和内部 controller.signal，任一 abort 都取消请求
+                const combinedSignal = this.signal
+                    ? (this.signal.aborted ? this.signal : AbortSignal.any([this.signal, controller.signal]))
+                    : controller.signal;
+                const response = await fetch(request.url, {
+                    method: 'POST',
+                    headers: request.headers,
+                    body: JSON.stringify(request.body),
+                    signal: combinedSignal,
+                });
+                if (!response.ok) {
+                    const errorText = await response.text();
+                    logger.error(errorText);
+                    throw new Error(`${response.status} - ${errorText}`);
+                }
+                const responseText = await response.text();
+                const data = responseText ? JSON.parse(responseText) : {};
+                clearTimeout(timer);
+                return this.parseResponse(data, model.modelName);
+            }
+            catch (error) {
+                if (error.message === 'exceed max message tokens') {
+                    throw error;
+                }
+                selector.markTried(model.id);
+                clearTimeout(timer);
+                lastError = error;
+            }
+        }
+        throw lastError || new Error('All models are unavailable or has been aborted');
+    }
+    /**
+     * 流式 streamChat 调用
+     * 通过回调函数推送 content 和 reasoningContent
+     */
+    async streamChat(callbacks) {
+        const selector = this.createSelector();
+        selector.resetTriedModels();
+        while (selector.hasNext()) {
+            if (this.signal.aborted) {
+                break;
+            }
+            const model = selector.getNext();
+            if (!model)
+                break;
+            try {
+                await this.streamRequest(model, callbacks);
+                return;
+            }
+            catch (error) {
+                selector.markTried(model.id);
+            }
+        }
+        throw new Error('All models are unavailable');
+    }
+    /**
+     * 创建模型选择器（全局单例）
+     */
+    createSelector() {
+        const selector = ModelSelectorWrapper.getInstance(this.models, this.preferredModelId);
+        selector.resetTriedModels();
+        return selector;
+    }
+    /**
+     * 构建请求
+     */
+    async buildRequest(model, stream) {
+        const apiKey = persistStore.getModelApiKey(model.id);
+        if (!apiKey) {
+            throw new Error('No API Key');
+        }
+        if (model.baseUrl.includes('coze.com')) {
+            // Coze API: 使用 query 字段，只支持文本
+            const lastMessage = this.messages[this.messages.length - 1];
+            let queryContent = lastMessage?.content || '';
+            // 如果有附件，在查询中添加附件信息
+            if (lastMessage?.attachments && lastMessage.attachments.length > 0) {
+                const attachmentInfos = lastMessage.attachments.map(a => `[${a.type === 'image' ? '图片' : '文件'}: ${a.name}](${a.url})`).join('\n');
+                queryContent += `\n\n${attachmentInfos}`;
+            }
+            return {
+                url: `${model.baseUrl}/chat`,
+                headers: {
+                    'Content-Type': 'application/json',
+                    'Authorization': `Bearer ${apiKey}`,
+                },
+                body: {
+                    bot_id: model.modelId,
+                    conversation_id: '', // 非会话模式
+                    user: '',
+                    query: queryContent,
+                    stream,
+                },
+            };
+        }
+        else if (model.baseUrl.includes('anthropic.com')) {
+            return {
+                url: `${model.baseUrl}/v1/messages`,
+                headers: {
+                    'Content-Type': 'application/json',
+                    'x-api-key': apiKey || '',
+                    'anthropic-version': '2023-06-01',
+                    'anthropic-dangerous-direct-browser-access': 'true',
+                },
+                body: {
+                    model: model.modelId,
+                    messages: this.messages.filter((m) => m.role !== 'system').map((m) => {
+                        // 处理工具消息
+                        if (m.role === 'tool') {
+                            return {
+                                role: 'user',
+                                content: [
+                                    {
+                                        type: 'tool_result',
+                                        tool_use_id: m.tool_call_id,
+                                        content: m.content,
+                                    }
+                                ],
+                            };
+                        }
+                        // 处理用户消息中的附件
+                        if (m.role === 'user' && m.attachments && m.attachments.length > 0) {
+                            const contentArray = [];
+                            // 如果有文本内容，先添加文本
+                            if (m.content && m.content.trim()) {
+                                contentArray.push({
+                                    type: 'text',
+                                    text: m.content,
+                                });
+                            }
+                            // 添加附件
+                            for (const attachment of m.attachments) {
+                                if (attachment.type === 'image') {
+                                    // Anthropic 支持 base64 图片
+                                    // 假设 attachment.url 可能是 base64 格式或 URL 格式
+                                    if (attachment.url.startsWith('data:')) {
+                                        // base64 格式
+                                        const base64Data = attachment.url.split(',')[1];
+                                        const mimeType = attachment.mimeType || 'image/png';
+                                        contentArray.push({
+                                            type: 'image',
+                                            source: {
+                                                type: 'base64',
+                                                media_type: mimeType,
+                                                data: base64Data,
+                                            },
+                                        });
+                                    }
+                                    else {
+                                        // URL 格式 - Anthropic 也支持
+                                        contentArray.push({
+                                            type: 'image',
+                                            source: {
+                                                type: 'url',
+                                                media_type: attachment.mimeType || 'image/png',
+                                                url: attachment.url,
+                                            },
+                                        });
+                                    }
+                                }
+                                else {
+                                    // 其他文件类型 - Anthropic 不直接支持，添加为文本引用
+                                    const fileInfo = `[附件: ${attachment.name}](${attachment.url})`;
+                                    if (contentArray.length === 0) {
+                                        contentArray.push({
+                                            type: 'text',
+                                            text: fileInfo,
+                                        });
+                                    }
+                                    else {
+                                        const lastItem = contentArray[contentArray.length - 1];
+                                        if (lastItem.type === 'text') {
+                                            lastItem.text += `\n${fileInfo}`;
+                                        }
+                                        else {
+                                            contentArray.push({
+                                                type: 'text',
+                                                text: fileInfo,
+                                            });
+                                        }
+                                    }
+                                }
+                            }
+                            return {
+                                role: 'user',
+                                content: contentArray,
+                            };
+                        }
+                        // 普通用户消息（无附件）
+                        return {
+                            role: m.role,
+                            content: m.content,
+                        };
+                    }),
+                    stream,
+                    max_tokens: model.maxTokens || 4096,
+                },
+            };
+        }
+        else {
+            // OpenAI compatible API
+            const body = {
+                model: model.modelId,
+                messages: this.messages.map((m) => {
+                    if (m.role === 'tool') {
+                        return [{
+                                role: 'tool',
+                                tool_call_id: m.tool_call_id,
+                                content: m.content,
+                            }];
+                    }
+                    // 助手调用工具的消息：必须保留 tool_calls！！（你之前丢了，导致报错）
+                    if (m.role === 'assistant' && m.tool_calls) {
+                        return [{
+                                role: 'assistant',
+                                content: m.content || null,
+                                tool_calls: m.tool_calls.map(m => {
+                                    return {
+                                        id: m.id,
+                                        function: {
+                                            name: m.toolName,
+                                            arguments: m.input
+                                        },
+                                        type: 'function'
+                                    };
+                                }),
+                            }];
+                    }
+                    if (m.role === 'assistant' && m.toolCalls) {
+                        let items = [];
+                        for (let toolCall of m.toolCalls) {
+                            const item = {
+                                role: 'assistant',
+                                content: toolCall.content,
+                                reasoning_content: toolCall.reasoningContent,
+                                tool_calls: []
+                            };
+                            const tools = [];
+                            for (let i = 0; i < toolCall.toolCalls.length; i++) {
+                                const toolCallItem = toolCall.toolCalls[i];
+                                if (toolCallItem.output != null) {
+                                    item.tool_calls.push({
+                                        id: toolCallItem.id,
+                                        function: {
+                                            name: toolCallItem.toolName,
+                                            arguments: toolCallItem.input
+                                        },
+                                        type: 'function'
+                                    });
+                                    tools.push({
+                                        role: 'tool',
+                                        tool_call_id: toolCallItem.id,
+                                        content: toolCallItem.output.substring(0, 100) + '...' + '(内容过长已截断)'
+                                    });
+                                }
+                            }
+                            if (item.tool_calls.length > 0) {
+                                items.push(item);
+                                items = items.concat(tools);
+                            }
+                        }
+                        if (m.content) {
+                            items.push({
+                                role: 'assistant',
+                                content: m.content
+                            });
+                        }
+                        return items;
+                    }
+                    // 处理用户消息中的附件
+                    if (m.role === 'user' && m.attachments && m.attachments.length > 0) {
+                        const contentArray = [];
+                        // 如果有文本内容，先添加文本
+                        if (m.content && m.content.trim()) {
+                            contentArray.push({
+                                type: 'text',
+                                text: m.content,
+                            });
+                        }
+                        // 添加附件
+                        for (const attachment of m.attachments) {
+                            if (attachment.type === 'image') {
+                                // 图片附件
+                                contentArray.push({
+                                    type: 'image_url',
+                                    image_url: {
+                                        url: attachment.url,
+                                        detail: 'high',
+                                    },
+                                });
+                            }
+                            else if (attachment.type === 'audio') {
+                                // 音频附件 - 使用 file 类型
+                                contentArray.push({
+                                    type: 'input_audio',
+                                    input_audio: {
+                                        data: attachment.url, // 如果是 base64 格式
+                                        format: attachment.mimeType?.split('/')[1] || 'wav',
+                                    },
+                                });
+                            }
+                            else {
+                                // 其他文件类型：video, file - 添加为文本引用
+                                const fileInfo = `[附件: ${attachment.name}](${attachment.url})`;
+                                if (contentArray.length === 0) {
+                                    contentArray.push({
+                                        type: 'text',
+                                        text: fileInfo,
+                                    });
+                                }
+                                else {
+                                    // 如果已经有文本，将文件信息追加到文本中
+                                    const lastItem = contentArray[contentArray.length - 1];
+                                    if (lastItem.type === 'text') {
+                                        lastItem.text += `\n${fileInfo}`;
+                                    }
+                                    else {
+                                        contentArray.push({
+                                            type: 'text',
+                                            text: fileInfo,
+                                        });
+                                    }
+                                }
+                            }
+                        }
+                        return [{
+                                role: m.role,
+                                content: contentArray,
+                            }];
+                    }
+                    // 普通消息（无附件）
+                    return [{
+                            role: m.role,
+                            content: m.content,
+                        }];
+                }).flatMap(x => x),
+                stream,
+                enable_thinking: true,
+            };
+            if (this.tools && this.tools.length > 0) {
+                body.tools = this.tools;
+            }
+            const tokens = JSON.stringify(body).length;
+            logger.debug('tokens', tokens);
+            if (tokens > 100000) {
+                logger.warn('message is too large and has writen to the file debug.json');
+                await fs.writeFile('debug.json', JSON.stringify(body.messages), 'utf-8');
+                throw Error('exceed max message tokens');
+            }
+            return {
+                url: `${model.baseUrl}/chat/completions`,
+                headers: {
+                    'Content-Type': 'application/json',
+                    'Authorization': `Bearer ${apiKey}`,
+                },
+                body,
+            };
+        }
+    }
+    /**
+     * 执行流式请求
+     */
+    async streamRequest(model, callbacks) {
+        const request = await this.buildRequest(model, true);
+        const response = await fetch(request.url, {
+            method: 'POST',
+            headers: request.headers,
+            body: JSON.stringify(request.body),
+            signal: this.signal
+        });
+        if (!response.ok) {
+            const errorText = await response.text();
+            throw new Error(`${response.status} - ${errorText}`);
+        }
+        const reader = response.body?.getReader();
+        if (!reader) {
+            throw new Error('Response body is not readable');
+        }
+        const decoder = new TextDecoder();
+        let buffer = '';
+        let reasoningContent = '';
+        // 解析 SSE 行
+        const parseSSELine = (line) => {
+            if (line.startsWith('data: ')) {
+                return { type: 'data', data: line.slice(6) };
+            }
+            return null;
+        };
+        // 解析增量内容
+        const parseDelta = (data) => {
+            // Coze 格式
+            if (data.type === 'conversation_message.delta') {
+                return { content: data.message?.content?.[0]?.text || '' };
+            }
+            if (data.type === 'conversation_message.completed') {
+                if (data.message?.thinking) {
+                    reasoningContent = data.message.thinking;
+                    return { reasoningContent };
+                }
+                return { content: data.message?.content?.[0]?.text || '' };
+            }
+            // OpenAI/DeepSeek 格式
+            if (data.choices?.[0]?.delta) {
+                const delta = data.choices[0].delta;
+                // reasoning_content (DeepSeek)
+                if (delta.reasoning_content) {
+                    return { reasoningContent: delta.reasoning_content };
+                }
+                // content
+                if (delta.content) {
+                    return { content: delta.content };
+                }
+                // tool_calls
+                if (delta.tool_calls) {
+                    return {
+                        toolCalls: delta.tool_calls.map((tc) => ({
+                            id: tc.id || '',
+                            name: tc.function?.name || '',
+                            arguments: tc.function?.arguments || '',
+                        })),
+                    };
+                }
+            }
+            // Claude 格式
+            if (data.type === 'message_delta') {
+                return {};
+            }
+            if (data.type === 'content_block_start') {
+                if (data.content_block?.type === 'thinking') {
+                    return {};
+                }
+                if (data.content_block?.type === 'text') {
+                    return {};
+                }
+            }
+            if (data.type === 'content_block_delta') {
+                if (data.delta?.type === 'thinking') {
+                    return { reasoningContent: data.delta.thinking };
+                }
+                if (data.delta?.type === 'text_delta') {
+                    return { content: data.delta.text };
+                }
+                if (data.delta?.type === 'tool_use') {
+                    return {
+                        toolCalls: [{
+                                id: data.delta.id || '',
+                                toolName: data.delta.name || '',
+                                input: data.delta.input || '',
+                            }],
+                    };
+                }
+            }
+            return {};
+        };
+        try {
+            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 parsed = parseSSELine(line);
+                    if (!parsed || parsed.data === '[DONE]')
+                        continue;
+                    try {
+                        const data = JSON.parse(parsed.data);
+                        const result = parseDelta(data);
+                        if (result.content) {
+                            callbacks.onContent?.(result.content);
+                        }
+                        if (result.reasoningContent) {
+                            reasoningContent += result.reasoningContent;
+                            callbacks.onReasoningContent?.(result.reasoningContent);
+                        }
+                        if (result.toolCalls) {
+                            for (const tc of result.toolCalls) {
+                                callbacks.onToolCall?.(tc);
+                            }
+                        }
+                    }
+                    catch (e) {
+                        // Ignore parse errors
+                    }
+                }
+            }
+        }
+        finally {
+            reader.releaseLock();
+        }
+    }
+    /**
+     * 解析非流式响应
+     */
+    parseResponse(data, modelName) {
+        // Coze 格式
+        if (data.type === 'conversation_message.completed' || data.message) {
+            const messageData = data.message || {};
+            return {
+                content: messageData.content?.[0]?.text || '',
+                reasoningContent: messageData.thinking || undefined,
+                modelName
+            };
+        }
+        // OpenAI/DeepSeek 格式
+        if (data.choices?.[0]?.message) {
+            const messageData = data.choices[0].message;
+            return {
+                content: messageData.content || '',
+                reasoningContent: messageData.reasoning_content || undefined,
+                toolCalls: messageData.tool_calls?.map((tc) => ({
+                    id: tc.id,
+                    toolName: tc.function?.name,
+                    input: tc.function?.arguments,
+                    actionName: this.getActionName(tc.function?.arguments)
+                })),
+                modelName
+            };
+        }
+        // Claude 格式
+        if (data.content) {
+            const toolCalls = [];
+            let content = '';
+            let reasoningContent = '';
+            for (const block of data.content) {
+                if (block.type === 'text') {
+                    content += block.text;
+                }
+                else if (block.type === 'thinking') {
+                    reasoningContent += block.thinking;
+                }
+                else if (block.type === 'tool_use') {
+                    toolCalls.push({
+                        id: block.id,
+                        toolName: block.name,
+                        input: typeof block.input === 'string' ? block.input : JSON.stringify(block.input),
+                        actionName: this.getActionName(typeof block.input === 'string' ? block.input : JSON.stringify(block.input))
+                    });
+                }
+            }
+            return {
+                content,
+                reasoningContent: reasoningContent || undefined,
+                toolCalls: toolCalls.length > 0 ? toolCalls : undefined,
+                modelName
+            };
+        }
+        return { content: '', modelName };
+    }
+    /**
+     * 检查是否是可用性错误
+     */
+    isAvailabilityError(error) {
+        if (!error)
+            return false;
+        const errorStr = String(error);
+        const availabilityCodes = [
+            'ECONNREFUSED',
+            'ETIMEDOUT',
+            'ENOTFOUND',
+            '429',
+            '500',
+            '502',
+            '503',
+            '504',
+            'insufficient_quota',
+            'rate_limit_exceeded',
+            'model_not_found',
+            'context_length_exceeded',
+            'Model call failed',
+            'No API Key',
+            'InvalidEndpointOrModel',
+            'AuthenticationError',
+            "model service has been paused",
+            "SetLimitExceeded"
+        ];
+        return availabilityCodes.some(code => errorStr.includes(code));
+    }
+}
+/**
+ * 模型选择器包装器（全局单例）
+ */
+let modelSelectorInstance = null;
+class ModelSelectorWrapper {
+    models;
+    triedModels;
+    preferredModelId;
+    scoreModels;
+    constructor(models, preferredModelId) {
+        this.models = models;
+        this.preferredModelId = preferredModelId;
+        this.triedModels = new Map();
+        this.scoreModels = new Map();
+    }
+    /**
+     * 获取全局单例实例
+     */
+    static getInstance(models, preferredModelId) {
+        if (!modelSelectorInstance) {
+            if (!models) {
+                throw new Error('Models are required for initializing ModelSelectorWrapper');
+            }
+            modelSelectorInstance = new ModelSelectorWrapper(models, preferredModelId);
+        }
+        else if (models) {
+            // 传入新参数时更新实例配置
+            modelSelectorInstance.models = models;
+            if (preferredModelId) {
+                modelSelectorInstance.preferredModelId = preferredModelId;
+            }
+        }
+        return modelSelectorInstance;
+    }
+    /**
+     * 重置模型尝试记录
+     */
+    resetTriedModels() {
+        this.triedModels.clear();
+    }
+    //模型调用次数小于2均可再次调用
+    canModelTry(id) {
+        return !this.triedModels.has(id) || this.triedModels.get(id) < 2;
+    }
+    getScore(model) {
+        return model.score + (this.scoreModels.has(model.id) ? this.scoreModels.get(model.id) : 0) + (model.isPrimary ? 1 : 0);
+    }
+    getNext() {
+        // 优先返回首选模型
+        if (this.preferredModelId && this.canModelTry(this.preferredModelId)) {
+            const preferred = this.models.find((m) => m.id === this.preferredModelId && m.isActive);
+            if (preferred)
+                return preferred;
+        }
+        // 按评分选择
+        const availableModels = this.models.filter((m) => m.isActive && this.canModelTry(m.id));
+        if (availableModels.length === 0)
+            return null;
+        availableModels.sort((a, b) => this.getScore(b) - this.getScore(a));
+        return availableModels[0] || null;
+    }
+    markTried(id) {
+        if (this.triedModels.has(id)) {
+            this.triedModels.set(id, this.triedModels.get(id) + 1);
+        }
+        else {
+            this.triedModels.set(id, 1);
+        }
+        if (this.scoreModels.has(id)) {
+            this.scoreModels.set(id, this.scoreModels.get(id) - 1);
+        }
+        else {
+            this.scoreModels.set(id, -1);
+        }
+    }
+    hasNext() {
+        return this.getNext() !== null;
+    }
+}
+export function parseAruments(params) {
+    try {
+        return typeof params === 'string' ? JSON.parse(params) : params;
+    }
+    catch {
+        return params;
+    }
+}
+/**
+ * 全局模型选择器单例访问入口
+ * @param models 模型列表（首次初始化时必填）
+ * @param preferredModelId 首选模型ID
+ * @returns 全局唯一的模型选择器实例
+ */
+export const getGlobalModelSelector = ModelSelectorWrapper.getInstance;