@omnicross/core 0.1.5 → 0.1.6

package/dist/{chunk-ZLX3KGXX.js → chunk-UX7VWA46.js}

@@ -1,5 +1,8 @@
 // src/usage/pricing-engine.ts
-import { DEFAULT_LITELLM_PRICING_URL } from "@omnicross/contracts/pricing-types";
+import {
+  DEFAULT_LITELLM_PRICING_URL,
+  DEFAULT_OPENROUTER_PRICING_URL
+} from "@omnicross/contracts/pricing-types";
 var PricingEngine = class {
   constructor(store, logger, options = {}) {
     this.store = store;
@@ -19,6 +22,8 @@ var PricingEngine = class {
    */
   cacheByModel = /* @__PURE__ */ new Map();
   cacheLoaded = false;
+  /** Coalesce manual and background refreshes to prevent a catalog stampede. */
+  refreshInFlight = null;
   // ===== Cache management =====
   /** Lazy-load and cache the full pricing table. */
   async ensureCache() {
@@ -27,7 +32,7 @@ var PricingEngine = class {
     this.cache = new Map(rows.map((r) => [keyOf(r.providerId, r.modelId), r]));
     this.cacheByModel = /* @__PURE__ */ new Map();
     for (const r of rows) {
-      if (r.providerId === "*") continue;
+      if (r.providerId === "*" || r.providerId === "openrouter" || r.source === "openrouter") continue;
       if (!this.cacheByModel.has(r.modelId)) this.cacheByModel.set(r.modelId, r);
     }
     this.cacheLoaded = true;
@@ -90,40 +95,82 @@ var PricingEngine = class {
       true
     );
     this.cache.set(keyOf(updated.providerId, updated.modelId), updated);
-    if (updated.providerId !== "*") this.cacheByModel.set(updated.modelId, updated);
+    if (updated.providerId !== "*" && updated.providerId !== "openrouter" && updated.source !== "openrouter") {
+      this.cacheByModel.set(updated.modelId, updated);
+    }
     return updated;
   }
   // ===== Source refresh =====
   async fetchLatestFromSource() {
+    if (this.refreshInFlight) return this.refreshInFlight;
+    const refresh = this.refreshSources();
+    this.refreshInFlight = refresh;
+    try {
+      return await refresh;
+    } finally {
+      if (this.refreshInFlight === refresh) this.refreshInFlight = null;
+    }
+  }
+  async refreshSources() {
     const sourceUrl = this.options.sourceUrl ?? DEFAULT_LITELLM_PRICING_URL;
+    const openRouterSourceUrl = this.options.openRouterSourceUrl ?? DEFAULT_OPENROUTER_PRICING_URL;
     const fetchImpl = this.options.fetchImpl ?? fetch;
+    const timeoutMs = this.options.fetchTimeoutMs ?? 1e4;
     const fetchedAt = Date.now();
-    let json;
-    try {
-      const res = await fetchImpl(sourceUrl);
-      if (!res.ok) {
-        throw new Error(`Pricing-source fetch failed with status ${res.status}`);
+    const [litellm, openrouter] = await Promise.all([
+      fetchCatalog(fetchImpl, sourceUrl, timeoutMs, parseLitellmJson),
+      fetchCatalog(fetchImpl, openRouterSourceUrl, timeoutMs, parseOpenRouterJson)
+    ]);
+    const sources = [
+      sourceResult("litellm", sourceUrl, litellm),
+      sourceResult("openrouter", openRouterSourceUrl, openrouter)
+    ];
+    for (const source of sources) {
+      if (source.status === "failed") {
+        this.logger.warn(`[PricingEngine] ${source.source} pricing-source fetch failed`, {
+          error: source.error
+        });
       }
-      json = await res.json();
-    } catch (e) {
-      this.logger.warn("[PricingEngine] pricing-source fetch failed", {
-        error: e instanceof Error ? e.message : String(e)
+    }
+    if (!litellm.ok && !openrouter.ok) {
+      throw new Error(
+        `Pricing-source fetch failed: LiteLLM (${litellm.error}); OpenRouter (${openrouter.error})`
+      );
+    }
+    const applied = [];
+    const conflicts = [];
+    if (litellm.ok) {
+      const result = await this.store.bulkApplyFromSource(litellm.entries, "litellm");
+      applied.push(...result.applied);
+      conflicts.push(
+        ...result.conflicts.map((c) => ({
+          providerId: c.current.providerId,
+          modelId: c.current.modelId,
+          current: c.current,
+          incoming: c.incoming
+        }))
+      );
+      sources[0].appliedCount = result.applied.length;
+    }
+    if (openrouter.ok) {
+      const current = new Map(
+        (await this.store.getAll()).map((row) => [keyOf(row.providerId, row.modelId), row])
+      );
+      const supplemental = openrouter.entries.filter((incoming) => {
+        const row = current.get(keyOf(incoming.providerId, incoming.modelId));
+        return !row || row.source === "openrouter" || row.source === "builtin";
       });
-      throw e;
+      const result = await this.store.bulkApplyFromSource(supplemental, "openrouter");
+      applied.push(...result.applied);
+      sources[1].appliedCount = result.applied.length;
     }
-    const incoming = parseLitellmJson(json);
-    const { applied, conflicts } = await this.store.bulkApplyFromSource(incoming);
-    await this.invalidateCache();
+    if (applied.length > 0) await this.invalidateCache();
     return {
       applied,
-      conflicts: conflicts.map((c) => ({
-        providerId: c.current.providerId,
-        modelId: c.current.modelId,
-        current: c.current,
-        incoming: c.incoming
-      })),
+      conflicts,
       fetchedAt,
-      sourceUrl
+      sourceUrl,
+      sources
     };
   }
   // ===== Conflict resolution =====
@@ -147,8 +194,12 @@ var PROVIDER_ALIASES = {
   azure: "openai"
 };
 var parseLitellmJson = (json) => {
+  if (!json || typeof json !== "object" || Array.isArray(json)) {
+    throw new Error("invalid LiteLLM catalog shape");
+  }
   const out = [];
   for (const [modelId, entry] of Object.entries(json)) {
+    if (modelId === "sample_spec") continue;
     if (!entry || typeof entry !== "object") continue;
     if (entry.input_cost_per_token == null || entry.output_cost_per_token == null) {
       continue;
@@ -167,6 +218,67 @@ var parseLitellmJson = (json) => {
   }
   return out;
 };
+var parseOpenRouterJson = (json) => {
+  if (!json || !Array.isArray(json.data)) {
+    throw new Error("invalid OpenRouter catalog shape");
+  }
+  const out = [];
+  for (const model of json.data) {
+    const modelId = typeof model?.id === "string" ? model.id.trim() : "";
+    const input = parseUnitPrice(model?.pricing?.prompt);
+    const output = parseUnitPrice(model?.pricing?.completion);
+    if (!modelId || input === null || output === null) continue;
+    const cacheRead = parseUnitPrice(model.pricing?.input_cache_read);
+    const cacheWrite = parseUnitPrice(model.pricing?.input_cache_write);
+    out.push({
+      providerId: "openrouter",
+      modelId,
+      inputPricePer1m: input * 1e6,
+      outputPricePer1m: output * 1e6,
+      cacheReadPricePer1m: cacheRead === null ? null : cacheRead * 1e6,
+      cacheWritePricePer1m: cacheWrite === null ? null : cacheWrite * 1e6
+    });
+  }
+  return out;
+};
+function parseUnitPrice(value) {
+  if (value === "" || value === null || value === void 0) return null;
+  const parsed = typeof value === "number" ? value : Number(value);
+  return Number.isFinite(parsed) && parsed >= 0 ? parsed : null;
+}
+async function fetchCatalog(fetchImpl, url, timeoutMs, parse) {
+  const controller = new AbortController();
+  const timer = setTimeout(() => controller.abort(), timeoutMs);
+  timer.unref?.();
+  try {
+    const response = await fetchImpl(url, { signal: controller.signal });
+    if (!response.ok) throw new Error(`status ${response.status}`);
+    const entries = parse(await response.json());
+    if (entries.length === 0) throw new Error("pricing catalog contained no usable entries");
+    return { ok: true, entries };
+  } catch (error) {
+    const message = controller.signal.aborted ? `timeout after ${timeoutMs}ms` : error instanceof Error ? error.message : String(error);
+    return { ok: false, error: message };
+  } finally {
+    clearTimeout(timer);
+  }
+}
+function sourceResult(source, sourceUrl, attempt) {
+  return attempt.ok ? {
+    source,
+    sourceUrl,
+    status: "applied",
+    parsedCount: attempt.entries.length,
+    appliedCount: 0
+  } : {
+    source,
+    sourceUrl,
+    status: "failed",
+    parsedCount: 0,
+    appliedCount: 0,
+    error: attempt.error
+  };
+}
 
 export {
   PricingEngine

package/dist/{chunk-K52THW2C.cjs → chunk-V4TXMEJS.cjs}

@@ -3,7 +3,7 @@
 
 
 
-var _chunkJWVTXXPXcjs = require('./chunk-JWVTXXPX.cjs');
+var _chunkKBM2W6UYcjs = require('./chunk-KBM2W6UY.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 = _chunkJWVTXXPXcjs.buildRequestBody.call(void 0, request);
+    const body = _chunkKBM2W6UYcjs.buildRequestBody.call(void 0, request);
     const action = request.stream ? "streamGenerateContent?alt=sse" : "generateContent";
     const url = new URL(`./${request.model}:${action}`, provider.baseUrl);
     const headers = {};
@@ -65,20 +65,20 @@ var GeminiTransformer = (_class = class {
    * (For requests coming into the Gemini endpoint)
    */
   async transformRequestOut(request, _context) {
-    return _chunkJWVTXXPXcjs.transformRequestOut.call(void 0, request);
+    return _chunkKBM2W6UYcjs.transformRequestOut.call(void 0, request);
   }
   /**
    * Transform Gemini response to OpenAI-compatible format
    */
   async transformResponseOut(response, _context) {
-    return _chunkJWVTXXPXcjs.transformResponseOut.call(void 0, response, this.name, this.logger);
+    return _chunkKBM2W6UYcjs.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 _chunkJWVTXXPXcjs.transformResponseIn.call(void 0, response, this.logger);
+    return _chunkKBM2W6UYcjs.transformResponseIn.call(void 0, response, this.logger);
   }
 }, _class.__initStatic(), _class);
 

package/dist/chunk-VRFBB5DB.js

@@ -0,0 +1,44 @@
+import {
+  GeminiTransformer
+} from "./chunk-LVUCAWMK.js";
+import {
+  OpenAIResponseTransformer
+} from "./chunk-OEWZUX4G.js";
+import {
+  OpenAITransformer
+} from "./chunk-LB6EBS6Y.js";
+import {
+  AnthropicTransformer
+} from "./chunk-6CL5HTPQ.js";
+import {
+  GeminiCodeAssistTransformer
+} from "./chunk-N5T4M4GU.js";
+
+// src/transformer/transformers/index.ts
+var BuiltinTransformers = {
+  OpenAITransformer,
+  GeminiTransformer,
+  GeminiCodeAssistTransformer,
+  AnthropicTransformer,
+  OpenAIResponseTransformer
+};
+function getBuiltinTransformers() {
+  return BuiltinTransformers;
+}
+var BUILTIN_TRANSFORMER_NAMES = [
+  "openai",
+  "gemini",
+  "gemini-code-assist",
+  "anthropic",
+  "openai-response"
+];
+async function registerBuiltinTransformers(service) {
+  await service.initialize(getBuiltinTransformers());
+}
+
+export {
+  BuiltinTransformers,
+  getBuiltinTransformers,
+  BUILTIN_TRANSFORMER_NAMES,
+  registerBuiltinTransformers
+};

package/dist/chunk-WB6PH56J.js

@@ -0,0 +1,166 @@
+// src/provider-proxy/matchText.ts
+var MATCH_TEXT_PER_MESSAGE_CAP = 8192;
+var MATCH_TEXT_RECENT_MESSAGES = 6;
+function flattenMatchText(value) {
+  if (typeof value === "string") return value;
+  if (Array.isArray(value)) {
+    const parts = [];
+    for (const item of value) {
+      const text = flattenMatchText(item);
+      if (text) parts.push(text);
+    }
+    return parts.join("\n");
+  }
+  if (value && typeof value === "object") {
+    const obj = value;
+    if (obj.type === "tool_result" && obj.content !== void 0) {
+      return flattenMatchText(obj.content);
+    }
+    if (typeof obj.text === "string") return obj.text;
+  }
+  return "";
+}
+function collectMatchText(anthropicBody) {
+  const messages = Array.isArray(anthropicBody.messages) ? anthropicBody.messages : [];
+  const slices = [];
+  const sys = flattenMatchText(anthropicBody.system).trim();
+  if (sys) slices.push(sys.slice(0, MATCH_TEXT_PER_MESSAGE_CAP));
+  const recent = [];
+  for (let i = messages.length - 1; i >= 0 && recent.length < MATCH_TEXT_RECENT_MESSAGES; i--) {
+    const message = messages[i];
+    if (!message || typeof message !== "object") continue;
+    const role = message.role;
+    if (role !== "user" && role !== "system") continue;
+    const text = flattenMatchText(message.content).trim();
+    if (text) recent.push(text.slice(0, MATCH_TEXT_PER_MESSAGE_CAP));
+  }
+  for (let i = recent.length - 1; i >= 0; i--) slices.push(recent[i]);
+  return slices;
+}
+function deriveSubscriptionSessionKey(anthropicBody) {
+  const system = flattenMatchText(anthropicBody.system).trim().slice(0, MATCH_TEXT_PER_MESSAGE_CAP);
+  const messages = Array.isArray(anthropicBody.messages) ? anthropicBody.messages : [];
+  let firstUser = "";
+  for (const message of messages) {
+    if (message && typeof message === "object" && message.role === "user") {
+      firstUser = flattenMatchText(message.content).trim().slice(0, MATCH_TEXT_PER_MESSAGE_CAP);
+      break;
+    }
+  }
+  const anchor = `${system}\0${firstUser}`;
+  if (!system && !firstUser) return void 0;
+  return fnv1a(anchor);
+}
+var SESSION_ID_CAP = 1024;
+function deriveGatewaySessionKey(body, headers = {}, options = {}) {
+  const sessionHeader = firstHeaderValue(headers, ["session-id", "session_id", "x-session-id"]);
+  if (sessionHeader) {
+    return { key: fnv1a(sessionHeader), source: "session-header" };
+  }
+  const threadHeader = firstHeaderValue(headers, ["thread-id", "thread_id", "x-thread-id"]);
+  if (threadHeader) {
+    return { key: fnv1a(threadHeader), source: "thread-header" };
+  }
+  const bodySessionId = scalarSessionValue(body.session_id);
+  if (bodySessionId) {
+    return { key: fnv1a(bodySessionId), source: "body-session-id" };
+  }
+  const bodyThreadId = scalarSessionValue(body.thread_id ?? body.threadId);
+  if (bodyThreadId) {
+    return { key: fnv1a(bodyThreadId), source: "body-thread-id" };
+  }
+  const conversationId = scalarSessionValue(body.conversation_id);
+  if (conversationId) {
+    return { key: fnv1a(conversationId), source: "body-session-id" };
+  }
+  const promptCacheKey = scalarSessionValue(body.prompt_cache_key);
+  if (promptCacheKey) {
+    return { key: fnv1a(promptCacheKey), source: "prompt-cache-key" };
+  }
+  const fingerprint = deriveResponsesContentFingerprint(body);
+  if (fingerprint) {
+    return { key: fnv1a(fingerprint), source: "content-fingerprint" };
+  }
+  const endpoint = options.endpoint?.trim() || "responses";
+  const fallback = options.fallbackKey?.trim() || "anonymous";
+  return {
+    key: fnv1a(`${endpoint}\0${fallback}`),
+    source: "api-key-fallback"
+  };
+}
+function firstHeaderValue(headers, names) {
+  const byLower = /* @__PURE__ */ new Map();
+  for (const [name, value] of Object.entries(headers)) {
+    if (typeof value === "string" || Array.isArray(value)) {
+      const lower = name.toLowerCase();
+      if (!byLower.has(lower)) byLower.set(lower, value);
+    }
+  }
+  for (const name of names) {
+    const value = byLower.get(name);
+    const values = Array.isArray(value) ? value : [value];
+    for (const item of values) {
+      if (typeof item !== "string") continue;
+      const trimmed = item.trim();
+      if (trimmed) return trimmed.slice(0, SESSION_ID_CAP);
+    }
+  }
+  return void 0;
+}
+function scalarSessionValue(value) {
+  if (typeof value !== "string" && typeof value !== "number") return void 0;
+  const trimmed = String(value).trim();
+  return trimmed ? trimmed.slice(0, SESSION_ID_CAP) : void 0;
+}
+function deriveResponsesContentFingerprint(body) {
+  const stable = [];
+  const instructions = flattenMatchText(body.instructions).trim();
+  if (instructions) stable.push(instructions.slice(0, MATCH_TEXT_PER_MESSAGE_CAP));
+  const input = body.input;
+  let firstUser = "";
+  const visitItem = (item) => {
+    if (typeof item === "string") {
+      if (!firstUser) firstUser = item.trim().slice(0, MATCH_TEXT_PER_MESSAGE_CAP);
+      return;
+    }
+    if (!item || typeof item !== "object") return;
+    const record = item;
+    const role = typeof record.role === "string" ? record.role.toLowerCase() : "";
+    const content = record.content ?? record.text ?? record.input;
+    const text = flattenMatchText(content !== void 0 ? content : record).trim();
+    if (!text) return;
+    if (role === "developer" || role === "system") {
+      stable.push(text.slice(0, MATCH_TEXT_PER_MESSAGE_CAP));
+    } else if (role === "user" || !role) {
+      if (!firstUser) firstUser = text.slice(0, MATCH_TEXT_PER_MESSAGE_CAP);
+    }
+  };
+  if (Array.isArray(input)) {
+    for (const item of input) visitItem(item);
+  } else if (input !== void 0) {
+    visitItem(input);
+  }
+  if (stable.length === 0) {
+    const legacySystem = flattenMatchText(body.system).trim();
+    if (legacySystem) stable.push(legacySystem.slice(0, MATCH_TEXT_PER_MESSAGE_CAP));
+  }
+  if (stable.length === 0 && !firstUser) return void 0;
+  return `${stable.join("\0")}\0${firstUser}`;
+}
+function fnv1a(str) {
+  let h = 2166136261;
+  for (let i = 0; i < str.length; i++) {
+    h ^= str.charCodeAt(i);
+    h = Math.imul(h, 16777619);
+  }
+  return (h >>> 0).toString(16).padStart(8, "0");
+}
+
+export {
+  MATCH_TEXT_PER_MESSAGE_CAP,
+  MATCH_TEXT_RECENT_MESSAGES,
+  flattenMatchText,
+  collectMatchText,
+  deriveSubscriptionSessionKey,
+  deriveGatewaySessionKey
+};

package/dist/{chunk-G2UTNSGU.js → chunk-WNKWAEUR.js}

@@ -134,7 +134,13 @@ var TransformerChainExecutor = class {
     const { endpointTransformer } = options;
     const context = {
       logger: this.logger,
-      providerName: provider.name
+      providerName: provider.name,
+      // The unified REQUEST this response answers. Response encoders need it to
+      // restore request-scoped protocol state that the chat wire cannot carry —
+      // e.g. which codex tools were declared `custom` (see
+      // `UnifiedChatRequestMeta.codexTools`), which decides whether a tool call
+      // is encoded back as a `function_call` or a `custom_tool_call` item.
+      req: request
     };
     let finalResponse = response;
     const bypass = this.shouldBypassTransformers(chain, endpointTransformer, request);

package/dist/{chunk-SUEGJ75D.cjs → chunk-WYTEQ4Q5.cjs}

@@ -59,6 +59,26 @@ 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 convertAnthropicToOpenAI(response) {
@@ -158,7 +178,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) {
@@ -368,7 +388,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-5ENKBSWO.js → chunk-YJVHCHQX.js}

@@ -7,6 +7,7 @@ var BAN_BODY_MARKERS = [
   "this organization has been disabled",
   "oauth authentication is currently not allowed"
 ];
+var ACCOUNT_HEALTH_DIAGNOSTIC_LIMIT = 200;
 function readHeader(headers, name) {
   if (typeof headers.get === "function") {
     return headers.get(name);
@@ -44,6 +45,7 @@ var SubscriptionAccountHealth = class {
   records = /* @__PURE__ */ new Map();
   listeners = /* @__PURE__ */ new Set();
   anomalyListeners = /* @__PURE__ */ new Set();
+  diagnostics = [];
   now;
   overloadEnabled;
   overloadTtlMs;
@@ -71,8 +73,8 @@ var SubscriptionAccountHealth = class {
   }
   /**
    * Whether an account may be scheduled RIGHT NOW. `blocked` → false; any timer
-   * still in the future → false. Expired timers are lazily deleted on read (CRS
-   * lazy-clear parity) so an elapsed cooldown restores the account WITHOUT a
+   * still in the future → false. Expired timers are lazily deleted on read so
+   * an elapsed cooldown restores the account WITHOUT a
    * timer — but the recovery SIGNAL is the sweeper's job (`sweepRecoveries`), so
    * this read never emits (correctness is independent of the tick).
    */
@@ -86,7 +88,7 @@ var SubscriptionAccountHealth = class {
     return !active;
   }
   /**
-   * The single marking entry point (design D3). Faithful to CRS status semantics:
+   * The single marking entry point (design D3):
    *  - 429 + authoritative reset → `rateLimitEndAt`; a non-claude 429 may use
    *    `retryAfterSeconds`; a bare 429 (no resolvable reset) is NOT marked;
    *  - 529 → `overloadUntil` (gated by `overloadEnabled`);
@@ -141,9 +143,20 @@ var SubscriptionAccountHealth = class {
     }
     if (isRecordEmpty(record)) this.records.delete(key);
     else this.records.set(key, record);
-    if (recovered) this.emit({ providerId, accountId, at: now, kind: "rateLimitRecovery" });
+    if (recovered) {
+      const recovery = {
+        providerId,
+        accountId,
+        at: now,
+        kind: "rateLimitRecovery"
+      };
+      this.recordDiagnostic({ kind: "health-recovery", providerId, accountId, at: now });
+      this.emit(recovery);
+    }
     if (anomalyState && !wasUnhealthyBefore) {
-      this.emitAnomaly({ providerId, accountId, at: now, state: anomalyState });
+      const anomaly = { providerId, accountId, at: now, state: anomalyState };
+      this.recordDiagnostic({ kind: "health-anomaly", ...anomaly });
+      this.emitAnomaly(anomaly);
     }
   }
   /** Whether a record is unhealthy at `now`: blocked, or any timer still future. */
@@ -196,7 +209,15 @@ var SubscriptionAccountHealth = class {
         this.records.delete(key);
       }
     }
-    for (const event of recovered) this.emit(event);
+    for (const event of recovered) {
+      this.recordDiagnostic({
+        kind: "health-recovery",
+        providerId: event.providerId,
+        accountId: event.accountId,
+        at: event.at
+      });
+      this.emit(event);
+    }
     return recovered;
   }
   /** Admin-facing coarse status + cooldown-until for one account (secret-free). */
@@ -215,6 +236,14 @@ var SubscriptionAccountHealth = class {
     }
     return { state: "healthy" };
   }
+  /** Return newest-first, bounded, secret-free health edge diagnostics. */
+  getDiagnostics(filter = {}) {
+    const requested = typeof filter.limit === "number" && Number.isFinite(filter.limit) ? Math.trunc(filter.limit) : ACCOUNT_HEALTH_DIAGNOSTIC_LIMIT;
+    const limit = Math.min(ACCOUNT_HEALTH_DIAGNOSTIC_LIMIT, Math.max(1, requested));
+    return this.diagnostics.filter(
+      (event) => (!filter.providerId || event.providerId === filter.providerId) && (!filter.accountId || event.accountId === filter.accountId)
+    ).slice(-limit).reverse().map((event) => ({ ...event }));
+  }
   /**
    * Register a recovery listener (the OQ3 seam #5 webhooks + #8 health-cron
    * consume). Returns an unsubscribe function. Two edges fire it:
@@ -257,6 +286,12 @@ var SubscriptionAccountHealth = class {
       }
     }
   }
+  recordDiagnostic(event) {
+    this.diagnostics.push({ ...event });
+    if (this.diagnostics.length > ACCOUNT_HEALTH_DIAGNOSTIC_LIMIT) {
+      this.diagnostics.splice(0, this.diagnostics.length - ACCOUNT_HEALTH_DIAGNOSTIC_LIMIT);
+    }
+  }
   /**
    * Delete every EXPIRED timer field on the record in place; return whether any
    * timer is STILL active (in the future). `blocked` is not a timer and is left
@@ -303,6 +338,7 @@ export {
   OVERLOAD_ENABLED_DEFAULT,
   AUTH_ERROR_TTL_MS,
   SERVER_ERROR_TTL_MS,
+  ACCOUNT_HEALTH_DIAGNOSTIC_LIMIT,
   resolveResetSeconds,
   SubscriptionAccountHealth,
   getSharedAccountHealth,