@omnicross/core 0.1.0 → 0.1.1

package/dist/transformer/transformers/AnthropicTransformer.js

@@ -0,0 +1,990 @@
+// 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" }
+      });
+    }
+  }
+};
+export {
+  AnthropicTransformer
+};