markpdfdown 0.1.0

package/dist/main/GeminiClient-CrtYbwaF.js

@@ -0,0 +1,196 @@
+import { L as LLMClient } from "./index.js";
+class GeminiClient extends LLMClient {
+  constructor(apiKey, baseUrl) {
+    super(apiKey, baseUrl || "https://generativelanguage.googleapis.com/v1beta/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`;
+      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") {
+        requestBody.generationConfig.response_mime_type = "application/json";
+      }
+      const response = await fetch(endpoint, {
+        method: "POST",
+        headers: {
+          "Content-Type": "application/json",
+          "x-goog-api-key": normalizedOptions.apiKey || this.apiKey,
+          "X-Title": "MarkPDFdown",
+          "HTTP-Referer": "https://github.com/MarkPDFdown"
+        },
+        body: JSON.stringify(requestBody)
+      });
+      console.log(`[${(/* @__PURE__ */ new Date()).toISOString()}] POST ${endpoint} (model: ${modelName}) ${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();
+      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 = [];
+    for (const message of messages) {
+      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}
+
+${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];
+    }
+    return "";
+  }
+  /**
+   * 将角色映射到Gemini支持的角色
+   */
+  mapRoleToGemini(role) {
+    switch (role) {
+      case "user":
+        return "user";
+      case "assistant":
+        return "model";
+      case "system":
+        return "user";
+      case "tool":
+        return "user";
+      default:
+        return "user";
+    }
+  }
+}
+export {
+  GeminiClient
+};

package/dist/main/OllamaClient-DKJsnvIt.js

@@ -0,0 +1,197 @@
+import { L as LLMClient } from "./index.js";
+class OllamaClient extends LLMClient {
+  constructor(apiKey, baseUrl) {
+    super(apiKey, baseUrl || "http://localhost:11434/api");
+  }
+  /**
+   * 执行Ollama文本补全
+   */
+  async completion(options) {
+    try {
+      const normalizedOptions = this.normalizeOptions(options);
+      const ollamaMessages = this.convertMessagesToOllamaFormat(normalizedOptions.messages);
+      const requestBody = {
+        model: normalizedOptions.model || "llama3",
+        messages: ollamaMessages,
+        stream: normalizedOptions.stream !== false,
+        // 默认为流式响应
+        options: {}
+      };
+      if (normalizedOptions.temperature !== void 0) {
+        requestBody.options.temperature = normalizedOptions.temperature;
+      }
+      if (normalizedOptions.maxTokens !== void 0) {
+        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",
+          "X-Title": "MarkPDFdown",
+          "HTTP-Referer": "https://github.com/MarkPDFdown"
+        },
+        body: JSON.stringify(requestBody)
+      });
+      console.log(`[${(/* @__PURE__ */ new Date()).toISOString()}] POST ${this.baseUrl} (model: ${requestBody.model}) ${response.status} - ${response.statusText}`);
+      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 {
+            }
+          }
+          return processStream();
+        };
+        return processStream();
+      } else {
+        const data = await response.json();
+        return {
+          content: data.message?.content || "",
+          model: data.model,
+          finishReason: data.done ? "stop" : void 0,
+          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) {
+    if (url.startsWith("data:")) {
+      const parts = url.split(";base64,");
+      if (parts.length === 2) {
+        return parts[1];
+      }
+    }
+    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":
+        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 "";
+    }
+  }
+}
+export {
+  OllamaClient
+};

package/dist/main/OpenAIClient-gyy2nFkw.js

@@ -0,0 +1,214 @@
+import { L as LLMClient } from "./index.js";
+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);
+      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}`,
+          "X-Title": "MarkPDFdown",
+          "HTTP-Referer": "https://github.com/MarkPDFdown"
+        },
+        body: JSON.stringify(requestBody)
+      });
+      console.log(`[${(/* @__PURE__ */ new Date()).toISOString()}] POST ${this.baseUrl} (model: ${requestBody.model}) ${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 : void 0,
+              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 {
+              }
+            }
+          }
+          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 : void 0,
+          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}`);
+    }
+  }
+}
+export {
+  OpenAIClient
+};