cartethyia 2.6.7 → 2.7.1

package/src/observability/metrics.ts

@@ -267,6 +267,16 @@ export class PrometheusRegistry {
   readonly cartethyia_redis_up: GaugeMetric;
   readonly proxy_requests_total: CounterMetric;
   readonly proxy_admission_total: CounterMetric;
+  /**
+   * Refusals from the per-IP abuse layer, by reason.
+   *
+   * These are the only 429s this process produces before dispatch, and they
+   * were invisible: a client-facing 429 could come from here, from admission,
+   * or from the upstream, and nothing recorded which. `ip-rate-limited` is the
+   * sliding window and `ip-banned` the escalation — different remedies, so
+   * they must not share a number.
+   */
+  readonly cartethyia_ip_abuse_refusals_total: CounterMetric;
   readonly proxy_in_flight: GaugeMetric;
   readonly proxy_request_latency_ms: HistogramMetric;
   readonly cartethyia_telemetry_buffered: GaugeMetric;
@@ -280,7 +290,6 @@ export class PrometheusRegistry {
   readonly cartethyia_quota_cache_entries: GaugeMetric;
   readonly cartethyia_model_catalog_entries: GaugeMetric;
   readonly cartethyia_process_in_flight: GaugeMetric;
-  readonly cartethyia_process_concurrency_limit: GaugeMetric;
   readonly cartethyia_telemetry_backlog_items: GaugeMetric;
   readonly cartethyia_telemetry_backlog_bytes: GaugeMetric;
   readonly cartethyia_proxy_dial_proxy_resolved_total: CounterMetric;
@@ -321,6 +330,11 @@ export class PrometheusRegistry {
       "Admission decisions by reason",
       ["reason"],
     );
+    this.cartethyia_ip_abuse_refusals_total = this.counter(
+      "cartethyia_ip_abuse_refusals_total",
+      "Requests refused by the per-IP abuse limit, by reason",
+      ["reason"],
+    );
     this.proxy_in_flight = this.gauge(
       "proxy_in_flight",
       "Provider dispatch requests currently in flight on this process",
@@ -358,10 +372,6 @@ export class PrometheusRegistry {
       "cartethyia_process_in_flight",
       "Gateway requests currently admitted into this process",
     );
-    this.cartethyia_process_concurrency_limit = this.gauge(
-      "cartethyia_process_concurrency_limit",
-      "Effective in-flight ceiling for this process, derived from the memory limit",
-    );
     this.cartethyia_telemetry_backlog_items = this.gauge(
       "cartethyia_telemetry_backlog_items",
       "Telemetry events queued for the next drain",

package/src/observability/runtime-metrics.ts

@@ -8,6 +8,7 @@
  * layers, keeping the observability boundary one-directional.
  */
 import { readFileSync } from "node:fs";
+import os from "node:os";
 import { metrics } from "./metrics";
 import { trackMemoryUsage } from "./performance-metrics";
 import { log } from "./logger";
@@ -66,12 +67,34 @@ const PRESSURE_GC_WINDOW_MS = 60_000;
 /** Fraction of the resolved limit at which memory pressure is reported. */
 const PRESSURE_THRESHOLD = 0.8;
 /**
- * Fallback limit used when neither an override nor a cgroup limit is
- * discoverable (native development, macOS, Windows). Without it the pressure
- * check bails and `Bun.gc` never runs, so an idle process holds its startup
- * peak forever. 512 MiB keeps reclaim active without assuming a container.
+ * Fallback limit when neither an override nor a cgroup limit is discoverable
+ * (native development, macOS, Windows).
+ *
+ * A fixed 512 MiB made every machine without a cgroup look like a 512 MiB
+ * container. On a desktop running the gateway natively that is far below what
+ * the machine has, so the pressure check fired against a number that described
+ * nothing — "RSS 430 MiB exceeds 80% of the 512 MiB limit" on a machine with
+ * gigabytes free — and the concurrency cap derived from it admitted a handful
+ * of requests while every tenant-level setting sat unreachable above it.
+ *
+ * The host's real memory is the honest stand-in. It is what the process can
+ * actually grow into here, and it is what "no container limit" means.
  */
-const DEFAULT_MEMORY_LIMIT_BYTES = 512 * 1024 * 1024;
+function defaultMemoryLimitBytes(): number {
+  try {
+    const total = os.totalmem();
+    if (Number.isFinite(total) && total > 0) return total;
+  } catch {
+    // Platform without totalmem; fall through to the last-resort constant.
+  }
+  return LAST_RESORT_MEMORY_LIMIT_BYTES;
+}
+
+/**
+ * Used only when the host's memory cannot be read at all. Deliberately large
+ * so an unmeasurable host is not treated as a small container.
+ */
+const LAST_RESORT_MEMORY_LIMIT_BYTES = 4 * 1024 * 1024 * 1024;
 /** Cooldown between idle full collections. */
 const IDLE_GC_WINDOW_MS = 5 * 60_000;
 /** RSS retained above the post-collection baseline before another idle collection runs. */
@@ -88,7 +111,7 @@ const IDLE_GC_MIN_GROWTH_BYTES = 32 * 1024 * 1024;
 export function resolveMemoryLimitBytes(): number | undefined {
   const override = resolveMemoryLimitOverrideBytes();
   if (override !== undefined) return override;
-  if (process.platform !== "linux") return DEFAULT_MEMORY_LIMIT_BYTES;
+  if (process.platform !== "linux") return defaultMemoryLimitBytes();
   for (const path of [
     "/sys/fs/cgroup/memory.max",
     "/sys/fs/cgroup/memory/memory.limit_in_bytes",
@@ -103,7 +126,7 @@ export function resolveMemoryLimitBytes(): number | undefined {
       // File absent (cgroup v1 vs v2) or unreadable — try the next source.
     }
   }
-  return DEFAULT_MEMORY_LIMIT_BYTES;
+  return defaultMemoryLimitBytes();
 }
 
 /** Samples process memory and bounded-collection sizes into the metric registry. */
@@ -120,8 +143,6 @@ export class RuntimeMetricsSampler {
    * first sample runs; consumers must treat that as "unknown", not as zero.
    */
   private snapshot: RuntimeMemorySnapshot | undefined;
-  /** The effective concurrency ceiling, published alongside the gauges. */
-  private concurrencyLimit: number | undefined;
 
   /**
    * Binds the live in-flight count after the request state store exists. The
@@ -149,9 +170,6 @@ export class RuntimeMetricsSampler {
    * limit, which is known here, but the guard that owns it is constructed in
    * the transport layer.
    */
-  bindConcurrencyLimit(limit: number): void {
-    this.concurrencyLimit = limit;
-  }
 
   constructor(
     private readonly sources: RuntimeMetricSources,
@@ -198,9 +216,6 @@ export class RuntimeMetricsSampler {
       metrics.cartethyia_telemetry_backlog_items.set(backlog.items);
       metrics.cartethyia_telemetry_backlog_bytes.set(backlog.bytes);
     }
-    if (this.concurrencyLimit !== undefined) {
-      metrics.cartethyia_process_concurrency_limit.set(this.concurrencyLimit);
-    }
 
     this.checkPressure(memory.rss);
     this.checkIdleReclaim(memory.rss);

package/src/persistence/health-event-flush.ts

@@ -15,6 +15,7 @@
 // Same shape as `persistence/usage-flush.ts`: enqueue and return, a timer
 // flushes, shutdown flushes what remains. A crash loses the unflushed rows and
 // nothing else — the durable state routing depends on was never in here.
+import { randomUUID } from "node:crypto";
 import type { CartethyiaDatabase } from "./db-handle";
 import { healthEvents } from "./schema";
 
@@ -141,6 +142,7 @@ export class HealthEventFlushBuffer {
     try {
       await this.db.insert(healthEvents).values(
         batch.map((row) => ({
+          id: randomUUID(),
           entityKind: row.entityKind,
           accountId: row.accountId ?? null,
           networkPoolId: row.networkPoolId ?? null,

package/src/persistence/schema.ts

@@ -490,6 +490,24 @@ export const networkPools = pgTable("network_pools", {
   /** The endpoint the verdict was measured against. Compared on read, so an
    * edited endpoint reports "never probed" instead of a stale verdict. */
   providerProbeEndpoint: text("provider_probe_endpoint"),
+  /**
+   * The database mirror of the pool selector's provider cooldown state, one
+   * entry per cooling provider keyed by its lowercased id:
+   * `{ "opencode": { "until": <epoch ms>, "reason": "...", "blocked": false } }`.
+   *
+   * The selector's own map is process-local (mirrored to Redis when present),
+   * so a restart dropped every flag while the upstream kept refusing the
+   * egress — dispatch re-picked a spent pool and the console showed nothing.
+   * The dispatch-side flaggers write each marker here, and boot reads this
+   * column back into the selector, so the state survives a restart the way the
+   * upstream's memory of the address does.
+   *
+   * `null` means no provider was ever flagged. Expired entries are left inert
+   * until the next write for the pool rather than swept eagerly: a marker with
+   * `until` in the past is skipped by every reader.
+   */
+  providerCooldowns: jsonb("provider_cooldowns")
+    .$type<Record<string, { until: number; reason: string; blocked?: boolean }>>(),
   /** Metered egress totals, flushed from the in-memory socket counters on
    * every pool-touching write so the quota bar survives a restart. */
   bytesSentTotal: bigint("bytes_sent_total", { mode: "number" }).notNull().default(0),
@@ -676,6 +694,7 @@ export const providerRoutingSettings = pgTable(
 export const poolRoutingStrategy = pgEnum("pool_routing_strategy", [
   "least_loaded",
   "round_robin",
+  "random",
 ]);
 export type PoolRoutingStrategy = (typeof poolRoutingStrategy.enumValues)[number];
 

package/src/persistence/usage-flush.ts

@@ -145,13 +145,18 @@ export class UsageFlushBuffer {
    * cost the others their delta. A key whose write fails goes back into the
    * pending map, added to anything enqueued while the flush ran, so a
    * transient failure retries instead of dropping.
+   *
+   * `force` bypasses the outage backoff. The scheduled timer never passes it —
+   * a failing database should not be probed on every tick — but `stop({flush:
+   * true})` must, or a shutdown during a backoff window would return without
+   * even attempting to persist the pending deltas.
    */
-  async flush(): Promise<void> {
+  async flush(options?: { force?: boolean }): Promise<void> {
     if (this.flushing || this.pending.size === 0) return;
     // Backing off during a sustained outage: without this the writer probed a
     // failing database on every tick, adding write load to the very overload
     // that caused the failure.
-    if (Date.now() < this.backoffUntil) return;
+    if (Date.now() < this.backoffUntil && options?.force !== true) return;
     this.flushing = true;
     const batch = new Map(this.pending);
     this.pending.clear();
@@ -210,7 +215,7 @@ export class UsageFlushBuffer {
       clearTimeout(this.timer);
       this.timer = undefined;
     }
-    if (options?.flush) await this.flush();
+    if (options?.flush) await this.flush({ force: true });
   }
 
   private arm(): void {

package/src/protocol/canonical-model.ts

@@ -52,7 +52,7 @@ export type ServiceKind = (typeof SERVICE_KINDS)[number];
  * their membership set from it, and the probe route's accepted subset is
  * declared separately because it is deliberately narrower.
  */
-export const REASONING_EFFORTS = ["none", "minimal", "low", "medium", "high", "xhigh", "max"] as const;
+export const REASONING_EFFORTS = ["none", "instant", "minimal", "low", "medium", "high", "xhigh", "max"] as const;
 
 /** One canonical reasoning effort. */
 export type ReasoningEffort = (typeof REASONING_EFFORTS)[number];

package/src/protocol/dsml.ts

@@ -0,0 +1,377 @@
+/**
+ * Canonical DSML (DeepSeek Markup Language) tool-call recovery.
+ *
+ * DeepSeek-family models occasionally write their tool calls as XML-like DSML
+ * markup inside the plain-text content stream instead of the structured
+ * `tool_calls` field. Two upstream families in this gateway see it:
+ *
+ * - CodeBuddy/WorkBuddy emit strict blocks (`<｜DSML｜ calls>…</｜DSML｜ calls>`)
+ *   that must be parsed exactly, with declared-tool allowlisting.
+ * - Qoder emits looser blocks (`<[^>]*DSML[^>]*calls>…`) that tolerate any
+ *   intermediate characters in the tag, and its parameter values are plain
+ *   strings.
+ *
+ * The two share the same recovery idea, so the mechanics live here once and
+ * each caller picks its dialect through options. The defaults reproduce the
+ * CodeBuddy dialect exactly (`app/dsml.py` in codebuddy2api); Qoder passes
+ * `fuzzy: true` and its id factory, mirroring `qoder_proxy.py`.
+ */
+import { randomUUID } from "node:crypto";
+
+export interface DsmlToolCall {
+  readonly id: string;
+  readonly name: string;
+  readonly arguments: string;
+}
+
+export interface DsmlRecovery {
+  readonly calls: readonly DsmlToolCall[];
+  readonly clean: string;
+}
+
+export interface DsmlParseOptions {
+  /** Separator spellings a strict block may use (CodeBuddy dialect). */
+  readonly separators?: readonly string[];
+  /** Block names a strict opener may name. */
+  readonly blockNames?: readonly string[];
+  /** When true, match the Qoder fuzzy form (`<[^>]*DSML[^>]*…`). */
+  readonly fuzzy?: boolean;
+  /** How parameter values decode: `json` (CodeBuddy) or `string` (Qoder). */
+  readonly params?: "json" | "string";
+  /** Call id factory. Defaults to sequential for strict, uuid for fuzzy. */
+  readonly id?: (call: { readonly name: string }, index: number, seq: number) => string;
+  /** Non-empty allowlist makes the strict dialect reject undeclared names. */
+  readonly allowedNames?: ReadonlySet<string>;
+  /**
+   * When true, JSON stringifies argument objects with recursively sorted keys,
+   * matching the reference bridge (`json.dumps(..., sort_keys=True)`). The
+   * strict dialect defaults to true; the fuzzy dialect never sorts, matching
+   * its reference's `json.dumps(params)`.
+   */
+  readonly sortKeys?: boolean;
+  /**
+   * Character cap for an unclosed strict block. Past it, the block is treated
+   * as plain text and passed through instead of buffered indefinitely — same
+   * fail-open as `MAX_BLOCK_BYTES` in the reference bridge (256 KB).
+   */
+  readonly maxBlockBytes?: number;
+}
+
+const DEFAULT_SEPARATORS = ["｜｜", "｜", "|"] as const;
+const DEFAULT_BLOCK_NAMES = ["calls", "function_calls"] as const;
+const DEFAULT_MAX_BLOCK_BYTES = 256 * 1024;
+const TOOL_NAME = /^[A-Za-z0-9_][A-Za-z0-9_.:-]{0,63}$/;
+
+/** Escapes regex metacharacters so a `|` separator is literal, not alternation. */
+export function escapeRegExp(value: string): string {
+  return value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+
+function openers(separators: readonly string[], blockNames: readonly string[]): readonly string[] {
+  return separators.flatMap((separator) => blockNames.map((name) => `<${separator}DSML${separator} ${name}>`));
+}
+
+function sequentialId(_call: { readonly name: string }, _index: number, seq: number): string {
+  return `call_dsml_${seq}_${_call.name}`;
+}
+
+function uuidId(_call: { readonly name: string }, _index: number, _seq: number): string {
+  return `call_${randomUUID().replace(/-/g, "").slice(0, 16)}`;
+}
+
+export interface DsmlParseResult {
+  readonly text: string;
+  readonly calls: readonly DsmlToolCall[];
+}
+
+/**
+ * Streaming strict-prefix parser (CodeBuddy dialect). Buffers text until a
+ * complete block is seen, emits clean prose as it settles, and recovers calls
+ * from complete blocks only. Incomplete blocks stay text; an unclosed block
+ * past `maxBlockBytes` passes through as text instead of buffering forever.
+ * With no allowlist the generic name rule applies; with one, undeclared names
+ * reject the whole block. The caller feeds chunks with `push` and drains the
+ * tail with `flush`.
+ */
+export class DsmlStreamParser {
+  readonly #separators: readonly string[];
+  readonly #blockNames: readonly string[];
+  readonly #openers: readonly string[];
+  readonly #allowedNames: ReadonlySet<string>;
+  readonly #params: "json" | "string";
+  readonly #sortKeys: boolean;
+  readonly #maxBlockBytes: number;
+  readonly #id: (call: { readonly name: string }, index: number, seq: number) => string;
+  #pending = "";
+  #callSequence = 0;
+
+  constructor(options: DsmlParseOptions = {}) {
+    this.#separators = options.separators ?? DEFAULT_SEPARATORS;
+    this.#blockNames = options.blockNames ?? DEFAULT_BLOCK_NAMES;
+    this.#openers = openers(this.#separators, this.#blockNames);
+    this.#allowedNames = options.allowedNames ?? new Set();
+    this.#params = options.params ?? "json";
+    this.#sortKeys = options.sortKeys ?? true;
+    this.#maxBlockBytes = options.maxBlockBytes ?? DEFAULT_MAX_BLOCK_BYTES;
+    this.#id = options.id ?? sequentialId;
+  }
+
+  push(chunk: string): DsmlParseResult {
+    this.#pending += chunk;
+    let cursor = 0;
+    let visible = "";
+    const calls: DsmlToolCall[] = [];
+    for (;;) {
+      let openIndex = -1;
+      let opener = "";
+      for (const candidate of this.#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 = this.#separators.find((value) => opener.startsWith(`<${value}DSML`));
+      const blockName = this.#blockNames.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) {
+        // An unclosed block past the cap is not markup — pass it through as
+        // text instead of buffering it indefinitely. Same fail-open as
+        // `feed()` in the reference bridge's `MAX_BLOCK_BYTES` guard.
+        if (this.#pending.length - openIndex > this.#maxBlockBytes) {
+          visible += this.#pending.slice(openIndex);
+          cursor = this.#pending.length;
+          break;
+        }
+        cursor = openIndex;
+        break;
+      }
+      const end = closeIndex + close.length;
+      const block = this.#pending.slice(openIndex, end);
+      const parsed = parseStrictBlock(block, opener, close, separator, this.#allowedNames, this.#params, this.#sortKeys);
+      if (parsed === undefined) visible += block;
+      else {
+        parsed.forEach((call, index) => {
+          calls.push({ ...call, id: this.#id(call, index, this.#callSequence++) });
+        });
+      }
+      cursor = end;
+    }
+    this.#pending = this.#pending.slice(cursor);
+    return { text: visible, calls };
+  }
+
+  flush(): DsmlParseResult {
+    const text = this.#pending;
+    this.#pending = "";
+    return { text, calls: [] };
+  }
+
+  #settledEnd(start: number): number {
+    const remaining = this.#pending.slice(start);
+    const maxOpener = this.#openers.reduce((max, opener) => Math.max(max, opener.length - 1), 0);
+    for (let length = Math.min(maxOpener, remaining.length); length > 0; length -= 1) {
+      const suffix = remaining.slice(-length);
+      if (this.#openers.some((opener) => opener.startsWith(suffix))) return this.#pending.length - length;
+    }
+    return this.#pending.length;
+  }
+}
+
+function parseStrictBlock(
+  block: string,
+  opener: string,
+  close: string,
+  separator: string,
+  allowedNames: ReadonlySet<string>,
+  params: "json" | "string",
+  sortKeys: boolean,
+): 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 (params === "string") args[key] = raw;
+      else 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(sortKeys ? normalizeForSort(args) : args) });
+    cursor = invokeEnd + invokeClose.length;
+  }
+  return calls.length > 0 && inner.slice(cursor).trim().length === 0 ? calls : undefined;
+}
+
+/**
+ * Returns `value` with plain-object keys recursively sorted, mirroring the
+ * reference bridge's `json.dumps(..., sort_keys=True)`. Arrays keep their
+ * order — sorting applies to object keys only.
+ */
+function normalizeForSort(value: unknown): unknown {
+  if (typeof value !== "object" || value === null || Array.isArray(value)) return value;
+  const record = value as Record<string, unknown>;
+  const out: Record<string, unknown> = {};
+  for (const key of Object.keys(record).sort()) out[key] = normalizeForSort(record[key]);
+  return out;
+}
+
+/** The Qoder fuzzy block scanner, mirroring the reference bridge's regexes. */
+const FUZZY_CALLS_RE = /<[^>]*DSML[^>]*calls>([\s\S]*?)<\/[^>]*DSML[^>]*calls>/;
+const FUZZY_INVOKE_RE = /<[^>]*DSML[^>]*invoke\s+name=["']([^"']+)["']>([\s\S]*?)<\/[^>]*invoke>/g;
+const FUZZY_PARAM_RE = /<[^>]*DSML[^>]*parameter\s+name=["']([^"']+)["'][^>]*>([\s\S]*?)<\/[^>]*parameter>/g;
+
+function parseFuzzyDsml(text: string, options: DsmlParseOptions): DsmlRecovery {
+  const id = options.id ?? uuidId;
+  if (text.length === 0 || !text.includes("DSML")) return { calls: [], clean: text };
+
+  const callsMatch = FUZZY_CALLS_RE.exec(text);
+  let block: string;
+  let clean: string;
+
+  if (callsMatch) {
+    block = callsMatch[1] ?? "";
+    const before = text.slice(0, callsMatch.index).trimEnd();
+    const after = text.slice(callsMatch.index + callsMatch[0].length).trimStart();
+    clean = (before + " " + after).trim();
+  } else {
+    // No <calls> wrapper (issue #51): find bare <invoke> blocks in the whole
+    // text, then cut the prose off at the last `<` before the first invoke —
+    // exclusive of the invoke's own tag start, exactly like the reference's
+    // `text.rfind("<", 0, first_index)`.
+    FUZZY_INVOKE_RE.lastIndex = 0;
+    const first = FUZZY_INVOKE_RE.exec(text);
+    if (!first) return { calls: [], clean: text };
+    block = text;
+    const cut = text.lastIndexOf("<", first.index - 1);
+    clean = text.slice(0, cut >= 0 ? cut : first.index).trim();
+  }
+
+  const calls: DsmlToolCall[] = [];
+  FUZZY_INVOKE_RE.lastIndex = 0;
+  let inv: RegExpExecArray | null;
+  let seq = 0;
+  while ((inv = FUZZY_INVOKE_RE.exec(block)) !== null) {
+    const params: Record<string, string> = {};
+    FUZZY_PARAM_RE.lastIndex = 0;
+    let par: RegExpExecArray | null;
+    while ((par = FUZZY_PARAM_RE.exec(inv[2] ?? "")) !== null) {
+      params[par[1] ?? ""] = (par[2] ?? "").trim();
+    }
+    const call = { name: inv[1] ?? "", arguments: JSON.stringify(params) };
+    calls.push({ ...call, id: id(call, calls.length, seq++) });
+  }
+
+  return { calls, clean };
+}
+
+/**
+ * Recovers DSML tool calls from one plain-text string using the Qoder fuzzy
+ * dialect. Always returns `{ calls, clean }` — no-DSML input returns the text
+ * unchanged with no calls.
+ */
+export function parseFuzzyDsmlToolCalls(text: string): DsmlRecovery {
+  return parseFuzzyDsml(text, {});
+}
+
+/**
+ * Recovers DSML tool calls from one plain-text string. The dialect is chosen
+ * by `options.fuzzy`; each dialect keeps its exact public shape:
+ *
+ * - strict (CodeBuddy): returns `{ text, calls }`, with `text` the clean
+ *   prose; `undefined` when nothing was recovered.
+ * - fuzzy (Qoder): returns `{ clean, calls }`, with no-DSML input returning
+ *   `{ calls: [], clean: text }`.
+ *
+ * Callers that need the streaming strict parser use {@link DsmlStreamParser}.
+ */
+export function parseDsmlToolCalls(
+  text: string,
+  options: DsmlParseOptions = {},
+): DsmlRecovery | DsmlParseResult | undefined {
+  if (options.fuzzy === true) return parseFuzzyDsml(text, options);
+  if (!text.includes("DSML")) return undefined;
+  const parser = new DsmlStreamParser(options);
+  const first = parser.push(text);
+  const last = parser.flush();
+  const recovered = [...first.calls, ...last.calls];
+  return recovered.length === 0 ? undefined : { text: `${first.text}${last.text}`.trim(), calls: recovered };
+}
+
+/**
+ * The holdable tail of a content chunk: a short suffix that looks like the
+ * start of a DSML tag and may finish in the next frame. Empty when there is
+ * nothing worth holding. Mirrors `_dsml_tail_hold` in the reference bridge.
+ */
+export function dsmlTailHold(text: string): string {
+  const at = text.lastIndexOf("<");
+  if (at < 0 || text.length - at > 24) return "";
+  const tail = text.slice(at);
+  // A complete tag already — nothing to wait for.
+  if (tail.includes(">")) return "";
+  const body = tail.replace(/\uFF5C/g, "|").toUpperCase().slice(1).replace(/^\//, "");
+  if (body.length === 0) return tail; // bare "<" or "</"
+  if (!body.startsWith("|")) return "";
+  const rest = body.slice(1);
+  if (rest.length === 0) return tail;
+  if ("DSML".startsWith(rest) || rest.startsWith("DSML")) return tail;
+  return "";
+}
+
+const DSML_CLOSE_TAG_RE = /<\/(?:[^>]*DSML[^>]*|parameter|invoke|calls|tool_calls|function_calls)\s*>\s*$/i;
+
+/**
+ * Removes leftover DSML closing tags from the tail of a text. Anchored to the
+ * end and looped, so several trailing tags come off one per pass; a closing
+ * tag in the middle of a text is not residue and is preserved.
+ */
+export function stripDsmlCloseTags(text: string): string {
+  let previous: string | null = null;
+  let out = text.trimEnd();
+  while (previous !== out) {
+    previous = out;
+    out = out.replace(DSML_CLOSE_TAG_RE, "").trimEnd();
+  }
+  return out;
+}

package/src/protocol/gateway-error.ts

@@ -52,7 +52,6 @@ export type GatewayErrorCode =
   | "proxy_unreachable"
   | "tool_call_loop_detected"
   | "client_router_denied"
-  | "model_abuse_banned"
   | "shutting_down"
   | "restart_for_update";
 

package/src/{providers/provider-reasoning.ts → protocol/reasoning.ts}

@@ -1,6 +1,6 @@
-import type { CanonicalRequest, ReasoningEffort, ReasoningIntent } from "../protocol/canonical-model";
-import { budgetToLevel } from "../transport/translation/thinking";
-import { isRecord } from "../protocol/codecs";
+import type { CanonicalRequest, ReasoningEffort, ReasoningIntent } from "./canonical-model";
+import { budgetToLevel } from "./translation/thinking";
+import { isRecord } from "./codecs";
 
 /**
  * The effective reasoning effort for a canonical intent, deriving one from an
@@ -132,12 +132,13 @@ const CLAMPED_EFFORT_MIN_OUTPUT_TOKENS = 16_384;
 const BUDDY_LEVEL_RANK: Readonly<Record<string, number>> = {
   off: 0,
   none: 0,
-  minimal: 1,
-  low: 2,
-  medium: 3,
-  high: 4,
-  xhigh: 5,
-  max: 6,
+  instant: 1,
+  minimal: 2,
+  low: 3,
+  medium: 4,
+  high: 5,
+  xhigh: 6,
+  max: 7,
 };
 
 /** Builds the Anthropic thinking block from canonical reasoning intent. */

package/src/protocol/request/chat.ts

@@ -3,18 +3,18 @@
  */
 import type { CanonicalRequest, ResponseFormat } from "../canonical-model";
 import { isRecord } from "../codecs";
-import { markLatestBreakpoint } from "../../transport/translation/cache-controls";
-import { isWebSearchTool } from "../../transport/translation/search";
-import { pickWireSupportedControls } from "../../transport/translation/capabilities";
-import { normalizeWireMaxTokens } from "../../transport/translation/normalize";
-import { resolveWireMaxTokens } from "../../transport/translation/quirks";
+import { markLatestBreakpoint } from "../../protocol/translation/cache-controls";
+import { isWebSearchTool } from "../../protocol/translation/search";
+import { pickWireSupportedControls } from "../../protocol/translation/capabilities";
+import { normalizeWireMaxTokens } from "../../protocol/translation/normalize";
+import { resolveWireMaxTokens } from "../../protocol/translation/quirks";
 import {
   clampReasoningEffort,
   resolveSupportedReasoningEfforts,
-} from "../../transport/translation/thinking";
+} from "../../protocol/translation/thinking";
 import { isClaudeBillingHeaderText, resolveImageSource } from "../codecs";
 import { resolvePromptCacheKey } from "../../providers/operations/session-resolution";
-import { reasoningEffortFromIntent } from "../../providers/provider-reasoning";
+import { reasoningEffortFromIntent } from "../../protocol/reasoning";
 import { parseChatResponseToEvents, decodeChatSseStream } from "../response/chat";
 
 /**