markpdfdown 0.1.0

package/dist/main/OpenAIResponsesClient-DETYz2nL.js

@@ -0,0 +1,297 @@
+import { L as LLMClient } from "./index.js";
+class OpenAIResponsesClient extends LLMClient {
+  constructor(apiKey, baseUrl) {
+    super(apiKey, baseUrl || "https://api.openai.com/v1/responses");
+  }
+  /**
+   * 执行OpenAI Responses API补全
+   */
+  async completion(options) {
+    try {
+      const normalizedOptions = this.normalizeOptions(options);
+      const { input, instructions } = this.convertMessagesToResponsesFormat(normalizedOptions.messages);
+      const requestBody = {
+        model: normalizedOptions.model || "gpt-4o",
+        input,
+        temperature: normalizedOptions.temperature ?? 0.7,
+        max_tokens: normalizedOptions.maxTokens,
+        stream: normalizedOptions.stream || false
+      };
+      if (instructions) {
+        requestBody.instructions = instructions;
+      }
+      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 Responses API错误: ${error.error?.message || response.statusText}`);
+      }
+      if (normalizedOptions.stream && response.body && normalizedOptions.onUpdate) {
+        return this.handleResponsesStreaming(response, normalizedOptions);
+      } else {
+        const data = await response.json();
+        return this.parseResponsesOutput(data, normalizedOptions);
+      }
+    } catch (error) {
+      const errorMessage = error instanceof Error ? error.message : String(error);
+      throw new Error(`OpenAI Responses API补全请求失败: ${errorMessage}`);
+    }
+  }
+  /**
+   * 将消息转换为Responses API格式
+   * 提取system消息作为instructions，其他消息放入input
+   */
+  convertMessagesToResponsesFormat(messages) {
+    const systemMessages = [];
+    const inputMessages = [];
+    for (const message of messages) {
+      if (message.role === "system") {
+        if (typeof message.content === "string") {
+          systemMessages.push(message.content);
+        } else if (Array.isArray(message.content)) {
+          for (const content of message.content) {
+            if (content.type === "text") {
+              systemMessages.push(content.text);
+            }
+          }
+        } else if (message.content.type === "text") {
+          systemMessages.push(message.content.text);
+        }
+      } else {
+        const inputMessage = {
+          role: message.role
+        };
+        if (message.name) {
+          inputMessage.name = message.name;
+        }
+        if (Array.isArray(message.content)) {
+          const allText = message.content.every((c) => c.type === "text");
+          if (allText) {
+            inputMessage.content = message.content.map((c) => c.text).join("");
+          } else {
+            inputMessage.content = message.content.map((content) => this.convertContentToResponsesAPIFormat(content));
+          }
+        } else {
+          if (typeof message.content === "string") {
+            inputMessage.content = message.content;
+          } else if (message.content.type === "text") {
+            inputMessage.content = message.content.text;
+          } else {
+            inputMessage.content = [this.convertContentToResponsesAPIFormat(message.content)];
+          }
+        }
+        inputMessages.push(inputMessage);
+      }
+    }
+    const result = {
+      input: inputMessages
+    };
+    if (systemMessages.length > 0) {
+      result.instructions = systemMessages.join("\n\n");
+    }
+    return result;
+  }
+  /**
+   * 将内容对象转换为Responses API格式（用于数组内容）
+   * Responses API有不同的内容类型命名
+   */
+  convertContentToResponsesAPIFormat(content) {
+    switch (content.type) {
+      case "text":
+        return {
+          type: "input_text",
+          text: content.text
+        };
+      case "image_url": {
+        const imageContent = content;
+        return {
+          type: "input_image",
+          // Responses API uses 'input_image' for user-provided images
+          image_url: imageContent.image_url.url
+        };
+      }
+      case "tool_call": {
+        const toolCallContent = content;
+        return {
+          type: "function_call",
+          // Responses API uses 'function_call'
+          call_id: toolCallContent.tool_call_id,
+          name: toolCallContent.function.name,
+          arguments: toolCallContent.function.arguments
+        };
+      }
+      case "tool_result": {
+        const toolResultContent = content;
+        return {
+          type: "function_call_output",
+          // Responses API uses 'function_call_output'
+          call_id: toolResultContent.tool_call_id,
+          output: toolResultContent.content
+        };
+      }
+      default:
+        throw new Error(`不支持的内容类型: ${content.type}`);
+    }
+  }
+  /**
+   * 解析Responses API的输出
+   */
+  parseResponsesOutput(data, options) {
+    let responseContent = "";
+    const toolCalls = [];
+    if (data.output && data.output.length > 0) {
+      const outputItem = data.output[0];
+      if (outputItem.content) {
+        if (typeof outputItem.content === "string") {
+          responseContent = outputItem.content;
+        } else if (Array.isArray(outputItem.content)) {
+          responseContent = outputItem.content.filter((c) => c.type === "text").map((c) => c.text).join("");
+        }
+      }
+      if (outputItem.tool_calls && outputItem.tool_calls.length > 0) {
+        for (const toolCall of outputItem.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.output?.[0]?.finish_reason || "stop",
+      toolCalls: toolCalls.length > 0 ? toolCalls : void 0,
+      responseFormat: options.response_format?.type,
+      rawResponse: data
+      // 保留原始响应以便调试
+    };
+  }
+  /**
+   * 处理Responses API的流式响应
+   * 使用SSE格式: event: <type>\ndata: <json>\n\n
+   */
+  async handleResponsesStreaming(response, options) {
+    const reader = response.body.getReader();
+    const decoder = new TextDecoder("utf-8");
+    let content = "";
+    const toolCalls = [];
+    let finishReason;
+    let model = options.model || "gpt-4o";
+    let buffer = "";
+    const processStream = async () => {
+      const { done, value } = await reader.read();
+      if (done) {
+        return {
+          content,
+          model,
+          finishReason: finishReason || "stop",
+          toolCalls: toolCalls.length > 0 ? toolCalls : void 0,
+          responseFormat: options.response_format?.type
+        };
+      }
+      buffer += decoder.decode(value, { stream: true });
+      const lines = buffer.split("\n");
+      buffer = lines.pop() || "";
+      let currentEvent = null;
+      for (const line of lines) {
+        const trimmedLine = line.trim();
+        if (trimmedLine === "") {
+          currentEvent = null;
+          continue;
+        }
+        if (trimmedLine.startsWith("event:")) {
+          currentEvent = trimmedLine.substring(6).trim();
+        } else if (trimmedLine.startsWith("data:")) {
+          const dataStr = trimmedLine.substring(5).trim();
+          if (dataStr === "[DONE]") {
+            continue;
+          }
+          try {
+            const data = JSON.parse(dataStr);
+            if (currentEvent === "response.output_text.delta") {
+              if (data.delta) {
+                content += data.delta;
+                if (options.onUpdate) {
+                  options.onUpdate(content);
+                }
+              }
+            } else if (currentEvent === "response.output_item.done") {
+              if (data.item) {
+                if (data.item.tool_calls && data.item.tool_calls.length > 0) {
+                  for (const toolCall of data.item.tool_calls) {
+                    toolCalls.push({
+                      id: toolCall.id,
+                      type: toolCall.type,
+                      function: {
+                        name: toolCall.function.name,
+                        arguments: toolCall.function.arguments
+                      }
+                    });
+                  }
+                }
+              }
+            } else if (currentEvent === "response.completed") {
+              if (data.response) {
+                model = data.response.model || model;
+                finishReason = data.response.output?.[0]?.finish_reason;
+              }
+            } else if (currentEvent === "response.tool_calls.delta") {
+              if (data.delta && data.index !== void 0) {
+                let toolCall = toolCalls[data.index];
+                if (!toolCall && data.delta.id) {
+                  toolCall = {
+                    id: data.delta.id,
+                    type: "function",
+                    function: {
+                      name: "",
+                      arguments: ""
+                    }
+                  };
+                  toolCalls[data.index] = toolCall;
+                }
+                if (toolCall && data.delta.function) {
+                  if (data.delta.function.name) {
+                    toolCall.function.name = data.delta.function.name;
+                  }
+                  if (data.delta.function.arguments) {
+                    toolCall.function.arguments += data.delta.function.arguments;
+                  }
+                }
+              }
+            }
+          } catch (e) {
+            console.warn("Failed to parse SSE data:", dataStr, e);
+          }
+        }
+      }
+      return processStream();
+    };
+    return processStream();
+  }
+}
+export {
+  OpenAIResponsesClient
+};