markpdfdown 0.1.8-beta.6 → 0.2.0

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

@@ -1,80 +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 || '');
-            default:
-                throw new Error(`不支持的LLM客户端类型: ${type}`);
-        }
-    }
-}

package/dist/app/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');
-    }
-    /**
-     * 执行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}/chat/completions`, {
-                method: 'POST',
-                headers: {
-                    'Content-Type': 'application/json',
-                    'Authorization': `Bearer ${normalizedOptions.apiKey || this.apiKey}`
-                },
-                body: JSON.stringify(requestBody)
-            });
-            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 = '';
-                let 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':
-                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/example-advanced.js

@@ -1,232 +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',
-                        image_url: 'https://example.com/sample-image.jpg', // 请替换为实际图片URL
-                        detail: 'high'
-                    }
-                ]
-            }
-        ];
-        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 };

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

@@ -1,14 +0,0 @@
-/**
- * LLM客户端模块导出
- */
-// 导出接口和基类
-export { LLMClient, LLMClientFactory } from './LLMClient.js';
-// 导出具体实现类
-export { OpenAIClient } from './OpenAIClient.js';
-export { AzureOpenAIClient } from './AzureOpenAIClient.js';
-export { GeminiClient } from './GeminiClient.js';
-export { AnthropicClient } from './AnthropicClient.js';
-// 导入工厂类以供默认导出
-import { LLMClientFactory } from './LLMClient.js';
-// 默认导出工厂类
-export default LLMClientFactory;

package/dist/app/logic/model.js

@@ -1,27 +0,0 @@
-// @ts-ignore
-import providerDal from '../dal/providerDal.js';
-import { LLMClientFactory } from './llm/LLMClient.js';
-// 根据服务商ID获取LLM客户端
-const getLLMClient = async (providerId) => {
-    const provider = await providerDal.findById(providerId);
-    if (!provider) {
-        throw new Error('服务商不存在');
-    }
-    return LLMClientFactory.createClient(provider.type || '', provider.api_key || '', `${provider.base_url || ''}${provider.suffix || ''}`);
-};
-// 补全请求
-const completion = async (providerId, modelId, messages, options) => {
-    const llmClient = await getLLMClient(providerId);
-    // 从options中提取除messages外的其他选项
-    const { messages: _messages, model: _model, ...otherOptions } = options || {};
-    // 按CompletionOptions格式转换messages
-    const completionOptions = {
-        messages: messages,
-        model: modelId,
-        ...otherOptions
-    };
-    return llmClient.completion(completionOptions);
-};
-export default {
-    completion
-};

package/dist/app/middleware/logger.js

@@ -1,23 +0,0 @@
-/**
- * 请求日志中间件
- * 记录所有API请求的信息
- */
-const requestLogger = (req, res, next) => {
-    const start = Date.now();
-    // 请求完成后记录日志信息
-    res.on('finish', () => {
-        const duration = Date.now() - start;
-        console.log(`[${new Date().toISOString()}] ${req.method} ${req.originalUrl} ${res.statusCode} - ${duration}ms`);
-    });
-    next();
-};
-/**
- * 错误日志中间件
- * 记录API错误信息
- */
-const errorLogger = (err, _req, _res, next) => {
-    console.error(`[${new Date().toISOString()}] 错误: ${err.message}`);
-    console.error(err.stack);
-    next(err);
-};
-export { requestLogger, errorLogger };

package/dist/app/routes/routes.js

@@ -1,16 +0,0 @@
-import express from 'express';
-import providerController from '../controllers/providerController.js';
-import modelController from '../controllers/modelController.js';
-const router = express.Router();
-// 服务商路由
-router.get('/providers', providerController.getAllProviders);
-router.get('/providers/:id', providerController.getProviderById);
-router.post('/providers', providerController.createProvider);
-router.put('/providers/:id', providerController.updateProvider);
-router.delete('/providers/:id', providerController.deleteProvider);
-router.put('/providers/:id/status', providerController.updateProviderStatus);
-// 模型路由
-router.get('/models/:provider', modelController.getModelsByProviderId);
-router.post('/models', modelController.createModel);
-router.delete('/models/:id/:provider', modelController.deleteModel);
-export default router;

package/dist/app/types/Provider.js

@@ -1 +0,0 @@
-export {};