@omnicross/core 0.1.10 → 0.2.1

package/dist/{chunk-CMVXX7ON.cjs → chunk-NOITAVHA.cjs}

@@ -6,7 +6,8 @@ var _chunk5RSZYQJHcjs = require('./chunk-5RSZYQJH.cjs');
 
 
 
-var _chunkAOFWNWLTcjs = require('./chunk-AOFWNWLT.cjs');
+
+var _chunkIUL4VWNUcjs = require('./chunk-IUL4VWNU.cjs');
 
 // src/transformer/transformers/OpenAIResponseTransformer.ts
 var OpenAIResponseTransformer = (_class = class {constructor() { _class.prototype.__init.call(this);_class.prototype.__init2.call(this); }
@@ -33,6 +34,7 @@ var OpenAIResponseTransformer = (_class = class {constructor() { _class.prototyp
    */
   async transformRequestIn(request, provider, context) {
     const input = [];
+    const codexTools = _optionalChain([request, 'access', _ => _.meta, 'optionalAccess', _2 => _2.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 = class {constructor() { _class.prototyp
           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: _optionalChain([codexTools, 'optionalAccess', _3 => _3.customToolCallIds, 'optionalAccess', _4 => _4.includes, 'call', _5 => _5(_nullishCoalesce(callId, () => ( "")))]) ? "custom_tool_call_output" : "function_call_output",
+          call_id: callId,
           output: typeof msg.content === "string" ? msg.content : ""
         });
       } else {
@@ -52,18 +55,17 @@ var OpenAIResponseTransformer = (_class = class {constructor() { _class.prototyp
           role: msg.role,
           content: [{ type: msg.role === "assistant" ? "output_text" : "input_text", text }]
         };
-        if (msg.role === "assistant" && _optionalChain([msg, 'access', _ => _.tool_calls, 'optionalAccess', _2 => _2.length])) {
+        if (msg.role === "assistant" && _optionalChain([msg, 'access', _6 => _6.tool_calls, 'optionalAccess', _7 => _7.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: 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,34 +79,50 @@ var OpenAIResponseTransformer = (_class = class {constructor() { _class.prototyp
       // 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 } : {}
     };
-    const reasoningPlan = _chunkAOFWNWLTcjs.resolveReasoningPlan.call(void 0, {
-      intent: _chunkAOFWNWLTcjs.extractReasoningIntent.call(void 0, request),
+    if (request.stop !== void 0) _chunkIUL4VWNUcjs.recordDroppedField.call(void 0, request, "stop", "openai-responses");
+    if (request.top_k !== void 0) _chunkIUL4VWNUcjs.recordDroppedField.call(void 0, request, "top_k", "openai-responses");
+    if (request.metadata_user_id !== void 0) {
+      _chunkIUL4VWNUcjs.recordDroppedField.call(void 0, request, "metadata_user_id", "openai-responses");
+    }
+    const reasoningPlan = _chunkIUL4VWNUcjs.resolveReasoningPlan.call(void 0, {
+      intent: _chunkIUL4VWNUcjs.extractReasoningIntent.call(void 0, request),
       model: request.model,
       provider,
       target: "openai-responses",
       requestMaxTokens: request.max_tokens,
       preserveNativeEffort: context.reasoningSourceFormat === this.name
     });
-    if (_optionalChain([reasoningPlan, 'optionalAccess', _3 => _3.kind]) === "level" && reasoningPlan.enabled) {
-      body.reasoning = { effort: reasoningPlan.effort, summary: "auto" };
+    if (_optionalChain([reasoningPlan, 'optionalAccess', _8 => _8.kind]) === "level" && reasoningPlan.enabled) {
+      body.reasoning = {
+        effort: reasoningPlan.effort,
+        summary: typeof context.responsesReasoningSummary === "string" ? context.responsesReasoningSummary : "auto"
+      };
     }
-    if (_optionalChain([request, 'access', _4 => _4.tools, 'optionalAccess', _5 => _5.length])) {
-      body.tools = request.tools.map((tool) => ({
+    if (_optionalChain([request, 'access', _9 => _9.tools, 'optionalAccess', _10 => _10.length])) {
+      body.tools = request.tools.map((tool) => _optionalChain([codexTools, 'optionalAccess', _11 => _11.customToolNames, 'optionalAccess', _12 => _12.includes, 'call', _13 => _13(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 = class {constructor() { _class.prototyp
   async transformRequestOut(request, context) {
     const req = request;
     const messages = [];
-    let codexTools = null;
+    let codexTools = collectCodexTools({ tools: req.tools });
+    context.responsesSourceFormat = this.name;
+    if (typeof _optionalChain([req, 'access', _14 => _14.reasoning, 'optionalAccess', _15 => _15.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 = class {constructor() { _class.prototyp
         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 = class {constructor() { _class.prototyp
           continue;
         }
         if (itemType === "custom_tool_call") {
+          rememberCustomCall(codexTools, _nullishCoalesce(entry.call_id, () => ( entry.id)), entry.name);
           const toolCall = {
             id: (_nullishCoalesce(entry.call_id, () => ( entry.id))) || "",
             type: "function",
@@ -172,6 +196,7 @@ var OpenAIResponseTransformer = (_class = class {constructor() { _class.prototyp
           continue;
         }
         if (itemType === "function_call") {
+          rememberToolNamespace(codexTools, entry.name, entry.namespace);
           const toolCall = {
             id: (_nullishCoalesce(entry.call_id, () => ( entry.id))) || "",
             type: "function",
@@ -205,7 +230,7 @@ var OpenAIResponseTransformer = (_class = class {constructor() { _class.prototyp
       temperature: req.temperature,
       stream: req.stream
     };
-    const effort = _chunkAOFWNWLTcjs.normalizeThinkLevel.call(void 0, _optionalChain([req, 'access', _6 => _6.reasoning, 'optionalAccess', _7 => _7.effort]));
+    const effort = _chunkIUL4VWNUcjs.normalizeThinkLevel.call(void 0, _optionalChain([req, 'access', _16 => _16.reasoning, 'optionalAccess', _17 => _17.effort]));
     if (effort) {
       context.reasoningSourceFormat = this.name;
       result.reasoning = {
@@ -214,28 +239,17 @@ var OpenAIResponseTransformer = (_class = class {constructor() { _class.prototyp
       };
     }
     const tools = [];
-    if (_optionalChain([req, 'access', _8 => _8.tools, 'optionalAccess', _9 => _9.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 (_optionalChain([codexTools, 'optionalAccess', _10 => _10.tools, 'access', _11 => _11.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 (_optionalChain([codexTools, 'optionalAccess', _12 => _12.customToolNames, 'access', _13 => _13.length]) || Object.keys(_nullishCoalesce(_optionalChain([codexTools, 'optionalAccess', _14 => _14.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 } : {}
         }
       };
@@ -281,7 +295,7 @@ var OpenAIResponseTransformer = (_class = class {constructor() { _class.prototyp
    */
   async transformResponseIn(response, context) {
     const contentType = _nullishCoalesce(response.headers.get("Content-Type"), () => ( ""));
-    const codexTools = _optionalChain([context, 'optionalAccess', _15 => _15.req, 'optionalAccess', _16 => _16.meta, 'optionalAccess', _17 => _17.codexTools]);
+    const codexTools = _optionalChain([context, 'optionalAccess', _18 => _18.req, 'optionalAccess', _19 => _19.meta, 'optionalAccess', _20 => _20.codexTools]);
     if (contentType.includes("text/event-stream")) {
       if (!response.body) {
         throw new Error("Stream response body is null");
@@ -324,7 +338,7 @@ function unwrapCustomToolInput(argumentsJson) {
 }
 function encodeToolCallItem(callId, name, argumentsJson, status, codexTools) {
   const bareId = callId.replace(/^(call_|fc_|ctc_)/, "");
-  if (_optionalChain([codexTools, 'optionalAccess', _18 => _18.customToolNames, 'optionalAccess', _19 => _19.includes, 'call', _20 => _20(name)])) {
+  if (_optionalChain([codexTools, 'optionalAccess', _21 => _21.customToolNames, 'optionalAccess', _22 => _22.includes, 'call', _23 => _23(name)])) {
     return {
       id: `ctc_${bareId}`,
       type: "custom_tool_call",
@@ -334,7 +348,7 @@ function encodeToolCallItem(callId, name, argumentsJson, status, codexTools) {
       input: unwrapCustomToolInput(argumentsJson)
     };
   }
-  const namespace = _optionalChain([codexTools, 'optionalAccess', _21 => _21.toolNamespaces, 'optionalAccess', _22 => _22[name]]);
+  const namespace = _optionalChain([codexTools, 'optionalAccess', _24 => _24.toolNamespaces, 'optionalAccess', _25 => _25[name]]);
   return {
     id: callId.startsWith("fc_") ? callId : `fc_${bareId}`,
     type: "function_call",
@@ -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 "";
@@ -458,7 +503,7 @@ function convertResponseApiJsonToOpenAI(data) {
 }
 function convertOpenAIJsonToResponseApi(data, codexTools) {
   const choices = data.choices;
-  const message = _optionalChain([choices, 'optionalAccess', _23 => _23[0], 'optionalAccess', _24 => _24.message]);
+  const message = _optionalChain([choices, 'optionalAccess', _26 => _26[0], 'optionalAccess', _27 => _27.message]);
   const output = [];
   if (message) {
     const contentParts = [];
@@ -469,14 +514,14 @@ function convertOpenAIJsonToResponseApi(data, codexTools) {
       output.push({ type: "message", role: "assistant", content: contentParts });
     }
     const toolCalls = message.tool_calls;
-    if (_optionalChain([toolCalls, 'optionalAccess', _25 => _25.length])) {
+    if (_optionalChain([toolCalls, 'optionalAccess', _28 => _28.length])) {
       for (const tc of toolCalls) {
         const func = tc.function;
         output.push(
           encodeToolCallItem(
             tc.id || "",
-            _optionalChain([func, 'optionalAccess', _26 => _26.name]) || "",
-            typeof _optionalChain([func, 'optionalAccess', _27 => _27.arguments]) === "string" ? func.arguments : "",
+            _optionalChain([func, 'optionalAccess', _29 => _29.name]) || "",
+            typeof _optionalChain([func, 'optionalAccess', _30 => _30.arguments]) === "string" ? func.arguments : "",
             "completed",
             codexTools
           )
@@ -542,7 +587,7 @@ function convertResponseApiStreamToOpenAI(responseApiStream) {
             if (data === "[DONE]") continue;
             try {
               const event = JSON.parse(data);
-              model = event.model || _optionalChain([event, 'access', _28 => _28.response, 'optionalAccess', _29 => _29.model]) || model;
+              model = event.model || _optionalChain([event, 'access', _31 => _31.response, 'optionalAccess', _32 => _32.model]) || model;
               switch (event.type) {
                 case "response.output_text.delta":
                   if (event.delta) {
@@ -564,7 +609,7 @@ function convertResponseApiStreamToOpenAI(responseApiStream) {
                   break;
                 case "response.output_item.added": {
                   const item = event.item;
-                  if (_optionalChain([item, 'optionalAccess', _30 => _30.type]) !== "function_call") break;
+                  if (_optionalChain([item, 'optionalAccess', _33 => _33.type]) !== "function_call") break;
                   if (!hasEmittedRole) {
                     emitChunk([{ index: 0, delta: { role: "assistant", content: null }, finish_reason: null }]);
                     hasEmittedRole = true;
@@ -600,7 +645,7 @@ function convertResponseApiStreamToOpenAI(responseApiStream) {
                 }
                 case "response.completed": {
                   const resp = event.response;
-                  const respUsage = _optionalChain([resp, 'optionalAccess', _31 => _31.usage]);
+                  const respUsage = _optionalChain([resp, 'optionalAccess', _34 => _34.usage]);
                   const usage = _chunk5RSZYQJHcjs.responsesUsageToChatUsage.call(void 0, respUsage);
                   emitChunk([{ index: 0, delta: {}, finish_reason: hasToolCalls ? "tool_calls" : "stop" }], usage);
                   safeEnqueue("data: [DONE]\n\n");
@@ -609,10 +654,21 @@ function convertResponseApiStreamToOpenAI(responseApiStream) {
                 case "error":
                   emitChunk([{
                     index: 0,
-                    delta: { content: `[Error: ${_optionalChain([event, 'access', _32 => _32.error, 'optionalAccess', _33 => _33.message]) || "Unknown error"}]` },
+                    delta: { content: `[Error: ${_optionalChain([event, 'access', _35 => _35.error, 'optionalAccess', _36 => _36.message]) || "Unknown error"}]` },
                     finish_reason: "stop"
                   }]);
                   break;
+                case "response.failed": {
+                  safeEnqueue(
+                    `data: ${JSON.stringify({
+                      error: _nullishCoalesce(_optionalChain([event, 'access', _37 => _37.response, 'optionalAccess', _38 => _38.error]), () => ( { message: "response.failed" }))
+                    })}
+
+`
+                  );
+                  safeEnqueue("data: [DONE]\n\n");
+                  break;
+                }
                 default:
                   break;
               }
@@ -682,10 +738,10 @@ function convertOpenAIStreamToResponseApi(openaiStream, codexTools) {
             if (data === "[DONE]") continue;
             try {
               const chunk = JSON.parse(data);
-              const choice = _optionalChain([chunk, 'access', _34 => _34.choices, 'optionalAccess', _35 => _35[0]]);
+              const choice = _optionalChain([chunk, 'access', _39 => _39.choices, 'optionalAccess', _40 => _40[0]]);
               model = chunk.model || model;
               if (!choice) continue;
-              if (_optionalChain([choice, 'access', _36 => _36.delta, 'optionalAccess', _37 => _37.content])) {
+              if (_optionalChain([choice, 'access', _41 => _41.delta, 'optionalAccess', _42 => _42.content])) {
                 if (!messageItemAdded) {
                   messageItemAdded = true;
                   emitEvent({
@@ -708,14 +764,14 @@ function convertOpenAIStreamToResponseApi(openaiStream, codexTools) {
                   delta: choice.delta.content
                 });
               }
-              const reasoningDelta = _nullishCoalesce(_optionalChain([choice, 'access', _38 => _38.delta, 'optionalAccess', _39 => _39.thinking, 'optionalAccess', _40 => _40.content]), () => ( _optionalChain([choice, 'access', _41 => _41.delta, 'optionalAccess', _42 => _42.reasoning_content])));
+              const reasoningDelta = _nullishCoalesce(_optionalChain([choice, 'access', _43 => _43.delta, 'optionalAccess', _44 => _44.thinking, 'optionalAccess', _45 => _45.content]), () => ( _optionalChain([choice, 'access', _46 => _46.delta, 'optionalAccess', _47 => _47.reasoning_content])));
               if (reasoningDelta) {
                 emitEvent({
                   type: "response.reasoning_summary_text.delta",
                   delta: reasoningDelta
                 });
               }
-              if (_optionalChain([choice, 'access', _43 => _43.delta, 'optionalAccess', _44 => _44.tool_calls])) {
+              if (_optionalChain([choice, 'access', _48 => _48.delta, 'optionalAccess', _49 => _49.tool_calls])) {
                 for (const tc of choice.delta.tool_calls) {
                   const tcIndex = typeof tc["index"] === "number" ? tc["index"] : 0;
                   const func = _nullishCoalesce(tc["function"], () => ( {}));
@@ -727,7 +783,7 @@ function convertOpenAIStreamToResponseApi(openaiStream, codexTools) {
                       callId,
                       name,
                       arguments: "",
-                      isCustom: _nullishCoalesce(_optionalChain([codexTools, 'optionalAccess', _45 => _45.customToolNames, 'optionalAccess', _46 => _46.includes, 'call', _47 => _47(name)]), () => ( false))
+                      isCustom: _nullishCoalesce(_optionalChain([codexTools, 'optionalAccess', _50 => _50.customToolNames, 'optionalAccess', _51 => _51.includes, 'call', _52 => _52(name)]), () => ( false))
                     };
                     toolCalls.set(tcIndex, entry);
                     const outIdx = nextOutputIndex++;

package/dist/{chunk-Q27JY5RG.cjs → chunk-OIKREZVQ.cjs}

@@ -1,10 +1,10 @@
 "use strict";Object.defineProperty(exports, "__esModule", {value: true}); function _nullishCoalesce(lhs, rhsFn) { if (lhs != null) { return lhs; } else { return rhsFn(); } }
 
-var _chunkA2YMUCBTcjs = require('./chunk-A2YMUCBT.cjs');
 
+var _chunkUNEFIWXIcjs = require('./chunk-UNEFIWXI.cjs');
 
 
-var _chunkUNEFIWXIcjs = require('./chunk-UNEFIWXI.cjs');
+var _chunkA2YMUCBTcjs = require('./chunk-A2YMUCBT.cjs');
 
 // src/completion/header-builder.ts
 function getProviderHeaders(provider, apiKey) {
@@ -17,8 +17,11 @@ function getProviderHeaders(provider, apiKey) {
         // Third-party Anthropic-Messages relays often gate on a Bearer token
         // rather than x-api-key; `provider.useBearer` opts into that.
         ...provider.useBearer ? { Authorization: `Bearer ${apiKey}` } : { "x-api-key": apiKey },
-        "anthropic-version": "2025-01-10"
-        // Required for extended thinking feature
+        // Official documented version date (claude-api-protocol-fidelity, R5);
+        // the former non-official future-dated value was removed. The BYO
+        // same-format path additionally forwards the caller's own
+        // `anthropic-version` verbatim when present (see `runSameFormatFetch`).
+        "anthropic-version": "2023-06-01"
       };
       break;
     case "google":