@omnicross/core 0.1.1 → 0.1.2

package/dist/ApiConverter.cjs

@@ -1,799 +1,24 @@
-"use strict";
-var __defProp = Object.defineProperty;
-var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
-var __getOwnPropNames = Object.getOwnPropertyNames;
-var __hasOwnProp = Object.prototype.hasOwnProperty;
-var __export = (target, all) => {
-  for (var name in all)
-    __defProp(target, name, { get: all[name], enumerable: true });
-};
-var __copyProps = (to, from, except, desc) => {
-  if (from && typeof from === "object" || typeof from === "function") {
-    for (let key of __getOwnPropNames(from))
-      if (!__hasOwnProp.call(to, key) && key !== except)
-        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
-  }
-  return to;
-};
-var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+"use strict";Object.defineProperty(exports, "__esModule", {value: true});
 
-// src/ApiConverter.ts
-var ApiConverter_exports = {};
-__export(ApiConverter_exports, {
-  convertAnthropicRequestToOpenAI: () => convertAnthropicRequestToOpenAI,
-  convertAnthropicStreamToOpenAI: () => convertAnthropicStreamToOpenAI,
-  convertAnthropicToOpenAI: () => convertAnthropicToOpenAI,
-  convertAnthropicToOpenAIWithThinking: () => convertAnthropicToOpenAIWithThinking,
-  convertOpenAIResponseToAnthropic: () => convertOpenAIResponseToAnthropic,
-  convertOpenAIStreamToAnthropic: () => convertOpenAIStreamToAnthropic,
-  convertOpenAIToAnthropic: () => convertOpenAIToAnthropic,
-  convertOpenAIToAnthropicWithThinking: () => convertOpenAIToAnthropicWithThinking,
-  hasImageContent: () => hasImageContent,
-  hasThinkingEnabled: () => hasThinkingEnabled
-});
-module.exports = __toCommonJS(ApiConverter_exports);
 
-// 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
-        })}
+var _chunkSUEGJ75Dcjs = require('./chunk-SUEGJ75D.cjs');
 
-`;
-        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 {
-    }
-  }
-}
-// Annotate the CommonJS export names for ESM import in node:
-0 && (module.exports = {
-  convertAnthropicRequestToOpenAI,
-  convertAnthropicStreamToOpenAI,
-  convertAnthropicToOpenAI,
-  convertAnthropicToOpenAIWithThinking,
-  convertOpenAIResponseToAnthropic,
-  convertOpenAIStreamToAnthropic,
-  convertOpenAIToAnthropic,
-  convertOpenAIToAnthropicWithThinking,
-  hasImageContent,
-  hasThinkingEnabled
-});
+exports.convertAnthropicRequestToOpenAI = _chunkSUEGJ75Dcjs.convertAnthropicRequestToOpenAI; exports.convertAnthropicStreamToOpenAI = _chunkSUEGJ75Dcjs.convertAnthropicStreamToOpenAI; exports.convertAnthropicToOpenAI = _chunkSUEGJ75Dcjs.convertAnthropicToOpenAI; exports.convertAnthropicToOpenAIWithThinking = _chunkSUEGJ75Dcjs.convertAnthropicToOpenAIWithThinking; exports.convertOpenAIResponseToAnthropic = _chunkSUEGJ75Dcjs.convertOpenAIResponseToAnthropic; exports.convertOpenAIStreamToAnthropic = _chunkSUEGJ75Dcjs.convertOpenAIStreamToAnthropic; exports.convertOpenAIToAnthropic = _chunkSUEGJ75Dcjs.convertOpenAIToAnthropic; exports.convertOpenAIToAnthropicWithThinking = _chunkSUEGJ75Dcjs.convertOpenAIToAnthropicWithThinking; exports.hasImageContent = _chunkSUEGJ75Dcjs.hasImageContent; exports.hasThinkingEnabled = _chunkSUEGJ75Dcjs.hasThinkingEnabled;