@omnicross/core 0.1.5 → 0.1.7

package/dist/{chunk-VACWOIRE.cjs → chunk-4VZX5F4T.cjs}

@@ -89,18 +89,6 @@ function validateEndpointModelConfig(config) {
     (kind) => !isNonBlankRef(map[kind])
   );
 }
-function validateServerModelConfig(config) {
-  const errors = [];
-  for (const endpoint of Object.keys(_chunk4IH4EL7Mcjs.ENDPOINT_MODEL_KINDS)) {
-    const ep = config.endpoints.find((e) => e.endpoint === endpoint);
-    const declared = modelKindsForEndpoint(endpoint);
-    const missingKinds = ep ? validateEndpointModelConfig(ep) : [...declared];
-    if (missingKinds.length > 0 && missingKinds.length < declared.length) {
-      errors.push({ endpoint, missingKinds });
-    }
-  }
-  return errors;
-}
 
 // src/outbound-api/modelPrefixDispatch.ts
 function classifyModelPrefix(model) {
@@ -149,6 +137,34 @@ function endpointSupportsSubscription(endpoint) {
 }
 
 // src/outbound-api/routeResolver.ts
+function bindDelegatedSubscriptionProfile(profile, config) {
+  const preferredAccountId = config.boundAccountId;
+  const preferredAccountGroup = config.boundAccountGroup;
+  const boundAccountFallbackPolicy = config.boundAccountFallbackPolicy;
+  if (!preferredAccountId && !preferredAccountGroup) return profile;
+  const strategy = profile.authStrategy;
+  return {
+    ...profile,
+    authStrategy: {
+      kind: strategy.kind,
+      providerId: strategy.providerId,
+      applyHeaders(headers, hints) {
+        return strategy.applyHeaders(headers, {
+          ...hints,
+          preferredAccountId,
+          preferredAccountGroup,
+          boundAccountFallbackPolicy
+        });
+      },
+      onUnauthorized(sessionKey) {
+        return strategy.onUnauthorized(sessionKey);
+      },
+      describeStatus() {
+        return strategy.describeStatus();
+      }
+    }
+  };
+}
 function parseModelRef(ref) {
   if (!ref) return null;
   const idx = ref.indexOf(",");
@@ -267,6 +283,8 @@ async function resolveRoute(args) {
       apiKey: resolveApiKey(provider.api_key),
       isOfficialProvider,
       passThrough: false,
+      preferredKeyId: config.boundKeyId,
+      boundKeyFallbackPolicy: config.boundKeyFallbackPolicy,
       attribution: { sessionId, apiKeyId: _nullishCoalesce(args.apiKeyId, () => ( null)) }
     };
   }
@@ -277,6 +295,8 @@ async function resolveRoute(args) {
     ingressFormat,
     authMode: "byo",
     providerId,
+    preferredKeyId: config.boundKeyId,
+    boundKeyFallbackPolicy: config.boundKeyFallbackPolicy,
     // Passthrough gate: the client's ORIGINAL requested id (kind-mapped only).
     requestedModel,
     // Usage attribution: the verified named-key id (undefined for internal traffic).
@@ -321,7 +341,10 @@ async function resolveSubscriptionRoute(args) {
     apiKey: "",
     isOfficialProvider: false,
     passThrough: false,
-    subscriptionProfile: profile,
+    subscriptionProfile: bindDelegatedSubscriptionProfile(profile, config),
+    preferredAccountId: config.boundAccountId,
+    preferredAccountGroup: config.boundAccountGroup,
+    boundAccountFallbackPolicy: config.boundAccountFallbackPolicy,
     attribution: { sessionId, apiKeyId: _nullishCoalesce(apiKeyId, () => ( null)) }
   };
   const subscriptionConfig = providerId === "opencodego" ? await _optionalChain([registry, 'optionalAccess', _9 => _9.getOpenCodeGoConfig, 'optionalCall', _10 => _10()]) : void 0;
@@ -353,6 +376,8 @@ async function resolveSubscriptionRoute(args) {
     subscriptionConfig,
     // Per-request preferred account (provider/subscription duality); undefined ⇒ pool.
     preferredAccountId: config.boundAccountId,
+    preferredAccountGroup: config.boundAccountGroup,
+    boundAccountFallbackPolicy: config.boundAccountFallbackPolicy,
     anthropicSdkHints: hints
   };
   return { ok: true, route, usedRole: effectiveRole };
@@ -381,5 +406,4 @@ function resolveApiKey(apiKey) {
 
 
 
-
-exports.extractRequestedModel = extractRequestedModel; exports.detectRequestRole = detectRequestRole; exports.endpointToIngressFormat = endpointToIngressFormat; exports.isKindMappedEndpoint = isKindMappedEndpoint; exports.modelKindsForEndpoint = modelKindsForEndpoint; exports.detectModelKind = detectModelKind; exports.validateEndpointModelConfig = validateEndpointModelConfig; exports.validateServerModelConfig = validateServerModelConfig; exports.classifyModelPrefix = classifyModelPrefix; exports.resolvePrefixTarget = resolvePrefixTarget; exports.SUBSCRIPTION_PROVIDER_IDS = SUBSCRIPTION_PROVIDER_IDS; exports.isSubscriptionProviderId = isSubscriptionProviderId; exports.endpointSupportsSubscription = endpointSupportsSubscription; exports.parseModelRef = parseModelRef; exports.pickModelRefFromList = pickModelRefFromList; exports.resolveRoute = resolveRoute;
+exports.extractRequestedModel = extractRequestedModel; exports.detectRequestRole = detectRequestRole; exports.endpointToIngressFormat = endpointToIngressFormat; exports.isKindMappedEndpoint = isKindMappedEndpoint; exports.modelKindsForEndpoint = modelKindsForEndpoint; exports.detectModelKind = detectModelKind; exports.validateEndpointModelConfig = validateEndpointModelConfig; exports.classifyModelPrefix = classifyModelPrefix; exports.resolvePrefixTarget = resolvePrefixTarget; exports.SUBSCRIPTION_PROVIDER_IDS = SUBSCRIPTION_PROVIDER_IDS; exports.isSubscriptionProviderId = isSubscriptionProviderId; exports.endpointSupportsSubscription = endpointSupportsSubscription; exports.parseModelRef = parseModelRef; exports.pickModelRefFromList = pickModelRefFromList; exports.resolveRoute = resolveRoute;

package/dist/{chunk-5ZQBEOMD.js → chunk-5NJLQ6T6.js}

@@ -59,8 +59,42 @@ function hasThinkingEnabled(request) {
   }
   return false;
 }
+function flattenToolResultContent(content) {
+  if (typeof content === "string") return content;
+  if (content == null) return "";
+  if (!Array.isArray(content)) return JSON.stringify(content);
+  const parts = [];
+  for (const block of content) {
+    if (typeof block === "string") {
+      parts.push(block);
+      continue;
+    }
+    if (!block || typeof block !== "object") continue;
+    const typed = block;
+    if (typed.type === "image" || typed.type === "image_url") {
+      parts.push("[image omitted]");
+    } else if (typeof typed.text === "string") {
+      parts.push(typed.text);
+    }
+  }
+  return parts.filter((text) => text !== "").join("\n");
+}
 
 // src/api-converter/anthropic-to-openai.ts
+function anthropicUsageToChatUsage(usage) {
+  const input = usage.input_tokens || 0;
+  const output = usage.output_tokens || 0;
+  const cacheRead = usage.cache_read_input_tokens || 0;
+  const cacheCreation = usage.cache_creation_input_tokens || 0;
+  const promptTokens = input + cacheRead + cacheCreation;
+  const out = {
+    prompt_tokens: promptTokens,
+    completion_tokens: output,
+    total_tokens: promptTokens + output
+  };
+  if (cacheRead > 0) out.prompt_tokens_details = { cached_tokens: cacheRead };
+  return out;
+}
 function convertAnthropicToOpenAI(response) {
   const content = [];
   const toolCalls = [];
@@ -98,11 +132,7 @@ function convertAnthropicToOpenAI(response) {
         finish_reason: finishReason
       }
     ],
-    usage: {
-      prompt_tokens: response.usage.input_tokens,
-      completion_tokens: response.usage.output_tokens,
-      total_tokens: response.usage.input_tokens + response.usage.output_tokens
-    }
+    usage: anthropicUsageToChatUsage(response.usage)
   };
   if (reasoningContent) {
     result.reasoning_content = reasoningContent;
@@ -158,7 +188,7 @@ function convertAnthropicRequestToOpenAI(request) {
           });
         } else if (part.type === "tool_result") {
           toolResultId = part.tool_use_id;
-          toolResultContent = typeof part.content === "string" ? part.content : JSON.stringify(part.content);
+          toolResultContent = flattenToolResultContent(part.content);
         }
       }
       if (toolResultId && toolResultContent !== void 0) {
@@ -332,11 +362,12 @@ async function* convertAnthropicStreamToOpenAI(anthropicStream) {
                 delta: {},
                 finish_reason: finishReason
               }],
-              usage: event.usage ? {
-                prompt_tokens: event.usage.input_tokens || 0,
-                completion_tokens: event.usage.output_tokens || 0,
-                total_tokens: (event.usage.input_tokens || 0) + (event.usage.output_tokens || 0)
-              } : void 0
+              usage: event.usage ? anthropicUsageToChatUsage({
+                input_tokens: event.usage.input_tokens || 0,
+                output_tokens: event.usage.output_tokens || 0,
+                cache_read_input_tokens: event.usage.cache_read_input_tokens,
+                cache_creation_input_tokens: event.usage.cache_creation_input_tokens
+              }) : void 0
             })}
 
 `;
@@ -368,7 +399,10 @@ function convertOpenAIToAnthropic(request, config) {
       const toolResult = {
         type: "tool_result",
         tool_use_id: msg.tool_call_id,
-        content: typeof msg.content === "string" ? msg.content : JSON.stringify(msg.content)
+        // An OpenAI tool message is normally a plain string, but a parts array
+        // must be flattened to text rather than stringified into a literal
+        // `[{"type":"text",…}]` envelope the model then has to read.
+        content: flattenToolResultContent(msg.content)
       };
       const lastMsg = messages[messages.length - 1];
       if (lastMsg && lastMsg.role === "user" && Array.isArray(lastMsg.content)) {

package/dist/chunk-5RSZYQJH.cjs

@@ -0,0 +1,62 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true}); 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; }// src/transformer/transformers/utils/usage-mapping.ts
+function num(obj, key) {
+  const v = _optionalChain([obj, 'optionalAccess', _ => _[key]]);
+  return typeof v === "number" && Number.isFinite(v) ? v : 0;
+}
+function detailCachedTokens(obj, detailKey) {
+  const detail = _optionalChain([obj, 'optionalAccess', _2 => _2[detailKey]]);
+  return num(detail, "cached_tokens");
+}
+function anthropicUsageToChatUsage(usage) {
+  if (!usage) return void 0;
+  const input = num(usage, "input_tokens");
+  const output = num(usage, "output_tokens");
+  const cacheRead = num(usage, "cache_read_input_tokens");
+  const cacheCreation = num(usage, "cache_creation_input_tokens");
+  const promptTokens = input + cacheRead + cacheCreation;
+  const out = {
+    prompt_tokens: promptTokens,
+    completion_tokens: output,
+    total_tokens: promptTokens + output
+  };
+  if (cacheRead > 0) {
+    out.prompt_tokens_details = { cached_tokens: cacheRead };
+  }
+  return out;
+}
+function chatUsageToResponsesUsage(usage) {
+  if (!usage) return void 0;
+  const prompt = num(usage, "prompt_tokens");
+  const completion = num(usage, "completion_tokens");
+  const out = {
+    input_tokens: prompt,
+    output_tokens: completion,
+    total_tokens: num(usage, "total_tokens") || prompt + completion
+  };
+  const cacheRead = detailCachedTokens(usage, "prompt_tokens_details");
+  if (cacheRead > 0) {
+    out.input_tokens_details = { cached_tokens: cacheRead };
+  }
+  return out;
+}
+function responsesUsageToChatUsage(usage) {
+  if (!usage) return void 0;
+  const input = num(usage, "input_tokens");
+  const output = num(usage, "output_tokens");
+  const out = {
+    prompt_tokens: input,
+    completion_tokens: output,
+    total_tokens: num(usage, "total_tokens") || input + output
+  };
+  const cacheRead = detailCachedTokens(usage, "input_tokens_details");
+  if (cacheRead > 0) {
+    out.prompt_tokens_details = { cached_tokens: cacheRead };
+  }
+  return out;
+}
+
+
+
+
+
+exports.anthropicUsageToChatUsage = anthropicUsageToChatUsage; exports.chatUsageToResponsesUsage = chatUsageToResponsesUsage; exports.responsesUsageToChatUsage = responsesUsageToChatUsage;

package/dist/chunk-6QQG7YG3.cjs

@@ -0,0 +1,153 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true}); function _nullishCoalesce(lhs, rhsFn) { if (lhs != null) { return lhs; } else { return rhsFn(); } } var _class; var _class2;
+
+var _chunkHVBBDBS3cjs = require('./chunk-HVBBDBS3.cjs');
+
+// src/pipeline/AccountAllowanceScheduling.ts
+var DEFAULT_POLICY = {
+  enabled: false,
+  demoteAtPercent: 80,
+  pauseAtPercent: 98,
+  priorityPenalty: 100
+};
+var HISTORY_LIMIT = 200;
+var AccountAllowanceExhaustedError = (_class = class extends Error {
+  constructor(providerId, resumeAt) {
+    super(
+      resumeAt ? `All ${providerId} subscription accounts are paused by the allowance policy until ${resumeAt}` : `All ${providerId} subscription accounts are paused by the allowance policy`
+    );_class.prototype.__init.call(this);_class.prototype.__init2.call(this);;
+    this.providerId = providerId;
+    this.resumeAt = resumeAt;
+    this.name = "AccountAllowanceExhaustedError";
+  }
+  
+  
+  __init() {this.code = "account_allowance_exhausted"}
+  __init2() {this.status = 429}
+}, _class);
+function isAccountAllowanceExhaustedError(error) {
+  if (error instanceof AccountAllowanceExhaustedError) return true;
+  if (!error || typeof error !== "object") return false;
+  const value = error;
+  return value.code === "account_allowance_exhausted" && value.status === 429;
+}
+function freshWorstWindow(snapshot) {
+  return snapshot.windows.filter((window) => window.state === "fresh" && typeof window.usedPercent === "number").sort((left, right) => (_nullishCoalesce(right.usedPercent, () => ( -1))) - (_nullishCoalesce(left.usedPercent, () => ( -1))))[0];
+}
+var AccountAllowanceScheduling = (_class2 = class {
+  constructor(store = _chunkHVBBDBS3cjs.getSharedAccountAllowanceStore.call(void 0, ), now = Date.now) {;_class2.prototype.__init3.call(this);_class2.prototype.__init4.call(this);_class2.prototype.__init5.call(this);
+    this.store = store;
+    this.now = now;
+  }
+  
+  
+  __init3() {this.config = { ...DEFAULT_POLICY }}
+  __init4() {this.history = []}
+  __init5() {this.lastRecorded = /* @__PURE__ */ new Map()}
+  configure(config) {
+    this.config = config ? { ...config } : { ...DEFAULT_POLICY };
+  }
+  getConfig() {
+    return { ...this.config };
+  }
+  evaluate(providerId, accountId, basePriority, now = this.now()) {
+    const decision = this.decide(providerId, accountId, basePriority, now);
+    this.recordApplied(decision);
+    return decision;
+  }
+  /**
+   * Project the current policy result without recording an applied decision.
+   * Admin/read-model callers use this so polling an account list never creates
+   * synthetic demotion/pause history entries.
+   */
+  preview(providerId, accountId, basePriority, now = this.now()) {
+    return this.decide(providerId, accountId, basePriority, now);
+  }
+  decide(providerId, accountId, basePriority, now) {
+    const decidedAt = new Date(now).toISOString();
+    const base = {
+      providerId,
+      accountId,
+      basePriority,
+      effectivePriority: basePriority,
+      schedulable: true,
+      decidedAt
+    };
+    if (!this.config.enabled) return { ...base, action: "ignore", reason: "policy-disabled" };
+    if (providerId !== "claude" && providerId !== "codex") {
+      return { ...base, action: "ignore", reason: "provider-unsupported" };
+    }
+    const snapshot = this.store.get(providerId, accountId, now);
+    if (!snapshot) return { ...base, action: "ignore", reason: "snapshot-missing" };
+    const worst = freshWorstWindow(snapshot);
+    if (!worst || worst.usedPercent === null) {
+      return { ...base, action: "ignore", reason: "snapshot-not-fresh", observedAt: snapshot.observedAt };
+    }
+    const resumeAt = _nullishCoalesce(worst.resetsAt, () => ( snapshot.expiresAt));
+    const resumeMs = resumeAt ? Date.parse(resumeAt) : Number.NaN;
+    const canPauseUntilKnownDeadline = Number.isFinite(resumeMs) && resumeMs > now;
+    let decision;
+    if (worst.usedPercent >= this.config.pauseAtPercent && canPauseUntilKnownDeadline) {
+      decision = {
+        ...base,
+        action: "pause",
+        reason: "pause-threshold",
+        schedulable: false,
+        usedPercent: worst.usedPercent,
+        observedAt: snapshot.observedAt,
+        resumeAt
+      };
+    } else if (worst.usedPercent >= this.config.demoteAtPercent) {
+      decision = {
+        ...base,
+        action: "demote",
+        reason: "demote-threshold",
+        effectivePriority: basePriority + this.config.priorityPenalty,
+        usedPercent: worst.usedPercent,
+        observedAt: snapshot.observedAt,
+        resumeAt: canPauseUntilKnownDeadline ? resumeAt : void 0
+      };
+    } else {
+      decision = {
+        ...base,
+        action: "normal",
+        reason: "below-threshold",
+        usedPercent: worst.usedPercent,
+        observedAt: snapshot.observedAt,
+        resumeAt: canPauseUntilKnownDeadline ? resumeAt : void 0
+      };
+    }
+    return decision;
+  }
+  getHistory() {
+    return this.history.map((decision) => ({ ...decision }));
+  }
+  clearHistory() {
+    this.history.length = 0;
+    this.lastRecorded.clear();
+  }
+  recordApplied(decision) {
+    if (decision.action !== "demote" && decision.action !== "pause") return;
+    const key = `${decision.providerId}\0${decision.accountId}`;
+    const signature = `${decision.action}\0${_nullishCoalesce(decision.observedAt, () => ( ""))}\0${_nullishCoalesce(decision.usedPercent, () => ( ""))}`;
+    if (this.lastRecorded.get(key) === signature) return;
+    this.lastRecorded.set(key, signature);
+    this.history.push({ ...decision });
+    if (this.history.length > HISTORY_LIMIT) this.history.splice(0, this.history.length - HISTORY_LIMIT);
+  }
+}, _class2);
+var sharedScheduling = null;
+function getSharedAccountAllowanceScheduling() {
+  if (!sharedScheduling) sharedScheduling = new AccountAllowanceScheduling();
+  return sharedScheduling;
+}
+function __resetSharedAccountAllowanceSchedulingForTests() {
+  sharedScheduling = null;
+}
+
+
+
+
+
+
+
+exports.AccountAllowanceExhaustedError = AccountAllowanceExhaustedError; exports.isAccountAllowanceExhaustedError = isAccountAllowanceExhaustedError; exports.AccountAllowanceScheduling = AccountAllowanceScheduling; exports.getSharedAccountAllowanceScheduling = getSharedAccountAllowanceScheduling; exports.__resetSharedAccountAllowanceSchedulingForTests = __resetSharedAccountAllowanceSchedulingForTests;

package/dist/{chunk-IFXJ2BG7.js → chunk-7C7DET6S.js}

@@ -11,6 +11,29 @@ import {
 
 // src/outbound-api/auditCapture.ts
 import { randomUUID } from "crypto";
+function completeUtf8PrefixLength(buf) {
+  if (buf.length === 0) return 0;
+  let leadIndex = buf.length - 1;
+  while (leadIndex >= 0 && (buf[leadIndex] & 192) === 128) leadIndex -= 1;
+  if (leadIndex < 0) return 0;
+  const lead = buf[leadIndex];
+  let expectedLength = 1;
+  if ((lead & 224) === 192) expectedLength = 2;
+  else if ((lead & 240) === 224) expectedLength = 3;
+  else if ((lead & 248) === 240) expectedLength = 4;
+  return buf.length - leadIndex < expectedLength ? leadIndex : buf.length;
+}
+function truncateToBytes(text, maxBytes) {
+  if (maxBytes < 0) return text;
+  const buf = Buffer.from(text, "utf8");
+  if (buf.length <= maxBytes) return text;
+  const head = buf.subarray(0, maxBytes);
+  return head.subarray(0, completeUtf8PrefixLength(head)).toString("utf8");
+}
+function decodeCapturedBody(body, truncated) {
+  if (!truncated) return body.toString("utf8");
+  return body.subarray(0, completeUtf8PrefixLength(body)).toString("utf8");
+}
 function resolveClientIp(req, trustForwardedFor) {
   if (trustForwardedFor) {
     const xff = req.headers["x-forwarded-for"];
@@ -25,18 +48,39 @@ function resolveClientIp(req, trustForwardedFor) {
 function beginAuditCapture(req, res, now) {
   const config = getAuditCaptureConfig();
   if (!config) return null;
-  let rawRequestBody;
+  let requestBody;
   const responseChunks = [];
+  let responseBytes = 0;
+  let responseTruncated = false;
   let finished = false;
   const ctx = {
     setRequestBody(raw) {
-      if (config.captureBodies) rawRequestBody = raw;
+      if (config.captureBodies) {
+        requestBody = truncateToBytes(redactAuditText(raw), config.maxBodyBytes);
+      }
     }
   };
   if (config.captureBodies) {
     installResponseCapture(res, {
       push(chunk) {
+        if (config.maxBodyBytes < 0) {
+          responseChunks.push(chunk);
+          responseBytes += chunk.length;
+          return;
+        }
+        const remaining = config.maxBodyBytes - responseBytes;
+        if (remaining <= 0) {
+          responseTruncated = true;
+          return;
+        }
+        if (chunk.length > remaining) {
+          responseChunks.push(chunk.subarray(0, remaining));
+          responseBytes += remaining;
+          responseTruncated = true;
+          return;
+        }
         responseChunks.push(chunk);
+        responseBytes += chunk.length;
       }
     });
   }
@@ -69,12 +113,13 @@ function beginAuditCapture(req, res, now) {
       }
       if (ctx.error) record.error = redactAuditText(ctx.error);
       if (config.captureBodies) {
-        if (rawRequestBody != null && rawRequestBody.length > 0) {
-          record.requestBody = redactAuditText(rawRequestBody);
+        if (requestBody != null && requestBody.length > 0) {
+          record.requestBody = requestBody;
         }
         if (responseChunks.length > 0) {
-          const body = Buffer.concat(responseChunks).toString("utf8");
-          record.responseBody = redactAuditText(body);
+          const captured = Buffer.concat(responseChunks, responseBytes);
+          const body = decodeCapturedBody(captured, responseTruncated);
+          record.responseBody = truncateToBytes(redactAuditText(body), config.maxBodyBytes);
         }
       }
       recordAudit(record);

package/dist/{chunk-IK3KE3AU.js → chunk-DE2SRBFZ.js}

@@ -28,7 +28,7 @@ async function executeProviderCall(ctx) {
   }
   const fetched = await fetchFn(url, headers, finalBody);
   let response = fetched;
-  if (runResponseChain) {
+  if (runResponseChain && fetched.ok) {
     response = await executor.executeResponseChain(
       // Preserve the EXACT first arg each site passed: proxy → requestBody,
       // unified ingresses → their pre-transform request. The caller supplies