markpdfdown 0.1.8-beta.6 → 0.2.0

package/dist/app/logic/llm/AnthropicClient.js

@@ -1,219 +0,0 @@
-import { LLMClient } from './LLMClient.js';
-/**
- * Anthropic客户端实现
- */
-export class AnthropicClient extends LLMClient {
-    constructor(apiKey, baseUrl, apiVersion = '2023-06-01') {
-        super(apiKey, baseUrl || 'https://api.anthropic.com/v1');
-        this.apiVersion = apiVersion;
-    }
-    /**
-     * 执行Anthropic文本补全
-     */
-    async completion(options) {
-        try {
-            // 标准化选项，处理向后兼容
-            const normalizedOptions = this.normalizeOptions(options);
-            const endpoint = `${this.baseUrl}/messages`;
-            const modelName = normalizedOptions.model || 'claude-3-opus-20240229';
-            // 将消息转换为Anthropic格式
-            const anthropicMessages = this.convertMessagesToAnthropicFormat(normalizedOptions.messages);
-            const requestBody = {
-                model: modelName,
-                messages: anthropicMessages,
-                temperature: normalizedOptions.temperature ?? 0.7,
-                max_tokens: normalizedOptions.maxTokens,
-                stream: normalizedOptions.stream || false
-            };
-            // Anthropic支持System指令，而不是作为一个普通消息
-            const systemMessage = normalizedOptions.messages.find(msg => msg.role === 'system');
-            if (systemMessage) {
-                const systemContent = Array.isArray(systemMessage.content)
-                    ? systemMessage.content.filter(c => c.type === 'text').map(c => c.text).join('\n')
-                    : systemMessage.content.type === 'text' ? systemMessage.content.text : '';
-                if (systemContent) {
-                    requestBody.system = systemContent;
-                }
-            }
-            // Claude没有直接的JSON响应格式，但可以通过系统指令引导
-            if (normalizedOptions.response_format?.type === 'json_object' && !requestBody.system) {
-                requestBody.system = "请以有效的JSON格式提供响应。";
-            }
-            else if (normalizedOptions.response_format?.type === 'json_object' && requestBody.system) {
-                requestBody.system += "\n\n请以有效的JSON格式提供响应。";
-            }
-            const response = await fetch(endpoint, {
-                method: 'POST',
-                headers: {
-                    'Content-Type': 'application/json',
-                    'x-api-key': normalizedOptions.apiKey || this.apiKey,
-                    'anthropic-version': this.apiVersion
-                },
-                body: JSON.stringify(requestBody)
-            });
-            if (!response.ok) {
-                const error = await response.json();
-                throw new Error(`Anthropic 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 processStream = async () => {
-                    const { done, value } = await reader.read();
-                    if (done) {
-                        return {
-                            content,
-                            model: modelName,
-                            finishReason: 'stop',
-                            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));
-                                // Claude 3使用content_block_delta类型流式传输内容
-                                if (data.type === 'content_block_delta' && data.delta?.text) {
-                                    content += data.delta.text;
-                                    if (normalizedOptions.onUpdate) {
-                                        normalizedOptions.onUpdate(content);
-                                    }
-                                }
-                                // 兼容Claude 2流式响应格式
-                                if (data.completion) {
-                                    const newContent = data.completion;
-                                    content = newContent; // Claude 2返回完整内容，而不是增量
-                                    if (normalizedOptions.onUpdate) {
-                                        normalizedOptions.onUpdate(content);
-                                    }
-                                }
-                            }
-                            catch (e) {
-                                // 忽略解析错误
-                            }
-                        }
-                    }
-                    return processStream();
-                };
-                return processStream();
-            }
-            else {
-                // 处理普通响应
-                const data = await response.json();
-                // Claude API返回格式
-                let content = '';
-                // Claude 3格式
-                if (data.content) {
-                    // 提取所有文本块
-                    for (const block of data.content) {
-                        if (block.type === 'text') {
-                            content += block.text;
-                        }
-                    }
-                }
-                // 兼容Claude 2格式
-                else if (data.completion) {
-                    content = data.completion;
-                }
-                return {
-                    content,
-                    model: data.model,
-                    finishReason: data.stop_reason,
-                    responseFormat: normalizedOptions.response_format?.type,
-                    rawResponse: data // 保留原始响应以便调试
-                };
-            }
-        }
-        catch (error) {
-            const errorMessage = error instanceof Error ? error.message : String(error);
-            throw new Error(`Anthropic补全请求失败: ${errorMessage}`);
-        }
-    }
-    /**
-     * 将消息转换为Anthropic API格式
-     * Claude API移除系统消息，这将在请求体中单独处理
-     */
-    convertMessagesToAnthropicFormat(messages) {
-        return messages
-            .filter(msg => msg.role !== 'system') // 系统消息会在请求体中单独处理
-            .map(message => {
-            // Anthropic只支持user和assistant角色
-            let role = message.role === 'user' ? 'user' : 'assistant';
-            // 将tool角色视为user角色
-            if (message.role === 'tool') {
-                role = 'user';
-            }
-            const anthropicMessage = {
-                role
-            };
-            // 处理内容
-            if (Array.isArray(message.content)) {
-                anthropicMessage.content = this.convertContentArrayToAnthropicFormat(message.content);
-            }
-            else {
-                anthropicMessage.content = this.convertContentToAnthropicFormat(message.content);
-            }
-            return anthropicMessage;
-        });
-    }
-    /**
-     * 将内容数组转换为Anthropic内容格式
-     */
-    convertContentArrayToAnthropicFormat(contentArray) {
-        return contentArray.map(content => this.convertContentToAnthropicFormat(content)).flat();
-    }
-    /**
-     * 将单个内容转换为Anthropic内容格式
-     */
-    convertContentToAnthropicFormat(content) {
-        switch (content.type) {
-            case 'text':
-                return [{
-                        type: 'text',
-                        text: content.text
-                    }];
-            case 'image':
-                const imageContent = content;
-                let source;
-                if (imageContent.image_url.startsWith('data:')) {
-                    // 处理Base64数据URI
-                    const parts = imageContent.image_url.split(';base64,');
-                    if (parts.length === 2) {
-                        const mediaType = parts[0].replace('data:', '');
-                        source = {
-                            type: 'base64',
-                            media_type: mediaType,
-                            data: parts[1]
-                        };
-                    }
-                }
-                else {
-                    // 处理URL
-                    source = {
-                        type: 'url',
-                        url: imageContent.image_url
-                    };
-                }
-                return [{
-                        type: 'image',
-                        source
-                    }];
-            // Anthropic不支持工具调用和工具结果，将其转换为文本
-            case 'tool_call':
-            case 'tool_result':
-                return [{
-                        type: 'text',
-                        text: JSON.stringify(content)
-                    }];
-            default:
-                throw new Error(`Anthropic不支持的内容类型: ${content.type}`);
-        }
-    }
-}

package/dist/app/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}/openai/deployments/${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)
-            });
-            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 = '';
-                let 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':
-                const imageContent = content;
-                return {
-                    type: 'image_url',
-                    image_url: {
-                        url: imageContent.image_url,
-                        detail: imageContent.detail || 'auto'
-                    }
-                };
-            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/app/logic/llm/GeminiClient.js

@@ -1,212 +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');
-    }
-    /**
-     * 执行Gemini文本补全
-     */
-    async completion(options) {
-        try {
-            // 标准化选项，处理向后兼容
-            const normalizedOptions = this.normalizeOptions(options);
-            const modelName = normalizedOptions.model || 'gemini-1.5-pro';
-            const endpoint = `${this.baseUrl}/models/${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)
-            });
-            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':
-                const imageContent = content;
-                return {
-                    inline_data: {
-                        mime_type: this.getMimeTypeFromUrl(imageContent.image_url),
-                        data: this.extractBase64FromUrl(imageContent.image_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';
-        }
-    }
-}