cartethyia 2.7.0 → 2.7.2

package/src/protocol/response/dsml.ts

@@ -1,98 +1,27 @@
 /**
  * CodeBuddy-family DeepSeek sometimes emits native tool markup as assistant text.
  * Complete declared calls are recovered; incomplete and undeclared blocks stay text.
+ *
+ * The mechanics live in `../dsml` with the CodeBuddy dialect as default; this
+ * module keeps the historical public surface (`DsmlToolCallParser`,
+ * `parseDsmlToolCalls`) stable for this wire family.
  */
-const SEPARATORS = ["｜｜", "｜", "|"] as const;
-const BLOCK_NAMES = ["calls", "function_calls"] as const;
-const OPENERS = SEPARATORS.flatMap((separator) => BLOCK_NAMES.map((name) => `<${separator}DSML${separator} ${name}>`));
-const TOOL_NAME = /^[A-Za-z0-9_][A-Za-z0-9_.:-]{0,63}$/;
+import {
+  DsmlStreamParser,
+  type DsmlToolCall,
+} from "../dsml";
 
-/** Escapes regex metacharacters so a `|` separator is literal, not alternation. */
-function escapeRegExp(value: string): string {
-  return value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
-}
-
-export interface DsmlToolCall {
-  readonly id: string;
-  readonly name: string;
-  readonly arguments: string;
-}
+export type { DsmlToolCall } from "../dsml";
 
 export interface DsmlRecovery {
   readonly text: string;
   readonly calls: readonly DsmlToolCall[];
 }
 
-export class DsmlToolCallParser {
-  readonly #allowedNames: ReadonlySet<string>;
-  #pending = "";
-  #callSequence = 0;
-
+/** Streaming strict-prefix parser with the CodeBuddy dialect defaults. */
+export class DsmlToolCallParser extends DsmlStreamParser {
   constructor(allowedNames: ReadonlySet<string>) {
-    this.#allowedNames = allowedNames;
-  }
-
-  push(chunk: string): DsmlRecovery {
-    this.#pending += chunk;
-    let cursor = 0;
-    let visible = "";
-    const calls: DsmlToolCall[] = [];
-    for (;;) {
-      let openIndex = -1;
-      let opener = "";
-      for (const candidate of OPENERS) {
-        const index = this.#pending.indexOf(candidate, cursor);
-        if (index >= 0 && (openIndex < 0 || index < openIndex)) {
-          openIndex = index;
-          opener = candidate;
-        }
-      }
-      if (openIndex < 0) {
-        const safeEnd = this.#settledEnd(cursor);
-        visible += this.#pending.slice(cursor, safeEnd);
-        cursor = safeEnd;
-        break;
-      }
-      visible += this.#pending.slice(cursor, openIndex);
-      const separator = SEPARATORS.find((value) => opener.startsWith(`<${value}DSML`));
-      const blockName = BLOCK_NAMES.find((value) => opener.endsWith(` ${value}>`));
-      if (separator === undefined || blockName === undefined) {
-        visible += "<";
-        cursor = openIndex + 1;
-        continue;
-      }
-      const close = `</${separator}DSML${separator} ${blockName}>`;
-      const closeIndex = this.#pending.indexOf(close, openIndex + opener.length);
-      if (closeIndex < 0) {
-        cursor = openIndex;
-        break;
-      }
-      const end = closeIndex + close.length;
-      const block = this.#pending.slice(openIndex, end);
-      const parsed = parseBlock(block, opener, close, separator, this.#allowedNames);
-      if (parsed === undefined) visible += block;
-      else {
-        for (const call of parsed) calls.push({ ...call, id: `call_dsml_${this.#callSequence++}_${call.name}` });
-      }
-      cursor = end;
-    }
-    this.#pending = this.#pending.slice(cursor);
-    return { text: visible, calls };
-  }
-
-  flush(): DsmlRecovery {
-    const text = this.#pending;
-    this.#pending = "";
-    return { text, calls: [] };
-  }
-
-  #settledEnd(start: number): number {
-    const remaining = this.#pending.slice(start);
-    for (let length = Math.min(OPENERS.reduce((max, opener) => Math.max(max, opener.length - 1), 0), remaining.length); length > 0; length -= 1) {
-      const suffix = remaining.slice(-length);
-      if (OPENERS.some((opener) => opener.startsWith(suffix))) return this.#pending.length - length;
-    }
-    return this.#pending.length;
+    super({ allowedNames });
   }
 }
 
@@ -107,53 +36,3 @@ export function parseDsmlToolCalls(
   const recovered = [...first.calls, ...last.calls];
   return recovered.length === 0 ? undefined : { text: `${first.text}${last.text}`.trim(), calls: recovered };
 }
-
-function parseBlock(
-  block: string,
-  opener: string,
-  close: string,
-  separator: string,
-  allowedNames: ReadonlySet<string>,
-): Omit<DsmlToolCall, "id">[] | undefined {
-  const inner = block.slice(opener.length, -close.length);
-  const pipe = escapeRegExp(separator);
-  const invokePattern = new RegExp(`<${pipe}DSML${pipe}\\s+invoke\\s+name="([^"]*)"\\s*>`, "g");
-  const calls: Omit<DsmlToolCall, "id">[] = [];
-  // The allowlist is strict only when the caller knows the declared tools: a
-  // caller without one (a direct parse) keeps the generic name rule, while a
-  // dispatch that declared its tools must never execute a name it did not offer.
-  const strict = allowedNames.size > 0;
-  let cursor = 0;
-  for (const invoke of inner.matchAll(invokePattern)) {
-    const name = invoke[1] ?? "";
-    if (!TOOL_NAME.test(name) || (strict && !allowedNames.has(name)) || invoke.index === undefined) return undefined;
-    if (inner.slice(cursor, invoke.index).trim().length > 0) return undefined;
-    const bodyStart = invoke.index + invoke[0].length;
-    const invokeClose = `</${separator}DSML${separator} invoke>`;
-    const invokeEnd = inner.indexOf(invokeClose, bodyStart);
-    if (invokeEnd < 0) return undefined;
-    const parameterPattern = new RegExp(`<${pipe}DSML${pipe}\\s+parameter\\s+name="([^"]*)"(?:\\s+string="(true|false)")?\\s*>`, "g");
-    const body = inner.slice(bodyStart, invokeEnd);
-    const args: Record<string, unknown> = {};
-    let parameterCursor = 0;
-    for (const parameter of body.matchAll(parameterPattern)) {
-      const key = parameter[1] ?? "";
-      if (key.length === 0 || parameter.index === undefined || body.slice(parameterCursor, parameter.index).trim().length > 0) return undefined;
-      const valueStart = parameter.index + parameter[0].length;
-      const parameterClose = `</${separator}DSML${separator} parameter>`;
-      const valueEnd = body.indexOf(parameterClose, valueStart);
-      if (valueEnd < 0) return undefined;
-      const raw = body.slice(valueStart, valueEnd);
-      if (parameter[2] === "true") args[key] = raw;
-      else {
-        try { args[key] = JSON.parse(raw); }
-        catch { args[key] = raw; }
-      }
-      parameterCursor = valueEnd + parameterClose.length;
-    }
-    if (body.slice(parameterCursor).trim().length > 0) return undefined;
-    calls.push({ name, arguments: JSON.stringify(args) });
-    cursor = invokeEnd + invokeClose.length;
-  }
-  return calls.length > 0 && inner.slice(cursor).trim().length === 0 ? calls : undefined;
-}

package/src/{transport → protocol}/translation/attachment-integrity.ts

@@ -1,5 +1,5 @@
-import { resolveImageSource, splitDataUrl } from "../../protocol/codecs";
-import type { CanonicalRequest, ContentPart } from "../../protocol/canonical-model";
+import { resolveImageSource, splitDataUrl } from "../codecs";
+import type { CanonicalRequest, ContentPart } from "../canonical-model";
 import { log } from "../../observability/logger";
 
 /**

package/src/{transport → protocol}/translation/cache-controls.ts

@@ -1,4 +1,4 @@
-import type { CacheHint } from "../../protocol/canonical-model";
+import type { CacheHint } from "../canonical-model";
 
 /**
  * Provider-specific cache control translation from canonical cache hints.

package/src/{transport → protocol}/translation/capabilities.ts

@@ -1,12 +1,12 @@
 // Capability contracts, wire-family matrices, projection, and preflight.
-import { capabilityUnsupported, GatewayError } from "../../protocol/gateway-error";
+import { capabilityUnsupported, GatewayError } from "../gateway-error";
 import {
   summarizeParts,
   type CacheHint,
   type CanonicalRequest,
   type GenerationControls,
   type WireFamily,
-} from "../../protocol/canonical-model";
+} from "../canonical-model";
 
 /** Capabilities declared by one resolved provider/model/route candidate. */
 export interface RouteCapabilities {

package/src/{transport → protocol}/translation/normalize.ts

@@ -1,6 +1,6 @@
 // Provider-neutral generation-controls normalization, used only after
 // capability preflight.
-import type { GenerationControls } from "../../protocol/canonical-model";
+import type { GenerationControls } from "../canonical-model";
 
 /** Normalizes the output-token control family onto `max_output_tokens`. */
 export function normalizeGenerationControls(controls: GenerationControls): GenerationControls {

package/src/{transport → protocol}/translation/quirks.ts

@@ -9,7 +9,7 @@
 // Add a row ONLY when a concrete upstream 400/422 proves the quirk; do not
 // speculate. The table is applied on the dispatch path before wire translation.
 
-import type { CanonicalRequest, GenerationControls } from "../../protocol/canonical-model";
+import type { CanonicalRequest, GenerationControls } from "../canonical-model";
 import {
   THINKING_STRIPPED_SAMPLING_CONTROLS,
   isThinkingEnabled,

package/src/{transport → protocol}/translation/search.ts

@@ -1,5 +1,5 @@
 // Hosted web-search tool identity.
-import type { ToolDefinition } from "../../protocol/canonical-model";
+import type { ToolDefinition } from "../canonical-model";
 
 /**
  * Returns whether a declaration is a provider-hosted search tool.

package/src/{transport → protocol}/translation/thinking.ts

@@ -5,13 +5,14 @@
 // so the native config (`thinking_type` + `budget_tokens`) is dropped while the
 // request-level effort intent (OpenAI `reasoning_effort`) survives — that field
 // is a property of the request, not of the turn.
-import type { CanonicalRequest, ReasoningIntent, WireFamily } from "../../protocol/canonical-model";
+import type { CanonicalRequest, ReasoningIntent, WireFamily } from "../canonical-model";
 
 /**
  * Canonical reasoning effort ladder, ordered least to most intensive.
  * Provides a unified effort scale across OpenAI, Anthropic, and open-weight models.
  */
 export const REASONING_EFFORT_LADDER = [
+  "instant",
   "minimal",
   "low",
   "medium",
@@ -54,6 +55,7 @@ export interface ParsedThinkingSuffix {
  */
 export const LEVEL_TO_BUDGET: Readonly<Record<ReasoningEffortLevel | "none", number>> = {
   none: 0,
+  instant: 256,
   minimal: 512,
   low: 1_024,
   medium: 8_192,
@@ -241,6 +243,20 @@ export const BASE_SUPPORTED_EFFORTS: readonly ReasoningEffortLevel[] = [
  */
 const MIMO_V26_SUPPORTED_EFFORTS: readonly ReasoningEffortLevel[] = ["low", "medium", "high"];
 
+/**
+ * Mercury (Inception Labs) — the chat ladder is `{instant, low, medium,
+ * high}`: `minimal`, `xhigh`, and `max` each answer a 400
+ * `reasoning_effort must be one of: 'instant', 'low', 'medium', 'high'`.
+ * `instant` is not on the canonical ladder, so it can only appear here; the
+ * clamp steps down to `high` for any higher request.
+ */
+const INCEPTION_SUPPORTED_EFFORTS: readonly ReasoningEffortLevel[] = [
+  "instant",
+  "low",
+  "medium",
+  "high",
+];
+
 /**
  * `low..max`: the OpenAI 5.6/6/daybreak generation and the new-gen Claude
  * adaptive models (`fable`/`mythos`/`opus-5`/`sonnet-5`/`opus-4-7`/`opus-4-8`)
@@ -320,6 +336,12 @@ export function resolveSupportedReasoningEfforts(
   if (id.includes("mimo-v2.6")) {
     return MIMO_V26_SUPPORTED_EFFORTS;
   }
+  // Checked before the generic default: Mercury's chat endpoint answers every
+  // effort outside {instant, low, medium, high} with a 400 that names the
+  // field (recorded live from request 40b60777).
+  if (id.includes("mercury") && wireFamily === "chat") {
+    return INCEPTION_SUPPORTED_EFFORTS;
+  }
   // Claude catalog ladders: `output_config.effort` rides the
   // Messages wire, so an out-of-ladder tier is an upstream rejection risk.
   // Dot-tolerant (`cb/claude-opus-4.6`) because gateway-prefixed ids keep the

package/src/{transport → protocol}/translation/tool-id.ts

@@ -6,7 +6,7 @@
 // strict wire encoder runs. The same original→sanitized mapping is applied to
 // both the `toolCall` and its matching `toolResult` so pairing is preserved.
 
-import type { CanonicalRequest } from "../../protocol/canonical-model";
+import type { CanonicalRequest } from "../canonical-model";
 
 /** Anthropic tool ID contract: alphanumerics, underscore, hyphen only. */
 export const TOOL_ID_PATTERN: RegExp = /^[a-zA-Z0-9_-]+$/;

package/src/{transport → protocol}/translation/tool-repair.ts

@@ -4,8 +4,8 @@
 // winning route's capabilities and before projection — keeps the request
 // dispatchable instead of failing upstream with a 400 the client cannot fix.
 
-import type { CanonicalMessage, CanonicalRequest } from "../../protocol/canonical-model";
-import { canContainToolResult } from "../../protocol/canonical-model";
+import type { CanonicalMessage, CanonicalRequest } from "../canonical-model";
+import { canContainToolResult } from "../canonical-model";
 
 const MISSING_TOOL_OUTPUT = "<missing tool output>";
 

package/src/protocol/upstream-parsing.ts

@@ -0,0 +1,176 @@
+const MAX_COOLDOWN_MS = 24 * 3600 * 1000;
+
+/** Parses Retry-After seconds or an HTTP date, bounded to one day. */
+export function parseRetryAfter(value: string | null | undefined): number | null {
+  if (!value) return null;
+  const trimmed = value.trim();
+  const numeric = Number(trimmed);
+  if (Number.isFinite(numeric) && numeric > 0) return Math.min(MAX_COOLDOWN_MS, numeric * 1000);
+  const parsed = Date.parse(trimmed);
+  if (!Number.isFinite(parsed)) return null;
+  const delay = parsed - Date.now();
+  return delay > 0 ? Math.min(MAX_COOLDOWN_MS, delay) : null;
+}
+
+/**
+ * Parses x-ratelimit-reset as epoch seconds or a relative delay.
+ *
+ * Returns `null` — not `0` — when the instant has already passed. This matters
+ * because `parseUpstreamBackoff` chains these parsers with `??`, which falls
+ * through only on null: a `0` from an elapsed `x-ratelimit-reset` (a cached error
+ * body, clock skew, a stale edge response) stopped the chain before the
+ * lower-priority headers that carried the real wait. The `0` was then written to
+ * `details.retryAfterMs` and read by `classifyAccountError` as `headerCooldown`,
+ * which outranks the provider's own message text — so both were discarded and the
+ * account fell back to the generic default cooldown while the provider had parked
+ * it for the rest of the window.
+ *
+ * `parseRetryAfter` above already returns `null` for an elapsed date; matching it
+ * is what removes the asymmetry.
+ */
+export function parseRateLimitReset(value: string | null | undefined): number | null {
+  if (!value) return null;
+  const numeric = Number(value.trim());
+  if (!Number.isFinite(numeric) || numeric <= 0) return null;
+  const target = numeric >= 1_000_000_000 ? numeric * 1000 : Date.now() + numeric * 1000;
+  const remaining = target - Date.now();
+  return remaining > 0 ? Math.min(MAX_COOLDOWN_MS, remaining) : null;
+}
+
+/** Parses a millisecond-denominated reset header (`retry-after-ms`, `x-ratelimit-reset-ms`). */
+export function parseResetAfterMs(value: string | null | undefined): number | null {
+  if (!value) return null;
+  const numeric = Number(value.trim());
+  if (!Number.isFinite(numeric) || numeric <= 0) return null;
+  return Math.min(MAX_COOLDOWN_MS, Math.round(numeric));
+}
+
+/**
+ * Reads upstream backoff evidence in reference priority order: millisecond
+ * variants first (`retry-after-ms`, then `x-ratelimit-reset-ms`), then the
+ * classic `retry-after` / `x-ratelimit-reset` pair.
+ */
+export function parseUpstreamBackoff(headers: {
+  get(name: string): string | null;
+}): number | null {
+  return (
+    parseResetAfterMs(headers.get("retry-after-ms")) ??
+    parseRetryAfter(headers.get("retry-after")) ??
+    parseResetAfterMs(headers.get("x-ratelimit-reset-ms")) ??
+    parseRateLimitReset(headers.get("x-ratelimit-reset")) ??
+    parseRateLimitReset(headers.get("x-ratelimit-reset-requests")) ??
+    parseRateLimitReset(headers.get("retry-after"))
+  );
+}
+
+/**
+ * Extracts bounded reset durations from provider messages when headers omit
+ * them.
+ *
+ * Two shapes are recognized, because providers state resets both ways:
+ *
+ *   - **Relative** — "quota will reset in 3 hours", "try again in 30s".
+ *   - **Absolute** — "your usage will reset at 2026-09-24 02:12:51 UTC+8"
+ *     (WorkBuddy/CodeBuddy `6004`). An absolute stamp is *not* a duration, and
+ *     the relative-only pattern silently missed it, so the account fell back to
+ *     the generic 15-minute default while the provider had actually parked it
+ *     for the rest of the window — the account kept re-entering rotation and
+ *     failing every request inside the stated reset window.
+ */
+/**
+ * One `amount unit` pair of a duration phrase: `4h`, `13m`, `2 hours`, `30s`.
+ *
+ * The unit ends on `(?![a-z])`, not `\b`: a compact compound like `2h30m` puts
+ * a digit straight after `h`, which is a word character, so a `\b` would refuse
+ * to end the pair and the whole phrase would parse as null. `m(?!s|o)` is what
+ * stops a bare `m` from swallowing `ms` (milliseconds) or `mo` (months),
+ * neither of which is a reset duration.
+ */
+const DURATION_PAIR_SOURCE = String.raw`(\d+(?:\.\d+)?)[\s-]*(hours?|hrs?|h|minutes?|mins?|m(?!s|o)|seconds?|secs?|s)(?![a-z])`;
+
+function durationUnitMs(unit: string): number {
+  const first = unit.toLowerCase()[0];
+  return first === "h" ? 3600_000 : first === "m" ? 60_000 : 1_000;
+}
+
+/**
+ * Sums the `amount unit` pairs at the head of a duration phrase.
+ *
+ * Providers state a reset as one compound duration at least as often as a
+ * single unit: a daily-limit 429 reads "Try again in 4h 13m". A single-pair
+ * parser read only `4h` and dropped the 13 minutes, so the stored retry
+ * deadline was earlier than the window the provider had actually stated and the
+ * account re-entered rotation before it. Pairs are accepted only while they
+ * continue the phrase — separated by whitespace, a comma, or `and` — so a
+ * number that merely follows later in the sentence cannot be absorbed.
+ */
+function parseCompoundDuration(text: string): number | null {
+  const pairs = new RegExp(DURATION_PAIR_SOURCE, "gi");
+  let totalMs = 0;
+  let lastEnd = 0;
+  let matched = false;
+  for (let pair = pairs.exec(text); pair !== null; pair = pairs.exec(text)) {
+    const gap = text.slice(lastEnd, pair.index);
+    const continues = matched ? /^[\s,]*(?:and\s+)?$/i.test(gap) : /^\s*$/.test(gap);
+    if (!continues) break;
+    const amount = Number(pair[1]);
+    if (!Number.isFinite(amount) || amount <= 0) break;
+    totalMs += amount * durationUnitMs(pair[2] ?? "");
+    matched = true;
+    lastEnd = pair.index + pair[0].length;
+  }
+  return matched ? Math.round(totalMs) : null;
+}
+
+export function parseProviderResetDuration(message: string): number | null {
+  const trigger =
+    /(?:quota will reset|resets?|try again|retry(?:ing)?)\s+(?:in|after|over)\s+(?:a\s+)?(?:rolling\s+)?/i.exec(
+      message,
+    );
+  if (trigger) {
+    const parsed = parseCompoundDuration(message.slice(trigger.index + trigger[0].length));
+    if (parsed !== null) return Math.min(MAX_COOLDOWN_MS, parsed);
+  }
+  return parseAbsoluteResetTimestamp(message);
+}
+
+/**
+ * Reads an absolute reset instant out of a provider message, e.g.
+ * `will reset at 2026-09-24 02:12:51 UTC+8`. Returns the delay from now,
+ * bounded to one day, or null when no future timestamp is present.
+ *
+ * `Date.parse` cannot read the space-separated `YYYY-MM-DD HH:MM:SS` form with
+ * a bare `UTC±H` offset, so the parts are normalized explicitly rather than
+ * relying on engine-specific leniency.
+ */
+export function parseAbsoluteResetTimestamp(message: string): number | null {
+  const match = /(\d{4})-(\d{2})-(\d{2})[ T](\d{2}):(\d{2}):(\d{2})\s*(?:UTC|GMT)?\s*([+-]\d{1,2})?(?::?(\d{2}))?/i.exec(
+    message,
+  );
+  if (!match) return null;
+  const [, year, month, day, hour, minute, second, offsetHours, offsetMinutes] = match;
+  if (!year || !month || !day || !hour || !minute || !second) return null;
+  // A bare `UTC+8` means a whole-hour offset; `+08:30`-style halves are rare
+  // but cheap to honor. No offset at all is read as UTC (providers that omit
+  // it always label the stamp "UTC" in practice).
+  const sign = offsetHours?.startsWith("-") ? -1 : 1;
+  const offsetTotalMinutes =
+    offsetHours === undefined
+      ? 0
+      : sign * (Math.abs(Number(offsetHours)) * 60 + Number(offsetMinutes ?? 0));
+  const utcMs = Date.UTC(
+    Number(year),
+    Number(month) - 1,
+    Number(day),
+    Number(hour),
+    Number(minute),
+    Number(second),
+  );
+  if (!Number.isFinite(utcMs)) return null;
+  const targetMs = utcMs - offsetTotalMinutes * 60_000;
+  const delay = targetMs - Date.now();
+  // A past stamp is not a usable reset (clock skew, stale cached error); fall
+  // through to the caller's default instead of returning a negative delay.
+  if (!Number.isFinite(delay) || delay <= 0) return null;
+  return Math.min(MAX_COOLDOWN_MS, Math.round(delay));
+}

package/src/providers/adapters/compatible-adapter.ts

@@ -3,6 +3,7 @@ import type { CanonicalEvent, CanonicalRequest, WireFamily } from "../../protoco
 import { isRecord } from "../../protocol/codecs";
 import {
   classifyUpstreamError,
+  isContextLengthFailure,
   throwIfHtmlResponse,
   mapUpstreamHttpError,
   extractUpstreamMessage,
@@ -408,12 +409,20 @@ export class OpenAICompatibleAdapter extends BaseProviderAdapter {
             value >= 400 &&
             value < 600,
         );
-        const classification = classifyUpstreamError(providerStatus, identifier);
+        // A context-window overflow arrives here on the streaming path with a
+        // numeric code that says nothing (`11115`) and the real cause in
+        // `extError.message`. The status table alone classifies it as a generic
+        // refusal, so the one thing a client acts on — the measured prompt size
+        // against the window — never reached it. The prose/identifier check
+        // mirrors the non-streaming path's pre-table branch.
+        const classification = isContextLengthFailure(json)
+          ? { code: "context_length_exceeded" as const, status: 413, origin: "upstream" as const, credentialEvidence: false, rateLimitScope: undefined }
+          : classifyUpstreamError(providerStatus, identifier);
         const message = extractUpstreamMessage(json) || "Upstream reported an error";
         throw new GatewayError(
           classification.code,
           classification.status,
-          message.slice(0, 300),
+          message,
           {
             providerId: this.provider_id,
             ...(providerStatus === undefined ? {} : { providerStatus }),

package/src/providers/authentication/oauth-refresh-service.ts

@@ -294,17 +294,21 @@ async function disableAccount(
  * "static token" toggle sets — the sweep skips it and its status stops reading
  * as a broken/re-auth account. Not lease-fenced: a non-destructive annotation
  * that any process may write, and the credential is not touched.
+ *
+ * This never changes `status`: a `disabled` account stays `disabled` (only an
+ * operator or an explicit recovery may re-enable it), while an `active` one
+ * stays `active`. The static marker and the error clearing are orthogonal to
+ * the account's health state.
  */
 async function markStaticToken(db: CartethyiaDatabase, accountId: string): Promise<void> {
   await db
     .update(providerAccounts)
     .set({
       staticToken: true,
-      // A static token is a normal, usable credential, not an error state: the
-      // account is `active` and dispatchable, so any error left by the failed
-      // refresh would otherwise keep the row reading "Re-login required" while
-      // it is in fact serving. Mirrors the console's static-token toggle.
-      status: "active",
+      // A static token is a normal, usable credential, not an error state: any
+      // error left by the failed refresh would otherwise keep the row reading
+      // "Re-login required" while it is in fact serving. Mirrors the console's
+      // static-token toggle.
       cooldownUntil: null,
       lastError: null,
       lastErrorCategory: null,

package/src/providers/default-registry.ts

@@ -366,10 +366,11 @@ export const PROVIDER_CAPABILITIES = {
     // catalog row behind it.
     // Dispatch base, not the catalog base: `/zen/v1/models` publishes the
     // listing while `/inference/v1/models` answers 404, and a byte-exact replay
-    // against `/inference/v1` returned 200 where `/zen/v1` did not.
+    // against `/inference/v1` returned 200 where `/zen/v1` did not. The wire
+    // paths are the 2.1 family-segment shapes on the `/inference` origin.
     endpointPathsByWireFamily: {
-      chat: "/inference/v1/chat/completions",
-      responses: "/inference/v1/responses",
+      chat: "/inference/openai/v1/chat/completions",
+      responses: "/inference/openai/v1/responses",
     },
     loadAdapter: async () => createApiKeyAdapter((await import("./integrations/opencode/provider")).OPENCODE_FREE_SPEC),
     loadModels: async () => (await import("./integrations/opencode/provider")).OPENCODE_FREE_MODELS,
@@ -386,8 +387,8 @@ export const PROVIDER_CAPABILITIES = {
   },
   "opencode-zen": {
     endpointPathsByWireFamily: {
-      chat: "/inference/v1/chat/completions",
-      responses: "/inference/v1/responses",
+      chat: "/inference/openai/v1/chat/completions",
+      responses: "/inference/openai/v1/responses",
     },
     loadAdapter: async () => createApiKeyAdapter((await import("./integrations/opencode/provider")).OPENCODE_ZEN_SPEC),
     loadModels: async () => (await import("./integrations/opencode/provider")).OPENCODE_ZEN_MODELS,
@@ -554,6 +555,21 @@ export const PROVIDER_CAPABILITIES = {
       });
     },
   },
+  inception: {
+    // Chat only: Mercury 3 / 2.5 / 2 answer the OpenAI-compatible chat wire.
+    // The base is version-rooted (`/v1`), so the path is declared below it.
+    endpointPathsByWireFamily: { chat: "/chat/completions" },
+    loadAdapter: async () => createApiKeyAdapter((await import("./integrations/inception/provider")).INCEPTION_SPEC),
+    loadModels: async () => (await import("./integrations/inception/provider")).INCEPTION_MODELS,
+    // The listing is bearer-authenticated and the whole provider is pinned to
+    // its free allowance, so every fetched row is stamped free-tier.
+    loadModelDiscovery: async () => async ({ baseUrl, credential, fetcher }) =>
+      (await import("./integrations/inception/provider")).discoverInceptionFreeModels({
+        baseUrl,
+        ...(typeof credential === "string" && credential.length > 0 ? { credential } : {}),
+        ...(fetcher === undefined ? {} : { fetcher }),
+      }),
+  },
   openrouter: {
     loadAdapter: async () => createApiKeyAdapter((await import("./integrations/openrouter/provider")).OPENROUTER_SPEC),
     // One dynamic import for both halves: this registry lazy-loads every
@@ -698,6 +714,7 @@ export const PROVIDER_CAPABILITIES = {
       responses: "/responses",
     },
     loadAdapter: async () => createApiKeyAdapter(GENERIC_API_KEY_SPECS.ollamacloud),
+    loadModels: async () => (await import("./integrations/ollamacloud-models")).OLLAMACLOUD_MODELS,
     loadQuotaCollector: quotaCapability(() => import("./integrations/ollamacloud-quota"), "fetchOllamaQuota"),
     loadModelDiscovery: openAIModelDiscovery("ollamacloud", { headers: (credential) => ({ authorization: `Bearer ${credential}` }) }),
   },