@omnicross/core 0.1.8 → 0.1.10

package/dist/{chunk-7C7DET6S.js → chunk-GXEZ2R3E.js}

@@ -11,6 +11,156 @@ import {
 
 // src/outbound-api/auditCapture.ts
 import { randomUUID } from "crypto";
+
+// src/outbound-api/auditSseCompact.ts
+var MERGED_FRAMES_FIELD = "_omnicrossMergedFrames";
+function asObject(value) {
+  return value !== null && typeof value === "object" && !Array.isArray(value) ? value : null;
+}
+function scalar(value) {
+  return typeof value === "string" || typeof value === "number" ? String(value) : "";
+}
+function classify(payload) {
+  const type = scalar(payload["type"]);
+  if (type === "content_block_delta") {
+    const delta = asObject(payload["delta"]);
+    const deltaType = scalar(delta?.["type"]);
+    const field = deltaType === "text_delta" ? "text" : deltaType === "thinking_delta" ? "thinking" : deltaType === "input_json_delta" ? "partial_json" : null;
+    if (!delta || !field || typeof delta[field] !== "string") return null;
+    return {
+      channel: "anthropic:" + scalar(payload["index"]) + ":" + deltaType,
+      text: delta[field],
+      payload,
+      textPath: ["delta", field]
+    };
+  }
+  if (type.endsWith(".delta") && typeof payload["delta"] === "string") {
+    const channel = [
+      "responses",
+      type,
+      scalar(payload["item_id"]),
+      scalar(payload["output_index"]),
+      scalar(payload["content_index"])
+    ].join(":");
+    return { channel, text: payload["delta"], payload, textPath: ["delta"] };
+  }
+  const choices = payload["choices"];
+  if (Array.isArray(choices) && choices.length === 1) {
+    const choice = asObject(choices[0]);
+    const delta = asObject(choice?.["delta"]);
+    if (choice && delta && typeof delta["content"] === "string" && choice["finish_reason"] == null && delta["tool_calls"] === void 0 && delta["function_call"] === void 0) {
+      return {
+        channel: "chat:" + scalar(choice["index"]),
+        text: delta["content"],
+        payload,
+        textPath: ["choices", "0", "delta", "content"]
+      };
+    }
+  }
+  return null;
+}
+function withMergedText(frame, text, mergedCount) {
+  const clone = JSON.parse(JSON.stringify(frame.payload));
+  let cursor = clone;
+  for (let i = 0; i < frame.textPath.length - 1; i += 1) {
+    const step = frame.textPath[i];
+    const next = Array.isArray(cursor) ? cursor[Number(step)] : cursor[step];
+    if (next === null || typeof next !== "object") return clone;
+    cursor = next;
+  }
+  const leaf = frame.textPath[frame.textPath.length - 1];
+  if (Array.isArray(cursor)) cursor[Number(leaf)] = text;
+  else cursor[leaf] = text;
+  clone[MERGED_FRAMES_FIELD] = mergedCount;
+  return clone;
+}
+function splitBlocks(text, nl) {
+  const blocks = [];
+  let head = [];
+  let data = null;
+  let raw = [];
+  const flush = () => {
+    if (raw.length === 0) return;
+    blocks.push({ head, data, raw: raw.join(nl) });
+    head = [];
+    data = null;
+    raw = [];
+  };
+  for (const line of text.split(nl)) {
+    if (line.trim() === "") {
+      flush();
+      continue;
+    }
+    raw.push(line);
+    if (line.startsWith("data:")) {
+      const payload = line.slice("data:".length).trimStart();
+      data = data === null ? payload : data + nl + payload;
+    } else {
+      head.push(line);
+    }
+  }
+  flush();
+  return blocks;
+}
+function compactSseBody(text) {
+  if (!text || !text.includes("data:")) return text;
+  const nl = "\n";
+  const blocks = splitBlocks(text, nl);
+  if (blocks.length === 0) return text;
+  const out = [];
+  let runFrame = null;
+  let runBlock = null;
+  let runText = "";
+  let runCount = 0;
+  let merged = 0;
+  const flushRun = () => {
+    if (runFrame === null || runBlock === null) return;
+    if (runCount === 1) {
+      out.push(runBlock.raw);
+    } else {
+      const payload = withMergedText(runFrame, runText, runCount);
+      out.push([...runBlock.head, "data: " + JSON.stringify(payload)].join(nl));
+      merged += runCount;
+    }
+    runFrame = null;
+    runBlock = null;
+    runText = "";
+    runCount = 0;
+  };
+  for (const block of blocks) {
+    let frame = null;
+    if (block.data !== null && block.data !== "[DONE]") {
+      try {
+        const parsed = asObject(JSON.parse(block.data));
+        if (parsed) frame = classify(parsed);
+      } catch {
+        frame = null;
+      }
+    }
+    if (frame === null) {
+      flushRun();
+      out.push(block.raw);
+      continue;
+    }
+    const open = runFrame;
+    if (open !== null && open.channel === frame.channel) {
+      runText += frame.text;
+      runCount += 1;
+      continue;
+    }
+    flushRun();
+    runFrame = frame;
+    runBlock = block;
+    runText = frame.text;
+    runCount = 1;
+  }
+  flushRun();
+  if (merged === 0) return text;
+  const trailer = /\s$/.test(text) ? nl + nl : "";
+  return out.join(nl + nl) + trailer;
+}
+
+// src/outbound-api/auditCapture.ts
 function completeUtf8PrefixLength(buf) {
   if (buf.length === 0) return 0;
   let leadIndex = buf.length - 1;
@@ -112,15 +262,20 @@ function beginAuditCapture(req, res, now) {
         if (!record.provider && usage.provider) record.provider = usage.provider;
       }
       if (ctx.error) record.error = redactAuditText(ctx.error);
+      if (ctx.sessionKey) record.sessionKey = ctx.sessionKey;
       if (config.captureBodies) {
         if (requestBody != null && requestBody.length > 0) {
           record.requestBody = requestBody;
         }
         if (responseChunks.length > 0) {
           const captured = Buffer.concat(responseChunks, responseBytes);
-          const body = decodeCapturedBody(captured, responseTruncated);
+          const decoded = decodeCapturedBody(captured, responseTruncated);
+          const body = config.compactStreamingBodies ? compactSseBody(decoded) : decoded;
           record.responseBody = truncateToBytes(redactAuditText(body), config.maxBodyBytes);
         }
+        if (record.requestBody !== void 0 || record.responseBody !== void 0) {
+          record.hasBody = true;
+        }
       }
       recordAudit(record);
     } catch {

package/dist/{chunk-PEGTIPB3.js → chunk-HKB656B4.js}

@@ -1,6 +1,16 @@
 import {
   anthropicUsageToChatUsage
 } from "./chunk-FU7EAR73.js";
+import {
+  flattenToolResultContent,
+  formatBase64,
+  getThinkLevel
+} from "./chunk-WYVGULTQ.js";
+import {
+  extractReasoningIntent,
+  normalizeThinkLevel,
+  resolveReasoningPlan
+} from "./chunk-N2EIM2XJ.js";
 
 // src/transformer/transformers/AnthropicToolHandling.ts
 function isServerSideTool(tool) {
@@ -18,38 +28,6 @@ function convertAnthropicToolsToOpenAI(tools) {
   }));
 }
 
-// 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}`;
-}
-function flattenToolResultContent(content) {
-  if (typeof content === "string") return content;
-  if (content == null) return "";
-  if (!Array.isArray(content)) return JSON.stringify(content);
-  const parts = [];
-  for (const block of content) {
-    if (typeof block === "string") {
-      parts.push(block);
-      continue;
-    }
-    if (!block || typeof block !== "object") continue;
-    const typed = block;
-    if (typed.type === "image" || typed.type === "image_url") {
-      parts.push("[image omitted]");
-    } else if (typeof typed.text === "string") {
-      parts.push(typed.text);
-    }
-  }
-  return parts.filter((text) => text !== "").join("\n");
-}
-
 // src/anthropicMaxTokens.ts
 import { lookupCanonicalCapabilities } from "@omnicross/contracts/canonical-models";
 var ANTHROPIC_FALLBACK_MAX_TOKENS = 128e3;
@@ -65,7 +43,7 @@ function resolveAnthropicMaxTokens(model, requested) {
 }
 
 // src/transformer/transformers/AnthropicRequestBuilder.ts
-function buildAnthropicRequestBody(request) {
+function buildAnthropicRequestBody(request, provider) {
   let systemContent;
   const anthropicMessages = [];
   for (let i = 0; i < request.messages.length; i++) {
@@ -202,10 +180,18 @@ function buildAnthropicRequestBody(request) {
       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 };
+  const reasoningPlan = resolveReasoningPlan({
+    intent: extractReasoningIntent(request),
+    model: request.model,
+    provider,
+    target: "anthropic",
+    requestMaxTokens: request.max_tokens
+  });
+  if (reasoningPlan?.kind === "level" && reasoningPlan.enabled) {
+    body.thinking = { type: "adaptive" };
+    body.output_config = { effort: reasoningPlan.effort };
+  } else if (reasoningPlan?.kind === "budget" && reasoningPlan.enabled) {
+    body.thinking = { type: "enabled", budget_tokens: reasoningPlan.budgetTokens };
     body.temperature = 1;
   }
   return body;
@@ -461,10 +447,18 @@ function transformAnthropicRequestToUnified(request) {
     result._serverSideTools = serverSideTools;
   }
   if (anthropicRequest.thinking) {
-    result.reasoning = {
-      effort: getThinkLevel(anthropicRequest.thinking.budget_tokens),
-      enabled: anthropicRequest.thinking.type === "enabled"
-    };
+    if (anthropicRequest.thinking.type === "disabled") {
+      result.reasoning = { effort: "none", enabled: false };
+    } else if (anthropicRequest.thinking.type === "adaptive") {
+      const effort = normalizeThinkLevel(anthropicRequest.output_config?.effort);
+      if (effort) result.reasoning = { effort, enabled: effort !== "none" };
+    } else {
+      result.reasoning = {
+        effort: getThinkLevel(anthropicRequest.thinking.budget_tokens),
+        enabled: true,
+        ...typeof anthropicRequest.thinking.budget_tokens === "number" ? { max_tokens: anthropicRequest.thinking.budget_tokens } : {}
+      };
+    }
   }
   if (anthropicRequest.tool_choice) {
     if (anthropicRequest.tool_choice.type === "tool" && anthropicRequest.tool_choice.name) {
@@ -994,8 +988,8 @@ var AnthropicTransformer = class {
    * 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);
+  async transformRequestIn(request, provider, _context) {
+    return buildAnthropicRequestBody(request, provider);
   }
   /**
    * Transform Anthropic response to OpenAI/unified format

package/dist/chunk-N2EIM2XJ.js

@@ -0,0 +1,203 @@
+// src/reasoning/reasoning-plan.ts
+import {
+  applyAlias,
+  normalizeModelId,
+  resolveModelCapabilities
+} from "@omnicross/contracts/canonical-models";
+import {
+  EFFORT_RATIO,
+  findLegacyTokenLimit
+} from "@omnicross/contracts/thinking-config";
+var THINK_LEVELS = [
+  "none",
+  "minimal",
+  "low",
+  "medium",
+  "high",
+  "xhigh",
+  "max"
+];
+var THINK_LEVEL_SET = new Set(THINK_LEVELS);
+var ANTHROPIC_FALLBACK_BUDGET = {
+  minimal: 1024,
+  low: 2048,
+  medium: 8192,
+  high: 32768,
+  xhigh: 32768,
+  max: 32768
+};
+function normalizeThinkLevel(value) {
+  if (typeof value !== "string") return void 0;
+  const normalized = value.toLowerCase();
+  return THINK_LEVEL_SET.has(normalized) ? normalized : void 0;
+}
+function extractReasoningIntent(request) {
+  const reasoning = request.reasoning;
+  if (reasoning) {
+    if (reasoning.enabled === false) {
+      return { ...reasoning, effort: "none", enabled: false };
+    }
+    const effort = normalizeThinkLevel(reasoning.effort);
+    if (effort) {
+      return { ...reasoning, effort, enabled: effort !== "none" };
+    }
+    if (reasoning.enabled === true || isPositiveFinite(reasoning.max_tokens)) {
+      return { ...reasoning, effort: "medium", enabled: true };
+    }
+    return void 0;
+  }
+  const nativeEffort = normalizeThinkLevel(request.reasoning_effort);
+  if (!nativeEffort) return void 0;
+  return { effort: nativeEffort, enabled: nativeEffort !== "none" };
+}
+function canonicalModelId(model) {
+  return applyAlias(normalizeModelId(model));
+}
+function findModelOverride(targetModel, modelConfigs) {
+  if (!modelConfigs) return void 0;
+  const targetId = canonicalModelId(targetModel);
+  return modelConfigs.find(
+    (config) => config.id === targetModel || canonicalModelId(config.id) === targetId
+  );
+}
+function resolveTargetModelCapabilities(targetModel, provider) {
+  const rowOverride = findModelOverride(targetModel, provider?.modelConfigs);
+  return resolveModelCapabilities(targetModel, void 0, rowOverride);
+}
+function resolveReasoningEffort(requested, targetModel, provider) {
+  if (requested === "none") return "none";
+  const capabilities = resolveTargetModelCapabilities(targetModel, provider);
+  const candidates = capabilities.thinkingLevels?.map(normalizeThinkLevel).filter((level) => level !== void 0 && level !== "none") ?? [];
+  if (candidates.includes(requested)) return requested;
+  if (capabilities.thinkingLevels?.length && candidates.length === 0) return "none";
+  if (candidates.length === 0) return requested;
+  const requestedRatio = EFFORT_RATIO[requested];
+  return candidates.reduce((best, candidate) => {
+    const distance = Math.abs(EFFORT_RATIO[candidate] - requestedRatio);
+    const bestDistance = Math.abs(EFFORT_RATIO[best] - requestedRatio);
+    if (distance < bestDistance - Number.EPSILON) return candidate;
+    if (Math.abs(distance - bestDistance) <= Number.EPSILON && EFFORT_RATIO[candidate] < EFFORT_RATIO[best]) {
+      return candidate;
+    }
+    return best;
+  });
+}
+function protocolFallback(model, target) {
+  if (target === "anthropic") return { min: 1024, max: 128e3 };
+  if (target === "gemini") {
+    return model.toLowerCase().includes("pro") ? { min: 128, max: 32768 } : { min: 0, max: 24576 };
+  }
+  return void 0;
+}
+function resolveTokenLimit(model, provider, target) {
+  const capabilities = resolveTargetModelCapabilities(model, provider);
+  if (capabilities.thinkingTokenLimit) {
+    return { limits: capabilities.thinkingTokenLimit, source: "capability" };
+  }
+  const legacy = findLegacyTokenLimit(model);
+  if (legacy) return { limits: legacy, source: "legacy" };
+  const fallback = protocolFallback(model, target);
+  return fallback ? { limits: fallback, source: "protocol" } : void 0;
+}
+function resolveReasoningTokenLimit(model, provider, target) {
+  return resolveTokenLimit(model, provider, target)?.limits;
+}
+function isPositiveFinite(value) {
+  return typeof value === "number" && Number.isFinite(value) && value > 0;
+}
+function isFiniteNumber(value) {
+  return typeof value === "number" && Number.isFinite(value);
+}
+function clampBudget(rawBudget, limits, target, effort, requestMaxTokens, explicitBudget = false) {
+  const protocolMin = target === "anthropic" ? 1024 : 0;
+  const min = Math.max(protocolMin, Math.floor(limits.min));
+  let max = Math.max(min, Math.floor(limits.max));
+  if (isPositiveFinite(requestMaxTokens)) {
+    const requestCeiling = target === "anthropic" ? explicitBudget ? Math.floor(requestMaxTokens) - 1 : Math.max(
+      min,
+      Math.floor(requestMaxTokens * Math.min(EFFORT_RATIO[effort], 0.75))
+    ) : Math.floor(requestMaxTokens);
+    if (requestCeiling < min) return void 0;
+    max = Math.min(max, requestCeiling);
+  }
+  return Math.max(min, Math.min(max, Math.floor(rawBudget)));
+}
+function resolveBudget(intent, effort, model, provider, target, requestMaxTokens) {
+  const resolved = resolveTokenLimit(model, provider, target);
+  if (!resolved) return void 0;
+  const { limits, source } = resolved;
+  const explicitBudget = isFiniteNumber(intent.max_tokens) ? Math.floor(intent.max_tokens) : void 0;
+  const interpolated = source === "protocol" && target === "anthropic" ? ANTHROPIC_FALLBACK_BUDGET[effort] : Math.floor((limits.max - limits.min) * EFFORT_RATIO[effort] + limits.min);
+  return clampBudget(
+    explicitBudget ?? interpolated,
+    limits,
+    target,
+    effort,
+    requestMaxTokens,
+    explicitBudget !== void 0
+  );
+}
+function resolveReasoningPlan(input) {
+  const normalizedIntent = input.intent ? extractReasoningIntent({ model: input.model, reasoning: input.intent }) : void 0;
+  if (!normalizedIntent?.effort) return void 0;
+  const capabilities = resolveTargetModelCapabilities(input.model, input.provider);
+  const nativeEffort = normalizedIntent.effort;
+  if (nativeEffort === "none") {
+    if (input.target === "gemini" && capabilities.thinkingLevels?.length && capabilities.thinkingLevels.includes("none")) {
+      return { kind: "level", effort: "none", enabled: false };
+    }
+    if (input.target === "gemini" && !capabilities.thinkingLevels?.length) {
+      const limits = resolveTokenLimit(input.model, input.provider, input.target)?.limits;
+      if (limits?.min === 0) {
+        return { kind: "budget", effort: "none", enabled: false, budgetTokens: 0 };
+      }
+    }
+    return { kind: "off" };
+  }
+  if (capabilities.thinkingLevels?.length && !capabilities.thinkingLevels.some((level) => level !== "none")) {
+    return { kind: "off" };
+  }
+  const effort = input.preserveNativeEffort ? nativeEffort : resolveReasoningEffort(nativeEffort, input.model, input.provider);
+  if (effort === "none") return { kind: "off" };
+  if (input.target === "openai-chat" || input.target === "openai-responses") {
+    return { kind: "level", effort, enabled: true };
+  }
+  if (capabilities.thinkingLevels?.length) {
+    return { kind: "level", effort, enabled: true };
+  }
+  const budgetTokens = resolveBudget(
+    normalizedIntent,
+    effort,
+    input.model,
+    input.provider,
+    input.target,
+    input.requestMaxTokens
+  );
+  if (budgetTokens === void 0) return { kind: "off" };
+  return { kind: "budget", effort, enabled: true, budgetTokens };
+}
+function resolveRequestReasoning(request, provider, options = {}) {
+  const intent = extractReasoningIntent(request);
+  if (!intent?.effort) return void 0;
+  const plan = resolveReasoningPlan({
+    intent,
+    model: request.model,
+    provider,
+    target: "openai-chat",
+    preserveNativeEffort: options.preserveNativeEffort
+  });
+  if (!plan) return void 0;
+  if (plan.kind === "off") return { ...intent, effort: "none", enabled: false };
+  return { ...intent, effort: plan.effort, enabled: plan.enabled };
+}
+
+export {
+  THINK_LEVELS,
+  normalizeThinkLevel,
+  extractReasoningIntent,
+  resolveTargetModelCapabilities,
+  resolveReasoningEffort,
+  resolveReasoningTokenLimit,
+  resolveReasoningPlan,
+  resolveRequestReasoning
+};

package/dist/{chunk-MYYR3HZL.js → chunk-NGYOO5TO.js}

@@ -1,18 +1,18 @@
 import {
   AnthropicTransformer
-} from "./chunk-PEGTIPB3.js";
+} from "./chunk-HKB656B4.js";
 import {
   GeminiTransformer
-} from "./chunk-LVUCAWMK.js";
+} from "./chunk-55FMGZ3L.js";
 import {
   OpenAIResponseTransformer
-} from "./chunk-32O35CIF.js";
+} from "./chunk-45FHEOKW.js";
 import {
   OpenAITransformer
-} from "./chunk-LB6EBS6Y.js";
+} from "./chunk-CCVRRJOX.js";
 import {
   GeminiCodeAssistTransformer
-} from "./chunk-N5T4M4GU.js";
+} from "./chunk-2UTGX6FM.js";
 
 // src/transformer/transformers/index.ts
 var BuiltinTransformers = {

package/dist/{chunk-OKMJLEXX.cjs → chunk-OC6DOOFX.cjs}

@@ -3,7 +3,7 @@
 
 
 
-var _chunkKBM2W6UYcjs = require('./chunk-KBM2W6UY.cjs');
+var _chunkRICPANBYcjs = require('./chunk-RICPANBY.cjs');
 
 // src/transformer/transformers/GeminiCodeAssistTransformer.ts
 var DEFAULT_CODE_ASSIST_ENDPOINT = "https://cloudcode-pa.googleapis.com";
@@ -117,7 +117,7 @@ var GeminiCodeAssistTransformer = (_class = class {constructor() { _class.protot
    * openaiResponsesIngress). `undefined` is the valid fresh free-tier value.
    */
   async transformRequestIn(request, provider, _context) {
-    const inner = _chunkKBM2W6UYcjs.buildRequestBody.call(void 0, request);
+    const inner = _chunkRICPANBYcjs.buildRequestBody.call(void 0, request, provider);
     const envelope = {
       model: request.model,
       project: provider.geminiProject,
@@ -147,7 +147,7 @@ var GeminiCodeAssistTransformer = (_class = class {constructor() { _class.protot
     if (inner && typeof inner === "object" && !("model" in inner) && "model" in r) {
       inner.model = r.model;
     }
-    return _chunkKBM2W6UYcjs.transformRequestOut.call(void 0, inner);
+    return _chunkRICPANBYcjs.transformRequestOut.call(void 0, inner);
   }
   /**
    * Code Assist response → OpenAI-compatible. PEEL the `.response` envelope from
@@ -155,7 +155,7 @@ var GeminiCodeAssistTransformer = (_class = class {constructor() { _class.protot
    */
   async transformResponseOut(response, _context) {
     const unwrapped = await unwrapCodeAssistResponse(response);
-    return _chunkKBM2W6UYcjs.transformResponseOut.call(void 0, unwrapped, this.name, this.logger);
+    return _chunkRICPANBYcjs.transformResponseOut.call(void 0, unwrapped, this.name, this.logger);
   }
   /**
    * OpenAI-compatible response → Code Assist (endpoint-encode parity). Re-wraps
@@ -164,7 +164,7 @@ var GeminiCodeAssistTransformer = (_class = class {constructor() { _class.protot
    * `transformResponseOut`'s peel.
    */
   async transformResponseIn(response, _context) {
-    const geminiResponse = await _chunkKBM2W6UYcjs.transformResponseIn.call(void 0, response, this.logger);
+    const geminiResponse = await _chunkRICPANBYcjs.transformResponseIn.call(void 0, response, this.logger);
     const contentType = _nullishCoalesce(geminiResponse.headers.get("Content-Type"), () => ( ""));
     if (contentType.includes("text/event-stream")) {
       return geminiResponse;

package/dist/{chunk-2Z4XM3H5.cjs → chunk-P7EM6BND.cjs}

@@ -1,26 +1,26 @@
 "use strict";Object.defineProperty(exports, "__esModule", {value: true});
 
-var _chunkOXHNSZ53cjs = require('./chunk-OXHNSZ53.cjs');
+var _chunkZQQUD66Mcjs = require('./chunk-ZQQUD66M.cjs');
 
 
-var _chunkV4TXMEJScjs = require('./chunk-V4TXMEJS.cjs');
+var _chunk5LNYGCIWcjs = require('./chunk-5LNYGCIW.cjs');
 
 
-var _chunkOVQBNVSVcjs = require('./chunk-OVQBNVSV.cjs');
+var _chunkCMVXX7ONcjs = require('./chunk-CMVXX7ON.cjs');
 
 
-var _chunkOF3BECU2cjs = require('./chunk-OF3BECU2.cjs');
+var _chunk56QD3YW6cjs = require('./chunk-56QD3YW6.cjs');
 
 
-var _chunkOKMJLEXXcjs = require('./chunk-OKMJLEXX.cjs');
+var _chunkOC6DOOFXcjs = require('./chunk-OC6DOOFX.cjs');
 
 // src/transformer/transformers/index.ts
 var BuiltinTransformers = {
-  OpenAITransformer: _chunkOF3BECU2cjs.OpenAITransformer,
-  GeminiTransformer: _chunkV4TXMEJScjs.GeminiTransformer,
-  GeminiCodeAssistTransformer: _chunkOKMJLEXXcjs.GeminiCodeAssistTransformer,
-  AnthropicTransformer: _chunkOXHNSZ53cjs.AnthropicTransformer,
-  OpenAIResponseTransformer: _chunkOVQBNVSVcjs.OpenAIResponseTransformer
+  OpenAITransformer: _chunk56QD3YW6cjs.OpenAITransformer,
+  GeminiTransformer: _chunk5LNYGCIWcjs.GeminiTransformer,
+  GeminiCodeAssistTransformer: _chunkOC6DOOFXcjs.GeminiCodeAssistTransformer,
+  AnthropicTransformer: _chunkZQQUD66Mcjs.AnthropicTransformer,
+  OpenAIResponseTransformer: _chunkCMVXX7ONcjs.OpenAIResponseTransformer
 };
 function getBuiltinTransformers() {
   return BuiltinTransformers;