markpdfdown 0.1.8-beta.6 → 0.2.0

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

@@ -1,220 +0,0 @@
-import { LLMClient } from './LLMClient.js';
-/**
- * Ollama客户端实现
- */
-export class OllamaClient extends LLMClient {
-    constructor(apiKey, baseUrl) {
-        super(apiKey, baseUrl || 'http://localhost:11434/api/chat');
-    }
-    /**
-     * 执行Ollama文本补全
-     */
-    async completion(options) {
-        try {
-            // 标准化选项，处理向后兼容
-            const normalizedOptions = this.normalizeOptions(options);
-            // 转换消息格式为Ollama格式
-            const ollamaMessages = this.convertMessagesToOllamaFormat(normalizedOptions.messages);
-            const requestBody = {
-                model: normalizedOptions.model || 'llama3',
-                messages: ollamaMessages,
-                stream: normalizedOptions.stream !== false, // 默认为流式响应
-                options: {}
-            };
-            // 添加额外选项
-            if (normalizedOptions.temperature !== undefined) {
-                requestBody.options.temperature = normalizedOptions.temperature;
-            }
-            if (normalizedOptions.maxTokens !== undefined) {
-                requestBody.options.num_predict = normalizedOptions.maxTokens;
-            }
-            // 添加工具配置（如果有）
-            if (normalizedOptions.tools && normalizedOptions.tools.length > 0) {
-                requestBody.tools = normalizedOptions.tools;
-            }
-            // 添加响应格式（如果指定）
-            if (normalizedOptions.response_format?.type === 'json_object') {
-                requestBody.format = 'json';
-            }
-            const response = await fetch(`${this.baseUrl}`, {
-                method: 'POST',
-                headers: {
-                    'Content-Type': 'application/json'
-                },
-                body: JSON.stringify(requestBody)
-            });
-            console.log(`[${new Date().toISOString()}] POST ${this.baseUrl} ${response.status} - ${response.statusText}`);
-            // console.log(JSON.stringify(requestBody));
-            if (!response.ok) {
-                const error = await response.json();
-                throw new Error(`Ollama API错误: ${error.error || response.statusText}`);
-            }
-            if (normalizedOptions.stream && response.body && normalizedOptions.onUpdate) {
-                // 处理流式响应
-                const reader = response.body.getReader();
-                const decoder = new TextDecoder('utf-8');
-                let content = '';
-                let model = '';
-                const processStream = async () => {
-                    const { done, value } = await reader.read();
-                    if (done) {
-                        return {
-                            content,
-                            model: model || normalizedOptions.model || 'llama3',
-                            finishReason: 'stop',
-                            responseFormat: normalizedOptions.response_format?.type
-                        };
-                    }
-                    // 解析流式响应数据
-                    const chunk = decoder.decode(value);
-                    const lines = chunk.split('\n').filter(line => line.trim() !== '');
-                    for (const line of lines) {
-                        try {
-                            const data = JSON.parse(line);
-                            // 存储模型名称
-                            if (data.model && !model) {
-                                model = data.model;
-                            }
-                            // 提取消息内容
-                            if (data.message && data.message.content) {
-                                if (!data.done) {
-                                    // 累加流式内容
-                                    content += data.message.content;
-                                    if (normalizedOptions.onUpdate) {
-                                        normalizedOptions.onUpdate(content);
-                                    }
-                                }
-                            }
-                            // 如果是最后一条消息，可以直接返回结果
-                            if (data.done === true) {
-                                return {
-                                    content,
-                                    model: data.model || normalizedOptions.model || 'llama3',
-                                    finishReason: 'stop',
-                                    responseFormat: normalizedOptions.response_format?.type,
-                                    rawResponse: data
-                                };
-                            }
-                        }
-                        catch (e) {
-                            // 忽略解析错误
-                        }
-                    }
-                    return processStream();
-                };
-                return processStream();
-            }
-            else {
-                // 处理非流式响应
-                const data = await response.json();
-                return {
-                    content: data.message?.content || '',
-                    model: data.model,
-                    finishReason: data.done ? 'stop' : undefined,
-                    responseFormat: normalizedOptions.response_format?.type,
-                    rawResponse: data // 保留原始响应以便调试
-                };
-            }
-        }
-        catch (error) {
-            const errorMessage = error instanceof Error ? error.message : String(error);
-            throw new Error(`Ollama补全请求失败: ${errorMessage}`);
-        }
-    }
-    /**
-     * 将消息转换为Ollama API格式
-     */
-    convertMessagesToOllamaFormat(messages) {
-        return messages.map(message => {
-            const ollamaMessage = {
-                role: message.role
-            };
-            // 处理内容
-            if (Array.isArray(message.content)) {
-                // 处理多部分内容
-                ollamaMessage.content = this.convertContentArrayToOllamaFormat(message.content);
-            }
-            else {
-                // 处理单一内容
-                ollamaMessage.content = this.convertContentToOllamaFormat(message.content);
-            }
-            // 处理图片（如果是多模态模型）
-            const images = this.extractImages(message.content);
-            if (images.length > 0) {
-                ollamaMessage.images = images;
-            }
-            return ollamaMessage;
-        });
-    }
-    /**
-     * 提取消息中的图片
-     */
-    extractImages(content) {
-        const images = [];
-        if (Array.isArray(content)) {
-            // 从内容数组中提取图片
-            for (const item of content) {
-                if (item.type === 'image_url') {
-                    const imageContent = item;
-                    images.push(this.processImageUrl(imageContent.image_url.url));
-                }
-            }
-        }
-        else if (content.type === 'image_url') {
-            // 从单个图片内容中提取
-            const imageContent = content;
-            images.push(this.processImageUrl(imageContent.image_url.url));
-        }
-        return images;
-    }
-    /**
-     * 处理图片 URL，去掉 data URI 前缀
-     */
-    processImageUrl(url) {
-        // 如果是 data URI，移除前缀
-        if (url.startsWith('data:')) {
-            const parts = url.split(';base64,');
-            if (parts.length === 2) {
-                return parts[1]; // 只返回 base64 编码部分
-            }
-        }
-        return url;
-    }
-    /**
-     * 将内容数组转换为Ollama内容格式
-     */
-    convertContentArrayToOllamaFormat(contentArray) {
-        return contentArray
-            .map(content => this.convertContentToOllamaFormat(content))
-            .join('\n');
-    }
-    /**
-     * 将单个内容转换为Ollama内容格式
-     */
-    convertContentToOllamaFormat(content) {
-        switch (content.type) {
-            case 'text':
-                return content.text;
-            case 'image_url':
-                // 图片会单独处理到images字段，这里只返回提示
-                return '';
-            case 'tool_call':
-                const toolCall = content;
-                return JSON.stringify({
-                    tool_call_id: toolCall.tool_call_id,
-                    function: {
-                        name: toolCall.function.name,
-                        arguments: toolCall.function.arguments
-                    }
-                });
-            case 'tool_result':
-                const toolResult = content;
-                return JSON.stringify({
-                    tool_call_id: toolResult.tool_call_id,
-                    content: toolResult.content
-                });
-            default:
-                return '';
-        }
-    }
-}

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

@@ -1,235 +0,0 @@
-import { LLMClient } from './LLMClient.js';
-/**
- * OpenAI客户端实现
- */
-export class OpenAIClient extends LLMClient {
-    constructor(apiKey, baseUrl) {
-        super(apiKey, baseUrl || 'https://api.openai.com/v1/chat/completions');
-    }
-    /**
-     * 执行OpenAI文本补全
-     */
-    async completion(options) {
-        try {
-            // 标准化选项，处理向后兼容
-            const normalizedOptions = this.normalizeOptions(options);
-            // 转换消息格式为OpenAI格式
-            const openaiMessages = this.convertMessagesToOpenAIFormat(normalizedOptions.messages);
-            const requestBody = {
-                model: normalizedOptions.model || 'gpt-3.5-turbo',
-                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(`${this.baseUrl}`, {
-                method: 'POST',
-                headers: {
-                    'Content-Type': 'application/json',
-                    'Authorization': `Bearer ${normalizedOptions.apiKey || this.apiKey}`
-                },
-                body: JSON.stringify(requestBody)
-            });
-            console.log(`[${new Date().toISOString()}] POST ${this.baseUrl} ${response.status} - ${response.statusText}`);
-            if (!response.ok) {
-                const error = await response.json();
-                throw new Error(`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 || 'gpt-3.5-turbo',
-                            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,
-                    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(`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/example-advanced.js

@@ -1,231 +0,0 @@
-import { LLMClientFactory } from './LLMClient.js';
-/**
- * 高级功能示例：多轮对话、多角色和图片支持
- */
-async function advancedExample() {
-    try {
-        // 创建OpenAI客户端
-        const openaiClient = await LLMClientFactory.createClient('openai', 'your-openai-api-key');
-        // 1. 基本多轮对话示例
-        console.log('=== 多轮对话示例 ===');
-        const chatMessages = [
-            {
-                role: 'system',
-                content: {
-                    type: 'text',
-                    text: '你是一个专业的AI助手，善于回答用户的问题。请简短、直接地回答。'
-                }
-            },
-            {
-                role: 'user',
-                content: {
-                    type: 'text',
-                    text: '你好，我想了解一下人工智能。'
-                }
-            },
-            {
-                role: 'assistant',
-                content: {
-                    type: 'text',
-                    text: '人工智能是计算机科学的一个分支，旨在创建能够像人类一样思考和学习的智能机器。它包括机器学习、深度学习、自然语言处理等领域。有什么具体方面你想了解的吗？'
-                }
-            },
-            {
-                role: 'user',
-                content: {
-                    type: 'text',
-                    text: '自然语言处理是什么？'
-                }
-            }
-        ];
-        const chatResponse = await openaiClient.completion({
-            messages: chatMessages,
-            model: 'gpt-4'
-        });
-        console.log('对话响应:', chatResponse.content);
-        // 2. 图片分析示例
-        console.log('\n=== 图片分析示例 ===');
-        const imageMessages = [
-            {
-                role: 'user',
-                content: [
-                    {
-                        type: 'text',
-                        text: '这张图片是什么？请详细描述一下。'
-                    },
-                    {
-                        type: 'image_url',
-                        image_url: { url: 'https://example.com/sample-image.jpg' }, // 请替换为实际图片URL
-                    }
-                ]
-            }
-        ];
-        const imageResponse = await openaiClient.completion({
-            messages: imageMessages,
-            model: 'gpt-4-vision-preview' // 支持图像的模型
-        });
-        console.log('图片分析响应:', imageResponse.content);
-        // 3. 工具调用示例
-        console.log('\n=== 工具调用示例 ===');
-        // 定义一个简单的计算器工具
-        const calculatorTool = {
-            type: 'function',
-            function: {
-                name: 'calculate',
-                description: '执行基本数学计算',
-                parameters: {
-                    type: 'object',
-                    properties: {
-                        operation: {
-                            type: 'string',
-                            enum: ['add', 'subtract', 'multiply', 'divide'],
-                            description: '要执行的操作'
-                        },
-                        a: {
-                            type: 'number',
-                            description: '第一个操作数'
-                        },
-                        b: {
-                            type: 'number',
-                            description: '第二个操作数'
-                        }
-                    },
-                    required: ['operation', 'a', 'b']
-                }
-            }
-        };
-        const toolMessages = [
-            {
-                role: 'user',
-                content: {
-                    type: 'text',
-                    text: '我需要计算123乘以456是多少'
-                }
-            }
-        ];
-        const toolResponse = await openaiClient.completion({
-            messages: toolMessages,
-            model: 'gpt-4',
-            tools: [calculatorTool],
-            tool_choice: 'auto'
-        });
-        console.log('工具调用响应:', toolResponse);
-        // 如果有工具调用，处理它并继续对话
-        if (toolResponse.toolCalls && toolResponse.toolCalls.length > 0) {
-            const toolCall = toolResponse.toolCalls[0];
-            console.log('工具调用:', toolCall.function.name);
-            console.log('参数:', toolCall.function.arguments);
-            // 解析参数
-            const args = JSON.parse(toolCall.function.arguments);
-            // 执行计算
-            let result;
-            switch (args.operation) {
-                case 'add':
-                    result = args.a + args.b;
-                    break;
-                case 'subtract':
-                    result = args.a - args.b;
-                    break;
-                case 'multiply':
-                    result = args.a * args.b;
-                    break;
-                case 'divide':
-                    result = args.a / args.b;
-                    break;
-                default:
-                    throw new Error(`不支持的操作: ${args.operation}`);
-            }
-            // 继续对话，添加工具响应
-            const toolResultMessages = [
-                ...toolMessages,
-                {
-                    role: 'assistant',
-                    content: {
-                        type: 'text',
-                        text: toolResponse.content
-                    }
-                },
-                {
-                    role: 'tool',
-                    content: {
-                        type: 'tool_result',
-                        tool_call_id: toolCall.id,
-                        content: JSON.stringify({ result })
-                    }
-                }
-            ];
-            const finalResponse = await openaiClient.completion({
-                messages: toolResultMessages,
-                model: 'gpt-4'
-            });
-            console.log('最终响应:', finalResponse.content);
-        }
-        // 4. JSON 响应格式示例
-        console.log('\n=== JSON响应格式示例 ===');
-        const jsonMessages = [
-            {
-                role: 'system',
-                content: {
-                    type: 'text',
-                    text: '你是一个API服务，返回结构化的JSON数据。'
-                }
-            },
-            {
-                role: 'user',
-                content: {
-                    type: 'text',
-                    text: '给我三本经典科幻小说的信息，包括书名、作者和出版年份。'
-                }
-            }
-        ];
-        const jsonResponse = await openaiClient.completion({
-            messages: jsonMessages,
-            model: 'gpt-4',
-            response_format: { type: 'json_object' }
-        });
-        console.log('JSON响应:', jsonResponse.content);
-        console.log('解析后的JSON:', JSON.parse(jsonResponse.content));
-    }
-    catch (error) {
-        console.error('示例运行出错:', error);
-    }
-}
-// 辅助函数：将图片文件转换为base64数据URI（用于本地文件）
-export function imageToDataURI(filePath) {
-    return new Promise((resolve, reject) => {
-        const fs = require('fs');
-        fs.readFile(filePath, (err, data) => {
-            if (err) {
-                reject(err);
-                return;
-            }
-            // 获取文件扩展名
-            const extension = filePath.split('.').pop()?.toLowerCase();
-            let mimeType;
-            switch (extension) {
-                case 'jpg':
-                case 'jpeg':
-                    mimeType = 'image/jpeg';
-                    break;
-                case 'png':
-                    mimeType = 'image/png';
-                    break;
-                case 'gif':
-                    mimeType = 'image/gif';
-                    break;
-                case 'webp':
-                    mimeType = 'image/webp';
-                    break;
-                default:
-                    mimeType = 'application/octet-stream';
-            }
-            const base64Data = data.toString('base64');
-            const dataURI = `data:${mimeType};base64,${base64Data}`;
-            resolve(dataURI);
-        });
-    });
-}
-// 运行示例
-// advancedExample().catch(console.error);
-// 导出函数
-export { advancedExample };