@omnicross/core 0.1.1 → 0.1.2

package/dist/chunk-5ZQBEOMD.js

@@ -0,0 +1,764 @@
+// src/api-converter/shared.ts
+function convertOpenAITool(tool) {
+  return {
+    name: tool.function.name,
+    description: tool.function.description,
+    input_schema: tool.function.parameters
+  };
+}
+function mapAnthropicStopReason(stopReason) {
+  switch (stopReason) {
+    case "end_turn":
+      return "stop";
+    case "max_tokens":
+      return "length";
+    case "tool_use":
+      return "tool_calls";
+    case "stop_sequence":
+      return "stop";
+    default:
+      return "stop";
+  }
+}
+function mapOpenAIFinishReason(finishReason) {
+  switch (finishReason) {
+    case "stop":
+      return "end_turn";
+    case "length":
+      return "max_tokens";
+    case "tool_calls":
+      return "tool_use";
+    case "content_filter":
+      return "end_turn";
+    default:
+      return "end_turn";
+  }
+}
+function hasImageContent(request) {
+  const messages = request.messages;
+  for (const msg of messages) {
+    if (Array.isArray(msg.content)) {
+      for (const part of msg.content) {
+        if ("type" in part && part.type === "image_url") {
+          return true;
+        }
+        if ("type" in part && part.type === "image") {
+          return true;
+        }
+      }
+    }
+  }
+  return false;
+}
+function hasThinkingEnabled(request) {
+  if ("thinking" in request && request.thinking?.type === "enabled") {
+    return true;
+  }
+  if ("reasoning" in request) {
+    return true;
+  }
+  return false;
+}
+
+// src/api-converter/anthropic-to-openai.ts
+function convertAnthropicToOpenAI(response) {
+  const content = [];
+  const toolCalls = [];
+  let reasoningContent = "";
+  for (const block of response.content) {
+    if (block.type === "text") {
+      content.push(block.text);
+    } else if (block.type === "tool_use") {
+      toolCalls.push({
+        id: block.id,
+        type: "function",
+        function: {
+          name: block.name,
+          arguments: JSON.stringify(block.input)
+        }
+      });
+    } else if (block.type === "thinking") {
+      reasoningContent += block.thinking;
+    }
+  }
+  const finishReason = mapAnthropicStopReason(response.stop_reason);
+  const result = {
+    id: response.id,
+    object: "chat.completion",
+    created: Math.floor(Date.now() / 1e3),
+    model: response.model,
+    choices: [
+      {
+        index: 0,
+        message: {
+          role: "assistant",
+          content: content.join("\n") || null,
+          ...toolCalls.length > 0 ? { tool_calls: toolCalls } : {}
+        },
+        finish_reason: finishReason
+      }
+    ],
+    usage: {
+      prompt_tokens: response.usage.input_tokens,
+      completion_tokens: response.usage.output_tokens,
+      total_tokens: response.usage.input_tokens + response.usage.output_tokens
+    }
+  };
+  if (reasoningContent) {
+    result.reasoning_content = reasoningContent;
+  }
+  return result;
+}
+function convertAnthropicRequestToOpenAI(request) {
+  const messages = [];
+  if (request.system) {
+    if (typeof request.system === "string") {
+      messages.push({ role: "system", content: request.system });
+    } else if (Array.isArray(request.system)) {
+      const systemText = request.system.filter((s) => s.type === "text").map((s) => s.text).join("\n");
+      messages.push({ role: "system", content: systemText });
+    }
+  }
+  for (const msg of request.messages) {
+    if (typeof msg.content === "string") {
+      messages.push({
+        role: msg.role,
+        content: msg.content
+      });
+    } else if (Array.isArray(msg.content)) {
+      const openaiContent = [];
+      const toolCalls = [];
+      let toolResultId;
+      let toolResultContent;
+      for (const part of msg.content) {
+        if (part.type === "text") {
+          openaiContent.push({ type: "text", text: part.text });
+        } else if (part.type === "image") {
+          if (part.source.type === "base64") {
+            openaiContent.push({
+              type: "image_url",
+              image_url: {
+                url: `data:${part.source.media_type};base64,${part.source.data}`
+              }
+            });
+          } else if (part.source.url) {
+            openaiContent.push({
+              type: "image_url",
+              image_url: { url: part.source.url }
+            });
+          }
+        } else if (part.type === "tool_use") {
+          toolCalls.push({
+            id: part.id,
+            type: "function",
+            function: {
+              name: part.name,
+              arguments: JSON.stringify(part.input)
+            }
+          });
+        } else if (part.type === "tool_result") {
+          toolResultId = part.tool_use_id;
+          toolResultContent = typeof part.content === "string" ? part.content : JSON.stringify(part.content);
+        }
+      }
+      if (toolResultId && toolResultContent !== void 0) {
+        messages.push({
+          role: "tool",
+          tool_call_id: toolResultId,
+          content: toolResultContent
+        });
+      } else if (toolCalls.length > 0) {
+        messages.push({
+          role: "assistant",
+          content: openaiContent.length > 0 ? openaiContent.map((c) => c.type === "text" ? c.text : "").join("\n") : null,
+          tool_calls: toolCalls
+        });
+      } else {
+        messages.push({
+          role: msg.role,
+          content: openaiContent.length > 0 ? openaiContent : null
+        });
+      }
+    }
+  }
+  const result = {
+    model: request.model,
+    messages,
+    max_tokens: request.max_tokens,
+    stream: request.stream
+  };
+  if (request.tools && request.tools.length > 0) {
+    result.tools = request.tools.map((tool) => ({
+      type: "function",
+      function: {
+        name: tool.name,
+        description: tool.description,
+        parameters: tool.input_schema
+      }
+    }));
+    if (request.tool_choice) {
+      if (request.tool_choice.type === "auto") {
+        result.tool_choice = "auto";
+      } else if (request.tool_choice.type === "any") {
+        result.tool_choice = "required";
+      } else if (request.tool_choice.type === "tool") {
+        result.tool_choice = {
+          type: "function",
+          function: { name: request.tool_choice.name }
+        };
+      }
+    }
+  }
+  return result;
+}
+function convertAnthropicToOpenAIWithThinking(response) {
+  const baseResult = convertAnthropicToOpenAI(response);
+  const thinkingBlocks = response.content.filter(
+    (block) => block.type === "thinking"
+  );
+  if (thinkingBlocks.length > 0) {
+    baseResult.reasoning_content = thinkingBlocks.map((block) => "thinking" in block ? block.thinking : "").join("\n");
+  }
+  return baseResult;
+}
+async function* convertAnthropicStreamToOpenAI(anthropicStream) {
+  let messageId = "";
+  let model = "unknown";
+  const toolCalls = /* @__PURE__ */ new Map();
+  for await (const line of anthropicStream) {
+    if (!line.startsWith("data:")) continue;
+    const data = line.slice(5).trim();
+    try {
+      const event = JSON.parse(data);
+      switch (event.type) {
+        case "message_start":
+          messageId = event.message?.id || `chatcmpl-${Date.now()}`;
+          model = event.message?.model || model;
+          break;
+        case "content_block_delta":
+          if (event.delta?.type === "text_delta") {
+            yield `data: ${JSON.stringify({
+              id: messageId,
+              object: "chat.completion.chunk",
+              created: Math.floor(Date.now() / 1e3),
+              model,
+              choices: [{
+                index: 0,
+                delta: { content: event.delta.text },
+                finish_reason: null
+              }]
+            })}
+
+`;
+          } else if (event.delta?.type === "thinking_delta") {
+            yield `data: ${JSON.stringify({
+              id: messageId,
+              object: "chat.completion.chunk",
+              created: Math.floor(Date.now() / 1e3),
+              model,
+              choices: [{
+                index: 0,
+                delta: { reasoning_content: event.delta.thinking },
+                finish_reason: null
+              }]
+            })}
+
+`;
+          } else if (event.delta?.type === "input_json_delta") {
+            const toolIndex = event.index || 0;
+            const tc = toolCalls.get(toolIndex);
+            if (tc) {
+              yield `data: ${JSON.stringify({
+                id: messageId,
+                object: "chat.completion.chunk",
+                created: Math.floor(Date.now() / 1e3),
+                model,
+                choices: [{
+                  index: 0,
+                  delta: {
+                    tool_calls: [{
+                      index: toolIndex,
+                      function: { arguments: event.delta.partial_json }
+                    }]
+                  },
+                  finish_reason: null
+                }]
+              })}
+
+`;
+            }
+          }
+          break;
+        case "content_block_start":
+          if (event.content_block?.type === "tool_use") {
+            const toolIndex = event.index || 0;
+            toolCalls.set(toolIndex, {
+              id: event.content_block.id,
+              name: event.content_block.name,
+              arguments: ""
+            });
+            yield `data: ${JSON.stringify({
+              id: messageId,
+              object: "chat.completion.chunk",
+              created: Math.floor(Date.now() / 1e3),
+              model,
+              choices: [{
+                index: 0,
+                delta: {
+                  tool_calls: [{
+                    index: toolIndex,
+                    id: event.content_block.id,
+                    type: "function",
+                    function: { name: event.content_block.name, arguments: "" }
+                  }]
+                },
+                finish_reason: null
+              }]
+            })}
+
+`;
+          }
+          break;
+        case "message_delta":
+          if (event.delta?.stop_reason) {
+            const finishReason = mapAnthropicStopReason(event.delta.stop_reason);
+            yield `data: ${JSON.stringify({
+              id: messageId,
+              object: "chat.completion.chunk",
+              created: Math.floor(Date.now() / 1e3),
+              model,
+              choices: [{
+                index: 0,
+                delta: {},
+                finish_reason: finishReason
+              }],
+              usage: event.usage ? {
+                prompt_tokens: event.usage.input_tokens || 0,
+                completion_tokens: event.usage.output_tokens || 0,
+                total_tokens: (event.usage.input_tokens || 0) + (event.usage.output_tokens || 0)
+              } : void 0
+            })}
+
+`;
+          }
+          break;
+        case "message_stop":
+          yield "data: [DONE]\n\n";
+          break;
+      }
+    } catch {
+    }
+  }
+}
+
+// src/api-converter/openai-to-anthropic.ts
+function convertOpenAIToAnthropic(request, config) {
+  const messages = [];
+  let system;
+  for (const msg of request.messages) {
+    if (msg.role === "system") {
+      if (typeof msg.content === "string") {
+        system = msg.content;
+      } else if (Array.isArray(msg.content)) {
+        system = msg.content.filter((p) => p.type === "text").map((p) => ({ type: "text", text: p.text || "" }));
+      }
+      continue;
+    }
+    if (msg.role === "tool" && msg.tool_call_id) {
+      const toolResult = {
+        type: "tool_result",
+        tool_use_id: msg.tool_call_id,
+        content: typeof msg.content === "string" ? msg.content : JSON.stringify(msg.content)
+      };
+      const lastMsg = messages[messages.length - 1];
+      if (lastMsg && lastMsg.role === "user" && Array.isArray(lastMsg.content)) {
+        lastMsg.content.push(toolResult);
+      } else {
+        messages.push({ role: "user", content: [toolResult] });
+      }
+      continue;
+    }
+    if (msg.role === "assistant" && msg.tool_calls && msg.tool_calls.length > 0) {
+      const content = [];
+      if (msg.content) {
+        if (typeof msg.content === "string") {
+          content.push({ type: "text", text: msg.content });
+        } else if (Array.isArray(msg.content)) {
+          for (const part of msg.content) {
+            if (part.type === "text" && part.text) {
+              content.push({ type: "text", text: part.text });
+            }
+          }
+        }
+      }
+      for (const tc of msg.tool_calls) {
+        content.push({
+          type: "tool_use",
+          id: tc.id,
+          name: tc.function.name,
+          input: JSON.parse(tc.function.arguments || "{}")
+        });
+      }
+      messages.push({ role: "assistant", content });
+      continue;
+    }
+    if (msg.role === "user" || msg.role === "assistant") {
+      const content = convertOpenAIMessageContent(msg);
+      messages.push({ role: msg.role, content });
+    }
+  }
+  let model = request.model;
+  if (config.modelMapping && config.modelMapping[model]) {
+    model = config.modelMapping[model];
+  } else if (!model.startsWith("claude")) {
+    model = config.defaultModel;
+  }
+  const result = {
+    model,
+    // Anthropic requires max_tokens; use high default (16384) if not explicitly set
+    // This prevents output truncation for long responses
+    max_tokens: request.max_tokens || 16384,
+    messages,
+    stream: request.stream
+  };
+  if (system) {
+    result.system = system;
+  }
+  if (request.tools && request.tools.length > 0) {
+    result.tools = request.tools.map(convertOpenAITool);
+    if (request.tool_choice) {
+      if (request.tool_choice === "auto") {
+        result.tool_choice = { type: "auto" };
+      } else if (request.tool_choice === "required") {
+        result.tool_choice = { type: "any" };
+      } else if (typeof request.tool_choice === "object") {
+        result.tool_choice = {
+          type: "tool",
+          name: request.tool_choice.function.name
+        };
+      }
+    }
+  }
+  return result;
+}
+function convertOpenAIMessageContent(msg) {
+  if (typeof msg.content === "string") {
+    return msg.content;
+  }
+  if (!msg.content || !Array.isArray(msg.content)) {
+    return "";
+  }
+  const parts = [];
+  for (const part of msg.content) {
+    if (part.type === "text" && part.text) {
+      parts.push({ type: "text", text: part.text });
+    } else if (part.type === "image_url" && part.image_url) {
+      const url = part.image_url.url;
+      if (url.startsWith("data:")) {
+        const match = url.match(/^data:([^;]+);base64,(.+)$/);
+        if (match) {
+          parts.push({
+            type: "image",
+            source: {
+              type: "base64",
+              media_type: match[1],
+              data: match[2]
+            }
+          });
+        }
+      } else {
+        parts.push({
+          type: "image",
+          source: { type: "url", url }
+        });
+      }
+    }
+  }
+  return parts.length > 0 ? parts : "";
+}
+function convertOpenAIResponseToAnthropic(response) {
+  const content = [];
+  const choice = response.choices[0];
+  if (choice.message.content) {
+    content.push({ type: "text", text: choice.message.content });
+  }
+  if (choice.message.tool_calls) {
+    for (const tc of choice.message.tool_calls) {
+      content.push({
+        type: "tool_use",
+        id: tc.id,
+        name: tc.function.name,
+        input: JSON.parse(tc.function.arguments || "{}")
+      });
+    }
+  }
+  if (response.reasoning_content) {
+    content.unshift({
+      type: "thinking",
+      thinking: response.reasoning_content
+    });
+  }
+  return {
+    id: response.id,
+    type: "message",
+    role: "assistant",
+    model: response.model,
+    content,
+    stop_reason: mapOpenAIFinishReason(choice.finish_reason),
+    usage: {
+      input_tokens: response.usage.prompt_tokens,
+      output_tokens: response.usage.completion_tokens
+    }
+  };
+}
+function convertOpenAIToAnthropicWithThinking(request, config) {
+  const baseResult = convertOpenAIToAnthropic(request, config);
+  if (config.enableThinking) {
+    baseResult.thinking = {
+      type: "enabled",
+      budget_tokens: config.thinkingBudget || 1e4
+    };
+  }
+  return baseResult;
+}
+async function* convertOpenAIStreamToAnthropic(openaiStream) {
+  const messageId = `msg_${Date.now()}`;
+  let hasStarted = false;
+  let hasTextContentStarted = false;
+  let hasThinkingContentStarted = false;
+  let contentIndex = 0;
+  let model = "unknown";
+  const toolCalls = /* @__PURE__ */ new Map();
+  for await (const line of openaiStream) {
+    if (!line.startsWith("data:")) continue;
+    const data = line.slice(5).trim();
+    if (data === "[DONE]") {
+      if (hasTextContentStarted) {
+        yield `event: content_block_stop
+data: ${JSON.stringify({
+          type: "content_block_stop",
+          index: contentIndex
+        })}
+
+`;
+        contentIndex++;
+        hasTextContentStarted = false;
+      }
+      if (hasThinkingContentStarted) {
+        yield `event: content_block_stop
+data: ${JSON.stringify({
+          type: "content_block_stop",
+          index: contentIndex
+        })}
+
+`;
+        contentIndex++;
+        hasThinkingContentStarted = false;
+      }
+      for (const [, tc] of toolCalls) {
+        yield `event: content_block_stop
+data: ${JSON.stringify({
+          type: "content_block_stop",
+          index: tc.contentIndex
+        })}
+
+`;
+      }
+      yield `event: message_delta
+data: ${JSON.stringify({
+        type: "message_delta",
+        delta: { stop_reason: "end_turn", stop_sequence: null },
+        usage: { input_tokens: 0, output_tokens: 0 }
+      })}
+
+`;
+      yield `event: message_stop
+data: ${JSON.stringify({ type: "message_stop" })}
+
+`;
+      break;
+    }
+    try {
+      const chunk = JSON.parse(data);
+      model = chunk.model || model;
+      if (!hasStarted) {
+        hasStarted = true;
+        yield `event: message_start
+data: ${JSON.stringify({
+          type: "message_start",
+          message: {
+            id: messageId,
+            type: "message",
+            role: "assistant",
+            content: [],
+            model,
+            stop_reason: null,
+            stop_sequence: null,
+            usage: { input_tokens: 0, output_tokens: 0 }
+          }
+        })}
+
+`;
+      }
+      const choice = chunk.choices?.[0];
+      if (!choice) continue;
+      if (choice.delta?.content) {
+        if (!hasTextContentStarted) {
+          hasTextContentStarted = true;
+          yield `event: content_block_start
+data: ${JSON.stringify({
+            type: "content_block_start",
+            index: contentIndex,
+            content_block: { type: "text", text: "" }
+          })}
+
+`;
+        }
+        yield `event: content_block_delta
+data: ${JSON.stringify({
+          type: "content_block_delta",
+          index: contentIndex,
+          delta: { type: "text_delta", text: choice.delta.content }
+        })}
+
+`;
+      }
+      if (choice.delta?.reasoning_content) {
+        if (hasTextContentStarted) {
+          yield `event: content_block_stop
+data: ${JSON.stringify({
+            type: "content_block_stop",
+            index: contentIndex
+          })}
+
+`;
+          contentIndex++;
+          hasTextContentStarted = false;
+        }
+        if (!hasThinkingContentStarted) {
+          hasThinkingContentStarted = true;
+          yield `event: content_block_start
+data: ${JSON.stringify({
+            type: "content_block_start",
+            index: contentIndex,
+            content_block: { type: "thinking", thinking: "" }
+          })}
+
+`;
+        }
+        yield `event: content_block_delta
+data: ${JSON.stringify({
+          type: "content_block_delta",
+          index: contentIndex,
+          delta: { type: "thinking_delta", thinking: choice.delta.reasoning_content }
+        })}
+
+`;
+      }
+      if (choice.delta?.tool_calls) {
+        if (hasTextContentStarted) {
+          yield `event: content_block_stop
+data: ${JSON.stringify({
+            type: "content_block_stop",
+            index: contentIndex
+          })}
+
+`;
+          contentIndex++;
+          hasTextContentStarted = false;
+        }
+        for (const toolCall of choice.delta.tool_calls) {
+          const toolIndex = toolCall.index ?? 0;
+          if (!toolCalls.has(toolIndex)) {
+            const toolContentIndex = contentIndex++;
+            const toolId = toolCall.id || `call_${Date.now()}_${toolIndex}`;
+            const toolName = toolCall.function?.name || `tool_${toolIndex}`;
+            toolCalls.set(toolIndex, { id: toolId, name: toolName, contentIndex: toolContentIndex });
+            yield `event: content_block_start
+data: ${JSON.stringify({
+              type: "content_block_start",
+              index: toolContentIndex,
+              content_block: { type: "tool_use", id: toolId, name: toolName, input: {} }
+            })}
+
+`;
+          }
+          if (toolCall.function?.arguments) {
+            const tc = toolCalls.get(toolIndex);
+            yield `event: content_block_delta
+data: ${JSON.stringify({
+              type: "content_block_delta",
+              index: tc.contentIndex,
+              delta: { type: "input_json_delta", partial_json: toolCall.function.arguments }
+            })}
+
+`;
+          }
+        }
+      }
+      if (choice.finish_reason) {
+        if (hasTextContentStarted) {
+          yield `event: content_block_stop
+data: ${JSON.stringify({
+            type: "content_block_stop",
+            index: contentIndex
+          })}
+
+`;
+          contentIndex++;
+          hasTextContentStarted = false;
+        }
+        if (hasThinkingContentStarted) {
+          yield `event: content_block_stop
+data: ${JSON.stringify({
+            type: "content_block_stop",
+            index: contentIndex
+          })}
+
+`;
+          contentIndex++;
+          hasThinkingContentStarted = false;
+        }
+        for (const [, tc] of toolCalls) {
+          yield `event: content_block_stop
+data: ${JSON.stringify({
+            type: "content_block_stop",
+            index: tc.contentIndex
+          })}
+
+`;
+        }
+        const stopReason = mapOpenAIFinishReason(choice.finish_reason);
+        yield `event: message_delta
+data: ${JSON.stringify({
+          type: "message_delta",
+          delta: { stop_reason: stopReason, stop_sequence: null },
+          usage: {
+            input_tokens: chunk.usage?.prompt_tokens || 0,
+            output_tokens: chunk.usage?.completion_tokens || 0
+          }
+        })}
+
+`;
+        yield `event: message_stop
+data: ${JSON.stringify({ type: "message_stop" })}
+
+`;
+      }
+    } catch {
+    }
+  }
+}
+
+export {
+  hasImageContent,
+  hasThinkingEnabled,
+  convertAnthropicToOpenAI,
+  convertAnthropicRequestToOpenAI,
+  convertAnthropicToOpenAIWithThinking,
+  convertAnthropicStreamToOpenAI,
+  convertOpenAIToAnthropic,
+  convertOpenAIResponseToAnthropic,
+  convertOpenAIToAnthropicWithThinking,
+  convertOpenAIStreamToAnthropic
+};