@omnicross/core 0.1.4 → 0.1.6

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-FTQ7IQUC.js → chunk-6CL5HTPQ.js}

@@ -25,6 +25,40 @@ function formatBase64(data, mediaType) {
   if (data.startsWith("data:")) return data;
   return `data:${mediaType || "image/png"};base64,${data}`;
 }
+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/anthropicMaxTokens.ts
+import { lookupCanonicalCapabilities } from "@omnicross/contracts/canonical-models";
+var ANTHROPIC_FALLBACK_MAX_TOKENS = 128e3;
+function resolveAnthropicMaxTokens(model, requested) {
+  if (typeof requested === "number" && Number.isFinite(requested) && requested > 0) {
+    return requested;
+  }
+  const canonical = model ? lookupCanonicalCapabilities(model)?.maxTokens : void 0;
+  if (typeof canonical === "number" && Number.isFinite(canonical) && canonical > 0) {
+    return canonical;
+  }
+  return ANTHROPIC_FALLBACK_MAX_TOKENS;
+}
 
 // src/transformer/transformers/AnthropicRequestBuilder.ts
 function buildAnthropicRequestBody(request) {
@@ -129,7 +163,11 @@ function buildAnthropicRequestBody(request) {
   const body = {
     model: request.model,
     messages: anthropicMessages,
-    max_tokens: request.max_tokens || 4096,
+    // Anthropic requires this field, so an absent caller cap must resolve to
+    // the model's real ceiling — NOT a small constant, which would silently
+    // truncate long responses (and corrupt tool-call JSON mid-stream).
+    // See `resolveAnthropicMaxTokens`.
+    max_tokens: resolveAnthropicMaxTokens(request.model, request.max_tokens),
     stream: request.stream ?? false
   };
   if (request.temperature !== void 0) {
@@ -237,6 +275,14 @@ function convertOpenAIResponseToAnthropic(openaiResponse) {
   }
   const message = choice.message;
   const content = [];
+  const thinking = message.thinking;
+  if (thinking?.content) {
+    content.push({
+      type: "thinking",
+      thinking: thinking.content,
+      signature: thinking.signature
+    });
+  }
   if (message.content) {
     content.push({
       type: "text",
@@ -262,14 +308,6 @@ function convertOpenAIResponseToAnthropic(openaiResponse) {
       });
     }
   }
-  const thinking = message.thinking;
-  if (thinking?.content) {
-    content.push({
-      type: "thinking",
-      thinking: thinking.content,
-      signature: thinking.signature
-    });
-  }
   const finishReason = choice.finish_reason;
   const stopReasonMapping = {
     stop: "end_turn",
@@ -337,7 +375,10 @@ function transformAnthropicRequestToUnified(request) {
         for (const tool of toolParts) {
           messages.push({
             role: "tool",
-            content: typeof tool.content === "string" ? tool.content : JSON.stringify(tool.content),
+            // Claude Code sends tool results as a block ARRAY; stringifying it
+            // fed the model the literal `[{"type":"text","text":"…"}]` envelope
+            // on every tool result.
+            content: flattenToolResultContent(tool.content),
             tool_call_id: tool.tool_use_id,
             cache_control: tool.cache_control
           });
@@ -987,5 +1028,6 @@ var AnthropicTransformer = class {
 };
 
 export {
+  resolveAnthropicMaxTokens,
   AnthropicTransformer
 };

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;