@omnicross/core 0.1.4 → 0.1.6

package/dist/{chunk-TIER4SUC.js → chunk-OEWZUX4G.js}

@@ -45,10 +45,12 @@ var OpenAIResponseTransformer = class {
         if (msg.role === "assistant" && msg.tool_calls?.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 {
     const body = {
       model: request.model,
       input,
-      stream: 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 {
   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: (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 {
           }
           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: (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 {
         enabled: true
       };
     }
+    const tools = [];
     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 || {}
+      tools.push(
+        ...req.tools.filter((t) => t.type === "function").map((t) => ({
+          type: "function",
+          function: {
+            name: t.name || "",
+            description: t.description || "",
+            parameters: t.parameters || {}
+          }
+        }))
+      );
+    }
+    if (codexTools?.tools.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 (codexTools?.customToolNames.length || Object.keys(codexTools?.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 {
   /**
    * Transform OpenAI CC response → Response API format
    */
-  async transformResponseIn(response, _context) {
+  async transformResponseIn(response, context) {
     const contentType = response.headers.get("Content-Type") ?? "";
+    const codexTools = context?.req?.meta?.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 {
       });
     }
     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" }
     });
   }
 };
+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 {
+  }
+  return argumentsJson;
+}
+function encodeToolCallItem(callId, name, argumentsJson, status, codexTools) {
+  const bareId = callId.replace(/^(call_|fc_|ctc_)/, "");
+  if (codexTools?.customToolNames?.includes(name)) {
+    return {
+      id: `ctc_${bareId}`,
+      type: "custom_tool_call",
+      status,
+      call_id: callId,
+      name,
+      input: unwrapCustomToolInput(argumentsJson)
+    };
+  }
+  const namespace = codexTools?.toolNamespaces?.[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,7 +440,7 @@ function convertResponseApiJsonToOpenAI(data) {
     } : void 0
   };
 }
-function convertOpenAIJsonToResponseApi(data) {
+function convertOpenAIJsonToResponseApi(data, codexTools) {
   const choices = data.choices;
   const message = choices?.[0]?.message;
   const output = [];
@@ -300,13 +456,15 @@ function convertOpenAIJsonToResponseApi(data) {
     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
-        });
+        output.push(
+          encodeToolCallItem(
+            tc.id || "",
+            func?.name || "",
+            typeof func?.arguments === "string" ? func.arguments : "",
+            "completed",
+            codexTools
+          )
+        );
       }
     }
   }
@@ -335,6 +493,7 @@ function convertResponseApiStreamToOpenAI(responseApiStream) {
       const messageId = `chatcmpl-${Date.now()}`;
       let model = "unknown";
       let hasEmittedRole = false;
+      let hasToolCalls = false;
       const safeEnqueue = (str) => {
         if (!isClosed) {
           try {
@@ -391,6 +550,42 @@ function convertResponseApiStreamToOpenAI(responseApiStream) {
                     }]);
                   }
                   break;
+                case "response.output_item.added": {
+                  const item = event.item;
+                  if (item?.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: 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: event.output_index ?? 0,
+                        function: { arguments: event.delta ?? "" }
+                      }]
+                    },
+                    finish_reason: null
+                  }]);
+                  break;
+                }
                 case "response.completed": {
                   const resp = event.response;
                   const respUsage = resp?.usage;
@@ -399,7 +594,7 @@ function convertResponseApiStreamToOpenAI(responseApiStream) {
                     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;
                 }
@@ -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,6 +637,11 @@ 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 {
@@ -478,30 +678,129 @@ function convertOpenAIStreamToResponseApi(openaiStream) {
               model = chunk.model || model;
               if (!choice) continue;
               if (choice.delta?.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 (choice.delta?.thinking?.content) {
+              const reasoningDelta = choice.delta?.thinking?.content ?? choice.delta?.reasoning_content;
+              if (reasoningDelta) {
                 emitEvent({
                   type: "response.reasoning_summary_text.delta",
-                  delta: choice.delta.thinking.content
+                  delta: reasoningDelta
                 });
               }
+              if (choice.delta?.tool_calls) {
+                for (const tc of choice.delta.tool_calls) {
+                  const tcIndex = typeof tc["index"] === "number" ? tc["index"] : 0;
+                  const func = 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: codexTools?.customToolNames?.includes(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,

package/dist/chunk-OF3BECU2.cjs

@@ -0,0 +1,69 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true}); function _optionalChain(ops) { let lastAccessLHS = undefined; let value = ops[0]; let i = 1; while (i < ops.length) { const op = ops[i]; const fn = ops[i + 1]; i += 2; if ((op === 'optionalAccess' || op === 'optionalCall') && value == null) { return undefined; } if (op === 'access' || op === 'optionalAccess') { lastAccessLHS = value; value = fn(value); } else if (op === 'call' || op === 'optionalCall') { value = fn((...args) => value.call(lastAccessLHS, ...args)); lastAccessLHS = undefined; } } return value; } var _class;// src/transformer/transformers/OpenAITransformer.ts
+var FOREIGN_MESSAGE_KEYS = ["cache_control", "thinking"];
+var FOREIGN_BODY_KEYS = ["meta", "reasoning", "thinking"];
+function normalizeContent(content) {
+  if (!Array.isArray(content)) return content;
+  const cleaned = content.map((block) => {
+    if (block && typeof block === "object" && "cache_control" in block) {
+      const { cache_control: _dropped, ...rest } = block;
+      return rest;
+    }
+    return block;
+  });
+  if (cleaned.length === 1) {
+    const only = cleaned[0];
+    if (_optionalChain([only, 'optionalAccess', _ => _.type]) === "text" && typeof only.text === "string") return only.text;
+  }
+  return cleaned;
+}
+var OpenAITransformer = (_class = class {constructor() { _class.prototype.__init.call(this);_class.prototype.__init2.call(this); }
+  static __initStatic() {this.TransformerName = "openai"}
+  __init() {this.name = "openai"}
+  __init2() {this.endPoint = "/v1/chat/completions"}
+  
+  /**
+   * Unified → OpenAI Chat Completions.
+   */
+  async transformRequestIn(request, _provider, _context) {
+    const source = request;
+    const out = {};
+    for (const key of Object.keys(source)) {
+      if (FOREIGN_BODY_KEYS.includes(key)) continue;
+      out[key] = source[key];
+    }
+    if (Array.isArray(request.messages)) {
+      out.messages = request.messages.map((message) => {
+        const src = message;
+        const encoded = {};
+        for (const key of Object.keys(src)) {
+          if (FOREIGN_MESSAGE_KEYS.includes(key)) continue;
+          encoded[key] = src[key];
+        }
+        if (message.content !== void 0) {
+          encoded.content = normalizeContent(message.content);
+        }
+        const thinkingContent = _optionalChain([message, 'access', _2 => _2.thinking, 'optionalAccess', _3 => _3.content]);
+        if (typeof thinkingContent === "string" && thinkingContent.length > 0) {
+          encoded.reasoning_content = thinkingContent;
+        }
+        return encoded;
+      });
+    }
+    const effort = _optionalChain([request, 'access', _4 => _4.reasoning, 'optionalAccess', _5 => _5.effort]);
+    if (typeof effort === "string" && effort !== "none") {
+      out.reasoning_effort = effort;
+    }
+    return out;
+  }
+  /**
+   * OpenAI Chat Completions → Unified. Identity — see the module JSDoc for why
+   * `reasoning_content` is NOT rewritten here.
+   */
+  async transformResponseOut(response, _context) {
+    return response;
+  }
+}, _class.__initStatic(), _class);
+
+
+
+exports.OpenAITransformer = OpenAITransformer;

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

@@ -3,7 +3,7 @@
 
 
 
-var _chunkYGXJGRFIcjs = require('./chunk-YGXJGRFI.cjs');
+var _chunkKBM2W6UYcjs = require('./chunk-KBM2W6UY.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 = _chunkYGXJGRFIcjs.buildRequestBody.call(void 0, request);
+    const inner = _chunkKBM2W6UYcjs.buildRequestBody.call(void 0, request);
     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 _chunkYGXJGRFIcjs.transformRequestOut.call(void 0, inner);
+    return _chunkKBM2W6UYcjs.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 _chunkYGXJGRFIcjs.transformResponseOut.call(void 0, unwrapped, this.name, this.logger);
+    return _chunkKBM2W6UYcjs.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 _chunkYGXJGRFIcjs.transformResponseIn.call(void 0, response, this.logger);
+    const geminiResponse = await _chunkKBM2W6UYcjs.transformResponseIn.call(void 0, response, this.logger);
     const contentType = _nullishCoalesce(geminiResponse.headers.get("Content-Type"), () => ( ""));
     if (contentType.includes("text/event-stream")) {
       return geminiResponse;