@omnicross/core 0.1.10 → 0.2.1

package/dist/{chunk-ZY6KU6P3.js → chunk-HOMUGKHR.js}

@@ -1,10 +1,10 @@
-import {
-  resolveApiFormat
-} from "./chunk-H5JUT3KV.js";
 import {
   OPENROUTER_APP_HEADERS,
   isOpenRouterProvider
 } from "./chunk-HUZZZ3JL.js";
+import {
+  resolveApiFormat
+} from "./chunk-H5JUT3KV.js";
 
 // 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":

package/dist/{chunk-AOFWNWLT.cjs → chunk-IUL4VWNU.cjs}

@@ -191,6 +191,27 @@ function resolveRequestReasoning(request, provider, options = {}) {
   return { ...intent, effort: plan.effort, enabled: plan.enabled };
 }
 
+// src/transformer/transformWarnings.ts
+var droppedFieldCounts = {};
+var warnedOnce = /* @__PURE__ */ new Set();
+function recordDroppedField(request, field, target) {
+  attachTransformWarnings(request).push({ field, target });
+  const key = `${field}\0${target}`;
+  droppedFieldCounts[key] = (_nullishCoalesce(droppedFieldCounts[key], () => ( 0))) + 1;
+  if (!warnedOnce.has(key)) {
+    warnedOnce.add(key);
+    console.warn(
+      `[transform] dropped_field: '${field}' has no representation on the '${target}' wire (counting; values never logged)`
+    );
+  }
+}
+function attachTransformWarnings(request) {
+  const holder = request;
+  holder._transformWarnings ??= [];
+  return holder._transformWarnings;
+}
+
+
 
 
 
@@ -200,4 +221,4 @@ function resolveRequestReasoning(request, provider, options = {}) {
 
 
 
-exports.THINK_LEVELS = THINK_LEVELS; exports.normalizeThinkLevel = normalizeThinkLevel; exports.extractReasoningIntent = extractReasoningIntent; exports.resolveTargetModelCapabilities = resolveTargetModelCapabilities; exports.resolveReasoningEffort = resolveReasoningEffort; exports.resolveReasoningTokenLimit = resolveReasoningTokenLimit; exports.resolveReasoningPlan = resolveReasoningPlan; exports.resolveRequestReasoning = resolveRequestReasoning;
+exports.THINK_LEVELS = THINK_LEVELS; exports.normalizeThinkLevel = normalizeThinkLevel; exports.extractReasoningIntent = extractReasoningIntent; exports.resolveTargetModelCapabilities = resolveTargetModelCapabilities; exports.resolveReasoningEffort = resolveReasoningEffort; exports.resolveReasoningTokenLimit = resolveReasoningTokenLimit; exports.resolveReasoningPlan = resolveReasoningPlan; exports.resolveRequestReasoning = resolveRequestReasoning; exports.recordDroppedField = recordDroppedField;

package/dist/{chunk-5LNYGCIW.cjs → chunk-KIQ2HA2A.cjs}

@@ -3,7 +3,7 @@
 
 
 
-var _chunkRICPANBYcjs = require('./chunk-RICPANBY.cjs');
+var _chunkWX2E2G7Hcjs = require('./chunk-WX2E2G7H.cjs');
 
 // src/transformer/transformers/GeminiTransformer.ts
 var GeminiTransformer = (_class = class {
@@ -44,7 +44,7 @@ var GeminiTransformer = (_class = class {
    * Also builds the correct URL for the Gemini API
    */
   async transformRequestIn(request, provider, context) {
-    const body = _chunkRICPANBYcjs.buildRequestBody.call(void 0, 
+    const body = _chunkWX2E2G7Hcjs.buildRequestBody.call(void 0, 
       request,
       provider,
       context.reasoningSourceFormat === this.name
@@ -69,7 +69,7 @@ var GeminiTransformer = (_class = class {
    * (For requests coming into the Gemini endpoint)
    */
   async transformRequestOut(request, context) {
-    const unifiedRequest = _chunkRICPANBYcjs.transformRequestOut.call(void 0, request);
+    const unifiedRequest = _chunkWX2E2G7Hcjs.transformRequestOut.call(void 0, request);
     if (_optionalChain([unifiedRequest, 'access', _2 => _2.reasoning, 'optionalAccess', _3 => _3.effort])) {
       context.reasoningSourceFormat = this.name;
     }
@@ -79,14 +79,14 @@ var GeminiTransformer = (_class = class {
    * Transform Gemini response to OpenAI-compatible format
    */
   async transformResponseOut(response, _context) {
-    return _chunkRICPANBYcjs.transformResponseOut.call(void 0, response, this.name, this.logger);
+    return _chunkWX2E2G7Hcjs.transformResponseOut.call(void 0, response, this.name, this.logger);
   }
   /**
    * Transform OpenAI-compatible response back to Gemini format
    * (For endpoint mode — returning Gemini-format responses to the client)
    */
   async transformResponseIn(response, _context) {
-    return _chunkRICPANBYcjs.transformResponseIn.call(void 0, response, this.logger);
+    return _chunkWX2E2G7Hcjs.transformResponseIn.call(void 0, response, this.logger);
   }
 }, _class.__initStatic(), _class);
 

package/dist/{chunk-MUHWHQVM.cjs → chunk-KQBLZMP6.cjs}

@@ -12,9 +12,10 @@ async function executeProviderCall(ctx) {
     prepareBody,
     fetchFn,
     runResponseChain = false,
-    responseChainRequest
+    responseChainRequest,
+    preserveEndpointRequestForResponseChain = false
   } = ctx;
-  const { requestBody, config } = await executor.executeRequestChain(
+  const { requestBody, endpointRequest, config } = await executor.executeRequestChain(
     request,
     provider,
     chain,
@@ -34,7 +35,7 @@ async function executeProviderCall(ctx) {
       // unified ingresses → their pre-transform request. The caller supplies
       // it via `responseChainRequest`; fall back to `requestBody` (the proxy
       // shape) so the contract is never silently `undefined`.
-      _nullishCoalesce(responseChainRequest, () => ( requestBody)),
+      _nullishCoalesce(_nullishCoalesce(responseChainRequest, () => ( (preserveEndpointRequestForResponseChain ? endpointRequest : void 0))), () => ( requestBody)),
       fetched,
       provider,
       chain,

package/dist/chunk-LFEH7CEO.js

@@ -0,0 +1,384 @@
+// src/transformer/transformers/AnthropicOpenAIToAnthropicStream.ts
+var DEFAULT_ANTHROPIC_PING_HEARTBEAT_MS = 2e4;
+var anthropicPingHeartbeatMs = DEFAULT_ANTHROPIC_PING_HEARTBEAT_MS;
+function setAnthropicPingHeartbeatMs(ms) {
+  anthropicPingHeartbeatMs = typeof ms === "number" && Number.isFinite(ms) ? ms : DEFAULT_ANTHROPIC_PING_HEARTBEAT_MS;
+}
+function getAnthropicPingHeartbeatMs() {
+  return anthropicPingHeartbeatMs;
+}
+var stopReasonContentFilterCount = 0;
+function __resetStopReasonContentFilterCountForTests() {
+  stopReasonContentFilterCount = 0;
+}
+function noteContentFilterRemap(logger) {
+  stopReasonContentFilterCount += 1;
+  console.warn(
+    `[AnthropicStream] upstream finish_reason=content_filter remapped to stop_reason=refusal (count ${stopReasonContentFilterCount})`
+  );
+  logger?.warn?.("upstream finish_reason=content_filter remapped to stop_reason=refusal");
+}
+function sniffErrorType(error) {
+  let text;
+  try {
+    text = JSON.stringify(error) ?? "";
+  } catch {
+    text = String(error);
+  }
+  const lower = text.toLowerCase();
+  if (lower.includes("overload") || lower.includes("capacity") || lower.includes("server_error")) {
+    return "overloaded_error";
+  }
+  const e = error;
+  for (const raw of [e?.status, e?.code]) {
+    const n = typeof raw === "string" ? Number.parseInt(raw, 10) : raw;
+    if (typeof n === "number" && Number.isFinite(n) && n >= 500) return "overloaded_error";
+  }
+  return "api_error";
+}
+function convertOpenAIStreamToAnthropic(openaiStream, _context, logger) {
+  const decoder = new TextDecoder();
+  const encoder = new TextEncoder();
+  let hasStarted = false;
+  let hasTextContentStarted = false;
+  let isThinkingStarted = false;
+  let contentIndex = 0;
+  let currentContentBlockIndex = -1;
+  const toolCallIndexToContentBlockIndex = /* @__PURE__ */ new Map();
+  let reader = null;
+  return new ReadableStream({
+    start: async (controller) => {
+      reader = openaiStream.getReader();
+      let buffer = "";
+      const messageId = `msg_${Date.now()}`;
+      let model = "unknown";
+      let isClosed = false;
+      let stopReasonDelta = null;
+      const safeEnqueue = (data) => {
+        if (!isClosed) {
+          try {
+            controller.enqueue(encoder.encode(data));
+          } catch (_e) {
+            isClosed = true;
+          }
+        }
+      };
+      let pingTimer = null;
+      const clearPing = () => {
+        if (pingTimer !== null) {
+          clearTimeout(pingTimer);
+          pingTimer = null;
+        }
+      };
+      const armPing = () => {
+        clearPing();
+        const interval = getAnthropicPingHeartbeatMs();
+        if (!(interval > 0)) return;
+        pingTimer = setTimeout(() => {
+          pingTimer = null;
+          safeEnqueue(`event: ping
+data: ${JSON.stringify({ type: "ping" })}
+
+`);
+          armPing();
+        }, interval);
+        pingTimer.unref?.();
+      };
+      const assignContentBlockIndex = () => {
+        return contentIndex++;
+      };
+      const safeClose = () => {
+        if (isClosed) return;
+        if (currentContentBlockIndex >= 0) {
+          safeEnqueue(`event: content_block_stop
+data: ${JSON.stringify({
+            type: "content_block_stop",
+            index: currentContentBlockIndex
+          })}
+
+`);
+        }
+        if (stopReasonDelta) {
+          safeEnqueue(`event: message_delta
+data: ${JSON.stringify(stopReasonDelta)}
+
+`);
+        } else {
+          safeEnqueue(`event: message_delta
+data: ${JSON.stringify({
+            type: "message_delta",
+            delta: { stop_reason: "end_turn", stop_sequence: null },
+            usage: { input_tokens: 0, output_tokens: 0 }
+          })}
+
+`);
+        }
+        safeEnqueue(`event: message_stop
+data: ${JSON.stringify({ type: "message_stop" })}
+
+`);
+        try {
+          controller.close();
+        } catch (_e) {
+        }
+        isClosed = true;
+      };
+      try {
+        armPing();
+        while (true) {
+          const { done, value } = await reader.read();
+          if (done) break;
+          buffer += decoder.decode(value, { stream: true });
+          const lines = buffer.split("\n");
+          buffer = lines.pop() || "";
+          for (const line of lines) {
+            if (isClosed) break;
+            if (!line.startsWith("data:")) continue;
+            const data = line.slice(5).trim();
+            if (data === "[DONE]") continue;
+            try {
+              const chunk = JSON.parse(data);
+              if (chunk.error) {
+                safeEnqueue(`event: error
+data: ${JSON.stringify({
+                  type: "error",
+                  error: {
+                    type: sniffErrorType(chunk.error),
+                    message: JSON.stringify(chunk.error)
+                  }
+                })}
+
+`);
+                continue;
+              }
+              if (chunk.type === "response.failed" && chunk.response?.error) {
+                safeEnqueue(`event: error
+data: ${JSON.stringify({
+                  type: "error",
+                  error: {
+                    type: sniffErrorType(chunk.response.error),
+                    message: JSON.stringify(chunk.response.error)
+                  }
+                })}
+
+`);
+                continue;
+              }
+              model = chunk.model || model;
+              if (!hasStarted) {
+                hasStarted = true;
+                const startUsage = chunk.usage ? {
+                  input_tokens: (chunk.usage.prompt_tokens || 0) - (chunk.usage.prompt_tokens_details?.cached_tokens || 0),
+                  output_tokens: chunk.usage.completion_tokens || 0
+                } : { input_tokens: 0, output_tokens: 0 };
+                safeEnqueue(`event: message_start
+data: ${JSON.stringify({
+                  type: "message_start",
+                  message: {
+                    id: messageId,
+                    type: "message",
+                    role: "assistant",
+                    content: [],
+                    model,
+                    stop_reason: null,
+                    stop_sequence: null,
+                    usage: startUsage
+                  }
+                })}
+
+`);
+              }
+              const choice = chunk.choices?.[0];
+              if (!choice) continue;
+              if (chunk.usage) {
+                stopReasonDelta = {
+                  type: "message_delta",
+                  delta: { stop_reason: "end_turn", stop_sequence: null },
+                  usage: {
+                    input_tokens: (chunk.usage.prompt_tokens || 0) - (chunk.usage.prompt_tokens_details?.cached_tokens || 0),
+                    output_tokens: chunk.usage.completion_tokens || 0,
+                    cache_read_input_tokens: chunk.usage.prompt_tokens_details?.cached_tokens || 0
+                  }
+                };
+              }
+              if (choice.delta?.thinking) {
+                if (!isThinkingStarted) {
+                  const thinkingBlockIndex = assignContentBlockIndex();
+                  safeEnqueue(`event: content_block_start
+data: ${JSON.stringify({
+                    type: "content_block_start",
+                    index: thinkingBlockIndex,
+                    content_block: { type: "thinking", thinking: "" }
+                  })}
+
+`);
+                  currentContentBlockIndex = thinkingBlockIndex;
+                  isThinkingStarted = true;
+                }
+                if (choice.delta.thinking.signature) {
+                  safeEnqueue(`event: content_block_delta
+data: ${JSON.stringify({
+                    type: "content_block_delta",
+                    index: currentContentBlockIndex,
+                    delta: { type: "signature_delta", signature: choice.delta.thinking.signature }
+                  })}
+
+`);
+                  safeEnqueue(`event: content_block_stop
+data: ${JSON.stringify({
+                    type: "content_block_stop",
+                    index: currentContentBlockIndex
+                  })}
+
+`);
+                  currentContentBlockIndex = -1;
+                } else if (choice.delta.thinking.content) {
+                  safeEnqueue(`event: content_block_delta
+data: ${JSON.stringify({
+                    type: "content_block_delta",
+                    index: currentContentBlockIndex,
+                    delta: { type: "thinking_delta", thinking: choice.delta.thinking.content }
+                  })}
+
+`);
+                }
+              }
+              if (choice.delta?.content) {
+                if (!hasTextContentStarted) {
+                  if (currentContentBlockIndex >= 0 && isThinkingStarted) {
+                    safeEnqueue(`event: content_block_stop
+data: ${JSON.stringify({
+                      type: "content_block_stop",
+                      index: currentContentBlockIndex
+                    })}
+
+`);
+                  }
+                  hasTextContentStarted = true;
+                  const textBlockIndex = assignContentBlockIndex();
+                  safeEnqueue(`event: content_block_start
+data: ${JSON.stringify({
+                    type: "content_block_start",
+                    index: textBlockIndex,
+                    content_block: { type: "text", text: "" }
+                  })}
+
+`);
+                  currentContentBlockIndex = textBlockIndex;
+                }
+                safeEnqueue(`event: content_block_delta
+data: ${JSON.stringify({
+                  type: "content_block_delta",
+                  index: currentContentBlockIndex,
+                  delta: { type: "text_delta", text: choice.delta.content }
+                })}
+
+`);
+              }
+              if (choice.delta?.tool_calls) {
+                for (const toolCall of choice.delta.tool_calls) {
+                  const toolCallIndex = toolCall.index ?? 0;
+                  if (!toolCallIndexToContentBlockIndex.has(toolCallIndex)) {
+                    if (currentContentBlockIndex >= 0) {
+                      safeEnqueue(`event: content_block_stop
+data: ${JSON.stringify({
+                        type: "content_block_stop",
+                        index: currentContentBlockIndex
+                      })}
+
+`);
+                      hasTextContentStarted = false;
+                    }
+                    const newBlockIndex = assignContentBlockIndex();
+                    toolCallIndexToContentBlockIndex.set(toolCallIndex, newBlockIndex);
+                    safeEnqueue(`event: content_block_start
+data: ${JSON.stringify({
+                      type: "content_block_start",
+                      index: newBlockIndex,
+                      content_block: {
+                        type: "tool_use",
+                        id: toolCall.id || `call_${Date.now()}_${toolCallIndex}`,
+                        name: toolCall.function?.name || `tool_${toolCallIndex}`,
+                        input: {}
+                      }
+                    })}
+
+`);
+                    currentContentBlockIndex = newBlockIndex;
+                  }
+                  if (toolCall.function?.arguments) {
+                    const blockIndex = toolCallIndexToContentBlockIndex.get(toolCallIndex);
+                    if (blockIndex !== void 0) {
+                      safeEnqueue(`event: content_block_delta
+data: ${JSON.stringify({
+                        type: "content_block_delta",
+                        index: blockIndex,
+                        delta: { type: "input_json_delta", partial_json: toolCall.function.arguments }
+                      })}
+
+`);
+                    }
+                  }
+                }
+              }
+              if (choice.finish_reason) {
+                if (choice.finish_reason === "content_filter") {
+                  noteContentFilterRemap(logger);
+                }
+                const stopReasonMapping = {
+                  stop: "end_turn",
+                  length: "max_tokens",
+                  tool_calls: "tool_use",
+                  content_filter: "refusal",
+                  refusal: "refusal",
+                  pause_turn: "pause_turn"
+                };
+                stopReasonDelta = {
+                  type: "message_delta",
+                  delta: {
+                    stop_reason: stopReasonMapping[choice.finish_reason] || "end_turn",
+                    stop_sequence: null
+                  },
+                  usage: {
+                    input_tokens: (chunk.usage?.prompt_tokens || 0) - (chunk.usage?.prompt_tokens_details?.cached_tokens || 0),
+                    output_tokens: chunk.usage?.completion_tokens || 0,
+                    cache_read_input_tokens: chunk.usage?.prompt_tokens_details?.cached_tokens || 0
+                  }
+                };
+              }
+            } catch (e) {
+              logger?.error("Error parsing stream chunk:", e);
+            }
+          }
+          armPing();
+        }
+      } catch (e) {
+        if (!isClosed) {
+          controller.error(e);
+        }
+      } finally {
+        clearPing();
+        safeClose();
+        reader.releaseLock();
+      }
+    },
+    // R6: client disconnect. Cancelling the upstream reader settles the pending
+    // read(), which unblocks the loop's `finally` → `clearPing` — the timer is
+    // cleared INDIRECTLY (pinned by the cancel-leak fake-timer test).
+    cancel: async () => {
+      try {
+        await reader?.cancel();
+      } catch (_e) {
+      }
+    }
+  });
+}
+
+export {
+  DEFAULT_ANTHROPIC_PING_HEARTBEAT_MS,
+  setAnthropicPingHeartbeatMs,
+  getAnthropicPingHeartbeatMs,
+  stopReasonContentFilterCount,
+  __resetStopReasonContentFilterCountForTests,
+  convertOpenAIStreamToAnthropic
+};