@omnicross/core 0.1.1 → 0.1.3

package/dist/transformer/transformers.cjs

@@ -1,3206 +1,39 @@
-"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/index.ts
-var transformers_exports = {};
-__export(transformers_exports, {
-  AnthropicTransformer: () => AnthropicTransformer,
-  BUILTIN_TRANSFORMER_NAMES: () => BUILTIN_TRANSFORMER_NAMES,
-  BuiltinTransformers: () => BuiltinTransformers,
-  DeepseekTransformer: () => DeepseekTransformer,
-  GeminiCodeAssistTransformer: () => GeminiCodeAssistTransformer,
-  GeminiTransformer: () => GeminiTransformer,
-  OpenAIResponseTransformer: () => OpenAIResponseTransformer,
-  OpenCodeGoTransformer: () => OpenCodeGoTransformer,
-  ReasoningTransformer: () => ReasoningTransformer,
-  getBuiltinTransformers: () => getBuiltinTransformers,
-  registerBuiltinTransformers: () => registerBuiltinTransformers
-});
-module.exports = __toCommonJS(transformers_exports);
 
-// 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(`
+var _chunkFFALUUZZcjs = require('../chunk-FFALUUZZ.cjs');
 
-**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;
-}
+var _chunkC72S6TTVcjs = require('../chunk-C72S6TTV.cjs');
 
-// 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)}
+var _chunkDWKQZ2SKcjs = require('../chunk-DWKQZ2SK.cjs');
 
-`);
-                } 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)}
+var _chunk4VAVYUZScjs = require('../chunk-4VAVYUZS.cjs');
 
-`);
-                  }
-                }
-              }
-              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();
-      }
-    }
-  });
-}
+var _chunk7YN22L2Hcjs = require('../chunk-7YN22L2H.cjs');
 
-// 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)}
+var _chunk2DCNB7DFcjs = require('../chunk-2DCNB7DF.cjs');
 
-`);
-        } 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" })}
+var _chunkRSJ3TWJQcjs = require('../chunk-RSJ3TWJQ.cjs');
+require('../chunk-YGXJGRFI.cjs');
 
-`);
-        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" }
-      });
-    }
-  }
-};
-
-// src/transformer/transformers/DeepseekTransformer.ts
-var DeepseekTransformer = class {
-  static TransformerName = "deepseek";
-  name = "deepseek";
-  logger;
-  /**
-   * Transform request: limit max_tokens to 8192 for legacy models only
-   * V4 models support up to 384K output tokens
-   */
-  async transformRequestIn(request, _provider, _context) {
-    const isV4 = request.model?.startsWith("deepseek-v4");
-    if (!isV4 && request.max_tokens && request.max_tokens > 8192) {
-      this.logger?.debug("DeepSeek: Limiting max_tokens from %d to 8192", request.max_tokens);
-      request.max_tokens = 8192;
-    }
-    return request;
-  }
-  /**
-   * Transform response: convert reasoning_content to thinking blocks
-   */
-  async transformResponseOut(response, _context) {
-    const contentType = response.headers.get("Content-Type") ?? "";
-    if (contentType.includes("application/json")) {
-      return this.handleJsonResponse(response);
-    } else if (contentType.includes("stream") || contentType.includes("text/event-stream")) {
-      return this.handleStreamResponse(response);
-    }
-    return response;
-  }
-  /**
-   * Handle JSON (non-streaming) response
-   */
-  async handleJsonResponse(response) {
-    const jsonResponse = await response.json();
-    if (jsonResponse.choices?.[0]?.message?.reasoning_content) {
-      jsonResponse.choices[0].message.thinking = {
-        content: jsonResponse.choices[0].message.reasoning_content
-      };
-      delete jsonResponse.choices[0].message.reasoning_content;
-    }
-    return new Response(JSON.stringify(jsonResponse), {
-      status: response.status,
-      statusText: response.statusText,
-      headers: response.headers
-    });
-  }
-  /**
-   * Handle streaming response - convert reasoning_content to thinking blocks
-   */
-  async handleStreamResponse(response) {
-    if (!response.body) {
-      return response;
-    }
-    const decoder = new TextDecoder();
-    const encoder = new TextEncoder();
-    let reasoningContent = "";
-    let isReasoningComplete = false;
-    let buffer = "";
-    const stream = new ReadableStream({
-      start: async (controller) => {
-        const reader = response.body.getReader();
-        const processLine = (line) => {
-          if (line.startsWith("data: ") && line.trim() !== "data: [DONE]") {
-            try {
-              const data = JSON.parse(line.slice(6));
-              if (data.choices?.[0]?.delta?.reasoning_content) {
-                reasoningContent += data.choices[0].delta.reasoning_content;
-                const thinkingChunk = {
-                  ...data,
-                  choices: [
-                    {
-                      ...data.choices[0],
-                      delta: {
-                        ...data.choices[0].delta,
-                        thinking: {
-                          content: data.choices[0].delta.reasoning_content
-                        }
-                      }
-                    }
-                  ]
-                };
-                delete thinkingChunk.choices[0].delta.reasoning_content;
-                const thinkingLine = `data: ${JSON.stringify(thinkingChunk)}
-
-`;
-                controller.enqueue(encoder.encode(thinkingLine));
-                return;
-              }
-              if (data.choices?.[0]?.delta?.content && reasoningContent && !isReasoningComplete) {
-                isReasoningComplete = true;
-                const signature = Date.now().toString();
-                const thinkingChunk = {
-                  ...data,
-                  choices: [
-                    {
-                      ...data.choices[0],
-                      delta: {
-                        ...data.choices[0].delta,
-                        content: null,
-                        thinking: {
-                          signature
-                        }
-                      }
-                    }
-                  ]
-                };
-                const thinkingLine = `data: ${JSON.stringify(thinkingChunk)}
-
-`;
-                controller.enqueue(encoder.encode(thinkingLine));
-              }
-              if (data.choices?.[0]?.delta?.reasoning_content) {
-                delete data.choices[0].delta.reasoning_content;
-              }
-              if (data.choices?.[0]?.delta && Object.keys(data.choices[0].delta).length > 0) {
-                if (isReasoningComplete) {
-                  data.choices[0].index++;
-                }
-                const modifiedLine = `data: ${JSON.stringify(data)}
-
-`;
-                controller.enqueue(encoder.encode(modifiedLine));
-              }
-            } catch (_e) {
-              controller.enqueue(encoder.encode(line + "\n"));
-            }
-          } else {
-            controller.enqueue(encoder.encode(line + "\n"));
-          }
-        };
-        try {
-          while (true) {
-            const { done, value } = await reader.read();
-            if (done) {
-              if (buffer.trim()) {
-                const lines2 = buffer.split("\n");
-                for (const line of lines2) {
-                  if (line.trim()) {
-                    controller.enqueue(encoder.encode(line + "\n"));
-                  }
-                }
-              }
-              break;
-            }
-            const chunk = decoder.decode(value, { stream: true });
-            buffer += chunk;
-            const lines = buffer.split("\n");
-            buffer = lines.pop() || "";
-            for (const line of lines) {
-              if (!line.trim()) continue;
-              try {
-                processLine(line);
-              } catch (error) {
-                this.logger?.error("Error processing DeepSeek stream line:", error);
-                controller.enqueue(encoder.encode(line + "\n"));
-              }
-            }
-          }
-        } catch (error) {
-          this.logger?.error("DeepSeek stream error:", error);
-          controller.error(error);
-        } finally {
-          try {
-            reader.releaseLock();
-          } catch (e) {
-            this.logger?.error("Error releasing reader lock:", e);
-          }
-          controller.close();
-        }
-      }
-    });
-    return new Response(stream, {
-      status: response.status,
-      statusText: response.statusText,
-      headers: new Headers({
-        "Content-Type": "text/event-stream",
-        "Cache-Control": "no-cache",
-        Connection: "keep-alive"
-      })
-    });
-  }
-};
-
-// src/transformer/transformers/utils/gemini.response-in.ts
-var FINISH_REASON_TO_GEMINI = {
-  stop: "STOP",
-  length: "MAX_TOKENS",
-  tool_calls: "STOP",
-  content_filter: "SAFETY",
-  // Already-lowercased Gemini reasons (pass-through from another transformer)
-  max_tokens: "MAX_TOKENS",
-  safety: "SAFETY"
-};
-function toGeminiFinishReason(openaiReason) {
-  if (!openaiReason) return null;
-  return FINISH_REASON_TO_GEMINI[openaiReason] || openaiReason.toUpperCase();
-}
-function convertOpenAIResponseToGemini(openaiData) {
-  const choice = openaiData.choices?.[0];
-  const message = choice?.message ?? {};
-  const usage = openaiData.usage;
-  const usagePromptDetails = usage?.prompt_tokens_details;
-  const usageOutputDetails = usage?.output_tokens_details;
-  const parts = [];
-  const thinking = message.thinking;
-  if (thinking?.content) {
-    parts.push({ text: thinking.content, thought: true });
-  }
-  if (thinking?.signature) {
-    parts.push({ thoughtSignature: thinking.signature });
-  }
-  if (message.content) {
-    parts.push({ text: message.content });
-  }
-  const toolCalls = message.tool_calls;
-  if (toolCalls?.length) {
-    for (const tc of toolCalls) {
-      const func = tc.function;
-      let args = {};
-      try {
-        const raw = func.arguments;
-        args = typeof raw === "string" ? JSON.parse(raw) : raw;
-      } catch {
-        args = {};
-      }
-      parts.push({
-        functionCall: {
-          id: tc.id,
-          name: func.name,
-          args
-        }
-      });
-    }
-  }
-  if (parts.length === 0) {
-    parts.push({ text: "" });
-  }
-  return {
-    responseId: openaiData.id || "",
-    modelVersion: openaiData.model || "",
-    candidates: [{
-      content: { parts },
-      finishReason: toGeminiFinishReason(choice?.finish_reason)
-    }],
-    usageMetadata: usage ? {
-      promptTokenCount: usage.prompt_tokens || 0,
-      candidatesTokenCount: usage.completion_tokens || 0,
-      totalTokenCount: usage.total_tokens || 0,
-      cachedContentTokenCount: usagePromptDetails?.cached_tokens || 0,
-      thoughtsTokenCount: usageOutputDetails?.reasoning_tokens || 0
-    } : void 0
-  };
-}
-function convertOpenAIStreamToGemini(openaiStream, logger) {
-  const decoder = new TextDecoder();
-  const encoder = new TextEncoder();
-  const pendingToolCalls = /* @__PURE__ */ new Map();
-  let model = "";
-  let responseId = "";
-  return new ReadableStream({
-    start: async (controller) => {
-      const reader = openaiStream.getReader();
-      let buffer = "";
-      let isClosed = false;
-      const emit = (data) => {
-        if (isClosed) return;
-        try {
-          controller.enqueue(encoder.encode(`data: ${JSON.stringify(data)}
-
-`));
-        } catch {
-          isClosed = true;
-        }
-      };
-      const flushToolCalls = () => {
-        if (pendingToolCalls.size === 0) return;
-        const parts = [];
-        for (const tc of pendingToolCalls.values()) {
-          let args = {};
-          try {
-            args = JSON.parse(tc.args || "{}");
-          } catch {
-          }
-          parts.push({
-            functionCall: { id: tc.id, name: tc.name, args }
-          });
-        }
-        pendingToolCalls.clear();
-        emit({
-          responseId,
-          modelVersion: model,
-          candidates: [{ content: { parts }, finishReason: null }]
-        });
-      };
-      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 chunk = JSON.parse(data);
-              if (!responseId && chunk.id) responseId = chunk.id;
-              if (!model && chunk.model) model = chunk.model;
-              const choice = chunk.choices?.[0];
-              if (!choice) continue;
-              const delta = choice.delta ?? {};
-              if (delta.thinking) {
-                const parts = [];
-                if (delta.thinking.content) {
-                  parts.push({ text: delta.thinking.content, thought: true });
-                }
-                if (delta.thinking.signature) {
-                  parts.push({ thoughtSignature: delta.thinking.signature });
-                }
-                if (parts.length > 0) {
-                  emit({
-                    responseId,
-                    modelVersion: model,
-                    candidates: [{ content: { parts }, finishReason: null }]
-                  });
-                }
-              }
-              if (delta.content) {
-                emit({
-                  responseId,
-                  modelVersion: model,
-                  candidates: [{
-                    content: { parts: [{ text: delta.content }] },
-                    finishReason: null
-                  }]
-                });
-              }
-              if (delta.tool_calls) {
-                for (const tc of delta.tool_calls) {
-                  const idx = tc.index ?? 0;
-                  const existing = pendingToolCalls.get(idx);
-                  const func = tc.function;
-                  if (existing) {
-                    if (func?.arguments) {
-                      existing.args += func.arguments;
-                    }
-                  } else {
-                    pendingToolCalls.set(idx, {
-                      id: tc.id || `tool_${Date.now()}_${idx}`,
-                      name: func?.name || "",
-                      args: func?.arguments || ""
-                    });
-                  }
-                }
-              }
-              if (choice.finish_reason) {
-                flushToolCalls();
-                const geminiUsage = chunk.usage ? {
-                  promptTokenCount: chunk.usage.prompt_tokens || 0,
-                  candidatesTokenCount: chunk.usage.completion_tokens || 0,
-                  totalTokenCount: chunk.usage.total_tokens || 0,
-                  cachedContentTokenCount: chunk.usage.prompt_tokens_details?.cached_tokens || 0,
-                  thoughtsTokenCount: chunk.usage.output_tokens_details?.reasoning_tokens || 0
-                } : void 0;
-                emit({
-                  responseId,
-                  modelVersion: model,
-                  candidates: [{
-                    content: { parts: [{ text: "" }] },
-                    finishReason: toGeminiFinishReason(choice.finish_reason) || "STOP"
-                  }],
-                  usageMetadata: geminiUsage
-                });
-              }
-            } catch (e) {
-              logger?.error(`Error parsing OpenAI stream chunk for Gemini conversion: ${e}`);
-            }
-          }
-        }
-        flushToolCalls();
-      } catch (e) {
-        if (!isClosed) controller.error(e);
-      } finally {
-        if (!isClosed) {
-          try {
-            controller.close();
-          } catch {
-          }
-        }
-        reader.releaseLock();
-      }
-    }
-  });
-}
-async function transformResponseIn(response, logger) {
-  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 geminiStream = convertOpenAIStreamToGemini(response.body, logger);
-    return new Response(geminiStream, {
-      headers: {
-        "Content-Type": "text/event-stream",
-        "Cache-Control": "no-cache",
-        Connection: "keep-alive"
-      }
-    });
-  }
-  const data = await response.json();
-  const geminiResponse = convertOpenAIResponseToGemini(data);
-  return new Response(JSON.stringify(geminiResponse), {
-    status: response.status,
-    statusText: response.statusText,
-    headers: { "Content-Type": "application/json" }
-  });
-}
-
-// src/transformer/transformers/utils/gemini.stream.ts
-async function transformResponseOut(response, providerName, logger) {
-  const contentType = response.headers.get("Content-Type") ?? "";
-  if (contentType.includes("application/json")) {
-    return handleJsonResponse(response, providerName, logger);
-  } else if (contentType.includes("stream") || contentType.includes("text/event-stream")) {
-    return handleStreamResponse(response, providerName, logger);
-  }
-  return response;
-}
-async function handleJsonResponse(response, providerName, logger) {
-  const jsonResponse = await response.json();
-  logger?.debug(`${providerName} JSON response received`);
-  const parts = jsonResponse.candidates?.[0]?.content?.parts || [];
-  let thinkingContent = "";
-  let thinkingSignature = "";
-  const nonThinkingParts = [];
-  for (const part of parts) {
-    if (part.text && part.thought === true) {
-      thinkingContent += part.text;
-    } else {
-      nonThinkingParts.push(part);
-    }
-  }
-  thinkingSignature = parts.find((part) => part.thoughtSignature)?.thoughtSignature ?? "";
-  const toolCalls = nonThinkingParts.filter((part) => part.functionCall).map((part) => ({
-    id: part.functionCall?.id || `tool_${Math.random().toString(36).substring(2, 15)}`,
-    type: "function",
-    function: {
-      name: part.functionCall?.name ?? "",
-      arguments: JSON.stringify(part.functionCall?.args || {})
-    }
-  }));
-  const textContent = nonThinkingParts.filter((part) => part.text).map((part) => part.text).join("\n");
-  const openAIResponse = {
-    id: jsonResponse.responseId ?? "",
-    choices: [
-      {
-        finish_reason: (jsonResponse.candidates?.[0]?.finishReason ?? "").toLowerCase() || null,
-        index: 0,
-        message: {
-          content: textContent,
-          role: "assistant",
-          tool_calls: toolCalls.length > 0 ? toolCalls : void 0,
-          ...thinkingSignature && {
-            thinking: {
-              content: thinkingContent || "(no content)",
-              signature: thinkingSignature
-            }
-          }
-        }
-      }
-    ],
-    created: Math.floor(Date.now() / 1e3),
-    model: jsonResponse.modelVersion ?? "",
-    object: "chat.completion",
-    usage: {
-      completion_tokens: jsonResponse.usageMetadata?.candidatesTokenCount || 0,
-      prompt_tokens: jsonResponse.usageMetadata?.promptTokenCount || 0,
-      prompt_tokens_details: {
-        cached_tokens: jsonResponse.usageMetadata?.cachedContentTokenCount || 0
-      },
-      total_tokens: jsonResponse.usageMetadata?.totalTokenCount || 0,
-      output_tokens_details: {
-        reasoning_tokens: jsonResponse.usageMetadata?.thoughtsTokenCount || 0
-      }
-    }
-  };
-  return new Response(JSON.stringify(openAIResponse), {
-    status: response.status,
-    statusText: response.statusText,
-    headers: response.headers
-  });
-}
-function handleStreamResponse(response, providerName, logger) {
-  if (!response.body) {
-    return response;
-  }
-  const decoder = new TextDecoder();
-  const encoder = new TextEncoder();
-  let signatureSent = false;
-  let contentSent = false;
-  let hasThinkingContent = false;
-  let pendingContent = "";
-  let contentIndex = 0;
-  let toolCallIndex = -1;
-  const stream = new ReadableStream({
-    async start(controller) {
-      const reader = response.body.getReader();
-      let buffer = "";
-      const processLine = async (line) => {
-        if (!line.startsWith("data: ")) return;
-        const chunkStr = line.slice(6).trim();
-        if (!chunkStr) return;
-        logger?.debug(`${providerName} chunk: ${chunkStr.substring(0, 100)}...`);
-        try {
-          const chunk = JSON.parse(chunkStr);
-          if (!chunk.candidates?.[0]) {
-            logger?.debug("Invalid chunk structure");
-            return;
-          }
-          const candidate = chunk.candidates[0];
-          const parts = candidate.content?.parts || [];
-          parts.filter((part) => part.text && part.thought === true).forEach((part) => {
-            hasThinkingContent = true;
-            const thinkingChunk = createChunk({
-              responseId: chunk.responseId,
-              modelVersion: chunk.modelVersion,
-              contentIndex,
-              delta: {
-                role: "assistant",
-                content: null,
-                thinking: { content: part.text }
-              }
-            });
-            controller.enqueue(encoder.encode(`data: ${JSON.stringify(thinkingChunk)}
-
-`));
-          });
-          const signature = parts.find((part) => part.thoughtSignature)?.thoughtSignature;
-          if (signature && !signatureSent) {
-            if (!hasThinkingContent) {
-              const thinkingChunk = createChunk({
-                responseId: chunk.responseId,
-                modelVersion: chunk.modelVersion,
-                contentIndex,
-                delta: {
-                  role: "assistant",
-                  content: null,
-                  thinking: { content: "" }
-                }
-              });
-              controller.enqueue(encoder.encode(`data: ${JSON.stringify(thinkingChunk)}
-
-`));
-            }
-            const signatureChunk = createChunk({
-              responseId: chunk.responseId,
-              modelVersion: chunk.modelVersion,
-              contentIndex,
-              delta: {
-                role: "assistant",
-                content: null,
-                thinking: { signature }
-              }
-            });
-            controller.enqueue(encoder.encode(`data: ${JSON.stringify(signatureChunk)}
-
-`));
-            signatureSent = true;
-            contentIndex++;
-            if (pendingContent) {
-              const pendingChunk = createChunk({
-                responseId: chunk.responseId,
-                modelVersion: chunk.modelVersion,
-                contentIndex,
-                delta: { role: "assistant", content: pendingContent }
-              });
-              controller.enqueue(encoder.encode(`data: ${JSON.stringify(pendingChunk)}
-
-`));
-              pendingContent = "";
-              contentSent = true;
-            }
-          }
-          const toolCalls = parts.filter((part) => part.functionCall).map((part) => ({
-            id: part.functionCall?.id || `ccr_tool_${Math.random().toString(36).substring(2, 15)}`,
-            type: "function",
-            function: {
-              name: part.functionCall?.name ?? "",
-              arguments: JSON.stringify(part.functionCall?.args || {})
-            }
-          }));
-          const textContent = parts.filter((part) => part.text && part.thought !== true).map((part) => part.text).join("\n");
-          if (!textContent && signatureSent && !contentSent) {
-            contentSent = true;
-          }
-          if (hasThinkingContent && textContent && !signatureSent) {
-            if (chunk.modelVersion?.includes("3")) {
-              pendingContent += textContent;
-              return;
-            } else {
-              const signatureChunk = createChunk({
-                responseId: chunk.responseId,
-                modelVersion: chunk.modelVersion,
-                contentIndex,
-                delta: {
-                  role: "assistant",
-                  content: null,
-                  thinking: { signature: `ccr_${Date.now()}` }
-                }
-              });
-              controller.enqueue(encoder.encode(`data: ${JSON.stringify(signatureChunk)}
-
-`));
-              signatureSent = true;
-            }
-          }
-          if (textContent) {
-            if (!pendingContent) contentIndex++;
-            const contentChunk = createChunk({
-              responseId: chunk.responseId,
-              modelVersion: chunk.modelVersion,
-              contentIndex,
-              delta: { role: "assistant", content: textContent },
-              finishReason: candidate.finishReason,
-              usageMetadata: chunk.usageMetadata,
-              groundingMetadata: candidate.groundingMetadata
-            });
-            controller.enqueue(encoder.encode(`data: ${JSON.stringify(contentChunk)}
-
-`));
-            contentSent = true;
-          }
-          if (toolCalls.length > 0) {
-            for (const tool of toolCalls) {
-              contentIndex++;
-              toolCallIndex++;
-              const toolChunk = createChunk({
-                responseId: chunk.responseId,
-                modelVersion: chunk.modelVersion,
-                contentIndex,
-                delta: {
-                  role: "assistant",
-                  tool_calls: [{ ...tool, index: toolCallIndex }]
-                },
-                finishReason: candidate.finishReason,
-                usageMetadata: chunk.usageMetadata,
-                groundingMetadata: candidate.groundingMetadata
-              });
-              controller.enqueue(encoder.encode(`data: ${JSON.stringify(toolChunk)}
-
-`));
-            }
-            contentSent = true;
-          }
-        } catch (_error) {
-          logger?.error(`Error parsing ${providerName} stream chunk: ${chunkStr}`);
-        }
-      };
-      try {
-        while (true) {
-          const { done, value } = await reader.read();
-          if (done) {
-            if (buffer) await processLine(buffer);
-            break;
-          }
-          buffer += decoder.decode(value, { stream: true });
-          const lines = buffer.split("\n");
-          buffer = lines.pop() || "";
-          for (const line of lines) {
-            await processLine(line);
-          }
-        }
-      } catch (error) {
-        controller.error(error);
-      } finally {
-        controller.close();
-      }
-    }
-  });
-  return new Response(stream, {
-    status: response.status,
-    statusText: response.statusText,
-    headers: response.headers
-  });
-}
-function createChunk(options) {
-  const {
-    responseId,
-    modelVersion,
-    contentIndex,
-    delta,
-    finishReason,
-    usageMetadata,
-    groundingMetadata
-  } = options;
-  const chunk = {
-    choices: [
-      {
-        delta,
-        finish_reason: finishReason?.toLowerCase() || null,
-        index: contentIndex,
-        logprobs: null
-      }
-    ],
-    created: Math.floor(Date.now() / 1e3),
-    id: responseId || "",
-    model: modelVersion || "",
-    object: "chat.completion.chunk",
-    system_fingerprint: "fp_a49d71b8a1"
-  };
-  if (usageMetadata) {
-    chunk.usage = {
-      completion_tokens: usageMetadata.candidatesTokenCount || 0,
-      prompt_tokens: usageMetadata.promptTokenCount || 0,
-      prompt_tokens_details: {
-        cached_tokens: usageMetadata.cachedContentTokenCount || 0
-      },
-      total_tokens: usageMetadata.totalTokenCount || 0,
-      output_tokens_details: {
-        reasoning_tokens: usageMetadata.thoughtsTokenCount || 0
-      }
-    };
-  }
-  if (groundingMetadata?.groundingChunks?.length) {
-    const annotations = groundingMetadata.groundingChunks.map((groundingChunk, index) => {
-      const support = groundingMetadata.groundingSupports?.find(
-        (s) => s.groundingChunkIndices?.includes(index)
-      );
-      return {
-        type: "url_citation",
-        url_citation: {
-          url: groundingChunk.web?.uri || "",
-          title: groundingChunk.web?.title || "",
-          content: support?.segment?.text || "",
-          start_index: support?.segment?.startIndex || 0,
-          end_index: support?.segment?.endIndex || 0
-        }
-      };
-    });
-    chunk.choices[0].delta.annotations = annotations;
-  }
-  return chunk;
-}
-
-// src/transformer/transformers/utils/gemini.schema.ts
-var GeminiType = {
-  TYPE_UNSPECIFIED: "TYPE_UNSPECIFIED",
-  STRING: "STRING",
-  NUMBER: "NUMBER",
-  INTEGER: "INTEGER",
-  BOOLEAN: "BOOLEAN",
-  ARRAY: "ARRAY",
-  OBJECT: "OBJECT",
-  NULL: "NULL"
-};
-function flattenTypeArrayToAnyOf(typeList, resultingSchema) {
-  if (typeList.includes("null")) {
-    resultingSchema.nullable = true;
-  }
-  const listWithoutNull = typeList.filter((type) => type !== "null");
-  if (listWithoutNull.length === 1) {
-    const upperCaseType = listWithoutNull[0].toUpperCase();
-    resultingSchema.type = Object.values(GeminiType).includes(upperCaseType) ? upperCaseType : GeminiType.TYPE_UNSPECIFIED;
-  } else {
-    resultingSchema.anyOf = listWithoutNull.map((typeName) => {
-      const upperCaseType = typeName.toUpperCase();
-      return {
-        type: Object.values(GeminiType).includes(upperCaseType) ? upperCaseType : GeminiType.TYPE_UNSPECIFIED
-      };
-    });
-  }
-}
-function processJsonSchema(jsonSchema) {
-  const genAISchema = {};
-  const schemaFieldNames = ["items"];
-  const listSchemaFieldNames = ["anyOf"];
-  const dictSchemaFieldNames = ["properties"];
-  let workingSchema = jsonSchema;
-  if (workingSchema.type && workingSchema.anyOf) {
-    throw new Error("type and anyOf cannot be both populated.");
-  }
-  const incomingAnyOf = workingSchema.anyOf;
-  if (incomingAnyOf && Array.isArray(incomingAnyOf) && incomingAnyOf.length === 2) {
-    if (incomingAnyOf[0]?.type === "null") {
-      genAISchema.nullable = true;
-      workingSchema = incomingAnyOf[1];
-    } else if (incomingAnyOf[1]?.type === "null") {
-      genAISchema.nullable = true;
-      workingSchema = incomingAnyOf[0];
-    }
-  }
-  if (workingSchema.type && Array.isArray(workingSchema.type)) {
-    flattenTypeArrayToAnyOf(workingSchema.type, genAISchema);
-  }
-  for (const [fieldName, fieldValue] of Object.entries(workingSchema)) {
-    if (fieldValue == null) {
-      continue;
-    }
-    if (fieldName === "type") {
-      if (fieldValue === "null") {
-        throw new Error("type: null cannot be the only possible type for the field.");
-      }
-      if (Array.isArray(fieldValue)) {
-        continue;
-      }
-      const upperCaseValue = fieldValue.toUpperCase();
-      genAISchema.type = Object.values(GeminiType).includes(upperCaseValue) ? upperCaseValue : GeminiType.TYPE_UNSPECIFIED;
-    } else if (schemaFieldNames.includes(fieldName)) {
-      genAISchema[fieldName] = processJsonSchema(fieldValue);
-    } else if (listSchemaFieldNames.includes(fieldName)) {
-      const listValue = [];
-      for (const item of fieldValue) {
-        if (item.type === "null") {
-          genAISchema.nullable = true;
-          continue;
-        }
-        listValue.push(processJsonSchema(item));
-      }
-      genAISchema[fieldName] = listValue;
-    } else if (dictSchemaFieldNames.includes(fieldName)) {
-      const dictValue = {};
-      for (const [key, value] of Object.entries(fieldValue)) {
-        dictValue[key] = processJsonSchema(value);
-      }
-      genAISchema[fieldName] = dictValue;
-    } else {
-      if (fieldName === "additionalProperties") {
-        continue;
-      }
-      genAISchema[fieldName] = fieldValue;
-    }
-  }
-  return genAISchema;
-}
-function transformTool(tool) {
-  const functionDeclarations = tool.functionDeclarations;
-  if (functionDeclarations) {
-    for (const functionDeclaration of functionDeclarations) {
-      if (functionDeclaration.parameters) {
-        const params = functionDeclaration.parameters;
-        if (!Object.keys(params).includes("$schema")) {
-          functionDeclaration.parameters = processJsonSchema(params);
-        } else {
-          if (!functionDeclaration.parametersJsonSchema) {
-            functionDeclaration.parametersJsonSchema = functionDeclaration.parameters;
-            delete functionDeclaration.parameters;
-          }
-        }
-      }
-      if (functionDeclaration.response) {
-        const response = functionDeclaration.response;
-        if (!Object.keys(response).includes("$schema")) {
-          functionDeclaration.response = processJsonSchema(response);
-        } else {
-          if (!functionDeclaration.responseJsonSchema) {
-            functionDeclaration.responseJsonSchema = functionDeclaration.response;
-            delete functionDeclaration.response;
-          }
-        }
-      }
-    }
-  }
-  return tool;
-}
-
-// src/transformer/transformers/utils/gemini.util.ts
-function buildRequestBody(request) {
-  const tools = [];
-  const functionDeclarations = request.tools?.filter((tool) => tool.function.name !== "web_search")?.map((tool) => ({
-    name: tool.function.name,
-    description: tool.function.description,
-    parametersJsonSchema: tool.function.parameters
-  }));
-  if (functionDeclarations?.length) {
-    tools.push(
-      transformTool({
-        functionDeclarations
-      })
-    );
-  }
-  const webSearch = request.tools?.find((tool) => tool.function.name === "web_search");
-  if (webSearch) {
-    tools.push({ googleSearch: {} });
-  }
-  const contents = [];
-  const toolResponses = request.messages.filter((item) => item.role === "tool");
-  request.messages.filter((item) => item.role !== "tool").forEach((message) => {
-    let role;
-    if (message.role === "assistant") {
-      role = "model";
-    } else if (["user", "system"].includes(message.role)) {
-      role = "user";
-    } else {
-      role = "user";
-    }
-    const parts = [];
-    if (typeof message.content === "string") {
-      const part = { text: message.content };
-      if (message.thinking?.signature) {
-        part.thoughtSignature = message.thinking.signature;
-      }
-      parts.push(part);
-    } else if (Array.isArray(message.content)) {
-      for (const content of message.content) {
-        if (content.type === "text") {
-          parts.push({ text: content.text || "" });
-        } else if (content.type === "image_url") {
-          const imageUrl = content.image_url?.url ?? "";
-          if (imageUrl.startsWith("http")) {
-            parts.push({
-              file_data: {
-                mime_type: content.media_type,
-                file_uri: imageUrl
-              }
-            });
-          } else {
-            const data = imageUrl.split(",").pop() || imageUrl;
-            parts.push({
-              inlineData: {
-                mime_type: content.media_type || "image/png",
-                data
-              }
-            });
-          }
-        }
-      }
-    } else if (message.content && typeof message.content === "object") {
-      const contentObj = message.content;
-      if (contentObj.text) {
-        parts.push({ text: contentObj.text });
-      } else {
-        parts.push({ text: JSON.stringify(message.content) });
-      }
-    }
-    if (Array.isArray(message.tool_calls)) {
-      for (let index = 0; index < message.tool_calls.length; index++) {
-        const toolCall = message.tool_calls[index];
-        const functionCallPart = {
-          functionCall: {
-            id: toolCall.id || `tool_${Math.random().toString(36).substring(2, 15)}`,
-            name: toolCall.function.name,
-            args: JSON.parse(toolCall.function.arguments || "{}")
-          }
-        };
-        if (index === 0 && message.thinking?.signature) {
-          functionCallPart.thoughtSignature = message.thinking.signature;
-        }
-        parts.push(functionCallPart);
-      }
-    }
-    if (parts.length === 0) {
-      parts.push({ text: "" });
-    }
-    contents.push({ role, parts });
-    if (role === "model" && message.tool_calls) {
-      const functionResponses = message.tool_calls.map(
-        (tool) => {
-          const response = toolResponses.find((item) => item.tool_call_id === tool.id);
-          return {
-            functionResponse: {
-              name: tool.function?.name ?? "",
-              response: { result: response?.content }
-            }
-          };
-        }
-      );
-      contents.push({
-        role: "user",
-        parts: functionResponses
-      });
-    }
-  });
-  const generationConfig = {};
-  if (request.reasoning?.effort && request.reasoning.effort !== "none") {
-    generationConfig.thinkingConfig = {
-      includeThoughts: true
-    };
-    if (request.model.includes("gemini-3")) {
-      generationConfig.thinkingConfig.thinkingLevel = request.reasoning.effort;
-    } else {
-      const thinkingBudgets = request.model.includes("pro") ? [128, 32768] : [0, 24576];
-      const maxTokens = request.reasoning.max_tokens;
-      if (typeof maxTokens !== "undefined") {
-        let thinkingBudget;
-        if (maxTokens >= thinkingBudgets[0] && maxTokens <= thinkingBudgets[1]) {
-          thinkingBudget = maxTokens;
-        } else if (maxTokens < thinkingBudgets[0]) {
-          thinkingBudget = thinkingBudgets[0];
-        } else {
-          thinkingBudget = thinkingBudgets[1];
-        }
-        generationConfig.thinkingConfig.thinkingBudget = thinkingBudget;
-      }
-    }
-  }
-  const body = {
-    contents,
-    tools: tools.length > 0 ? tools : void 0,
-    generationConfig: Object.keys(generationConfig).length > 0 ? generationConfig : void 0
-  };
-  if (request.tool_choice) {
-    const toolConfig = {
-      functionCallingConfig: {}
-    };
-    if (request.tool_choice === "auto") {
-      toolConfig.functionCallingConfig.mode = "auto";
-    } else if (request.tool_choice === "none") {
-      toolConfig.functionCallingConfig.mode = "none";
-    } else if (request.tool_choice === "required") {
-      toolConfig.functionCallingConfig.mode = "any";
-    } else if (typeof request.tool_choice === "object" && request.tool_choice.function?.name) {
-      toolConfig.functionCallingConfig.mode = "any";
-      toolConfig.functionCallingConfig.allowedFunctionNames = [
-        request.tool_choice.function.name
-      ];
-    }
-    body.toolConfig = toolConfig;
-  }
-  return body;
-}
-function transformRequestOut(request) {
-  const contents = request.contents;
-  const tools = request.tools;
-  const model = request.model;
-  const maxTokens = request.max_tokens;
-  const temperature = request.temperature;
-  const stream = request.stream;
-  const toolChoice = request.tool_choice;
-  const unifiedRequest = {
-    messages: [],
-    model,
-    max_tokens: maxTokens,
-    temperature,
-    stream,
-    tool_choice: toolChoice
-  };
-  if (Array.isArray(contents)) {
-    for (const content of contents) {
-      if (typeof content === "string") {
-        unifiedRequest.messages.push({
-          role: "user",
-          content
-        });
-      } else if ("text" in content && typeof content.text === "string") {
-        unifiedRequest.messages.push({
-          role: "user",
-          content: content.text || null
-        });
-      } else if ("role" in content && content.role === "user") {
-        const geminiContent = content;
-        unifiedRequest.messages.push({
-          role: "user",
-          content: geminiContent.parts?.map((part) => ({
-            type: "text",
-            text: part.text || ""
-          })) || []
-        });
-      } else if (content.role === "model") {
-        unifiedRequest.messages.push({
-          role: "assistant",
-          content: content.parts?.map((part) => ({
-            type: "text",
-            text: part.text || ""
-          })) || []
-        });
-      }
-    }
-  }
-  if (Array.isArray(tools)) {
-    unifiedRequest.tools = [];
-    for (const tool of tools) {
-      if (Array.isArray(tool.functionDeclarations)) {
-        for (const funcDecl of tool.functionDeclarations) {
-          unifiedRequest.tools.push({
-            type: "function",
-            function: {
-              name: funcDecl.name,
-              description: funcDecl.description ?? "",
-              parameters: funcDecl.parameters ?? {}
-            }
-          });
-        }
-      }
-    }
-  }
-  return unifiedRequest;
-}
-
-// src/transformer/transformers/GeminiCodeAssistTransformer.ts
-var DEFAULT_CODE_ASSIST_ENDPOINT = "https://cloudcode-pa.googleapis.com";
-var DEFAULT_CODE_ASSIST_API_VERSION = "v1internal";
-function resolveCodeAssistEndpoint() {
-  return (process.env.CODE_ASSIST_ENDPOINT || DEFAULT_CODE_ASSIST_ENDPOINT).replace(/\/+$/, "");
-}
-function resolveCodeAssistApiVersion() {
-  return process.env.CODE_ASSIST_API_VERSION || DEFAULT_CODE_ASSIST_API_VERSION;
-}
-function buildCodeAssistUrl(stream) {
-  const base = resolveCodeAssistEndpoint();
-  const version = resolveCodeAssistApiVersion();
-  const method = stream ? "streamGenerateContent?alt=sse" : "generateContent";
-  return `${base}/${version}:${method}`;
-}
-function generateUserPromptId() {
-  const c = globalThis.crypto;
-  if (c?.randomUUID) return c.randomUUID();
-  return `omnicross-${Date.now()}-${Math.random().toString(36).slice(2, 10)}`;
-}
-function peelResponseEnvelope(parsed) {
-  if (parsed && typeof parsed === "object" && "response" in parsed) {
-    return parsed.response;
-  }
-  return parsed;
-}
-async function unwrapCodeAssistResponse(response) {
-  const contentType = response.headers.get("Content-Type") ?? "";
-  if (contentType.includes("stream") || contentType.includes("text/event-stream")) {
-    const sourceBody = response.body;
-    if (!sourceBody) return response;
-    const decoder = new TextDecoder();
-    const encoder = new TextEncoder();
-    const peeled = new ReadableStream({
-      async start(controller) {
-        const reader = sourceBody.getReader();
-        let buffer = "";
-        const processLine = (line) => {
-          if (!line.startsWith("data:")) {
-            if (line.length > 0) controller.enqueue(encoder.encode(`${line}
-`));
-            return;
-          }
-          const payload = line.slice(line.indexOf(":") + 1).trim();
-          if (!payload || payload === "[DONE]") {
-            controller.enqueue(encoder.encode(`${line}
-`));
-            return;
-          }
-          try {
-            const parsed = JSON.parse(payload);
-            const inner2 = peelResponseEnvelope(parsed);
-            controller.enqueue(encoder.encode(`data: ${JSON.stringify(inner2)}
-`));
-          } catch {
-            controller.enqueue(encoder.encode(`${line}
-`));
-          }
-        };
-        try {
-          while (true) {
-            const { done, value } = await reader.read();
-            if (done) {
-              if (buffer) processLine(buffer);
-              break;
-            }
-            buffer += decoder.decode(value, { stream: true });
-            const lines = buffer.split("\n");
-            buffer = lines.pop() || "";
-            for (const line of lines) processLine(line);
-          }
-        } catch (err) {
-          controller.error(err);
-        } finally {
-          controller.close();
-        }
-      }
-    });
-    return new Response(peeled, {
-      status: response.status,
-      statusText: response.statusText,
-      headers: response.headers
-    });
-  }
-  const raw = await response.json().catch(() => null);
-  const inner = peelResponseEnvelope(raw);
-  return new Response(JSON.stringify(inner), {
-    status: response.status,
-    statusText: response.statusText,
-    headers: response.headers
-  });
-}
-var GeminiCodeAssistTransformer = class {
-  static TransformerName = "gemini-code-assist";
-  name = "gemini-code-assist";
-  logger;
-  /** Code Assist has no fixed `/models/:modelAndAction` endpoint pattern — the
-   *  URL is built per-request in `transformRequestIn`. Left undefined so the
-   *  TransformerService does NOT treat this as an endpoint (reverse) transformer. */
-  endPoint = void 0;
-  /**
-   * unified → Code Assist envelope.
-   *
-   * Builds the inner public-Gemini body via the shared `buildRequestBody`, then
-   * wraps it as `{ model, project, user_prompt_id, request: <inner> }` and sets
-   * the Code Assist URL + Bearer-only headers.
-   *
-   * The resolved Code Assist `project` is threaded in via `provider.geminiProject`
-   * (stashed by the subscription dispatch seam — see SubscriptionDispatcher /
-   * openaiResponsesIngress). `undefined` is the valid fresh free-tier value.
-   */
-  async transformRequestIn(request, provider, _context) {
-    const inner = buildRequestBody(request);
-    const envelope = {
-      model: request.model,
-      project: provider.geminiProject,
-      user_prompt_id: generateUserPromptId(),
-      request: inner
-    };
-    const url = buildCodeAssistUrl(Boolean(request.stream));
-    const headers = {
-      "x-goog-api-key": void 0,
-      "X-Goog-Api-Key": void 0
-    };
-    return {
-      body: envelope,
-      config: { url, headers }
-    };
-  }
-  /**
-   * Code Assist request → unified (endpoint-decode parity with GeminiTransformer).
-   * Peels the top-level `request` envelope first, then delegates to the shared
-   * gemini request decoder. Not used on the subscription dispatch path (the
-   * endpoint transformer there is Anthropic/OpenAI-Response), but provided for
-   * completeness so this transformer is a drop-in for the gemini one.
-   */
-  async transformRequestOut(request, _context) {
-    const r = request;
-    const inner = r && typeof r === "object" && "request" in r ? r.request : r;
-    if (inner && typeof inner === "object" && !("model" in inner) && "model" in r) {
-      inner.model = r.model;
-    }
-    return transformRequestOut(inner);
-  }
-  /**
-   * Code Assist response → OpenAI-compatible. PEEL the `.response` envelope from
-   * the body / each SSE chunk, then DELEGATE to the existing gemini parser.
-   */
-  async transformResponseOut(response, _context) {
-    const unwrapped = await unwrapCodeAssistResponse(response);
-    return transformResponseOut(unwrapped, this.name, this.logger);
-  }
-  /**
-   * OpenAI-compatible response → Code Assist (endpoint-encode parity). Re-wraps
-   * the standard gemini response under the top-level `response` key after the
-   * shared gemini encoder produces a public-Gemini body. Symmetric with
-   * `transformResponseOut`'s peel.
-   */
-  async transformResponseIn(response, _context) {
-    const geminiResponse = await transformResponseIn(response, this.logger);
-    const contentType = geminiResponse.headers.get("Content-Type") ?? "";
-    if (contentType.includes("text/event-stream")) {
-      return geminiResponse;
-    }
-    const data = await geminiResponse.json().catch(() => null);
-    return new Response(JSON.stringify({ response: data }), {
-      status: geminiResponse.status,
-      statusText: geminiResponse.statusText,
-      headers: { "Content-Type": "application/json" }
-    });
-  }
-};
-
-// src/transformer/transformers/GeminiTransformer.ts
-var GeminiTransformer = class {
-  static TransformerName = "gemini";
-  name = "gemini";
-  logger;
-  /**
-   * API endpoint pattern for Gemini
-   * :modelAndAction will be replaced with actual model and action
-   */
-  endPoint = "/v1beta/models/:modelAndAction";
-  /** Use Bearer token instead of x-goog-api-key (for relay providers) */
-  useBearer;
-  constructor(options) {
-    this.useBearer = options?.UseBearer ?? false;
-  }
-  /**
-   * Handle authentication
-   * - Official Gemini: x-goog-api-key header
-   * - Relay providers: Authorization: Bearer header
-   */
-  async auth(request, provider, _context) {
-    const headers = {};
-    if (this.useBearer) {
-      headers["authorization"] = `Bearer ${provider.apiKey}`;
-      headers["x-goog-api-key"] = void 0;
-    } else {
-      headers["x-goog-api-key"] = provider.apiKey;
-      headers["authorization"] = void 0;
-    }
-    return {
-      body: request,
-      config: { headers }
-    };
-  }
-  /**
-   * Transform request from unified format to Gemini format
-   * Also builds the correct URL for the Gemini API
-   */
-  async transformRequestIn(request, provider, _context) {
-    const body = buildRequestBody(request);
-    const action = request.stream ? "streamGenerateContent?alt=sse" : "generateContent";
-    const url = new URL(`./${request.model}:${action}`, provider.baseUrl);
-    const headers = {};
-    if (this.useBearer) {
-      headers["authorization"] = `Bearer ${provider.apiKey}`;
-      headers["x-goog-api-key"] = void 0;
-    } else {
-      headers["x-goog-api-key"] = provider.apiKey;
-      headers["Authorization"] = void 0;
-    }
-    return {
-      body,
-      config: { url, headers }
-    };
-  }
-  /**
-   * Transform incoming request to unified format
-   * (For requests coming into the Gemini endpoint)
-   */
-  async transformRequestOut(request, _context) {
-    return transformRequestOut(request);
-  }
-  /**
-   * Transform Gemini response to OpenAI-compatible format
-   */
-  async transformResponseOut(response, _context) {
-    return transformResponseOut(response, this.name, this.logger);
-  }
-  /**
-   * Transform OpenAI-compatible response back to Gemini format
-   * (For endpoint mode — returning Gemini-format responses to the client)
-   */
-  async transformResponseIn(response, _context) {
-    return transformResponseIn(response, this.logger);
-  }
-};
-
-// src/transformer/transformers/OpenAIResponseTransformer.ts
-var OpenAIResponseTransformer = class {
-  static TransformerName = "openai-response";
-  name = "openai-response";
-  endPoint = "/v1/responses";
-  logger;
-  /**
-   * Handle authentication - Bearer token
-   */
-  async auth(request, provider, _context) {
-    return {
-      body: request,
-      config: {
-        headers: {
-          Authorization: `Bearer ${provider.apiKey}`,
-          "Content-Type": "application/json"
-        }
-      }
-    };
-  }
-  /**
-   * Transform unified request → Response API format
-   */
-  async transformRequestIn(request, provider, _context) {
-    const input = [];
-    for (const msg of request.messages) {
-      if (msg.role === "system") {
-        input.push({
-          role: "developer",
-          content: typeof msg.content === "string" ? msg.content : flattenContent(msg.content)
-        });
-      } else if (msg.role === "tool") {
-        input.push({
-          type: "function_call_output",
-          call_id: msg.tool_call_id,
-          output: typeof msg.content === "string" ? msg.content : ""
-        });
-      } else {
-        const entry = {
-          role: msg.role,
-          content: typeof msg.content === "string" ? msg.content : flattenContent(msg.content)
-        };
-        if (msg.role === "assistant" && msg.tool_calls?.length) {
-          input.push(entry);
-          for (const tc of msg.tool_calls) {
-            input.push({
-              type: "function_call",
-              id: tc.id,
-              call_id: tc.id,
-              name: tc.function.name,
-              arguments: tc.function.arguments
-            });
-          }
-          continue;
-        }
-        input.push(entry);
-      }
-    }
-    const body = {
-      model: request.model,
-      input,
-      stream: request.stream ?? false,
-      ...request.max_tokens ? { max_output_tokens: request.max_tokens } : {},
-      ...request.temperature !== void 0 ? { temperature: request.temperature } : {}
-    };
-    if (request.reasoning?.effort && request.reasoning.effort !== "none") {
-      body.reasoning = { effort: request.reasoning.effort, summary: "auto" };
-    }
-    if (request.tools?.length) {
-      body.tools = request.tools.map((tool) => ({
-        type: "function",
-        name: tool.function.name,
-        description: tool.function.description,
-        parameters: tool.function.parameters
-      }));
-    }
-    if (request.tool_choice) {
-      if (typeof request.tool_choice === "string") {
-        body.tool_choice = request.tool_choice;
-      } else if (typeof request.tool_choice === "object" && "function" in request.tool_choice) {
-        body.tool_choice = { type: "function", name: request.tool_choice.function.name };
-      }
-    }
-    const url = new URL("/v1/responses", provider.baseUrl);
-    return { body, config: { url } };
-  }
-  /**
-   * Transform Response API request → unified format
-   */
-  async transformRequestOut(request, _context) {
-    const req = request;
-    const messages = [];
-    if (req.input) {
-      for (const item of req.input) {
-        const entry = item;
-        if (entry.type === "function_call_output") {
-          messages.push({
-            role: "tool",
-            content: entry.output || "",
-            tool_call_id: entry.call_id || void 0
-          });
-          continue;
-        }
-        if (entry.type === "function_call") {
-          const toolCall = {
-            id: (entry.call_id ?? entry.id) || "",
-            type: "function",
-            function: {
-              name: entry.name || "",
-              arguments: typeof entry.arguments === "string" ? entry.arguments : ""
-            }
-          };
-          const last = messages[messages.length - 1];
-          if (last && last.role === "assistant") {
-            (last.tool_calls ??= []).push(toolCall);
-          } else {
-            messages.push({ role: "assistant", content: null, tool_calls: [toolCall] });
-          }
-          continue;
-        }
-        const role = entry.role;
-        if (role === "developer") {
-          messages.push({
-            role: "system",
-            content: typeof entry.content === "string" ? entry.content : JSON.stringify(entry.content)
-          });
-        } else if (role === "user" || role === "assistant") {
-          messages.push({
-            role,
-            content: typeof entry.content === "string" ? entry.content : JSON.stringify(entry.content)
-          });
-        }
-      }
-    }
-    const result = {
-      messages,
-      model: req.model,
-      max_tokens: req.max_output_tokens,
-      temperature: req.temperature,
-      stream: req.stream
-    };
-    if (req.reasoning?.effort) {
-      result.reasoning = {
-        effort: req.reasoning.effort,
-        enabled: true
-      };
-    }
-    if (req.tools?.length) {
-      result.tools = req.tools.filter((t) => t.type === "function").map((t) => ({
-        type: "function",
-        function: {
-          name: t.name || "",
-          description: t.description || "",
-          parameters: t.parameters || {}
-        }
-      }));
-    }
-    return result;
-  }
-  /**
-   * Transform Response API response → unified (OpenAI CC) format
-   */
-  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");
-      }
-      return new Response(convertResponseApiStreamToOpenAI(response.body), {
-        headers: {
-          "Content-Type": "text/event-stream",
-          "Cache-Control": "no-cache",
-          Connection: "keep-alive"
-        }
-      });
-    }
-    const data = await response.json();
-    return new Response(JSON.stringify(convertResponseApiJsonToOpenAI(data)), {
-      headers: { "Content-Type": "application/json" }
-    });
-  }
-  /**
-   * Transform OpenAI CC response → Response API format
-   */
-  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");
-      }
-      return new Response(convertOpenAIStreamToResponseApi(response.body), {
-        headers: {
-          "Content-Type": "text/event-stream",
-          "Cache-Control": "no-cache",
-          Connection: "keep-alive"
-        }
-      });
-    }
-    const data = await response.json();
-    return new Response(JSON.stringify(convertOpenAIJsonToResponseApi(data)), {
-      headers: { "Content-Type": "application/json" }
-    });
-  }
-};
-function flattenContent(content) {
-  if (typeof content === "string") return content;
-  if (!content) return "";
-  if (Array.isArray(content)) {
-    return content.filter((c) => c.type === "text").map((c) => c.text || "").join("\n");
-  }
-  return "";
-}
-function convertResponseApiJsonToOpenAI(data) {
-  let textContent = "";
-  const toolCalls = [];
-  const output = data.output;
-  if (output) {
-    for (const item of output) {
-      if (item.type === "message") {
-        const content = item.content;
-        if (content) {
-          for (const part of content) {
-            if (part.type === "output_text" && typeof part.text === "string") {
-              textContent += part.text;
-            }
-          }
-        }
-      } else if (item.type === "function_call") {
-        toolCalls.push({
-          id: item.call_id || item.id || `call_${Date.now()}`,
-          type: "function",
-          function: {
-            name: item.name,
-            arguments: typeof item.arguments === "string" ? item.arguments : JSON.stringify(item.arguments || {})
-          }
-        });
-      }
-    }
-  }
-  const usage = data.usage;
-  const message = {
-    role: "assistant",
-    content: textContent || null
-  };
-  if (toolCalls.length > 0) {
-    message.tool_calls = toolCalls;
-  }
-  return {
-    id: data.id || `chatcmpl-${Date.now()}`,
-    object: "chat.completion",
-    created: Math.floor(Date.now() / 1e3),
-    model: data.model || "unknown",
-    choices: [
-      {
-        index: 0,
-        message,
-        finish_reason: toolCalls.length > 0 ? "tool_calls" : "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 convertOpenAIJsonToResponseApi(data) {
-  const choices = data.choices;
-  const message = choices?.[0]?.message;
-  const output = [];
-  if (message) {
-    const contentParts = [];
-    if (message.content) {
-      contentParts.push({ type: "output_text", text: message.content });
-    }
-    if (contentParts.length > 0) {
-      output.push({ type: "message", role: "assistant", content: contentParts });
-    }
-    const toolCalls = message.tool_calls;
-    if (toolCalls?.length) {
-      for (const tc of toolCalls) {
-        const func = tc.function;
-        output.push({
-          type: "function_call",
-          id: tc.id,
-          call_id: tc.id,
-          name: func?.name,
-          arguments: func?.arguments
-        });
-      }
-    }
-  }
-  const usage = data.usage;
-  return {
-    id: data.id || `resp_${Date.now()}`,
-    object: "response",
-    status: "completed",
-    model: data.model || "unknown",
-    output,
-    usage: usage ? {
-      input_tokens: usage.prompt_tokens || 0,
-      output_tokens: usage.completion_tokens || 0,
-      total_tokens: usage.total_tokens || (usage.prompt_tokens || 0) + (usage.completion_tokens || 0)
-    } : void 0
-  };
-}
-function convertResponseApiStreamToOpenAI(responseApiStream) {
-  const decoder = new TextDecoder();
-  const encoder = new TextEncoder();
-  return new ReadableStream({
-    start: async (controller) => {
-      const reader = responseApiStream.getReader();
-      let buffer = "";
-      let isClosed = false;
-      const messageId = `chatcmpl-${Date.now()}`;
-      let model = "unknown";
-      let hasEmittedRole = false;
-      const safeEnqueue = (str) => {
-        if (!isClosed) {
-          try {
-            controller.enqueue(encoder.encode(str));
-          } catch {
-            isClosed = true;
-          }
-        }
-      };
-      const emitChunk = (choices, usage) => {
-        const chunk = {
-          id: messageId,
-          object: "chat.completion.chunk",
-          created: Math.floor(Date.now() / 1e3),
-          model,
-          choices
-        };
-        if (usage) chunk.usage = usage;
-        safeEnqueue(`data: ${JSON.stringify(chunk)}
-
-`);
-      };
-      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 event = JSON.parse(data);
-              model = event.model || event.response?.model || model;
-              switch (event.type) {
-                case "response.output_text.delta":
-                  if (event.delta) {
-                    if (!hasEmittedRole) {
-                      emitChunk([{ index: 0, delta: { role: "assistant", content: "" }, finish_reason: null }]);
-                      hasEmittedRole = true;
-                    }
-                    emitChunk([{ index: 0, delta: { content: event.delta }, finish_reason: null }]);
-                  }
-                  break;
-                case "response.reasoning_summary_text.delta":
-                  if (event.delta) {
-                    emitChunk([{
-                      index: 0,
-                      delta: { thinking: { content: event.delta } },
-                      finish_reason: null
-                    }]);
-                  }
-                  break;
-                case "response.completed": {
-                  const resp = event.response;
-                  const respUsage = resp?.usage;
-                  const usage = respUsage ? {
-                    prompt_tokens: respUsage.input_tokens || 0,
-                    completion_tokens: respUsage.output_tokens || 0,
-                    total_tokens: (respUsage.input_tokens || 0) + (respUsage.output_tokens || 0)
-                  } : void 0;
-                  emitChunk([{ index: 0, delta: {}, finish_reason: "stop" }], usage);
-                  safeEnqueue("data: [DONE]\n\n");
-                  break;
-                }
-                case "error":
-                  emitChunk([{
-                    index: 0,
-                    delta: { content: `[Error: ${event.error?.message || "Unknown error"}]` },
-                    finish_reason: "stop"
-                  }]);
-                  break;
-                default:
-                  break;
-              }
-            } catch {
-            }
-          }
-        }
-      } catch (e) {
-        if (!isClosed) controller.error(e);
-      } finally {
-        if (!isClosed) {
-          try {
-            controller.close();
-          } catch {
-          }
-        }
-        reader.releaseLock();
-      }
-    }
-  });
-}
-function convertOpenAIStreamToResponseApi(openaiStream) {
-  const decoder = new TextDecoder();
-  const encoder = new TextEncoder();
-  return new ReadableStream({
-    start: async (controller) => {
-      const reader = openaiStream.getReader();
-      let buffer = "";
-      let isClosed = false;
-      let accumulatedContent = "";
-      let model = "unknown";
-      const responseId = `resp_${Date.now()}`;
-      const safeEnqueue = (str) => {
-        if (!isClosed) {
-          try {
-            controller.enqueue(encoder.encode(str));
-          } catch {
-            isClosed = true;
-          }
-        }
-      };
-      const emitEvent = (event) => {
-        safeEnqueue(`data: ${JSON.stringify(event)}
-
-`);
-      };
-      emitEvent({
-        type: "response.created",
-        response: { id: responseId, status: "in_progress" }
-      });
-      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);
-              const choice = chunk.choices?.[0];
-              model = chunk.model || model;
-              if (!choice) continue;
-              if (choice.delta?.content) {
-                accumulatedContent += choice.delta.content;
-                emitEvent({ type: "response.output_text.delta", delta: choice.delta.content });
-              }
-              if (choice.delta?.thinking?.content) {
-                emitEvent({
-                  type: "response.reasoning_summary_text.delta",
-                  delta: choice.delta.thinking.content
-                });
-              }
-              if (choice.finish_reason) {
-                emitEvent({ type: "response.output_text.done", text: accumulatedContent });
-                emitEvent({
-                  type: "response.completed",
-                  response: {
-                    id: responseId,
-                    status: "completed",
-                    model,
-                    output: [
-                      {
-                        type: "message",
-                        role: "assistant",
-                        content: [{ type: "output_text", text: accumulatedContent }]
-                      }
-                    ],
-                    usage: chunk.usage ? {
-                      input_tokens: chunk.usage.prompt_tokens || 0,
-                      output_tokens: chunk.usage.completion_tokens || 0,
-                      total_tokens: chunk.usage.total_tokens || 0
-                    } : void 0
-                  }
-                });
-              }
-            } catch {
-            }
-          }
-        }
-      } catch (e) {
-        if (!isClosed) controller.error(e);
-      } finally {
-        if (!isClosed) {
-          try {
-            controller.close();
-          } catch {
-          }
-        }
-        reader.releaseLock();
-      }
-    }
-  });
-}
-
-// src/transformer/transformers/OpenCodeGoTransformer.ts
-var OpenCodeGoTransformer = class {
-  static TransformerName = "opencodego";
-  name = "opencodego";
-  endPoint = "/v1/chat/completions";
-  logger;
-  async auth(request, _provider, _context) {
-    return { body: request, config: { headers: {} } };
-  }
-  /**
-   * Unified → OpenAI Chat Completions.
-   * Unified IS chat completions shape; this is mostly stripping `meta` and
-   * normalizing string-content single-block messages.
-   */
-  async transformRequestIn(request, _provider, _context) {
-    const messages = request.messages.map((m) => {
-      const content = m.content;
-      if (Array.isArray(content) && content.length === 1 && content[0]?.type === "text") {
-        return { ...m, content: content[0].text };
-      }
-      return m;
-    });
-    const out = {
-      model: request.model,
-      messages,
-      stream: request.stream
-    };
-    if (request.temperature !== void 0) out.temperature = request.temperature;
-    if (request.max_tokens !== void 0) out.max_tokens = request.max_tokens;
-    if (request.tools && request.tools.length > 0) out.tools = request.tools;
-    if (request.tool_choice !== void 0) out.tool_choice = request.tool_choice;
-    if (request.reasoning?.effort && request.reasoning.effort !== "none") {
-      out.reasoning_effort = request.reasoning.effort;
-    }
-    return out;
-  }
-  /**
-   * OpenAI Chat Completions response → Unified.
-   * The upstream's response shape already matches Unified — pass through.
-   * The endpoint AnthropicTransformer re-encodes to Anthropic for the SDK.
-   */
-  async transformResponseOut(response, _context) {
-    return response;
-  }
-};
-
-// src/transformer/transformers/ReasoningTransformer.ts
-var import_thinking_config = require("@omnicross/contracts/thinking-config");
-var ReasoningTransformer = class {
-  static TransformerName = "reasoning";
-  name = "reasoning";
-  logger;
-  enabled;
-  constructor(options) {
-    this.enabled = options?.enable !== false;
-  }
-  /**
-   * Transform request: convert reasoning config to thinking parameters
-   * Uses model-specific budget calculation based on effort level
-   */
-  async transformRequestIn(request, provider, _context) {
-    const extendedRequest = request;
-    const modelId = request.model;
-    if (!this.enabled) {
-      extendedRequest.thinking = {
-        type: "disabled",
-        budget_tokens: -1
-      };
-      extendedRequest.enable_thinking = false;
-      return extendedRequest;
-    }
-    if (request.reasoning) {
-      const effortLevel = request.reasoning.effort || "none";
-      const userMaxTokens = request.reasoning.max_tokens || request.max_tokens;
-      const calculatedBudget = (0, import_thinking_config.calculateThinkingBudget)(modelId, effortLevel, userMaxTokens);
-      const providerName = provider.name?.toLowerCase() || "";
-      if (providerName === "anthropic" || providerName.includes("claude")) {
-        const thinkingConfig = (0, import_thinking_config.buildAnthropicThinking)(modelId, effortLevel, userMaxTokens);
-        if (thinkingConfig) {
-          extendedRequest.thinking = thinkingConfig;
-        } else {
-          extendedRequest.thinking = {
-            type: "disabled"
-          };
-        }
-      } else if (providerName === "openai" || modelId.match(/^o[134]/i)) {
-        const reasoningEffort = (0, import_thinking_config.getOpenAIReasoningEffort)(effortLevel);
-        if (reasoningEffort) {
-          extendedRequest.reasoning_effort = reasoningEffort;
-        }
-        extendedRequest.thinking = {
-          type: effortLevel === "none" ? "disabled" : "enabled",
-          budget_tokens: calculatedBudget
-        };
-      } else if (providerName === "deepseek" && modelId?.startsWith("deepseek-v4")) {
-        extendedRequest.thinking = {
-          type: effortLevel === "none" ? "disabled" : "enabled",
-          budget_tokens: calculatedBudget
-        };
-        if (effortLevel !== "none") {
-          extendedRequest.reasoning_effort = effortLevel === "high" ? "max" : "high";
-        }
-      } else if (providerName === "deepseek" || providerName === "qwen" || providerName === "alibaba") {
-        const qwenConfig = (0, import_thinking_config.buildQwenThinkingConfig)(effortLevel, userMaxTokens);
-        extendedRequest.enable_thinking = qwenConfig.enable_thinking;
-        if (qwenConfig.thinking_budget) {
-          extendedRequest.thinking_budget = qwenConfig.thinking_budget;
-        }
-        extendedRequest.thinking = {
-          type: qwenConfig.enable_thinking ? "enabled" : "disabled",
-          budget_tokens: calculatedBudget
-        };
-      } else {
-        extendedRequest.thinking = {
-          type: effortLevel === "none" ? "disabled" : "enabled",
-          budget_tokens: calculatedBudget
-        };
-        extendedRequest.enable_thinking = effortLevel !== "none";
-      }
-      this.logger?.debug(`[ReasoningTransformer] Model: ${modelId}, Effort: ${effortLevel}, Budget: ${calculatedBudget}`);
-    }
-    return extendedRequest;
-  }
-  /**
-   * Transform response: convert reasoning_content to thinking blocks
-   */
-  async transformResponseOut(response, _context) {
-    if (!this.enabled) return response;
-    const contentType = response.headers.get("Content-Type") ?? "";
-    if (contentType.includes("application/json")) {
-      return this.handleJsonResponse(response);
-    } else if (contentType.includes("stream") || contentType.includes("text/event-stream")) {
-      return this.handleStreamResponse(response);
-    }
-    return response;
-  }
-  /**
-   * Handle JSON (non-streaming) response
-   */
-  async handleJsonResponse(response) {
-    const jsonResponse = await response.json();
-    if (jsonResponse.choices?.[0]?.message?.reasoning_content) {
-      jsonResponse.thinking = {
-        content: jsonResponse.choices[0].message.reasoning_content
-      };
-      delete jsonResponse.choices[0].message.reasoning_content;
-    }
-    return new Response(JSON.stringify(jsonResponse), {
-      status: response.status,
-      statusText: response.statusText,
-      headers: response.headers
-    });
-  }
-  /**
-   * Handle streaming response - convert reasoning_content to thinking blocks
-   */
-  handleStreamResponse(response) {
-    if (!response.body) {
-      return response;
-    }
-    const decoder = new TextDecoder();
-    const encoder = new TextEncoder();
-    let reasoningContent = "";
-    let isReasoningComplete = false;
-    let buffer = "";
-    const stream = new ReadableStream({
-      start: async (controller) => {
-        const reader = response.body.getReader();
-        const processLine = (line) => {
-          this.logger?.debug("Processing reasoning line:", line);
-          if (line.startsWith("data: ") && line.trim() !== "data: [DONE]") {
-            try {
-              const data = JSON.parse(line.slice(6));
-              if (data.choices?.[0]?.delta?.reasoning_content) {
-                reasoningContent += data.choices[0].delta.reasoning_content;
-                const thinkingChunk = {
-                  ...data,
-                  choices: [
-                    {
-                      ...data.choices[0],
-                      delta: {
-                        ...data.choices[0].delta,
-                        thinking: {
-                          content: data.choices[0].delta.reasoning_content
-                        }
-                      }
-                    }
-                  ]
-                };
-                delete thinkingChunk.choices[0].delta.reasoning_content;
-                const thinkingLine = `data: ${JSON.stringify(thinkingChunk)}
-
-`;
-                controller.enqueue(encoder.encode(thinkingLine));
-                return;
-              }
-              if ((data.choices?.[0]?.delta?.content || data.choices?.[0]?.delta?.tool_calls) && reasoningContent && !isReasoningComplete) {
-                isReasoningComplete = true;
-                const signature = Date.now().toString();
-                const thinkingChunk = {
-                  ...data,
-                  choices: [
-                    {
-                      ...data.choices[0],
-                      delta: {
-                        ...data.choices[0].delta,
-                        content: null,
-                        thinking: {
-                          signature
-                        }
-                      }
-                    }
-                  ]
-                };
-                delete thinkingChunk.choices[0].delta.reasoning_content;
-                const thinkingLine = `data: ${JSON.stringify(thinkingChunk)}
-
-`;
-                controller.enqueue(encoder.encode(thinkingLine));
-              }
-              if (data.choices?.[0]?.delta?.reasoning_content) {
-                delete data.choices[0].delta.reasoning_content;
-              }
-              if (data.choices?.[0]?.delta && Object.keys(data.choices[0].delta).length > 0) {
-                if (isReasoningComplete) {
-                  data.choices[0].index++;
-                }
-                const modifiedLine = `data: ${JSON.stringify(data)}
-
-`;
-                controller.enqueue(encoder.encode(modifiedLine));
-              }
-            } catch (_e) {
-              controller.enqueue(encoder.encode(line + "\n"));
-            }
-          } else {
-            controller.enqueue(encoder.encode(line + "\n"));
-          }
-        };
-        try {
-          while (true) {
-            const { done, value } = await reader.read();
-            if (done) {
-              if (buffer.trim()) {
-                const lines2 = buffer.split("\n");
-                for (const line of lines2) {
-                  if (line.trim()) {
-                    controller.enqueue(encoder.encode(line + "\n"));
-                  }
-                }
-              }
-              break;
-            }
-            const chunk = decoder.decode(value, { stream: true });
-            buffer += chunk;
-            const lines = buffer.split("\n");
-            buffer = lines.pop() || "";
-            for (const line of lines) {
-              if (!line.trim()) continue;
-              try {
-                processLine(line);
-              } catch (error) {
-                this.logger?.error("Error processing reasoning stream line:", error);
-                controller.enqueue(encoder.encode(line + "\n"));
-              }
-            }
-          }
-        } catch (error) {
-          this.logger?.error("Reasoning stream error:", error);
-          controller.error(error);
-        } finally {
-          try {
-            reader.releaseLock();
-          } catch (e) {
-            this.logger?.error("Error releasing reader lock:", e);
-          }
-          controller.close();
-        }
-      }
-    });
-    return new Response(stream, {
-      status: response.status,
-      statusText: response.statusText,
-      headers: new Headers({
-        "Content-Type": "text/event-stream",
-        "Cache-Control": "no-cache",
-        Connection: "keep-alive"
-      })
-    });
-  }
-};
-
-// src/transformer/transformers/index.ts
-var BuiltinTransformers = {
-  DeepseekTransformer,
-  ReasoningTransformer,
-  GeminiTransformer,
-  GeminiCodeAssistTransformer,
-  AnthropicTransformer,
-  OpenAIResponseTransformer,
-  OpenCodeGoTransformer
-};
-function getBuiltinTransformers() {
-  return BuiltinTransformers;
-}
-var BUILTIN_TRANSFORMER_NAMES = [
-  "deepseek",
-  "reasoning",
-  "gemini",
-  "gemini-code-assist",
-  "anthropic",
-  "openai-response",
-  "opencodego"
-];
-async function registerBuiltinTransformers(service) {
-  await service.initialize(getBuiltinTransformers());
-}
-// Annotate the CommonJS export names for ESM import in node:
-0 && (module.exports = {
-  AnthropicTransformer,
-  BUILTIN_TRANSFORMER_NAMES,
-  BuiltinTransformers,
-  DeepseekTransformer,
-  GeminiCodeAssistTransformer,
-  GeminiTransformer,
-  OpenAIResponseTransformer,
-  OpenCodeGoTransformer,
-  ReasoningTransformer,
-  getBuiltinTransformers,
-  registerBuiltinTransformers
-});
+exports.AnthropicTransformer = _chunk4VAVYUZScjs.AnthropicTransformer; exports.BUILTIN_TRANSFORMER_NAMES = _chunkFFALUUZZcjs.BUILTIN_TRANSFORMER_NAMES; exports.BuiltinTransformers = _chunkFFALUUZZcjs.BuiltinTransformers; exports.DeepseekTransformer = _chunkFFALUUZZcjs.DeepseekTransformer; exports.GeminiCodeAssistTransformer = _chunkRSJ3TWJQcjs.GeminiCodeAssistTransformer; exports.GeminiTransformer = _chunk7YN22L2Hcjs.GeminiTransformer; exports.OpenAIResponseTransformer = _chunk2DCNB7DFcjs.OpenAIResponseTransformer; exports.OpenCodeGoTransformer = _chunkC72S6TTVcjs.OpenCodeGoTransformer; exports.ReasoningTransformer = _chunkDWKQZ2SKcjs.ReasoningTransformer; exports.getBuiltinTransformers = _chunkFFALUUZZcjs.getBuiltinTransformers; exports.registerBuiltinTransformers = _chunkFFALUUZZcjs.registerBuiltinTransformers;