@omnicross/core 0.1.5 → 0.1.7

package/dist/{chunk-BODMAL6G.js → chunk-32O35CIF.js}

@@ -1,3 +1,8 @@
+import {
+  chatUsageToResponsesUsage,
+  responsesUsageToChatUsage
+} from "./chunk-FU7EAR73.js";
+
 // src/transformer/transformers/OpenAIResponseTransformer.ts
 var OpenAIResponseTransformer = class {
   static TransformerName = "openai-response";
@@ -104,24 +109,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];
@@ -132,17 +150,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 });
         }
       }
     }
@@ -159,15 +198,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;
   }
@@ -208,13 +264,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",
@@ -223,16 +280,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 "";
 }
@@ -283,14 +438,10 @@ function convertResponseApiJsonToOpenAI(data) {
         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
+    usage: responsesUsageToChatUsage(usage)
   };
 }
-function convertOpenAIJsonToResponseApi(data) {
+function convertOpenAIJsonToResponseApi(data, codexTools) {
   const choices = data.choices;
   const message = choices?.[0]?.message;
   const output = [];
@@ -306,13 +457,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
+          )
+        );
       }
     }
   }
@@ -323,11 +476,7 @@ function convertOpenAIJsonToResponseApi(data) {
     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
+    usage: chatUsageToResponsesUsage(usage)
   };
 }
 function convertResponseApiStreamToOpenAI(responseApiStream) {
@@ -437,11 +586,7 @@ function convertResponseApiStreamToOpenAI(responseApiStream) {
                 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;
+                  const usage = responsesUsageToChatUsage(respUsage);
                   emitChunk([{ index: 0, delta: {}, finish_reason: hasToolCalls ? "tool_calls" : "stop" }], usage);
                   safeEnqueue("data: [DONE]\n\n");
                   break;
@@ -474,7 +619,7 @@ function convertResponseApiStreamToOpenAI(responseApiStream) {
     }
   });
 }
-function convertOpenAIStreamToResponseApi(openaiStream) {
+function convertOpenAIStreamToResponseApi(openaiStream, codexTools) {
   const decoder = new TextDecoder();
   const encoder = new TextEncoder();
   return new ReadableStream({
@@ -485,6 +630,8 @@ 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;
@@ -524,13 +671,33 @@ 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) {
@@ -541,66 +708,83 @@ function convertOpenAIStreamToResponseApi(openaiStream) {
                   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: "" };
+                    entry = {
+                      callId,
+                      name,
+                      arguments: "",
+                      isCustom: codexTools?.customToolNames?.includes(name) ?? false
+                    };
                     toolCalls.set(tcIndex, entry);
                     const outIdx = nextOutputIndex++;
                     toolOutputIndex.set(tcIndex, outIdx);
-                    const itemId = callId.startsWith("fc_") ? callId : `fc_${callId.replace(/^(call_|fc_)/, "")}`;
                     emitEvent({
                       type: "response.output_item.added",
                       output_index: outIdx,
-                      item: {
-                        id: itemId,
-                        type: "function_call",
-                        status: "in_progress",
-                        call_id: callId,
-                        name,
-                        arguments: ""
-                      }
+                      item: encodeToolCallItem(callId, name, "", "in_progress", codexTools)
                     });
                   }
                   const argsFragment = typeof func["arguments"] === "string" ? func["arguments"] : "";
                   if (argsFragment) {
                     entry.arguments += argsFragment;
-                    emitEvent({
-                      type: "response.function_call_arguments.delta",
-                      output_index: toolOutputIndex.get(tcIndex),
-                      delta: 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 (accumulatedContent) {
-                  output.push({
+                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 itemId = entry.callId.startsWith("fc_") ? entry.callId : `fc_${entry.callId.replace(/^(call_|fc_)/, "")}`;
-                  output.push({
-                    id: itemId,
-                    type: "function_call",
-                    status: "completed",
-                    call_id: entry.callId,
-                    name: entry.name,
-                    arguments: entry.arguments
-                  });
+                  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: toolOutputIndex.get(tcIndex),
-                    item: {
-                      id: itemId,
-                      type: "function_call",
-                      status: "completed",
-                      call_id: entry.callId,
-                      name: entry.name,
-                      arguments: entry.arguments
-                    }
+                    output_index: outIdx,
+                    item
                   });
                 }
                 emitEvent({
@@ -610,11 +794,7 @@ function convertOpenAIStreamToResponseApi(openaiStream) {
                     status: "completed",
                     model,
                     output,
-                    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
+                    usage: chatUsageToResponsesUsage(chunk.usage)
                   }
                 });
               }

package/dist/chunk-3SCOLIPT.cjs

@@ -0,0 +1,63 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true});// src/provider-proxy/identity/headerMerge.ts
+function fillMissingHeaders(headers, source) {
+  const present = new Set(Object.keys(headers).map((k) => k.toLowerCase()));
+  for (const [key, value] of Object.entries(source)) {
+    const lower = key.toLowerCase();
+    if (present.has(lower)) continue;
+    headers[lower] = value;
+    present.add(lower);
+  }
+}
+function flattenHeaderValue(raw) {
+  if (raw === void 0) return void 0;
+  const value = Array.isArray(raw) ? raw.filter((v) => typeof v === "string").join(", ") : raw;
+  return typeof value === "string" && value.length > 0 ? value : void 0;
+}
+var NEVER_FORWARD_HEADERS = /* @__PURE__ */ new Set([
+  "authorization",
+  "x-api-key",
+  "cookie",
+  "proxy-authorization",
+  "host",
+  "connection",
+  "content-length",
+  "content-type",
+  "accept-encoding"
+]);
+
+// src/provider-proxy/identity/codexCliHeaders.ts
+var DEFAULT_CODEX_CLI_HEADERS = Object.freeze({
+  originator: "codex_cli_rs",
+  "user-agent": "codex_cli_rs/0.144.5",
+  version: "0.144.5"
+});
+var CODEX_FORWARD_ALLOWLIST = /* @__PURE__ */ new Set([
+  "version",
+  "openai-beta",
+  "session_id",
+  "originator",
+  "user-agent"
+]);
+function extractCodexClientHeaders(reqHeaders) {
+  const out = {};
+  for (const [rawKey, rawVal] of Object.entries(reqHeaders)) {
+    const key = rawKey.toLowerCase();
+    if (NEVER_FORWARD_HEADERS.has(key)) continue;
+    if (!CODEX_FORWARD_ALLOWLIST.has(key)) continue;
+    const value = flattenHeaderValue(rawVal);
+    if (value !== void 0) out[key] = value;
+  }
+  return out;
+}
+function codexAcceptHeader(isStream) {
+  return isStream ? "text/event-stream" : "application/json";
+}
+
+
+
+
+
+
+
+
+exports.fillMissingHeaders = fillMissingHeaders; exports.flattenHeaderValue = flattenHeaderValue; exports.NEVER_FORWARD_HEADERS = NEVER_FORWARD_HEADERS; exports.DEFAULT_CODEX_CLI_HEADERS = DEFAULT_CODEX_CLI_HEADERS; exports.extractCodexClientHeaders = extractCodexClientHeaders; exports.codexAcceptHeader = codexAcceptHeader;

package/dist/{chunk-SYQF7OIR.js → chunk-3WD4HTR2.js}

@@ -2,6 +2,7 @@
 import { appendFile, mkdir } from "fs/promises";
 import { dirname } from "path";
 var tracePath = null;
+var REDACTED_BODY = "***REDACTED (credential exchange)***";
 var SECRET_HEADER_NAMES = /* @__PURE__ */ new Set([
   "authorization",
   "api-key",
@@ -44,6 +45,7 @@ function __resetUpstreamTraceForTests() {
 }
 
 export {
+  REDACTED_BODY,
   setUpstreamTracePath,
   getUpstreamTracePath,
   redactHeaders,