@omnicross/core 0.1.9 → 0.2.0

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-OC6DOOFX.cjs → chunk-VXRTQZF2.cjs}

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