@omnicross/core 0.1.1 → 0.1.2

package/dist/transformer/transformers/AnthropicTransformer.cjs

@@ -1,1017 +1,6 @@
-"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/transformer/transformers/AnthropicTransformer.ts
-var AnthropicTransformer_exports = {};
-__export(AnthropicTransformer_exports, {
-  AnthropicTransformer: () => AnthropicTransformer
-});
-module.exports = __toCommonJS(AnthropicTransformer_exports);
+var _chunk4VAVYUZScjs = require('../../chunk-4VAVYUZS.cjs');
 
-// src/transformer/transformers/AnthropicToolHandling.ts
-function isServerSideTool(tool) {
-  const type = String(tool.type || "");
-  return type.startsWith("web_search_") || type.startsWith("code_execution_") || type.startsWith("text_editor_") || type.startsWith("memory_") || type.startsWith("web_fetch_") || type.startsWith("search_tool_");
-}
-function convertAnthropicToolsToOpenAI(tools) {
-  return tools.filter((tool) => !isServerSideTool(tool)).map((tool) => ({
-    type: "function",
-    function: {
-      name: String(tool.name),
-      description: String(tool.description || ""),
-      parameters: tool.input_schema
-    }
-  }));
-}
 
-// src/transformer/transformers/AnthropicTypes.ts
-function getThinkLevel(budgetTokens) {
-  if (!budgetTokens || budgetTokens <= 0) return "none";
-  if (budgetTokens < 4096) return "low";
-  if (budgetTokens < 16384) return "medium";
-  return "high";
-}
-function formatBase64(data, mediaType) {
-  if (data.startsWith("data:")) return data;
-  return `data:${mediaType || "image/png"};base64,${data}`;
-}
-
-// src/transformer/transformers/AnthropicRequestBuilder.ts
-function buildAnthropicRequestBody(request) {
-  let systemContent;
-  const anthropicMessages = [];
-  for (let i = 0; i < request.messages.length; i++) {
-    const msg = request.messages[i];
-    if (msg.role === "system") {
-      if (typeof msg.content === "string") {
-        systemContent = msg.content;
-      } else if (Array.isArray(msg.content)) {
-        systemContent = msg.content.filter((c) => c.type === "text").map((c) => ({
-          type: "text",
-          text: c.text,
-          ...c.cache_control ? { cache_control: c.cache_control } : {}
-        }));
-      }
-      continue;
-    }
-    if (msg.role === "assistant") {
-      const content = [];
-      if (msg.thinking?.content) {
-        const block = {
-          type: "thinking",
-          thinking: msg.thinking.content
-        };
-        if (msg.thinking.signature) {
-          block.signature = msg.thinking.signature;
-        }
-        content.push(block);
-      }
-      if (msg.content) {
-        const text = typeof msg.content === "string" ? msg.content : msg.content.filter((c) => c.type === "text").map((c) => c.text).join("\n");
-        if (text) {
-          content.push({ type: "text", text });
-        }
-      }
-      if (msg.tool_calls?.length) {
-        for (const tc of msg.tool_calls) {
-          let input;
-          try {
-            input = typeof tc.function.arguments === "string" ? JSON.parse(tc.function.arguments) : tc.function.arguments;
-          } catch {
-            input = { text: tc.function.arguments || "" };
-          }
-          content.push({
-            type: "tool_use",
-            id: tc.id,
-            name: tc.function.name,
-            input
-          });
-        }
-      }
-      anthropicMessages.push({
-        role: "assistant",
-        content: content.length > 0 ? content : ""
-      });
-      continue;
-    }
-    if (msg.role === "tool") {
-      const toolResults = [];
-      let j = i;
-      while (j < request.messages.length && request.messages[j].role === "tool") {
-        const t = request.messages[j];
-        toolResults.push({
-          type: "tool_result",
-          tool_use_id: t.tool_call_id || "",
-          content: typeof t.content === "string" ? t.content : JSON.stringify(t.content),
-          ...t.cache_control ? { cache_control: t.cache_control } : {}
-        });
-        j++;
-      }
-      anthropicMessages.push({ role: "user", content: toolResults });
-      i = j - 1;
-      continue;
-    }
-    if (typeof msg.content === "string") {
-      anthropicMessages.push({ role: "user", content: msg.content });
-    } else if (Array.isArray(msg.content)) {
-      const content = msg.content.map((part) => {
-        if (part.type === "image_url") {
-          const url = part.image_url.url;
-          if (url.startsWith("data:")) {
-            const match = url.match(/^data:([^;]+);base64,(.+)$/);
-            if (match) {
-              return {
-                type: "image",
-                source: { type: "base64", media_type: match[1], data: match[2] }
-              };
-            }
-          }
-          return {
-            type: "image",
-            source: { type: "url", url }
-          };
-        }
-        return { type: "text", text: part.text };
-      });
-      anthropicMessages.push({ role: "user", content });
-    }
-  }
-  const body = {
-    model: request.model,
-    messages: anthropicMessages,
-    max_tokens: request.max_tokens || 4096,
-    stream: request.stream ?? false
-  };
-  if (request.temperature !== void 0) {
-    body.temperature = request.temperature;
-  }
-  if (systemContent !== void 0) {
-    body.system = systemContent;
-  }
-  if (request.tools?.length) {
-    body.tools = request.tools.map((tool) => ({
-      name: tool.function.name,
-      description: tool.function.description || "",
-      input_schema: tool.function.parameters
-    }));
-  }
-  const serverSideTools = request._serverSideTools;
-  if (serverSideTools?.length) {
-    body.tools = [...body.tools || [], ...serverSideTools];
-  }
-  if (request.tool_choice) {
-    if (typeof request.tool_choice === "string") {
-      if (request.tool_choice === "required") {
-        body.tool_choice = { type: "any" };
-      } else if (request.tool_choice !== "none") {
-        body.tool_choice = { type: request.tool_choice };
-      }
-    } else if (typeof request.tool_choice === "object" && "function" in request.tool_choice) {
-      body.tool_choice = { type: "tool", name: request.tool_choice.function.name };
-    }
-  }
-  if (request.reasoning?.enabled) {
-    const budgetMap = { low: 2048, medium: 8192, high: 32768 };
-    const budget = request.reasoning.max_tokens || budgetMap[request.reasoning.effort || "medium"] || 8192;
-    body.thinking = { type: "enabled", budget_tokens: budget };
-    body.temperature = 1;
-  }
-  return body;
-}
-
-// src/transformer/transformers/AnthropicResponseConversion.ts
-function convertAnthropicResponseToOpenAI(anthropicResponse) {
-  const content = anthropicResponse.content || [];
-  const textParts = content.filter((c) => c.type === "text").map((c) => c.text);
-  const toolUses = content.filter((c) => c.type === "tool_use" || c.type === "server_tool_use");
-  const thinkingBlock = content.find((c) => c.type === "thinking");
-  const searchResults = content.filter((c) => c.type === "web_search_tool_result");
-  for (const sr of searchResults) {
-    const searches = sr.content;
-    if (searches?.length) {
-      const formatted = searches.map((s) => `[${s.title}](${s.url}): ${s.page_content || s.snippet || ""}`).join("\n");
-      textParts.push(`
-
-**Search Results:**
-${formatted}`);
-    }
-  }
-  const message = {
-    role: "assistant",
-    content: textParts.join("") || null
-  };
-  if (toolUses.length > 0) {
-    message.tool_calls = toolUses.map((tc) => ({
-      id: tc.id,
-      type: "function",
-      function: {
-        name: tc.name,
-        arguments: JSON.stringify(tc.input || {})
-      }
-    }));
-  }
-  if (thinkingBlock) {
-    message.thinking = {
-      content: thinkingBlock.thinking,
-      signature: thinkingBlock.signature
-    };
-  }
-  const stopReasonMapping = {
-    end_turn: "stop",
-    max_tokens: "length",
-    tool_use: "tool_calls",
-    stop_sequence: "stop"
-  };
-  const usage = anthropicResponse.usage;
-  return {
-    id: anthropicResponse.id || `chatcmpl-${Date.now()}`,
-    object: "chat.completion",
-    created: Math.floor(Date.now() / 1e3),
-    model: anthropicResponse.model || "unknown",
-    choices: [{
-      index: 0,
-      message,
-      finish_reason: stopReasonMapping[anthropicResponse.stop_reason] || "stop"
-    }],
-    usage: usage ? {
-      prompt_tokens: usage.input_tokens || 0,
-      completion_tokens: usage.output_tokens || 0,
-      total_tokens: (usage.input_tokens || 0) + (usage.output_tokens || 0)
-    } : void 0
-  };
-}
-function convertOpenAIResponseToAnthropic(openaiResponse) {
-  const choice = openaiResponse.choices?.[0];
-  if (!choice) {
-    throw new Error("No choices found in OpenAI response");
-  }
-  const message = choice.message;
-  const content = [];
-  if (message.content) {
-    content.push({
-      type: "text",
-      text: message.content
-    });
-  }
-  const toolCalls = message.tool_calls;
-  if (toolCalls?.length) {
-    for (const toolCall of toolCalls) {
-      const func = toolCall.function;
-      let parsedInput = {};
-      try {
-        const args = func.arguments;
-        parsedInput = typeof args === "string" ? JSON.parse(args) : args;
-      } catch {
-        parsedInput = { text: func.arguments || "" };
-      }
-      content.push({
-        type: "tool_use",
-        id: toolCall.id,
-        name: func.name,
-        input: parsedInput
-      });
-    }
-  }
-  const thinking = message.thinking;
-  if (thinking?.content) {
-    content.push({
-      type: "thinking",
-      thinking: thinking.content,
-      signature: thinking.signature
-    });
-  }
-  const finishReason = choice.finish_reason;
-  const stopReasonMapping = {
-    stop: "end_turn",
-    length: "max_tokens",
-    tool_calls: "tool_use",
-    content_filter: "stop_sequence"
-  };
-  const usage = openaiResponse.usage;
-  const usageDetails = usage?.prompt_tokens_details;
-  return {
-    id: openaiResponse.id,
-    type: "message",
-    role: "assistant",
-    model: openaiResponse.model,
-    content,
-    stop_reason: stopReasonMapping[finishReason] || "end_turn",
-    stop_sequence: null,
-    usage: {
-      input_tokens: (usage?.prompt_tokens || 0) - (usageDetails?.cached_tokens || 0),
-      output_tokens: usage?.completion_tokens || 0,
-      cache_read_input_tokens: usageDetails?.cached_tokens || 0
-    }
-  };
-}
-
-// src/transformer/transformers/AnthropicConversion.ts
-function transformAnthropicRequestToUnified(request) {
-  const anthropicRequest = request;
-  const messages = [];
-  if (anthropicRequest.system) {
-    if (typeof anthropicRequest.system === "string") {
-      messages.push({
-        role: "system",
-        content: anthropicRequest.system
-      });
-    } else if (Array.isArray(anthropicRequest.system)) {
-      const textParts = anthropicRequest.system.filter((item) => item.type === "text" && item.text).map((item) => ({
-        type: "text",
-        text: item.text,
-        cache_control: item.cache_control
-      }));
-      if (textParts.length > 0) {
-        messages.push({
-          role: "system",
-          content: textParts
-        });
-      }
-    }
-  }
-  const requestMessages = JSON.parse(JSON.stringify(anthropicRequest.messages || []));
-  for (const msg of requestMessages) {
-    if (msg.role !== "user" && msg.role !== "assistant") continue;
-    if (typeof msg.content === "string") {
-      messages.push({
-        role: msg.role,
-        content: msg.content
-      });
-      continue;
-    }
-    if (Array.isArray(msg.content)) {
-      if (msg.role === "user") {
-        const toolParts = msg.content.filter(
-          (c) => c.type === "tool_result" && c.tool_use_id
-        );
-        for (const tool of toolParts) {
-          messages.push({
-            role: "tool",
-            content: typeof tool.content === "string" ? tool.content : JSON.stringify(tool.content),
-            tool_call_id: tool.tool_use_id,
-            cache_control: tool.cache_control
-          });
-        }
-        const textAndMediaParts = msg.content.filter(
-          (c) => c.type === "text" && c.text || c.type === "image" && c.source
-        );
-        if (textAndMediaParts.length > 0) {
-          messages.push({
-            role: "user",
-            content: textAndMediaParts.map((part) => {
-              if (part.type === "image") {
-                const imagePart = part;
-                return {
-                  type: "image_url",
-                  image_url: {
-                    url: imagePart.source.type === "base64" ? formatBase64(imagePart.source.data || "", imagePart.source.media_type) : imagePart.source.url || ""
-                  },
-                  media_type: imagePart.source.media_type
-                };
-              }
-              return {
-                type: "text",
-                text: part.text
-              };
-            })
-          });
-        }
-      } else if (msg.role === "assistant") {
-        const assistantMessage = {
-          role: "assistant",
-          content: ""
-        };
-        const textParts = msg.content.filter(
-          (c) => c.type === "text" && c.text
-        );
-        if (textParts.length > 0) {
-          assistantMessage.content = textParts.map((t) => t.text).join("\n");
-        }
-        const toolCallParts = msg.content.filter(
-          (c) => c.type === "tool_use" && c.id
-        );
-        if (toolCallParts.length > 0) {
-          assistantMessage.tool_calls = toolCallParts.map((tool) => ({
-            id: tool.id,
-            type: "function",
-            function: {
-              name: tool.name,
-              arguments: JSON.stringify(tool.input || {})
-            }
-          }));
-        }
-        const thinkingPart = msg.content.find(
-          (c) => c.type === "thinking"
-        );
-        if (thinkingPart?.thinking) {
-          assistantMessage.thinking = {
-            content: thinkingPart.thinking,
-            signature: thinkingPart.signature
-          };
-        }
-        messages.push(assistantMessage);
-      }
-    }
-  }
-  const rawTools = anthropicRequest.tools || [];
-  const serverSideTools = rawTools.filter((t) => isServerSideTool(t));
-  const functionTools = rawTools.length > 0 ? convertAnthropicToolsToOpenAI(rawTools) : void 0;
-  const result = {
-    messages,
-    model: anthropicRequest.model,
-    max_tokens: anthropicRequest.max_tokens,
-    temperature: anthropicRequest.temperature,
-    stream: anthropicRequest.stream,
-    tools: functionTools?.length ? functionTools : void 0
-  };
-  if (serverSideTools.length > 0) {
-    result._serverSideTools = serverSideTools;
-  }
-  if (anthropicRequest.thinking) {
-    result.reasoning = {
-      effort: getThinkLevel(anthropicRequest.thinking.budget_tokens),
-      enabled: anthropicRequest.thinking.type === "enabled"
-    };
-  }
-  if (anthropicRequest.tool_choice) {
-    if (anthropicRequest.tool_choice.type === "tool" && anthropicRequest.tool_choice.name) {
-      result.tool_choice = {
-        type: "function",
-        function: { name: anthropicRequest.tool_choice.name }
-      };
-    } else {
-      result.tool_choice = anthropicRequest.tool_choice.type;
-    }
-  }
-  return result;
-}
-
-// src/transformer/transformers/AnthropicAnthropicToOpenAIStream.ts
-function convertAnthropicStreamToOpenAI(anthropicStream, logger) {
-  const decoder = new TextDecoder();
-  const encoder = new TextEncoder();
-  const activeToolCalls = /* @__PURE__ */ new Map();
-  let toolCallCounter = 0;
-  let model = "unknown";
-  let messageId = `chatcmpl-${Date.now()}`;
-  return new ReadableStream({
-    start: async (controller) => {
-      const reader = anthropicStream.getReader();
-      let buffer = "";
-      let isClosed = false;
-      const safeEnqueue = (data) => {
-        if (!isClosed) {
-          try {
-            controller.enqueue(encoder.encode(data));
-          } catch {
-            isClosed = true;
-          }
-        }
-      };
-      try {
-        while (true) {
-          const { done, value } = await reader.read();
-          if (done) break;
-          buffer += decoder.decode(value, { stream: true });
-          const lines = buffer.split("\n");
-          buffer = lines.pop() || "";
-          for (const line of lines) {
-            if (isClosed) break;
-            if (!line.startsWith("data:")) continue;
-            const data = line.slice(5).trim();
-            if (!data || data === "[DONE]") continue;
-            try {
-              const event = JSON.parse(data);
-              if (event.type === "message_start" && event.message) {
-                model = event.message.model || model;
-                messageId = event.message.id || messageId;
-              }
-              if (event.type === "content_block_delta" && event.delta) {
-                const chunk = {
-                  id: messageId,
-                  object: "chat.completion.chunk",
-                  created: Math.floor(Date.now() / 1e3),
-                  model,
-                  choices: [{ index: 0, delta: {}, finish_reason: null }]
-                };
-                const delta = chunk.choices[0].delta;
-                if (event.delta.type === "text_delta") {
-                  delta.content = event.delta.text;
-                } else if (event.delta.type === "input_json_delta") {
-                  const toolInfo = activeToolCalls.get(event.index);
-                  if (toolInfo) {
-                    delta.tool_calls = [{
-                      index: toolInfo.index,
-                      function: { arguments: event.delta.partial_json }
-                    }];
-                  }
-                } else if (event.delta.type === "thinking_delta") {
-                  delta.thinking = { content: event.delta.thinking };
-                } else if (event.delta.type === "signature_delta") {
-                  delta.thinking = { signature: event.delta.signature };
-                } else {
-                  continue;
-                }
-                safeEnqueue(`data: ${JSON.stringify(chunk)}
-
-`);
-              }
-              if (event.type === "content_block_start" && event.content_block) {
-                if (event.content_block.type === "tool_use" || event.content_block.type === "server_tool_use") {
-                  const tcIndex = toolCallCounter++;
-                  activeToolCalls.set(event.index, {
-                    id: event.content_block.id,
-                    name: event.content_block.name,
-                    index: tcIndex
-                  });
-                  const chunk = {
-                    id: messageId,
-                    object: "chat.completion.chunk",
-                    created: Math.floor(Date.now() / 1e3),
-                    model,
-                    choices: [{
-                      index: 0,
-                      delta: {
-                        tool_calls: [{
-                          index: tcIndex,
-                          id: event.content_block.id,
-                          type: "function",
-                          function: { name: event.content_block.name, arguments: "" }
-                        }]
-                      },
-                      finish_reason: null
-                    }]
-                  };
-                  safeEnqueue(`data: ${JSON.stringify(chunk)}
-
-`);
-                } else if (event.content_block.type === "web_search_tool_result") {
-                  const searches = event.content_block.content;
-                  if (searches?.length) {
-                    const formatted = searches.map((s) => `[${s.title}](${s.url}): ${s.page_content || s.snippet || ""}`).join("\n");
-                    const chunk = {
-                      id: messageId,
-                      object: "chat.completion.chunk",
-                      created: Math.floor(Date.now() / 1e3),
-                      model,
-                      choices: [{
-                        index: 0,
-                        delta: { content: `
-
-**Search Results:**
-${formatted}` },
-                        finish_reason: null
-                      }]
-                    };
-                    safeEnqueue(`data: ${JSON.stringify(chunk)}
-
-`);
-                  }
-                }
-              }
-              if (event.type === "message_delta" && event.delta) {
-                const stopReasonMapping = {
-                  end_turn: "stop",
-                  max_tokens: "length",
-                  tool_use: "tool_calls",
-                  stop_sequence: "stop"
-                };
-                const chunk = {
-                  id: messageId,
-                  object: "chat.completion.chunk",
-                  created: Math.floor(Date.now() / 1e3),
-                  model,
-                  choices: [{
-                    index: 0,
-                    delta: {},
-                    finish_reason: stopReasonMapping[event.delta.stop_reason] || "stop"
-                  }]
-                };
-                if (event.usage) {
-                  chunk.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)
-                  };
-                }
-                safeEnqueue(`data: ${JSON.stringify(chunk)}
-
-`);
-              }
-            } catch (e) {
-              logger?.error("Error parsing Anthropic stream event:", e);
-            }
-          }
-        }
-      } catch (e) {
-        if (!isClosed) {
-          controller.error(e);
-        }
-      } finally {
-        safeEnqueue("data: [DONE]\n\n");
-        if (!isClosed) {
-          try {
-            controller.close();
-          } catch {
-          }
-        }
-        reader.releaseLock();
-      }
-    }
-  });
-}
-
-// src/transformer/transformers/AnthropicOpenAIToAnthropicStream.ts
-function convertOpenAIStreamToAnthropic(openaiStream, _context, logger) {
-  const decoder = new TextDecoder();
-  const encoder = new TextEncoder();
-  let hasStarted = false;
-  let hasTextContentStarted = false;
-  let isThinkingStarted = false;
-  let contentIndex = 0;
-  let currentContentBlockIndex = -1;
-  const toolCallIndexToContentBlockIndex = /* @__PURE__ */ new Map();
-  return new ReadableStream({
-    start: async (controller) => {
-      const reader = openaiStream.getReader();
-      let buffer = "";
-      const messageId = `msg_${Date.now()}`;
-      let model = "unknown";
-      let isClosed = false;
-      let stopReasonDelta = null;
-      const safeEnqueue = (data) => {
-        if (!isClosed) {
-          try {
-            controller.enqueue(encoder.encode(data));
-          } catch (_e) {
-            isClosed = true;
-          }
-        }
-      };
-      const assignContentBlockIndex = () => {
-        return contentIndex++;
-      };
-      const safeClose = () => {
-        if (isClosed) return;
-        if (currentContentBlockIndex >= 0) {
-          safeEnqueue(`event: content_block_stop
-data: ${JSON.stringify({
-            type: "content_block_stop",
-            index: currentContentBlockIndex
-          })}
-
-`);
-        }
-        if (stopReasonDelta) {
-          safeEnqueue(`event: message_delta
-data: ${JSON.stringify(stopReasonDelta)}
-
-`);
-        } else {
-          safeEnqueue(`event: message_delta
-data: ${JSON.stringify({
-            type: "message_delta",
-            delta: { stop_reason: "end_turn", stop_sequence: null },
-            usage: { input_tokens: 0, output_tokens: 0 }
-          })}
-
-`);
-        }
-        safeEnqueue(`event: message_stop
-data: ${JSON.stringify({ type: "message_stop" })}
-
-`);
-        try {
-          controller.close();
-        } catch (_e) {
-        }
-        isClosed = true;
-      };
-      try {
-        while (true) {
-          const { done, value } = await reader.read();
-          if (done) break;
-          buffer += decoder.decode(value, { stream: true });
-          const lines = buffer.split("\n");
-          buffer = lines.pop() || "";
-          for (const line of lines) {
-            if (isClosed) break;
-            if (!line.startsWith("data:")) continue;
-            const data = line.slice(5).trim();
-            if (data === "[DONE]") continue;
-            try {
-              const chunk = JSON.parse(data);
-              if (chunk.error) {
-                safeEnqueue(`event: error
-data: ${JSON.stringify({
-                  type: "error",
-                  message: { type: "api_error", message: JSON.stringify(chunk.error) }
-                })}
-
-`);
-                continue;
-              }
-              model = chunk.model || model;
-              if (!hasStarted) {
-                hasStarted = true;
-                safeEnqueue(`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 (chunk.usage) {
-                stopReasonDelta = {
-                  type: "message_delta",
-                  delta: { stop_reason: "end_turn", stop_sequence: null },
-                  usage: {
-                    input_tokens: (chunk.usage.prompt_tokens || 0) - (chunk.usage.prompt_tokens_details?.cached_tokens || 0),
-                    output_tokens: chunk.usage.completion_tokens || 0,
-                    cache_read_input_tokens: chunk.usage.prompt_tokens_details?.cached_tokens || 0
-                  }
-                };
-              }
-              if (choice.delta?.thinking) {
-                if (!isThinkingStarted) {
-                  const thinkingBlockIndex = assignContentBlockIndex();
-                  safeEnqueue(`event: content_block_start
-data: ${JSON.stringify({
-                    type: "content_block_start",
-                    index: thinkingBlockIndex,
-                    content_block: { type: "thinking", thinking: "" }
-                  })}
-
-`);
-                  currentContentBlockIndex = thinkingBlockIndex;
-                  isThinkingStarted = true;
-                }
-                if (choice.delta.thinking.signature) {
-                  safeEnqueue(`event: content_block_delta
-data: ${JSON.stringify({
-                    type: "content_block_delta",
-                    index: currentContentBlockIndex,
-                    delta: { type: "signature_delta", signature: choice.delta.thinking.signature }
-                  })}
-
-`);
-                  safeEnqueue(`event: content_block_stop
-data: ${JSON.stringify({
-                    type: "content_block_stop",
-                    index: currentContentBlockIndex
-                  })}
-
-`);
-                  currentContentBlockIndex = -1;
-                } else if (choice.delta.thinking.content) {
-                  safeEnqueue(`event: content_block_delta
-data: ${JSON.stringify({
-                    type: "content_block_delta",
-                    index: currentContentBlockIndex,
-                    delta: { type: "thinking_delta", thinking: choice.delta.thinking.content }
-                  })}
-
-`);
-                }
-              }
-              if (choice.delta?.content) {
-                if (!hasTextContentStarted) {
-                  if (currentContentBlockIndex >= 0 && isThinkingStarted) {
-                    safeEnqueue(`event: content_block_stop
-data: ${JSON.stringify({
-                      type: "content_block_stop",
-                      index: currentContentBlockIndex
-                    })}
-
-`);
-                  }
-                  hasTextContentStarted = true;
-                  const textBlockIndex = assignContentBlockIndex();
-                  safeEnqueue(`event: content_block_start
-data: ${JSON.stringify({
-                    type: "content_block_start",
-                    index: textBlockIndex,
-                    content_block: { type: "text", text: "" }
-                  })}
-
-`);
-                  currentContentBlockIndex = textBlockIndex;
-                }
-                safeEnqueue(`event: content_block_delta
-data: ${JSON.stringify({
-                  type: "content_block_delta",
-                  index: currentContentBlockIndex,
-                  delta: { type: "text_delta", text: choice.delta.content }
-                })}
-
-`);
-              }
-              if (choice.delta?.tool_calls) {
-                for (const toolCall of choice.delta.tool_calls) {
-                  const toolCallIndex = toolCall.index ?? 0;
-                  if (!toolCallIndexToContentBlockIndex.has(toolCallIndex)) {
-                    if (currentContentBlockIndex >= 0) {
-                      safeEnqueue(`event: content_block_stop
-data: ${JSON.stringify({
-                        type: "content_block_stop",
-                        index: currentContentBlockIndex
-                      })}
-
-`);
-                      hasTextContentStarted = false;
-                    }
-                    const newBlockIndex = assignContentBlockIndex();
-                    toolCallIndexToContentBlockIndex.set(toolCallIndex, newBlockIndex);
-                    safeEnqueue(`event: content_block_start
-data: ${JSON.stringify({
-                      type: "content_block_start",
-                      index: newBlockIndex,
-                      content_block: {
-                        type: "tool_use",
-                        id: toolCall.id || `call_${Date.now()}_${toolCallIndex}`,
-                        name: toolCall.function?.name || `tool_${toolCallIndex}`,
-                        input: {}
-                      }
-                    })}
-
-`);
-                    currentContentBlockIndex = newBlockIndex;
-                  }
-                  if (toolCall.function?.arguments) {
-                    const blockIndex = toolCallIndexToContentBlockIndex.get(toolCallIndex);
-                    if (blockIndex !== void 0) {
-                      safeEnqueue(`event: content_block_delta
-data: ${JSON.stringify({
-                        type: "content_block_delta",
-                        index: blockIndex,
-                        delta: { type: "input_json_delta", partial_json: toolCall.function.arguments }
-                      })}
-
-`);
-                    }
-                  }
-                }
-              }
-              if (choice.finish_reason) {
-                const stopReasonMapping = {
-                  stop: "end_turn",
-                  length: "max_tokens",
-                  tool_calls: "tool_use",
-                  content_filter: "stop_sequence"
-                };
-                stopReasonDelta = {
-                  type: "message_delta",
-                  delta: {
-                    stop_reason: stopReasonMapping[choice.finish_reason] || "end_turn",
-                    stop_sequence: null
-                  },
-                  usage: {
-                    input_tokens: (chunk.usage?.prompt_tokens || 0) - (chunk.usage?.prompt_tokens_details?.cached_tokens || 0),
-                    output_tokens: chunk.usage?.completion_tokens || 0,
-                    cache_read_input_tokens: chunk.usage?.prompt_tokens_details?.cached_tokens || 0
-                  }
-                };
-              }
-            } catch (e) {
-              logger?.error("Error parsing stream chunk:", e);
-            }
-          }
-        }
-      } catch (e) {
-        if (!isClosed) {
-          controller.error(e);
-        }
-      } finally {
-        safeClose();
-        reader.releaseLock();
-      }
-    }
-  });
-}
-
-// src/transformer/transformers/AnthropicTransformer.ts
-var AnthropicTransformer = class {
-  static TransformerName = "anthropic";
-  name = "anthropic";
-  logger;
-  endPoint = "/v1/messages";
-  useBearer;
-  constructor(options) {
-    this.useBearer = options?.UseBearer ?? false;
-  }
-  /**
-   * Handle authentication - Anthropic uses x-api-key header
-   */
-  async auth(request, provider, _context) {
-    const headers = {};
-    if (this.useBearer) {
-      headers["authorization"] = `Bearer ${provider.apiKey}`;
-      headers["x-api-key"] = void 0;
-    } else {
-      headers["x-api-key"] = provider.apiKey;
-      headers["authorization"] = void 0;
-    }
-    return {
-      body: request,
-      config: { headers }
-    };
-  }
-  /**
-   * Transform Anthropic request to unified format.
-   */
-  async transformRequestOut(request, _context) {
-    return transformAnthropicRequestToUnified(request);
-  }
-  /**
-   * Transform OpenAI/unified response back to Anthropic format
-   * (auto-detects stream vs JSON via Content-Type).
-   */
-  async transformResponseIn(response, context) {
-    const contentType = response.headers.get("Content-Type") ?? "";
-    if (contentType.includes("text/event-stream")) {
-      if (!response.body) {
-        throw new Error("Stream response body is null");
-      }
-      const convertedStream = convertOpenAIStreamToAnthropic(response.body, context, this.logger);
-      return new Response(convertedStream, {
-        headers: {
-          "Content-Type": "text/event-stream",
-          "Cache-Control": "no-cache",
-          Connection: "keep-alive"
-        }
-      });
-    } else {
-      const data = await response.json();
-      const anthropicResponse = convertOpenAIResponseToAnthropic(data);
-      return new Response(JSON.stringify(anthropicResponse), {
-        headers: { "Content-Type": "application/json" }
-      });
-    }
-  }
-  /**
-   * Transform unified request to Anthropic Messages API format.
-   * This is the reverse of transformRequestOut — converts OpenAI/unified format
-   * to Anthropic's expected request body structure.
-   */
-  async transformRequestIn(request, _provider, _context) {
-    return buildAnthropicRequestBody(request);
-  }
-  /**
-   * Transform Anthropic response to OpenAI/unified format
-   * (auto-detects stream vs JSON via Content-Type).
-   */
-  async transformResponseOut(response, _context) {
-    const contentType = response.headers.get("Content-Type") ?? "";
-    if (contentType.includes("text/event-stream")) {
-      if (!response.body) {
-        throw new Error("Stream response body is null");
-      }
-      const convertedStream = convertAnthropicStreamToOpenAI(response.body, this.logger);
-      return new Response(convertedStream, {
-        headers: {
-          "Content-Type": "text/event-stream",
-          "Cache-Control": "no-cache",
-          Connection: "keep-alive"
-        }
-      });
-    } else {
-      const data = await response.json();
-      const openaiResponse = convertAnthropicResponseToOpenAI(data);
-      return new Response(JSON.stringify(openaiResponse), {
-        headers: { "Content-Type": "application/json" }
-      });
-    }
-  }
-};
-// Annotate the CommonJS export names for ESM import in node:
-0 && (module.exports = {
-  AnthropicTransformer
-});
+exports.AnthropicTransformer = _chunk4VAVYUZScjs.AnthropicTransformer;