@omnicross/core 0.1.5 → 0.1.6

package/dist/{chunk-C6OV7GCC.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) {
@@ -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;