@omnicross/core 0.1.4 → 0.1.6

package/dist/{chunk-SU2GCLAC.cjs → chunk-6VUQPOV3.cjs}

@@ -45,10 +45,12 @@ var OpenAIResponseTransformer = (_class = class {constructor() { _class.prototyp
         if (msg.role === "assistant" && _optionalChain([msg, 'access', _ => _.tool_calls, 'optionalAccess', _2 => _2.length])) {
           input.push(entry);
           for (const tc of msg.tool_calls) {
+            const callId = tc.id;
+            const itemId = callId.startsWith("fc_") ? callId : `fc_${callId.replace(/^(call_|fc_)/, "")}`;
             input.push({
               type: "function_call",
-              id: tc.id,
-              call_id: tc.id,
+              id: itemId,
+              call_id: callId,
               name: tc.function.name,
               arguments: tc.function.arguments
             });
@@ -61,7 +63,11 @@ var OpenAIResponseTransformer = (_class = class {constructor() { _class.prototyp
     const body = {
       model: request.model,
       input,
-      stream: _nullishCoalesce(request.stream, () => ( false)),
+      // codex's backend REQUIRES `stream:true` (it 400s with "Stream must be
+      // set to true" otherwise). Always force it; a non-streaming CLIENT is
+      // served by aggregating the SSE upstream of the wire (the ingress buffers
+      // it into a single message), not by asking codex for a non-streaming reply.
+      stream: true,
       // `store:false` is required by the codex backend and accepted by the
       // public Responses API (which defaults to store:true). Always set it so
       // codex relays (no discoverable url token) work without configuration.
@@ -98,24 +104,37 @@ var OpenAIResponseTransformer = (_class = class {constructor() { _class.prototyp
   async transformRequestOut(request, _context) {
     const req = request;
     const messages = [];
+    let codexTools = null;
+    const instructions = typeof req.instructions === "string" ? req.instructions.trim() : "";
+    if (instructions) {
+      messages.push({ role: "system", content: instructions });
+    }
     if (req.input) {
       for (const item of req.input) {
         const entry = item;
-        if (entry.type === "function_call_output") {
+        const itemType = typeof entry.type === "string" ? entry.type : void 0;
+        if (itemType && SKIPPED_INPUT_ITEM_TYPES.has(itemType)) continue;
+        if (itemType === "additional_tools") {
+          codexTools = collectCodexTools(entry);
+          continue;
+        }
+        if (itemType === "custom_tool_call_output") {
           messages.push({
             role: "tool",
-            content: entry.output || "",
+            content: flattenContent(entry.output),
             tool_call_id: entry.call_id || void 0
           });
           continue;
         }
-        if (entry.type === "function_call") {
+        if (itemType === "custom_tool_call") {
           const toolCall = {
             id: (_nullishCoalesce(entry.call_id, () => ( entry.id))) || "",
             type: "function",
             function: {
               name: entry.name || "",
-              arguments: typeof entry.arguments === "string" ? entry.arguments : ""
+              arguments: JSON.stringify({
+                input: typeof entry.input === "string" ? entry.input : ""
+              })
             }
           };
           const last = messages[messages.length - 1];
@@ -126,17 +145,38 @@ var OpenAIResponseTransformer = (_class = class {constructor() { _class.prototyp
           }
           continue;
         }
-        const role = entry.role;
-        if (role === "developer") {
+        if (itemType === "function_call_output") {
           messages.push({
-            role: "system",
-            content: typeof entry.content === "string" ? entry.content : JSON.stringify(entry.content)
+            role: "tool",
+            content: flattenContent(entry.output),
+            tool_call_id: entry.call_id || void 0
           });
+          continue;
+        }
+        if (itemType === "function_call") {
+          const toolCall = {
+            id: (_nullishCoalesce(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;
+        const text = flattenContent(entry.content);
+        if (!text) continue;
+        if (role === "developer" || role === "system") {
+          messages.push({ role: "system", content: text });
         } else if (role === "user" || role === "assistant") {
-          messages.push({
-            role,
-            content: typeof entry.content === "string" ? entry.content : JSON.stringify(entry.content)
-          });
+          messages.push({ role, content: text });
         }
       }
     }
@@ -153,15 +193,32 @@ var OpenAIResponseTransformer = (_class = class {constructor() { _class.prototyp
         enabled: true
       };
     }
+    const tools = [];
     if (_optionalChain([req, 'access', _9 => _9.tools, 'optionalAccess', _10 => _10.length])) {
-      result.tools = req.tools.filter((t) => t.type === "function").map((t) => ({
-        type: "function",
-        function: {
-          name: t.name || "",
-          description: t.description || "",
-          parameters: t.parameters || {}
+      tools.push(
+        ...req.tools.filter((t) => t.type === "function").map((t) => ({
+          type: "function",
+          function: {
+            name: t.name || "",
+            description: t.description || "",
+            parameters: t.parameters || {}
+          }
+        }))
+      );
+    }
+    if (_optionalChain([codexTools, 'optionalAccess', _11 => _11.tools, 'access', _12 => _12.length])) {
+      const declared = new Set(tools.map((t) => t.function.name));
+      tools.push(...codexTools.tools.filter((t) => !declared.has(t.function.name)));
+    }
+    if (tools.length) result.tools = tools;
+    if (_optionalChain([codexTools, 'optionalAccess', _13 => _13.customToolNames, 'access', _14 => _14.length]) || Object.keys(_nullishCoalesce(_optionalChain([codexTools, 'optionalAccess', _15 => _15.toolNamespaces]), () => ( {}))).length) {
+      result.meta = {
+        ...result.meta,
+        codexTools: {
+          ...codexTools.customToolNames.length ? { customToolNames: codexTools.customToolNames } : {},
+          ...Object.keys(codexTools.toolNamespaces).length ? { toolNamespaces: codexTools.toolNamespaces } : {}
         }
-      }));
+      };
     }
     return result;
   }
@@ -202,13 +259,14 @@ var OpenAIResponseTransformer = (_class = class {constructor() { _class.prototyp
   /**
    * Transform OpenAI CC response → Response API format
    */
-  async transformResponseIn(response, _context) {
+  async transformResponseIn(response, context) {
     const contentType = _nullishCoalesce(response.headers.get("Content-Type"), () => ( ""));
+    const codexTools = _optionalChain([context, 'optionalAccess', _16 => _16.req, 'optionalAccess', _17 => _17.meta, 'optionalAccess', _18 => _18.codexTools]);
     if (contentType.includes("text/event-stream")) {
       if (!response.body) {
         throw new Error("Stream response body is null");
       }
-      return new Response(convertOpenAIStreamToResponseApi(response.body), {
+      return new Response(convertOpenAIStreamToResponseApi(response.body, codexTools), {
         headers: {
           "Content-Type": "text/event-stream",
           "Cache-Control": "no-cache",
@@ -217,16 +275,114 @@ var OpenAIResponseTransformer = (_class = class {constructor() { _class.prototyp
       });
     }
     const data = await response.json();
-    return new Response(JSON.stringify(convertOpenAIJsonToResponseApi(data)), {
+    return new Response(JSON.stringify(convertOpenAIJsonToResponseApi(data, codexTools)), {
       headers: { "Content-Type": "application/json" }
     });
   }
 }, _class.__initStatic(), _class);
+var TEXT_PART_TYPES = /* @__PURE__ */ new Set(["text", "input_text", "output_text", "summary_text"]);
+var SKIPPED_INPUT_ITEM_TYPES = /* @__PURE__ */ new Set(["reasoning", "agent_message"]);
+var CUSTOM_TOOL_PARAMETERS = {
+  type: "object",
+  properties: {
+    input: {
+      type: "string",
+      description: "The complete free-form input for this tool, passed through verbatim."
+    }
+  },
+  required: ["input"]
+};
+function unwrapCustomToolInput(argumentsJson) {
+  try {
+    const parsed = JSON.parse(argumentsJson);
+    if (parsed && typeof parsed === "object" && typeof parsed.input === "string") {
+      return parsed.input;
+    }
+  } catch (e3) {
+  }
+  return argumentsJson;
+}
+function encodeToolCallItem(callId, name, argumentsJson, status, codexTools) {
+  const bareId = callId.replace(/^(call_|fc_|ctc_)/, "");
+  if (_optionalChain([codexTools, 'optionalAccess', _19 => _19.customToolNames, 'optionalAccess', _20 => _20.includes, 'call', _21 => _21(name)])) {
+    return {
+      id: `ctc_${bareId}`,
+      type: "custom_tool_call",
+      status,
+      call_id: callId,
+      name,
+      input: unwrapCustomToolInput(argumentsJson)
+    };
+  }
+  const namespace = _optionalChain([codexTools, 'optionalAccess', _22 => _22.toolNamespaces, 'optionalAccess', _23 => _23[name]]);
+  return {
+    id: callId.startsWith("fc_") ? callId : `fc_${bareId}`,
+    type: "function_call",
+    status,
+    call_id: callId,
+    name,
+    ...namespace ? { namespace } : {},
+    arguments: argumentsJson
+  };
+}
+function collectCodexTools(entry) {
+  const result = { tools: [], customToolNames: [], toolNamespaces: {} };
+  const visit = (declarations, namespace) => {
+    if (!Array.isArray(declarations)) return;
+    for (const raw of declarations) {
+      if (!raw || typeof raw !== "object") continue;
+      const tool = raw;
+      const name = typeof tool.name === "string" ? tool.name : "";
+      if (!name) continue;
+      const description = typeof tool.description === "string" ? tool.description : "";
+      if (tool.type === "namespace") {
+        visit(tool.tools, name);
+        continue;
+      }
+      if (tool.type === "custom") {
+        result.customToolNames.push(name);
+        result.tools.push({
+          type: "function",
+          function: {
+            name,
+            description,
+            parameters: CUSTOM_TOOL_PARAMETERS
+          }
+        });
+      } else if (tool.type === "function") {
+        result.tools.push({
+          type: "function",
+          function: {
+            name,
+            description,
+            parameters: tool.parameters || {}
+          }
+        });
+      } else {
+        continue;
+      }
+      if (namespace) result.toolNamespaces[name] = namespace;
+    }
+  };
+  visit(entry.tools);
+  return result;
+}
 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 content.map((part) => {
+      if (typeof part === "string") return part;
+      if (!part || typeof part !== "object") return "";
+      const c = part;
+      if (typeof c.type === "string" && !TEXT_PART_TYPES.has(c.type)) return "";
+      return typeof c.text === "string" ? c.text : "";
+    }).filter((text) => text !== "").join("\n");
+  }
+  if (typeof content === "object") {
+    const obj = content;
+    if (typeof obj.text === "string") return obj.text;
+    if (Array.isArray(obj.content)) return flattenContent(obj.content);
   }
   return "";
 }
@@ -284,9 +440,9 @@ function convertResponseApiJsonToOpenAI(data) {
     } : void 0
   };
 }
-function convertOpenAIJsonToResponseApi(data) {
+function convertOpenAIJsonToResponseApi(data, codexTools) {
   const choices = data.choices;
-  const message = _optionalChain([choices, 'optionalAccess', _11 => _11[0], 'optionalAccess', _12 => _12.message]);
+  const message = _optionalChain([choices, 'optionalAccess', _24 => _24[0], 'optionalAccess', _25 => _25.message]);
   const output = [];
   if (message) {
     const contentParts = [];
@@ -297,16 +453,18 @@ function convertOpenAIJsonToResponseApi(data) {
       output.push({ type: "message", role: "assistant", content: contentParts });
     }
     const toolCalls = message.tool_calls;
-    if (_optionalChain([toolCalls, 'optionalAccess', _13 => _13.length])) {
+    if (_optionalChain([toolCalls, 'optionalAccess', _26 => _26.length])) {
       for (const tc of toolCalls) {
         const func = tc.function;
-        output.push({
-          type: "function_call",
-          id: tc.id,
-          call_id: tc.id,
-          name: _optionalChain([func, 'optionalAccess', _14 => _14.name]),
-          arguments: _optionalChain([func, 'optionalAccess', _15 => _15.arguments])
-        });
+        output.push(
+          encodeToolCallItem(
+            tc.id || "",
+            _optionalChain([func, 'optionalAccess', _27 => _27.name]) || "",
+            typeof _optionalChain([func, 'optionalAccess', _28 => _28.arguments]) === "string" ? func.arguments : "",
+            "completed",
+            codexTools
+          )
+        );
       }
     }
   }
@@ -335,11 +493,12 @@ function convertResponseApiStreamToOpenAI(responseApiStream) {
       const messageId = `chatcmpl-${Date.now()}`;
       let model = "unknown";
       let hasEmittedRole = false;
+      let hasToolCalls = false;
       const safeEnqueue = (str) => {
         if (!isClosed) {
           try {
             controller.enqueue(encoder.encode(str));
-          } catch (e3) {
+          } catch (e4) {
             isClosed = true;
           }
         }
@@ -371,7 +530,7 @@ function convertResponseApiStreamToOpenAI(responseApiStream) {
             if (data === "[DONE]") continue;
             try {
               const event = JSON.parse(data);
-              model = event.model || _optionalChain([event, 'access', _16 => _16.response, 'optionalAccess', _17 => _17.model]) || model;
+              model = event.model || _optionalChain([event, 'access', _29 => _29.response, 'optionalAccess', _30 => _30.model]) || model;
               switch (event.type) {
                 case "response.output_text.delta":
                   if (event.delta) {
@@ -391,29 +550,65 @@ function convertResponseApiStreamToOpenAI(responseApiStream) {
                     }]);
                   }
                   break;
+                case "response.output_item.added": {
+                  const item = event.item;
+                  if (_optionalChain([item, 'optionalAccess', _31 => _31.type]) !== "function_call") break;
+                  if (!hasEmittedRole) {
+                    emitChunk([{ index: 0, delta: { role: "assistant", content: null }, finish_reason: null }]);
+                    hasEmittedRole = true;
+                  }
+                  hasToolCalls = true;
+                  emitChunk([{
+                    index: 0,
+                    delta: {
+                      tool_calls: [{
+                        index: _nullishCoalesce(event.output_index, () => ( 0)),
+                        id: item.call_id,
+                        type: "function",
+                        function: { name: item.name, arguments: "" }
+                      }]
+                    },
+                    finish_reason: null
+                  }]);
+                  break;
+                }
+                case "response.function_call_arguments.delta": {
+                  hasToolCalls = true;
+                  emitChunk([{
+                    index: 0,
+                    delta: {
+                      tool_calls: [{
+                        index: _nullishCoalesce(event.output_index, () => ( 0)),
+                        function: { arguments: _nullishCoalesce(event.delta, () => ( "")) }
+                      }]
+                    },
+                    finish_reason: null
+                  }]);
+                  break;
+                }
                 case "response.completed": {
                   const resp = event.response;
-                  const respUsage = _optionalChain([resp, 'optionalAccess', _18 => _18.usage]);
+                  const respUsage = _optionalChain([resp, 'optionalAccess', _32 => _32.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);
+                  emitChunk([{ index: 0, delta: {}, finish_reason: hasToolCalls ? "tool_calls" : "stop" }], usage);
                   safeEnqueue("data: [DONE]\n\n");
                   break;
                 }
                 case "error":
                   emitChunk([{
                     index: 0,
-                    delta: { content: `[Error: ${_optionalChain([event, 'access', _19 => _19.error, 'optionalAccess', _20 => _20.message]) || "Unknown error"}]` },
+                    delta: { content: `[Error: ${_optionalChain([event, 'access', _33 => _33.error, 'optionalAccess', _34 => _34.message]) || "Unknown error"}]` },
                     finish_reason: "stop"
                   }]);
                   break;
                 default:
                   break;
               }
-            } catch (e4) {
+            } catch (e5) {
             }
           }
         }
@@ -423,7 +618,7 @@ function convertResponseApiStreamToOpenAI(responseApiStream) {
         if (!isClosed) {
           try {
             controller.close();
-          } catch (e5) {
+          } catch (e6) {
           }
         }
         reader.releaseLock();
@@ -431,7 +626,7 @@ function convertResponseApiStreamToOpenAI(responseApiStream) {
     }
   });
 }
-function convertOpenAIStreamToResponseApi(openaiStream) {
+function convertOpenAIStreamToResponseApi(openaiStream, codexTools) {
   const decoder = new TextDecoder();
   const encoder = new TextEncoder();
   return new ReadableStream({
@@ -442,11 +637,16 @@ function convertOpenAIStreamToResponseApi(openaiStream) {
       let accumulatedContent = "";
       let model = "unknown";
       const responseId = `resp_${Date.now()}`;
+      const messageId = `msg_${Date.now()}`;
+      let messageItemAdded = false;
+      const toolCalls = /* @__PURE__ */ new Map();
+      const toolOutputIndex = /* @__PURE__ */ new Map();
+      let nextOutputIndex = 1;
       const safeEnqueue = (str) => {
         if (!isClosed) {
           try {
             controller.enqueue(encoder.encode(str));
-          } catch (e6) {
+          } catch (e7) {
             isClosed = true;
           }
         }
@@ -474,34 +674,133 @@ function convertOpenAIStreamToResponseApi(openaiStream) {
             if (data === "[DONE]") continue;
             try {
               const chunk = JSON.parse(data);
-              const choice = _optionalChain([chunk, 'access', _21 => _21.choices, 'optionalAccess', _22 => _22[0]]);
+              const choice = _optionalChain([chunk, 'access', _35 => _35.choices, 'optionalAccess', _36 => _36[0]]);
               model = chunk.model || model;
               if (!choice) continue;
-              if (_optionalChain([choice, 'access', _23 => _23.delta, 'optionalAccess', _24 => _24.content])) {
+              if (_optionalChain([choice, 'access', _37 => _37.delta, 'optionalAccess', _38 => _38.content])) {
+                if (!messageItemAdded) {
+                  messageItemAdded = true;
+                  emitEvent({
+                    type: "response.output_item.added",
+                    output_index: 0,
+                    item: {
+                      id: messageId,
+                      type: "message",
+                      role: "assistant",
+                      status: "in_progress",
+                      content: []
+                    }
+                  });
+                }
                 accumulatedContent += choice.delta.content;
-                emitEvent({ type: "response.output_text.delta", delta: choice.delta.content });
+                emitEvent({
+                  type: "response.output_text.delta",
+                  output_index: 0,
+                  content_index: 0,
+                  delta: choice.delta.content
+                });
               }
-              if (_optionalChain([choice, 'access', _25 => _25.delta, 'optionalAccess', _26 => _26.thinking, 'optionalAccess', _27 => _27.content])) {
+              const reasoningDelta = _nullishCoalesce(_optionalChain([choice, 'access', _39 => _39.delta, 'optionalAccess', _40 => _40.thinking, 'optionalAccess', _41 => _41.content]), () => ( _optionalChain([choice, 'access', _42 => _42.delta, 'optionalAccess', _43 => _43.reasoning_content])));
+              if (reasoningDelta) {
                 emitEvent({
                   type: "response.reasoning_summary_text.delta",
-                  delta: choice.delta.thinking.content
+                  delta: reasoningDelta
                 });
               }
+              if (_optionalChain([choice, 'access', _44 => _44.delta, 'optionalAccess', _45 => _45.tool_calls])) {
+                for (const tc of choice.delta.tool_calls) {
+                  const tcIndex = typeof tc["index"] === "number" ? tc["index"] : 0;
+                  const func = _nullishCoalesce(tc["function"], () => ( {}));
+                  let entry = toolCalls.get(tcIndex);
+                  if (!entry) {
+                    const callId = typeof tc["id"] === "string" ? tc["id"] : `call_${Date.now()}_${tcIndex}`;
+                    const name = typeof func["name"] === "string" ? func["name"] : "";
+                    entry = {
+                      callId,
+                      name,
+                      arguments: "",
+                      isCustom: _nullishCoalesce(_optionalChain([codexTools, 'optionalAccess', _46 => _46.customToolNames, 'optionalAccess', _47 => _47.includes, 'call', _48 => _48(name)]), () => ( false))
+                    };
+                    toolCalls.set(tcIndex, entry);
+                    const outIdx = nextOutputIndex++;
+                    toolOutputIndex.set(tcIndex, outIdx);
+                    emitEvent({
+                      type: "response.output_item.added",
+                      output_index: outIdx,
+                      item: encodeToolCallItem(callId, name, "", "in_progress", codexTools)
+                    });
+                  }
+                  const argsFragment = typeof func["arguments"] === "string" ? func["arguments"] : "";
+                  if (argsFragment) {
+                    entry.arguments += argsFragment;
+                    if (!entry.isCustom) {
+                      emitEvent({
+                        type: "response.function_call_arguments.delta",
+                        output_index: toolOutputIndex.get(tcIndex),
+                        delta: argsFragment
+                      });
+                    }
+                  }
+                }
+              }
               if (choice.finish_reason) {
-                emitEvent({ type: "response.output_text.done", text: accumulatedContent });
+                const output = [];
+                if (messageItemAdded) {
+                  emitEvent({
+                    type: "response.output_text.done",
+                    output_index: 0,
+                    content_index: 0,
+                    text: accumulatedContent
+                  });
+                  const messageItem = {
+                    id: messageId,
+                    type: "message",
+                    role: "assistant",
+                    status: "completed",
+                    content: [{ type: "output_text", text: accumulatedContent }]
+                  };
+                  emitEvent({
+                    type: "response.output_item.done",
+                    output_index: 0,
+                    item: messageItem
+                  });
+                  output.push(messageItem);
+                }
+                for (const [tcIndex, entry] of toolCalls) {
+                  const outIdx = toolOutputIndex.get(tcIndex);
+                  const item = encodeToolCallItem(
+                    entry.callId,
+                    entry.name,
+                    entry.arguments,
+                    "completed",
+                    codexTools
+                  );
+                  if (entry.isCustom) {
+                    emitEvent({
+                      type: "response.custom_tool_call_input.delta",
+                      output_index: outIdx,
+                      delta: item.input
+                    });
+                    emitEvent({
+                      type: "response.custom_tool_call_input.done",
+                      output_index: outIdx,
+                      input: item.input
+                    });
+                  }
+                  output.push(item);
+                  emitEvent({
+                    type: "response.output_item.done",
+                    output_index: outIdx,
+                    item
+                  });
+                }
                 emitEvent({
                   type: "response.completed",
                   response: {
                     id: responseId,
                     status: "completed",
                     model,
-                    output: [
-                      {
-                        type: "message",
-                        role: "assistant",
-                        content: [{ type: "output_text", text: accumulatedContent }]
-                      }
-                    ],
+                    output,
                     usage: chunk.usage ? {
                       input_tokens: chunk.usage.prompt_tokens || 0,
                       output_tokens: chunk.usage.completion_tokens || 0,
@@ -510,7 +809,7 @@ function convertOpenAIStreamToResponseApi(openaiStream) {
                   }
                 });
               }
-            } catch (e7) {
+            } catch (e8) {
             }
           }
         }
@@ -520,7 +819,7 @@ function convertOpenAIStreamToResponseApi(openaiStream) {
         if (!isClosed) {
           try {
             controller.close();
-          } catch (e8) {
+          } catch (e9) {
           }
         }
         reader.releaseLock();

package/dist/chunk-7AK7B36B.cjs

@@ -0,0 +1,44 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true});
+
+var _chunkV4TXMEJScjs = require('./chunk-V4TXMEJS.cjs');
+
+
+var _chunk6VUQPOV3cjs = require('./chunk-6VUQPOV3.cjs');
+
+
+var _chunkOF3BECU2cjs = require('./chunk-OF3BECU2.cjs');
+
+
+var _chunk4VLRHHFEcjs = require('./chunk-4VLRHHFE.cjs');
+
+
+var _chunkOKMJLEXXcjs = require('./chunk-OKMJLEXX.cjs');
+
+// src/transformer/transformers/index.ts
+var BuiltinTransformers = {
+  OpenAITransformer: _chunkOF3BECU2cjs.OpenAITransformer,
+  GeminiTransformer: _chunkV4TXMEJScjs.GeminiTransformer,
+  GeminiCodeAssistTransformer: _chunkOKMJLEXXcjs.GeminiCodeAssistTransformer,
+  AnthropicTransformer: _chunk4VLRHHFEcjs.AnthropicTransformer,
+  OpenAIResponseTransformer: _chunk6VUQPOV3cjs.OpenAIResponseTransformer
+};
+function getBuiltinTransformers() {
+  return BuiltinTransformers;
+}
+var BUILTIN_TRANSFORMER_NAMES = [
+  "openai",
+  "gemini",
+  "gemini-code-assist",
+  "anthropic",
+  "openai-response"
+];
+async function registerBuiltinTransformers(service) {
+  await service.initialize(getBuiltinTransformers());
+}
+
+
+
+
+
+
+exports.BuiltinTransformers = BuiltinTransformers; exports.getBuiltinTransformers = getBuiltinTransformers; exports.BUILTIN_TRANSFORMER_NAMES = BUILTIN_TRANSFORMER_NAMES; exports.registerBuiltinTransformers = registerBuiltinTransformers;