markpdfdown 0.1.8-beta.6 → 0.2.0

package/dist/server/logic/llm/AzureOpenAIClient.js

@@ -1,239 +0,0 @@
-import { LLMClient } from './LLMClient.js';
-/**
- * Azure OpenAI客户端实现
- */
-export class AzureOpenAIClient extends LLMClient {
-    constructor(apiKey, baseUrl, deploymentName = 'gpt-35-turbo', apiVersion = '2023-05-15') {
-        // Azure OpenAI需要完整的资源URL
-        super(apiKey, baseUrl);
-        this.deploymentName = deploymentName;
-        this.apiVersion = apiVersion;
-    }
-    /**
-     * 执行Azure OpenAI文本补全
-     */
-    async completion(options) {
-        try {
-            // 标准化选项，处理向后兼容
-            const normalizedOptions = this.normalizeOptions(options);
-            // Azure OpenAI端点格式
-            const endpoint = `${this.baseUrl}${normalizedOptions.model || this.deploymentName}/chat/completions?api-version=${this.apiVersion}`;
-            // 转换消息格式为OpenAI格式（Azure OpenAI API兼容OpenAI API）
-            const openaiMessages = this.convertMessagesToOpenAIFormat(normalizedOptions.messages);
-            const requestBody = {
-                messages: openaiMessages,
-                temperature: normalizedOptions.temperature ?? 0.7,
-                max_tokens: normalizedOptions.maxTokens,
-                stream: normalizedOptions.stream || false
-            };
-            // 添加工具配置（如果有）
-            if (normalizedOptions.tools && normalizedOptions.tools.length > 0) {
-                requestBody.tools = normalizedOptions.tools;
-                if (normalizedOptions.tool_choice) {
-                    requestBody.tool_choice = normalizedOptions.tool_choice;
-                }
-            }
-            // 添加响应格式（如果指定）
-            if (normalizedOptions.response_format) {
-                requestBody.response_format = normalizedOptions.response_format;
-            }
-            const response = await fetch(endpoint, {
-                method: 'POST',
-                headers: {
-                    'Content-Type': 'application/json',
-                    'api-key': normalizedOptions.apiKey || this.apiKey
-                },
-                body: JSON.stringify(requestBody)
-            });
-            console.log(`[${new Date().toISOString()}] POST ${endpoint} ${response.status} - ${response.statusText}`);
-            if (!response.ok) {
-                const error = await response.json();
-                throw new Error(`Azure OpenAI API错误: ${error.error?.message || response.statusText}`);
-            }
-            if (normalizedOptions.stream && response.body && normalizedOptions.onUpdate) {
-                // 处理流式响应
-                const reader = response.body.getReader();
-                const decoder = new TextDecoder('utf-8');
-                let content = '';
-                const toolCalls = [];
-                const processStream = async () => {
-                    const { done, value } = await reader.read();
-                    if (done) {
-                        return {
-                            content,
-                            model: normalizedOptions.model || this.deploymentName,
-                            finishReason: 'stop',
-                            toolCalls: toolCalls.length > 0 ? toolCalls : undefined,
-                            responseFormat: normalizedOptions.response_format?.type
-                        };
-                    }
-                    // 解析流式响应数据
-                    const chunk = decoder.decode(value);
-                    const lines = chunk
-                        .split('\n')
-                        .filter(line => line.trim() !== '' && line.trim() !== 'data: [DONE]');
-                    for (const line of lines) {
-                        if (line.startsWith('data: ')) {
-                            try {
-                                const data = JSON.parse(line.slice(6));
-                                // 处理常规文本内容
-                                if (data.choices && data.choices[0]?.delta?.content) {
-                                    const newContent = data.choices[0].delta.content;
-                                    content += newContent;
-                                    if (normalizedOptions.onUpdate) {
-                                        normalizedOptions.onUpdate(content);
-                                    }
-                                }
-                                // 处理工具调用
-                                if (data.choices && data.choices[0]?.delta?.tool_calls) {
-                                    const deltaToolCalls = data.choices[0].delta.tool_calls;
-                                    for (const deltaTool of deltaToolCalls) {
-                                        // 查找现有工具调用或创建新的
-                                        let toolCall = toolCalls.find(tc => tc.id === deltaTool.id);
-                                        if (!toolCall && deltaTool.id) {
-                                            toolCall = {
-                                                id: deltaTool.id,
-                                                type: 'function',
-                                                function: {
-                                                    name: '',
-                                                    arguments: ''
-                                                }
-                                            };
-                                            toolCalls.push(toolCall);
-                                        }
-                                        if (toolCall && deltaTool.function) {
-                                            if (deltaTool.function.name) {
-                                                toolCall.function.name = deltaTool.function.name;
-                                            }
-                                            if (deltaTool.function.arguments) {
-                                                toolCall.function.arguments += deltaTool.function.arguments;
-                                            }
-                                        }
-                                    }
-                                    // 如果有工具调用，同时更新内容
-                                    if (normalizedOptions.onUpdate) {
-                                        normalizedOptions.onUpdate(content);
-                                    }
-                                }
-                            }
-                            catch (e) {
-                                // 忽略解析错误
-                            }
-                        }
-                    }
-                    return processStream();
-                };
-                return processStream();
-            }
-            else {
-                // 处理普通响应
-                const data = await response.json();
-                // 提取响应内容
-                let responseContent = '';
-                const toolCalls = [];
-                if (data.choices && data.choices[0]?.message) {
-                    const message = data.choices[0].message;
-                    // 提取文本内容
-                    if (typeof message.content === 'string') {
-                        responseContent = message.content;
-                    }
-                    // 提取工具调用
-                    if (message.tool_calls && message.tool_calls.length > 0) {
-                        for (const toolCall of message.tool_calls) {
-                            toolCalls.push({
-                                id: toolCall.id,
-                                type: toolCall.type,
-                                function: {
-                                    name: toolCall.function.name,
-                                    arguments: toolCall.function.arguments
-                                }
-                            });
-                        }
-                    }
-                }
-                return {
-                    content: responseContent,
-                    model: data.model || normalizedOptions.model || this.deploymentName,
-                    finishReason: data.choices[0]?.finish_reason,
-                    toolCalls: toolCalls.length > 0 ? toolCalls : undefined,
-                    responseFormat: normalizedOptions.response_format?.type,
-                    rawResponse: data // 保留原始响应以便调试
-                };
-            }
-        }
-        catch (error) {
-            const errorMessage = error instanceof Error ? error.message : String(error);
-            throw new Error(`Azure OpenAI补全请求失败: ${errorMessage}`);
-        }
-    }
-    /**
-     * 将消息转换为OpenAI API格式
-     */
-    convertMessagesToOpenAIFormat(messages) {
-        return messages.map(message => {
-            const openaiMessage = {
-                role: message.role
-            };
-            // 处理名称字段（如果存在）
-            if (message.name) {
-                openaiMessage.name = message.name;
-            }
-            // 处理内容
-            if (Array.isArray(message.content)) {
-                // 处理多部分内容
-                openaiMessage.content = message.content.map(content => this.convertContentToOpenAIFormat(content));
-            }
-            else {
-                // 处理单一内容
-                const content = this.convertContentToOpenAIFormat(message.content);
-                // 如果是简单的文本内容，则直接使用字符串
-                if (content.type === 'text') {
-                    openaiMessage.content = content.text;
-                }
-                else {
-                    openaiMessage.content = [content];
-                }
-            }
-            return openaiMessage;
-        });
-    }
-    /**
-     * 将内容对象转换为OpenAI API格式
-     */
-    convertContentToOpenAIFormat(content) {
-        switch (content.type) {
-            case 'text':
-                return {
-                    type: 'text',
-                    text: content.text
-                };
-            case 'image_url':
-                const imageContent = content;
-                return {
-                    type: 'image_url',
-                    image_url: {
-                        url: imageContent.image_url.url,
-                    }
-                };
-            case 'tool_call':
-                const toolCallContent = content;
-                return {
-                    type: 'tool_call',
-                    tool_call_id: toolCallContent.tool_call_id,
-                    function: {
-                        name: toolCallContent.function.name,
-                        arguments: toolCallContent.function.arguments
-                    }
-                };
-            case 'tool_result':
-                const toolResultContent = content;
-                return {
-                    type: 'tool_result',
-                    tool_call_id: toolResultContent.tool_call_id,
-                    content: toolResultContent.content
-                };
-            default:
-                throw new Error(`不支持的内容类型: ${content.type}`);
-        }
-    }
-}

package/dist/server/logic/llm/GeminiClient.js

@@ -1,213 +0,0 @@
-import { LLMClient } from './LLMClient.js';
-/**
- * Google Gemini客户端实现
- */
-export class GeminiClient extends LLMClient {
-    constructor(apiKey, baseUrl) {
-        super(apiKey, baseUrl || 'https://generativelanguage.googleapis.com/v1/models');
-    }
-    /**
-     * 执行Gemini文本补全
-     */
-    async completion(options) {
-        try {
-            // 标准化选项，处理向后兼容
-            const normalizedOptions = this.normalizeOptions(options);
-            const modelName = normalizedOptions.model || 'gemini-1.5-pro';
-            const endpoint = `${this.baseUrl}/${modelName}:generateContent?key=${normalizedOptions.apiKey || this.apiKey}`;
-            // 将消息转换为Gemini格式
-            const geminiContents = this.convertMessagesToGeminiFormat(normalizedOptions.messages);
-            const requestBody = {
-                contents: geminiContents,
-                generationConfig: {
-                    temperature: normalizedOptions.temperature ?? 0.7,
-                    maxOutputTokens: normalizedOptions.maxTokens,
-                    topP: 0.95
-                }
-            };
-            // 添加响应格式（如果指定）
-            if (normalizedOptions.response_format?.type === 'json_object') {
-                // Gemini使用不同的键来指定JSON输出
-                requestBody.generationConfig.response_mime_type = 'application/json';
-            }
-            const response = await fetch(endpoint, {
-                method: 'POST',
-                headers: {
-                    'Content-Type': 'application/json'
-                },
-                body: JSON.stringify(requestBody)
-            });
-            console.log(`[${new Date().toISOString()}] POST ${endpoint} ${response.status} - ${response.statusText}`);
-            if (!response.ok) {
-                const error = await response.json();
-                throw new Error(`Gemini API错误: ${error.error?.message || response.statusText}`);
-            }
-            const data = await response.json();
-            // Gemini API返回格式与其他模型不同
-            if (data.candidates && data.candidates.length > 0) {
-                const candidate = data.candidates[0];
-                let content = '';
-                if (candidate.content && candidate.content.parts) {
-                    for (const part of candidate.content.parts) {
-                        if (part.text) {
-                            content += part.text;
-                        }
-                    }
-                }
-                return {
-                    content,
-                    model: modelName,
-                    finishReason: candidate.finishReason,
-                    responseFormat: normalizedOptions.response_format?.type,
-                    rawResponse: data // 保留原始响应以便调试
-                };
-            }
-            throw new Error('Gemini API返回格式错误');
-        }
-        catch (error) {
-            const errorMessage = error instanceof Error ? error.message : String(error);
-            throw new Error(`Gemini补全请求失败: ${errorMessage}`);
-        }
-    }
-    /**
-     * 将消息转换为Gemini API格式
-     */
-    convertMessagesToGeminiFormat(messages) {
-        const geminiContents = [];
-        let currentRole = null;
-        let currentContent = [];
-        // Gemini有不同的消息格式，需要相邻的相同角色消息合并
-        for (const message of messages) {
-            // 跳过System消息，因为Gemini不直接支持，稍后会特殊处理
-            if (message.role === 'system') {
-                continue;
-            }
-            // 如果角色变化，创建新的内容块
-            const geminiRole = this.mapRoleToGemini(message.role);
-            if (currentRole !== geminiRole && currentContent.length > 0) {
-                geminiContents.push({
-                    role: currentRole,
-                    parts: currentContent
-                });
-                currentContent = [];
-            }
-            currentRole = geminiRole;
-            // 处理消息内容
-            if (Array.isArray(message.content)) {
-                // 处理多部分内容
-                for (const content of message.content) {
-                    currentContent.push(this.convertContentToGeminiFormat(content));
-                }
-            }
-            else {
-                // 处理单一内容
-                currentContent.push(this.convertContentToGeminiFormat(message.content));
-            }
-        }
-        // 添加最后一组消息
-        if (currentRole && currentContent.length > 0) {
-            geminiContents.push({
-                role: currentRole,
-                parts: currentContent
-            });
-        }
-        // 特殊处理系统消息：将系统消息添加到第一个用户消息的前面
-        const systemMessages = messages.filter(msg => msg.role === 'system');
-        if (systemMessages.length > 0 && geminiContents.length > 0 && geminiContents[0].role === 'user') {
-            for (const sysMsg of systemMessages) {
-                const text = Array.isArray(sysMsg.content)
-                    ? sysMsg.content.map(c => c.type === 'text' ? c.text : '').join('\n')
-                    : sysMsg.content.type === 'text' ? sysMsg.content.text : '';
-                if (text) {
-                    // 在用户消息前添加系统指令
-                    if (typeof geminiContents[0].parts[0] === 'object' && geminiContents[0].parts[0].text) {
-                        geminiContents[0].parts[0].text = `[System Instructions]: ${text}\n\n${geminiContents[0].parts[0].text}`;
-                    }
-                }
-            }
-        }
-        return geminiContents;
-    }
-    /**
-     * 将内容对象转换为Gemini API格式
-     */
-    convertContentToGeminiFormat(content) {
-        switch (content.type) {
-            case 'text':
-                return {
-                    text: content.text
-                };
-            case 'image_url':
-                const imageContent = content;
-                return {
-                    inline_data: {
-                        mime_type: this.getMimeTypeFromUrl(imageContent.image_url.url),
-                        data: this.extractBase64FromUrl(imageContent.image_url.url)
-                    }
-                };
-            // Gemini不直接支持工具调用和工具结果
-            case 'tool_call':
-            case 'tool_result':
-                // 将工具相关内容转换为文本
-                return {
-                    text: JSON.stringify(content)
-                };
-            default:
-                throw new Error(`Gemini不支持的内容类型: ${content.type}`);
-        }
-    }
-    /**
-     * 从URL中提取MIME类型
-     */
-    getMimeTypeFromUrl(url) {
-        if (url.startsWith('data:')) {
-            const mimeMatch = url.match(/^data:([^;]+);/);
-            return mimeMatch ? mimeMatch[1] : 'image/jpeg';
-        }
-        const extension = url.split('.').pop()?.toLowerCase();
-        switch (extension) {
-            case 'jpg':
-            case 'jpeg':
-                return 'image/jpeg';
-            case 'png':
-                return 'image/png';
-            case 'gif':
-                return 'image/gif';
-            case 'webp':
-                return 'image/webp';
-            default:
-                return 'image/jpeg';
-        }
-    }
-    /**
-     * 从数据URL中提取base64数据
-     */
-    extractBase64FromUrl(url) {
-        if (url.startsWith('data:')) {
-            return url.split(',')[1];
-        }
-        // 对于非数据URL，需要先获取图像数据
-        // 在实际应用中，这里可能需要进行异步请求获取图像并转换为base64
-        // 这里简化处理，返回空字符串
-        return '';
-    }
-    /**
-     * 将角色映射到Gemini支持的角色
-     */
-    mapRoleToGemini(role) {
-        switch (role) {
-            case 'user':
-                return 'user';
-            case 'assistant':
-                return 'model';
-            case 'system':
-                // Gemini不直接支持系统角色，将在处理中特殊处理
-                return 'user';
-            case 'tool':
-                // Gemini不直接支持工具角色，将其视为用户输入
-                return 'user';
-            default:
-                return 'user';
-        }
-    }
-}

package/dist/server/logic/llm/LLMClient.js

@@ -1,83 +0,0 @@
-/**
- * LLM客户端接口定义
- */
-/**
- * LLM客户端基类
- */
-export class LLMClient {
-    constructor(apiKey, baseUrl = '') {
-        this.apiKey = apiKey;
-        this.baseUrl = baseUrl;
-    }
-    /**
-     * 向后兼容处理单一prompt
-     * @param options 可能包含旧格式prompt的选项
-     * @returns 标准化后的选项
-     */
-    normalizeOptions(options) {
-        const normalizedOptions = { ...options };
-        // 如果存在旧的prompt字段，将其转换为消息格式
-        if ('prompt' in normalizedOptions && normalizedOptions.prompt) {
-            // 如果没有messages字段或为空数组，则使用prompt创建一个用户消息
-            if (!normalizedOptions.messages || normalizedOptions.messages.length === 0) {
-                normalizedOptions.messages = [{
-                        role: 'user',
-                        content: {
-                            type: 'text',
-                            text: normalizedOptions.prompt
-                        }
-                    }];
-            }
-            // 删除原始prompt字段
-            delete normalizedOptions.prompt;
-        }
-        // 如果有systemPrompt但没有system角色消息，添加一个system角色消息
-        if (normalizedOptions.systemPrompt &&
-            (!normalizedOptions.messages || !normalizedOptions.messages.some(m => m.role === 'system'))) {
-            const systemMessage = {
-                role: 'system',
-                content: {
-                    type: 'text',
-                    text: normalizedOptions.systemPrompt
-                }
-            };
-            normalizedOptions.messages = normalizedOptions.messages || [];
-            normalizedOptions.messages.unshift(systemMessage);
-            // 删除原始systemPrompt字段
-            delete normalizedOptions.systemPrompt;
-        }
-        return normalizedOptions;
-    }
-}
-/**
- * LLM客户端工厂类，用于创建不同的LLM客户端实例
- */
-export class LLMClientFactory {
-    /**
-     * 创建LLM客户端实例
-     * @param type LLM客户端类型
-     * @param apiKey API密钥
-     * @param baseUrl 基础URL，某些服务需要自定义
-     */
-    static async createClient(type, apiKey, baseUrl) {
-        switch (type) {
-            case 'openai':
-                const OpenAIModule = await import('./OpenAIClient.js');
-                return new OpenAIModule.OpenAIClient(apiKey, baseUrl || '');
-            case 'azure-openai':
-                const AzureOpenAIModule = await import('./AzureOpenAIClient.js');
-                return new AzureOpenAIModule.AzureOpenAIClient(apiKey, baseUrl || '');
-            case 'gemini':
-                const GeminiModule = await import('./GeminiClient.js');
-                return new GeminiModule.GeminiClient(apiKey, baseUrl || '');
-            case 'anthropic':
-                const AnthropicModule = await import('./AnthropicClient.js');
-                return new AnthropicModule.AnthropicClient(apiKey, baseUrl || '');
-            case 'ollama':
-                const OllamaModule = await import('./OllamaClient.js');
-                return new OllamaModule.OllamaClient(apiKey, baseUrl || '');
-            default:
-                throw new Error(`不支持的LLM客户端类型: ${type}`);
-        }
-    }
-}