@omnicross/core 0.1.10 → 0.2.1

package/dist/{chunk-N7OOJI5V.js → chunk-V2UKUTJ3.js}

@@ -104,6 +104,11 @@ var SubscriptionAccountHealth = class {
     const preExisting = this.records.get(key);
     const record = preExisting ?? {};
     const status = input.status;
+    if (input.upstreamErrorType) {
+      console.info(
+        `[AccountHealth] upstream error type ${input.upstreamErrorType} (provider=${providerId} status=${String(status)})`
+      );
+    }
     const wasUnhealthyBefore = preExisting ? this.isUnhealthyAt(preExisting, now) : false;
     let anomalyState;
     let recovered = false;

package/dist/{chunk-45FHEOKW.js → chunk-V53ZEFXC.js}

@@ -5,8 +5,9 @@ import {
 import {
   extractReasoningIntent,
   normalizeThinkLevel,
+  recordDroppedField,
   resolveReasoningPlan
-} from "./chunk-N2EIM2XJ.js";
+} from "./chunk-ZLNHPUFA.js";
 
 // src/transformer/transformers/OpenAIResponseTransformer.ts
 var OpenAIResponseTransformer = class {
@@ -33,6 +34,7 @@ var OpenAIResponseTransformer = class {
    */
   async transformRequestIn(request, provider, context) {
     const input = [];
+    const codexTools = request.meta?.codexTools;
     for (const msg of request.messages) {
       if (msg.role === "system") {
         const sysText = typeof msg.content === "string" ? msg.content : flattenContent(msg.content);
@@ -41,9 +43,10 @@ var OpenAIResponseTransformer = class {
           content: [{ type: "input_text", text: sysText }]
         });
       } else if (msg.role === "tool") {
+        const callId = msg.tool_call_id;
         input.push({
-          type: "function_call_output",
-          call_id: msg.tool_call_id,
+          type: codexTools?.customToolCallIds?.includes(callId ?? "") ? "custom_tool_call_output" : "function_call_output",
+          call_id: callId,
           output: typeof msg.content === "string" ? msg.content : ""
         });
       } else {
@@ -56,14 +59,13 @@ var OpenAIResponseTransformer = class {
           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: itemId,
-              call_id: callId,
-              name: tc.function.name,
-              arguments: tc.function.arguments
-            });
+            input.push(encodeToolCallItem(
+              callId,
+              tc.function.name,
+              tc.function.arguments,
+              "completed",
+              codexTools
+            ));
           }
           continue;
         }
@@ -77,16 +79,25 @@ var OpenAIResponseTransformer = class {
       // 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,
+      stream: context.responsesSourceFormat === this.name ? request.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.
       store: false,
-      // `max_output_tokens` is intentionally omitted: the codex backend rejects
-      // it, and the public API falls back to its default when absent. If a
-      // public provider ever needs it honored, gate that on an opt-out flag.
-      ...request.temperature !== void 0 ? { temperature: request.temperature } : {}
+      // `max_output_tokens`: the codex backend REJECTS it, so it maps only when
+      // the client already speaks the Responses wire (public providers); the
+      // public API falls back to its default when absent.
+      ...request.temperature !== void 0 ? { temperature: request.temperature } : {},
+      // R7 (claude-api-transform-fidelity): the Responses wire HAS `top_p`, so
+      // the decoded hub value maps through — conditionally (absent ⇒ absent).
+      ...request.top_p !== void 0 ? { top_p: request.top_p } : {},
+      ...context.responsesSourceFormat === this.name && request.max_tokens !== void 0 ? { max_output_tokens: request.max_tokens } : {}
     };
+    if (request.stop !== void 0) recordDroppedField(request, "stop", "openai-responses");
+    if (request.top_k !== void 0) recordDroppedField(request, "top_k", "openai-responses");
+    if (request.metadata_user_id !== void 0) {
+      recordDroppedField(request, "metadata_user_id", "openai-responses");
+    }
     const reasoningPlan = resolveReasoningPlan({
       intent: extractReasoningIntent(request),
       model: request.model,
@@ -96,15 +107,22 @@ var OpenAIResponseTransformer = class {
       preserveNativeEffort: context.reasoningSourceFormat === this.name
     });
     if (reasoningPlan?.kind === "level" && reasoningPlan.enabled) {
-      body.reasoning = { effort: reasoningPlan.effort, summary: "auto" };
+      body.reasoning = {
+        effort: reasoningPlan.effort,
+        summary: typeof context.responsesReasoningSummary === "string" ? context.responsesReasoningSummary : "auto"
+      };
     }
     if (request.tools?.length) {
-      body.tools = request.tools.map((tool) => ({
+      body.tools = request.tools.map((tool) => codexTools?.customToolNames?.includes(tool.function.name) ? {
+        type: "custom",
+        name: tool.function.name,
+        description: tool.function.description
+      } : {
         type: "function",
         name: tool.function.name,
         description: tool.function.description,
         parameters: tool.function.parameters
-      }));
+      });
     }
     if (request.tool_choice) {
       if (typeof request.tool_choice === "string") {
@@ -122,7 +140,11 @@ var OpenAIResponseTransformer = class {
   async transformRequestOut(request, context) {
     const req = request;
     const messages = [];
-    let codexTools = null;
+    let codexTools = collectCodexTools({ tools: req.tools });
+    context.responsesSourceFormat = this.name;
+    if (typeof req.reasoning?.summary === "string") {
+      context.responsesReasoningSummary = req.reasoning.summary;
+    }
     const instructions = typeof req.instructions === "string" ? req.instructions.trim() : "";
     if (instructions) {
       messages.push({ role: "system", content: instructions });
@@ -133,10 +155,11 @@ var OpenAIResponseTransformer = class {
         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);
+          codexTools = mergeCodexTools(codexTools, collectCodexTools(entry));
           continue;
         }
         if (itemType === "custom_tool_call_output") {
+          rememberCustomCall(codexTools, entry.call_id);
           messages.push({
             role: "tool",
             content: flattenContent(entry.output),
@@ -145,6 +168,7 @@ var OpenAIResponseTransformer = class {
           continue;
         }
         if (itemType === "custom_tool_call") {
+          rememberCustomCall(codexTools, entry.call_id ?? entry.id, entry.name);
           const toolCall = {
             id: (entry.call_id ?? entry.id) || "",
             type: "function",
@@ -172,6 +196,7 @@ var OpenAIResponseTransformer = class {
           continue;
         }
         if (itemType === "function_call") {
+          rememberToolNamespace(codexTools, entry.name, entry.namespace);
           const toolCall = {
             id: (entry.call_id ?? entry.id) || "",
             type: "function",
@@ -214,28 +239,17 @@ var OpenAIResponseTransformer = class {
       };
     }
     const tools = [];
-    if (req.tools?.length) {
-      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) {
+    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) {
+    if (codexTools.customToolNames.length || codexTools.customToolCallIds.length || Object.keys(codexTools.toolNamespaces).length) {
       result.meta = {
         ...result.meta,
         codexTools: {
           ...codexTools.customToolNames.length ? { customToolNames: codexTools.customToolNames } : {},
+          ...codexTools.customToolCallIds.length ? { customToolCallIds: codexTools.customToolCallIds } : {},
           ...Object.keys(codexTools.toolNamespaces).length ? { toolNamespaces: codexTools.toolNamespaces } : {}
         }
       };
@@ -346,7 +360,12 @@ function encodeToolCallItem(callId, name, argumentsJson, status, codexTools) {
   };
 }
 function collectCodexTools(entry) {
-  const result = { tools: [], customToolNames: [], toolNamespaces: {} };
+  const result = {
+    tools: [],
+    customToolNames: [],
+    customToolCallIds: [],
+    toolNamespaces: {}
+  };
   const visit = (declarations, namespace) => {
     if (!Array.isArray(declarations)) return;
     for (const raw of declarations) {
@@ -387,6 +406,32 @@ function collectCodexTools(entry) {
   visit(entry.tools);
   return result;
 }
+function mergeCodexTools(left, right) {
+  const tools = [...left.tools];
+  const names = new Set(tools.map((tool) => tool.function.name));
+  for (const tool of right.tools) {
+    if (!names.has(tool.function.name)) tools.push(tool);
+  }
+  return {
+    tools,
+    customToolNames: [.../* @__PURE__ */ new Set([...left.customToolNames, ...right.customToolNames])],
+    customToolCallIds: [.../* @__PURE__ */ new Set([...left.customToolCallIds, ...right.customToolCallIds])],
+    toolNamespaces: { ...left.toolNamespaces, ...right.toolNamespaces }
+  };
+}
+function rememberCustomCall(state, rawCallId, rawName) {
+  if (typeof rawCallId === "string" && rawCallId && !state.customToolCallIds.includes(rawCallId)) {
+    state.customToolCallIds.push(rawCallId);
+  }
+  if (typeof rawName === "string" && rawName && !state.customToolNames.includes(rawName)) {
+    state.customToolNames.push(rawName);
+  }
+}
+function rememberToolNamespace(state, rawName, rawNamespace) {
+  if (typeof rawName === "string" && rawName && typeof rawNamespace === "string" && rawNamespace) {
+    state.toolNamespaces[rawName] = rawNamespace;
+  }
+}
 function flattenContent(content) {
   if (typeof content === "string") return content;
   if (!content) return "";
@@ -613,6 +658,17 @@ function convertResponseApiStreamToOpenAI(responseApiStream) {
                     finish_reason: "stop"
                   }]);
                   break;
+                case "response.failed": {
+                  safeEnqueue(
+                    `data: ${JSON.stringify({
+                      error: event.response?.error ?? { message: "response.failed" }
+                    })}
+
+`
+                  );
+                  safeEnqueue("data: [DONE]\n\n");
+                  break;
+                }
                 default:
                   break;
               }

package/dist/{chunk-RJ5ZGNI3.js → chunk-VL5TUDTM.js}

@@ -32,6 +32,12 @@ function bumpUpstreamProxyGeneration() {
     }
   }
 }
+function isClientDisconnectAbort(signal) {
+  if (!signal?.aborted) return false;
+  const reason = signal.reason;
+  if (!reason || typeof reason !== "object") return false;
+  return reason.code === "client_disconnect";
+}
 function normalizeProxy(cfg) {
   if ("url" in cfg) {
     let u;
@@ -144,7 +150,7 @@ function fetchUpstream(url, init, ctx) {
       return response;
     },
     (error) => {
-      recordActivity(0);
+      if (!isClientDisconnectAbort(init.signal)) recordActivity(0);
       throw error;
     }
   );
@@ -158,7 +164,7 @@ function fetchUpstream(url, init, ctx) {
   const redactBodies = ctx.redactBodies === true;
   const requestBody = redactBodies ? REDACTED_BODY : typeof init.body === "string" ? init.body : null;
   const providerId = ctx.providerId;
-  const accountId = ctx.accountId;
+  const accountId = ctx.traceAccountFingerprint ?? ctx.accountId;
   return doFetchWithActivity().then((res) => {
     const clone = res.clone();
     const status = res.status;