@omnicross/core 0.1.4 → 0.1.5

package/dist/auth/GeminiCodeAssistProjectResolver.cjs

@@ -1,11 +1,12 @@
 "use strict";Object.defineProperty(exports, "__esModule", {value: true}); function _nullishCoalesce(lhs, rhsFn) { if (lhs != null) { return lhs; } else { return rhsFn(); } } 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;
 
 
-var _chunkRSJ3TWJQcjs = require('../chunk-RSJ3TWJQ.cjs');
-require('../chunk-YGXJGRFI.cjs');
+var _chunkDDMRUL76cjs = require('../chunk-DDMRUL76.cjs');
+require('../chunk-JWVTXXPX.cjs');
 
 
-var _chunkOCEUVQHWcjs = require('../chunk-OCEUVQHW.cjs');
+var _chunkPG7PS2NNcjs = require('../chunk-PG7PS2NN.cjs');
+require('../chunk-3Z5BQZFM.cjs');
 
 // src/auth/GeminiCodeAssistProjectResolver.ts
 var FREE_TIER_ID = "free-tier";
@@ -25,7 +26,7 @@ var GeminiCodeAssistHandshakeError = class extends Error {
 var GeminiCodeAssistProjectResolver = (_class = class {
   // upstream-proxy: the Code Assist handshake is upstream egress → honor the
   // gemini proxy by default (still injectable for tests).
-  constructor(fetchImpl = (url, init) => _chunkOCEUVQHWcjs.fetchUpstream.call(void 0, url, init, { providerId: "gemini" })) {;_class.prototype.__init.call(this);_class.prototype.__init2.call(this);
+  constructor(fetchImpl = (url, init) => _chunkPG7PS2NNcjs.fetchUpstream.call(void 0, url, init, { providerId: "gemini" })) {;_class.prototype.__init.call(this);_class.prototype.__init2.call(this);
     this.fetchImpl = fetchImpl;
   }
   
@@ -59,7 +60,7 @@ var GeminiCodeAssistProjectResolver = (_class = class {
     return run;
   }
   codeAssistUrl(method) {
-    return `${_chunkRSJ3TWJQcjs.resolveCodeAssistEndpoint.call(void 0, )}/${_chunkRSJ3TWJQcjs.resolveCodeAssistApiVersion.call(void 0, )}:${method}`;
+    return `${_chunkDDMRUL76cjs.resolveCodeAssistEndpoint.call(void 0, )}/${_chunkDDMRUL76cjs.resolveCodeAssistApiVersion.call(void 0, )}:${method}`;
   }
   /** Seed project id from env; reject a purely-numeric value (project NUMBER). */
   seedProjectId() {

package/dist/auth/GeminiCodeAssistProjectResolver.js

@@ -1,11 +1,12 @@
 import {
   resolveCodeAssistApiVersion,
   resolveCodeAssistEndpoint
-} from "../chunk-Z7Y2NPHY.js";
-import "../chunk-S4WBV25P.js";
+} from "../chunk-MFZ5437A.js";
+import "../chunk-6QZGDLL4.js";
 import {
   fetchUpstream
-} from "../chunk-XK5CIRMQ.js";
+} from "../chunk-D3TDKWRP.js";
+import "../chunk-SYQF7OIR.js";
 
 // src/auth/GeminiCodeAssistProjectResolver.ts
 var FREE_TIER_ID = "free-tier";

package/dist/{chunk-SU2GCLAC.cjs → chunk-3Q6Z6JTO.cjs}

@@ -45,10 +45,12 @@ var OpenAIResponseTransformer = (_class = class {constructor() { _class.prototyp
         if (msg.role === "assistant" && _optionalChain([msg, 'access', _ => _.tool_calls, 'optionalAccess', _2 => _2.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 = class {constructor() { _class.prototyp
     const body = {
       model: request.model,
       input,
-      stream: _nullishCoalesce(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.
@@ -335,6 +341,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,22 +398,58 @@ function convertResponseApiStreamToOpenAI(responseApiStream) {
                     }]);
                   }
                   break;
+                case "response.output_item.added": {
+                  const item = event.item;
+                  if (_optionalChain([item, 'optionalAccess', _18 => _18.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: _nullishCoalesce(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: _nullishCoalesce(event.output_index, () => ( 0)),
+                        function: { arguments: _nullishCoalesce(event.delta, () => ( "")) }
+                      }]
+                    },
+                    finish_reason: null
+                  }]);
+                  break;
+                }
                 case "response.completed": {
                   const resp = event.response;
-                  const respUsage = _optionalChain([resp, 'optionalAccess', _18 => _18.usage]);
+                  const respUsage = _optionalChain([resp, 'optionalAccess', _19 => _19.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;
-                  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;
                 }
                 case "error":
                   emitChunk([{
                     index: 0,
-                    delta: { content: `[Error: ${_optionalChain([event, 'access', _19 => _19.error, 'optionalAccess', _20 => _20.message]) || "Unknown error"}]` },
+                    delta: { content: `[Error: ${_optionalChain([event, 'access', _20 => _20.error, 'optionalAccess', _21 => _21.message]) || "Unknown error"}]` },
                     finish_reason: "stop"
                   }]);
                   break;
@@ -442,6 +485,9 @@ function convertOpenAIStreamToResponseApi(openaiStream) {
       let accumulatedContent = "";
       let model = "unknown";
       const responseId = `resp_${Date.now()}`;
+      const toolCalls = /* @__PURE__ */ new Map();
+      const toolOutputIndex = /* @__PURE__ */ new Map();
+      let nextOutputIndex = 1;
       const safeEnqueue = (str) => {
         if (!isClosed) {
           try {
@@ -474,34 +520,96 @@ function convertOpenAIStreamToResponseApi(openaiStream) {
             if (data === "[DONE]") continue;
             try {
               const chunk = JSON.parse(data);
-              const choice = _optionalChain([chunk, 'access', _21 => _21.choices, 'optionalAccess', _22 => _22[0]]);
+              const choice = _optionalChain([chunk, 'access', _22 => _22.choices, 'optionalAccess', _23 => _23[0]]);
               model = chunk.model || model;
               if (!choice) continue;
-              if (_optionalChain([choice, 'access', _23 => _23.delta, 'optionalAccess', _24 => _24.content])) {
+              if (_optionalChain([choice, 'access', _24 => _24.delta, 'optionalAccess', _25 => _25.content])) {
                 accumulatedContent += choice.delta.content;
                 emitEvent({ type: "response.output_text.delta", delta: choice.delta.content });
               }
-              if (_optionalChain([choice, 'access', _25 => _25.delta, 'optionalAccess', _26 => _26.thinking, 'optionalAccess', _27 => _27.content])) {
+              if (_optionalChain([choice, 'access', _26 => _26.delta, 'optionalAccess', _27 => _27.thinking, 'optionalAccess', _28 => _28.content])) {
                 emitEvent({
                   type: "response.reasoning_summary_text.delta",
                   delta: choice.delta.thinking.content
                 });
               }
+              if (_optionalChain([choice, 'access', _29 => _29.delta, 'optionalAccess', _30 => _30.tool_calls])) {
+                for (const tc of choice.delta.tool_calls) {
+                  const tcIndex = typeof tc["index"] === "number" ? tc["index"] : 0;
+                  const func = _nullishCoalesce(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: "" };
+                    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: ""
+                      }
+                    });
+                  }
+                  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 (choice.finish_reason) {
                 emitEvent({ type: "response.output_text.done", text: accumulatedContent });
+                const output = [];
+                if (accumulatedContent) {
+                  output.push({
+                    type: "message",
+                    role: "assistant",
+                    content: [{ type: "output_text", text: accumulatedContent }]
+                  });
+                }
+                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
+                  });
+                  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
+                    }
+                  });
+                }
                 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-3Z5BQZFM.cjs

@@ -0,0 +1,52 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true});// src/pipeline/upstreamTrace.ts
+var _promises = require('fs/promises');
+var _path = require('path');
+var tracePath = null;
+var SECRET_HEADER_NAMES = /* @__PURE__ */ new Set([
+  "authorization",
+  "api-key",
+  "x-api-key",
+  "x-goog-api-key"
+]);
+function setUpstreamTracePath(path) {
+  tracePath = typeof path === "string" && path.trim() ? path.trim() : null;
+}
+function getUpstreamTracePath() {
+  return tracePath;
+}
+function redactHeaders(headers) {
+  const out = {};
+  if (!headers) return out;
+  let entries;
+  if (Array.isArray(headers)) {
+    entries = headers;
+  } else if (typeof headers.entries === "function") {
+    entries = Array.from(headers.entries());
+  } else {
+    entries = Object.entries(headers);
+  }
+  for (const [key, value] of entries) {
+    out[key] = SECRET_HEADER_NAMES.has(key.toLowerCase()) ? "***REDACTED***" : String(value);
+  }
+  return out;
+}
+async function writeUpstreamTrace(record) {
+  const path = tracePath;
+  if (!path) return;
+  try {
+    await _promises.mkdir.call(void 0, _path.dirname.call(void 0, path), { recursive: true });
+    await _promises.appendFile.call(void 0, path, JSON.stringify(record) + "\n", "utf8");
+  } catch (e) {
+  }
+}
+function __resetUpstreamTraceForTests() {
+  tracePath = null;
+}
+
+
+
+
+
+
+
+exports.setUpstreamTracePath = setUpstreamTracePath; exports.getUpstreamTracePath = getUpstreamTracePath; exports.redactHeaders = redactHeaders; exports.writeUpstreamTrace = writeUpstreamTrace; exports.__resetUpstreamTraceForTests = __resetUpstreamTraceForTests;

package/dist/{chunk-4VAVYUZS.cjs → chunk-4XMYPW46.cjs}

@@ -237,6 +237,14 @@ function convertOpenAIResponseToAnthropic(openaiResponse) {
   }
   const message = choice.message;
   const content = [];
+  const thinking = message.thinking;
+  if (_optionalChain([thinking, 'optionalAccess', _13 => _13.content])) {
+    content.push({
+      type: "thinking",
+      thinking: thinking.content,
+      signature: thinking.signature
+    });
+  }
   if (message.content) {
     content.push({
       type: "text",
@@ -244,7 +252,7 @@ function convertOpenAIResponseToAnthropic(openaiResponse) {
     });
   }
   const toolCalls = message.tool_calls;
-  if (_optionalChain([toolCalls, 'optionalAccess', _13 => _13.length])) {
+  if (_optionalChain([toolCalls, 'optionalAccess', _14 => _14.length])) {
     for (const toolCall of toolCalls) {
       const func = toolCall.function;
       let parsedInput = {};
@@ -262,14 +270,6 @@ function convertOpenAIResponseToAnthropic(openaiResponse) {
       });
     }
   }
-  const thinking = message.thinking;
-  if (_optionalChain([thinking, 'optionalAccess', _14 => _14.content])) {
-    content.push({
-      type: "thinking",
-      thinking: thinking.content,
-      signature: thinking.signature
-    });
-  }
   const finishReason = choice.finish_reason;
   const stopReasonMapping = {
     stop: "end_turn",

package/dist/{chunk-S4WBV25P.js → chunk-6QZGDLL4.js}

@@ -321,6 +321,7 @@ function handleStreamResponse(response, providerName, logger) {
   let pendingContent = "";
   let contentIndex = 0;
   let toolCallIndex = -1;
+  let textBuffered = false;
   const stream = new ReadableStream({
     async start(controller) {
       const reader = response.body.getReader();
@@ -338,6 +339,7 @@ function handleStreamResponse(response, providerName, logger) {
           }
           const candidate = chunk.candidates[0];
           const parts = candidate.content?.parts || [];
+          textBuffered = false;
           parts.filter((part) => part.text && part.thought === true).forEach((part) => {
             hasThinkingContent = true;
             const thinkingChunk = createChunk({
@@ -415,7 +417,7 @@ function handleStreamResponse(response, providerName, logger) {
           if (hasThinkingContent && textContent && !signatureSent) {
             if (chunk.modelVersion?.includes("3")) {
               pendingContent += textContent;
-              return;
+              textBuffered = true;
             } else {
               const signatureChunk = createChunk({
                 responseId: chunk.responseId,
@@ -433,7 +435,7 @@ function handleStreamResponse(response, providerName, logger) {
               signatureSent = true;
             }
           }
-          if (textContent) {
+          if (textContent && !textBuffered) {
             if (!pendingContent) contentIndex++;
             const contentChunk = createChunk({
               responseId: chunk.responseId,
@@ -854,35 +856,116 @@ function transformRequestOut(request) {
     tool_choice: toolChoice
   };
   if (Array.isArray(contents)) {
+    const toolCallIdsByName = /* @__PURE__ */ new Map();
     for (const content of contents) {
       if (typeof content === "string") {
-        unifiedRequest.messages.push({
-          role: "user",
-          content
-        });
-      } else if ("text" in content && typeof content.text === "string") {
+        unifiedRequest.messages.push({ role: "user", content });
+        continue;
+      }
+      if (content && typeof content === "object" && "text" in content && typeof content.text === "string" && !("parts" in content)) {
         unifiedRequest.messages.push({
           role: "user",
           content: content.text || null
         });
-      } else if ("role" in content && content.role === "user") {
-        const geminiContent = content;
-        unifiedRequest.messages.push({
-          role: "user",
-          content: geminiContent.parts?.map((part) => ({
-            type: "text",
-            text: part.text || ""
-          })) || []
-        });
-      } else if (content.role === "model") {
+        continue;
+      }
+      if (!content || typeof content !== "object" || !("role" in content)) {
+        continue;
+      }
+      const geminiContent = content;
+      const isModel = geminiContent.role === "model";
+      const role = isModel ? "assistant" : "user";
+      const parts = geminiContent.parts ?? [];
+      const functionResponses = [];
+      const functionCalls = [];
+      const textParts = [];
+      const contentParts = [];
+      let thinkingText = "";
+      let signature;
+      for (const part of parts) {
+        if ("thoughtSignature" in part) {
+          signature = part.thoughtSignature;
+        }
+        if ("functionResponse" in part) {
+          functionResponses.push(part);
+        } else if ("functionCall" in part) {
+          functionCalls.push(part);
+        } else if ("inlineData" in part || "file_data" in part) {
+          const inline = part.inlineData;
+          const fileData = part.file_data;
+          if (inline?.data) {
+            const mime = inline.mime_type || "image/png";
+            contentParts.push({
+              type: "image_url",
+              image_url: { url: `data:${mime};base64,${inline.data}` },
+              media_type: mime
+            });
+          } else if (fileData?.file_uri) {
+            contentParts.push({
+              type: "image_url",
+              image_url: { url: fileData.file_uri },
+              media_type: fileData.mime_type
+            });
+          }
+        } else if ("text" in part) {
+          if (part.thought === true) {
+            thinkingText += part.text ?? "";
+          } else {
+            textParts.push(part);
+          }
+        }
+      }
+      for (const fr of functionResponses) {
+        const fnName = fr.functionResponse.name ?? "";
+        const queue = toolCallIdsByName.get(fnName);
+        const id = queue && queue.length > 0 ? queue.shift() : `tool_${Math.random().toString(36).substring(2, 15)}`;
+        const response = fr.functionResponse.response;
+        const result = response?.result;
+        const toolContent = typeof result === "string" ? result : result !== void 0 ? JSON.stringify(result) : response !== void 0 ? JSON.stringify(response) : "";
         unifiedRequest.messages.push({
-          role: "assistant",
-          content: content.parts?.map((part) => ({
-            type: "text",
-            text: part.text || ""
-          })) || []
+          role: "tool",
+          tool_call_id: id,
+          content: toolContent
         });
       }
+      const toolCalls = functionCalls.map((p) => {
+        const id = p.functionCall.id || `tool_${Math.random().toString(36).substring(2, 15)}`;
+        if (p.functionCall.name) {
+          const arr = toolCallIdsByName.get(p.functionCall.name) ?? [];
+          arr.push(id);
+          toolCallIdsByName.set(p.functionCall.name, arr);
+        }
+        return {
+          id,
+          type: "function",
+          function: {
+            name: p.functionCall.name,
+            arguments: JSON.stringify(p.functionCall.args ?? {})
+          }
+        };
+      });
+      const onlyToolResults = functionResponses.length > 0 && textParts.length === 0 && functionCalls.length === 0 && contentParts.length === 0 && !thinkingText && !signature;
+      if (onlyToolResults) continue;
+      let messageContent;
+      if (contentParts.length > 0) {
+        messageContent = [
+          ...textParts.map((p) => ({ type: "text", text: p.text })),
+          ...contentParts
+        ];
+      } else {
+        messageContent = textParts.map((p) => p.text).join("\n") || null;
+      }
+      const message = {
+        role,
+        content: messageContent
+      };
+      if (toolCalls.length > 0) {
+        message.tool_calls = toolCalls;
+      }
+      if (signature || thinkingText) {
+        message.thinking = { content: thinkingText || "", signature };
+      }
+      unifiedRequest.messages.push(message);
     }
   }
   if (Array.isArray(tools)) {
@@ -895,7 +978,7 @@ function transformRequestOut(request) {
             function: {
               name: funcDecl.name,
               description: funcDecl.description ?? "",
-              parameters: funcDecl.parameters ?? {}
+              parameters: funcDecl.parameters ?? funcDecl.parametersJsonSchema ?? {}
             }
           });
         }

package/dist/{chunk-C72S6TTV.cjs → chunk-7FEBOPJO.cjs}

@@ -15,10 +15,11 @@ var OpenCodeGoTransformer = (_class = class {constructor() { _class.prototype.__
   async transformRequestIn(request, _provider, _context) {
     const messages = request.messages.map((m) => {
       const content = m.content;
-      if (Array.isArray(content) && content.length === 1 && _optionalChain([content, 'access', _ => _[0], 'optionalAccess', _2 => _2.type]) === "text") {
-        return { ...m, content: content[0].text };
-      }
-      return m;
+      const normalizedContent = Array.isArray(content) && content.length === 1 && _optionalChain([content, 'access', _ => _[0], 'optionalAccess', _2 => _2.type]) === "text" ? content[0].text : content;
+      const out2 = { role: m.role, content: normalizedContent };
+      if (m.tool_calls) out2.tool_calls = m.tool_calls;
+      if (m.tool_call_id) out2.tool_call_id = m.tool_call_id;
+      return out2;
     });
     const out = {
       model: request.model,