cartethyia 2.4.4 → 2.4.6

package/src/providers/integrations/qoder/qoder-oauth.ts

@@ -17,6 +17,7 @@
  */
 import { createHash, randomBytes, randomUUID } from "node:crypto";
 import {
+  base64UrlEncode,
   nonEmptyTrimmedString,
   record,
 } from "../../authentication/oauth-flow-store";
@@ -58,13 +59,6 @@ export function parseQoderOAuthState(value: unknown): QoderOAuthState | undefine
   return { userId, machineId };
 }
 
-function base64Url(buffer: Buffer): string {
-  return buffer
-    .toString("base64")
-    .replace(/=/g, "")
-    .replace(/\+/g, "-")
-    .replace(/\//g, "_");
-}
 
 /**
  * Converts the upstream's expiry hint into a Unix-millisecond timestamp.
@@ -131,8 +125,8 @@ export class QoderOAuthClient extends OAuthDeviceFlow {
   override async startDeviceAuth(
     _context?: OAuthDeviceFlowContext,
   ): Promise<OAuthDeviceStartResult> {
-    const verifier = base64Url(randomBytes(32));
-    const challenge = base64Url(createHash("sha256").update(verifier).digest());
+    const verifier = base64UrlEncode(randomBytes(32));
+    const challenge = base64UrlEncode(createHash("sha256").update(verifier).digest());
     const nonce = randomUUID();
     const machineId = randomUUID();
     const params = new URLSearchParams({

package/src/providers/integrations/shared/install-id.ts

@@ -53,17 +53,44 @@ function installIdDirectories(): readonly string[] {
  * process so a request does not see a different identity than the one before
  * it, which is the least surprising behaviour available when persistence is
  * impossible.
+ *
+ * Both maps are bounded: the key is derived from the install-id *path*, so an
+ * unbounded map would grow with every directory an operator ever pointed
+ * `CARTETHYIA_INSTALL_ID_DIR` at. The cap matches the other per-process
+ * identity caches (`qoderMachineIds`, `MAX_SESSION_STATES` in antigravity):
+ * oldest-first eviction, which for an identity cache only costs a fresh uuid.
  */
+const MAX_IN_MEMORY_IDS = 1024;
 const inMemoryIds = new Map<string, string>();
 const warnedPaths = new Set<string>();
 
+/** Evicts oldest-first once the cap is exceeded. */
+function boundMapInsert<K, V>(map: Map<K, V>, key: K, value: V): void {
+  map.set(key, value);
+  while (map.size > MAX_IN_MEMORY_IDS) {
+    const oldest = map.keys().next();
+    if (oldest.done === true) break;
+    map.delete(oldest.value);
+  }
+}
+
+/** Evicts oldest-first once the cap is exceeded. */
+function boundSetInsert(set: Set<string>, value: string): void {
+  set.add(value);
+  while (set.size > MAX_IN_MEMORY_IDS) {
+    const oldest = set.values().next();
+    if (oldest.done === true) break;
+    set.delete(oldest.value);
+  }
+}
+
 function fallbackId(key: string, path: string, reason: unknown): string {
   const existing = inMemoryIds.get(key);
   if (existing !== undefined) return existing;
   const id = randomUUID();
-  inMemoryIds.set(key, id);
+  boundMapInsert(inMemoryIds, key, id);
   if (!warnedPaths.has(key)) {
-    warnedPaths.add(key);
+    boundSetInsert(warnedPaths, key);
     const message = reason instanceof Error ? reason.message : String(reason);
     log.warn(
       `[install-id] could not persist "${path}" (${message}); using an id that ` +

package/src/providers/operations/client-versions.ts

@@ -525,9 +525,19 @@ export const getKimiCliVersion = accessor("kimiCli").get;
 
 export const getCodeBuddyVersion = accessor("codebuddy").get;
 export const getCodeBuddyCnVersion = accessor("codebuddyCn").get;
+/**
+ * The CodeBuddy User-Agent.
+ *
+ * Both identities share the CLI *package* version, which is why `codebuddy`
+ * (the npm `@tencent-ai/codebuddy-code` pin, `2.168.2` — the value both
+ * references use for CLI) is the version for each. `codebuddyCn` is the CN
+ * *desktop* build (`4.12.2.…`), and using it here produced
+ * `CLI/4.12.2.41207131 CodeBuddy/4.12.2.41207131` — a CLI claiming a desktop
+ * version, which no official client emits.
+ */
 export function buildCodeBuddyUserAgent(
   identity: "IDE" | "CLI",
-  version = identity === "CLI" ? getCodeBuddyCnVersion() : getCodeBuddyVersion(),
+  version = getCodeBuddyVersion(),
 ): string {
   return `${identity}/${version} CodeBuddy/${version}`;
 }

package/src/providers/operations/model-catalog-cache.ts

@@ -14,10 +14,14 @@ import { cachedRead } from "../../console/shared/read-through-cache";
 
 /**
  * Provider entries retained before the least-recently-used catalog is evicted.
- * One entry per provider is tiny, but an unbounded cache would pin every
- * catalog for the process lifetime.
+ *
+ * Must clear the bundled provider count — there are **73** of them — because a
+ * cap below it thrashes: a catalog rebuild evicts a provider it is about to
+ * need again, so `bundledModelCatalog()` re-imports a module it already had.
+ * Sized above that count with room for BYOK rows. One entry is a model list, so
+ * the bound still matters; it just has to be the right one.
  */
-export const MODEL_CATALOG_CACHE_MAX_ENTRIES = 64;
+export const MODEL_CATALOG_CACHE_MAX_ENTRIES = 128;
 
 /**
  * Cross-instance tier lifetime. Static provider catalogs change only on a
@@ -82,3 +86,14 @@ export function getCachedModels(
 export function resetModelCatalogCacheForTesting(): void {
   catalogCache.clear();
 }
+
+/**
+ * Live entry count, for the `/metrics` gauge.
+ *
+ * Exported so a rebuild that saturates the cap is visible from outside the
+ * process: before this, every in-process cache except the quota tier was
+ * invisible, and growth could only be found with a heap dump.
+ */
+export function modelCatalogCacheSize(): number {
+  return catalogCache.size;
+}

package/src/providers/operations/provider-catalog-service.ts

@@ -20,6 +20,57 @@ import { GATEWAY_USER_AGENT } from "./gateway-user-agent";
 import { isIP } from "node:net";
 import { isAddressAllowed } from "../../network/ssrf";
 import type { SsrfPolicy } from "../../config/network";
+
+/**
+ * Revision of the compiled provider catalog, and the last one materialized.
+ *
+ * The snapshot builder re-seeds on **every** rebuild, and a re-seed is a
+ * `DELETE` per provider plus a full `INSERT … ON CONFLICT DO UPDATE` of the
+ * compiled catalog. That is correct work when the catalog changed and pure
+ * waste when it did not — and the invalidation that triggers it is a timer
+ * (`account-health-sweep`), so the waste lands on a proxy request.
+ *
+ * Only the paths that can actually change the compiled catalog bump this: a
+ * provider registered, edited, or retired. A cooldown recovery changes account
+ * health, not the catalog, so it must not.
+ */
+let catalogRevision = 0;
+let lastSeededCatalogRevision = -1;
+
+/** Current catalog revision. */
+export function currentCatalogRevision(): number {
+  return catalogRevision;
+}
+
+/** Bumps the revision after a change to the compiled catalog. */
+export function bumpCatalogRevision(): number {
+  catalogRevision += 1;
+  return catalogRevision;
+}
+
+/**
+ * Forces the next re-seed to run even when the revision is unchanged.
+ *
+ * For the boot path and for tests: the compiled catalog has to be materialized
+ * once for the current process regardless of what an earlier call already
+ * applied, because a fresh database or a fresh registry is not a revision
+ * change.
+ */
+export function invalidateCatalogSeed(): void {
+  lastSeededCatalogRevision = -1;
+}
+
+/**
+ * Records that the caller has just materialized the current catalog itself, so
+ * the next `refreshActiveProviderCatalogs` is a no-op.
+ *
+ * The boot path seeds directly rather than through the gate — it must always
+ * run, against a database and a registry that are both fresh — and without this
+ * the first snapshot build would pay for a second identical seed.
+ */
+export function markCatalogSeeded(): void {
+  lastSeededCatalogRevision = catalogRevision;
+}
 /**
  * Idempotently materializes every shipped provider in the database catalog.
  * The canonical provider definition supplies identity and routing defaults;
@@ -60,6 +111,9 @@ export async function seedBundledProviders(db: CartethyiaDatabase): Promise<void
         ),
       },
     });
+  // The compiled catalog is derived from the registry, and this is the path
+  // that reconciles the bundle's own rows into it.
+  bumpCatalogRevision();
 }
 
 /**
@@ -94,6 +148,9 @@ export async function retireUnbundledProviders(db: CartethyiaDatabase): Promise<
     .delete(providers)
     .where(and(isNull(providers.tenantId), notInArray(providers.id, bundledIds)))
     .returning({ id: providers.id });
+  // Deleting a provider removes it from the compiled catalog, so the next
+  // re-seed must run even though no revision bumped on this path otherwise.
+  if (retired.length > 0) bumpCatalogRevision();
   return retired.length;
 }
 
@@ -172,13 +229,22 @@ export async function bundledModelCatalog(
  * boot. Seeding is no longer account-gated, so this is now simply the same walk
  * as at boot; it exists because an account makes the rows routable and the
  * snapshot must reflect that without waiting for a restart.
+ *
+ * Gated on {@link currentCatalogRevision}: this is the seeder the snapshot
+ * builder calls on every rebuild, and the invalidation that triggers it is a
+ * 30 s timer, so an ungated re-seed could be pushed onto the next proxy
+ * request for a catalog that had not changed. The paths that do change the
+ * catalog bump the revision; everything else is a no-op here.
  */
 export async function refreshActiveProviderCatalogs(
   db: CartethyiaDatabase,
   registry: ProviderRegistry,
 ): Promise<void> {
+  const revision = currentCatalogRevision();
+  if (revision === lastSeededCatalogRevision) return;
   const catalog = await bundledModelCatalog(registry);
   await seedBundledModels(db, catalog.modelsByProvider);
+  lastSeededCatalogRevision = revision;
 }
 
 
@@ -217,6 +283,7 @@ export async function registerByokProviders(
     .from(providers)
     .where(and(isNotNull(providers.baseUrl), eq(providers.enabled, true)));
   const hosts = new Map<string, ByokUpstreamHost>();
+  let registered = false;
   for (const row of rows) {
     if (!row.baseUrl) continue;
     const baseUrl = row.baseUrl;
@@ -307,7 +374,13 @@ export async function registerByokProviders(
         }),
     });
     byokRegistrationFingerprints.set(providerId, fingerprint);
+    registered = true;
   }
+  // A changed BYOK registration changes what the compiled catalog contains, so
+  // the next re-seed must run. An unchanged one deliberately does not: this
+  // function is called on every console provider mutation, most of which do not
+  // alter the registration at all.
+  if (registered) bumpCatalogRevision();
   return hosts;
 }
 
@@ -341,6 +414,9 @@ export async function syncByokProvider(
   if (host === undefined && fingerprintBefore !== undefined) {
     registry.unregister(normalized);
     byokRegistrationFingerprints.delete(normalized);
+    // The provider left the registry, so the compiled catalog no longer
+    // contains it: the next re-seed must run to prune its rows.
+    bumpCatalogRevision();
   }
   return host;
 }

package/src/transport/dispatch/attempt-finalize.ts

@@ -249,7 +249,13 @@ export function captureProviderExchange(
       method: init?.method ?? "GET",
       url,
       ...(headers === undefined ? {} : { headers }),
-      ...(rawBody === null ? {} : { body: parseCapturedBody(rawBody) }),
+      // Capped the same way the response is. A capture is a diagnostic, and an
+      // unbounded translated request body per attempt — up to `maxAttempts` of
+      // them, all alive until the loop returns — costs more than it can tell
+      // an operator.
+      ...(rawBody === null
+        ? {}
+        : { body: parseCapturedBody(rawBody.slice(0, PROVIDER_CAPTURE_MAX_BYTES)) }),
     };
     const response = await inner(input, init);
     sink.response =

package/src/transport/dispatch/attempt-loop.ts

@@ -10,7 +10,13 @@
  */
 import { GatewayError } from "../../protocol/gateway-error";
 import type { ResolvedCredential } from "../../providers/provider-contracts";
-import { classifyTerminalOutcome, fallbackRetryDelayMs, isRetryableFailure, sleep } from "../failure-policy";
+import {
+  classifyTerminalOutcome,
+  fallbackRetryDelayMs,
+  isRetryableFailure,
+  MIN_RETRY_BUDGET_MS,
+  sleep,
+} from "../failure-policy";
 import { resolveRouteMaxAttempts } from "../../config/timeouts";
 import type { OAuthTokenRefresher } from "../../providers/authentication/oauth-refresh-service";
 import type { OAuthRefreshService } from "../../providers/authentication/oauth-refresh-service";
@@ -178,12 +184,8 @@ export async function runAttemptLoop<TResult, TAdapter>(
   const perMemberCap =
     memberCount > 1 ? Math.max(1, Math.ceil(maxAttempts / memberCount)) : maxAttempts;
   const attemptsByMember = new Map<string, number>();
-  // Minimum wall-clock left before a follow-on attempt is worth starting. A
-  // retry repeats the whole pre-dispatch phase (credential, admission, pool
-  // slot, prepare), so it needs at least that much budget on top of whatever
-  // the upstream itself takes. Below this, the attempt would be killed by the
-  // deadline before it could return anything the client could use.
-  const MIN_RETRY_BUDGET_MS = 15_000;
+  // The budget itself is owned by failure-policy, so this loop, the
+  // empty-stream replay, and the Codex retry budget cannot drift apart.
   let index = 0;
   let attempts = 0;
   while (index < candidates.length && attempts < maxAttempts) {

package/src/transport/dispatch/empty-stream.ts

@@ -18,6 +18,11 @@
  * rather than surfacing an empty body to the client.
  */
 import { GatewayError } from "../../protocol/gateway-error";
+import {
+  fallbackRetryDelayMs,
+  MIN_RETRY_BUDGET_MS,
+  sleep as abortableSleep,
+} from "../failure-policy";
 
 // ─── Public types ──────────────────────────────────────────────────────────
 
@@ -38,9 +43,17 @@ export type EmptyStreamFetch = (
   init: { headers: Record<string, string>; body: string; signal: AbortSignal },
 ) => Promise<Response>;
 
+/**
+ * Retry-delay policy.
+ *
+ * Delays come from `fallbackRetryDelayMs` (capped exponential with full
+ * jitter), whose base and cap are operator-tunable. There is deliberately no
+ * per-caller base: the local formula this replaced was uncapped and
+ * unjittered, so a provider returning 200-with-no-events could drive an
+ * unbounded wait, and concurrent clients could resynchronize their retries.
+ */
 export interface EmptyStreamPolicy {
   readonly maxEmptyReplays?: number;
-  readonly baseDelayMs?: number;
   readonly firstEventTimeoutMs?: number;
   readonly sleep?: (ms: number, signal: AbortSignal) => Promise<void>;
 }
@@ -55,9 +68,8 @@ export interface EmptyStreamResult {
 // ─── Defaults ──────────────────────────────────────────────────────────────
 
 const DEFAULT_MAX_REPLAYS = 2;
-const DEFAULT_BASE_DELAY_MS = 500;
 const DEFAULT_FIRST_EVENT_TIMEOUT_MS = 200_000; // 200s, matches CARTETHYIA_STREAM_FIRST_CHUNK_TIMEOUT_MS default
-const MIN_RETRY_BUDGET_MS = 15_000; // attempt-loop floor
+
 
 // ─── Helpers ───────────────────────────────────────────────────────────────
 
@@ -66,27 +78,7 @@ export function isEmptyStream(tally: StreamTally): boolean {
   return tally.dataEvents === 0 || (!tally.meaningful && !tally.thoughtOnly);
 }
 
-function defaultSleep(ms: number, signal: AbortSignal): Promise<void> {
-  return new Promise((resolve, reject) => {
-    if (signal.aborted) {
-      reject(new GatewayError("transport_closed", 499, "Aborted"));
-      return;
-    }
-    const timer = setTimeout(() => {
-      signal.removeEventListener("abort", onAbort);
-      resolve();
-    }, ms);
-    const onAbort = () => {
-      clearTimeout(timer);
-      reject(new GatewayError("transport_closed", 499, "Aborted"));
-    };
-    signal.addEventListener("abort", onAbort, { once: true });
-  });
-}
 
-function backoffMs(attempt: number, base: number): number {
-  return base * 2 ** attempt;
-}
 
 // ─── Main function ─────────────────────────────────────────────────────────
 
@@ -109,9 +101,8 @@ export async function fetchWithEmptyStreamRecovery(
   },
 ): Promise<EmptyStreamResult> {
   const maxReplays = deps.policy?.maxEmptyReplays ?? DEFAULT_MAX_REPLAYS;
-  const baseDelay = deps.policy?.baseDelayMs ?? DEFAULT_BASE_DELAY_MS;
   const firstEventTimeout = deps.policy?.firstEventTimeoutMs ?? DEFAULT_FIRST_EVENT_TIMEOUT_MS;
-  const sleep = deps.policy?.sleep ?? defaultSleep;
+  const sleep = deps.policy?.sleep ?? abortableSleep;
 
   if (endpoints.length === 0) {
     throw new GatewayError("platform_unavailable", 502, "No endpoints available", {}, "upstream");
@@ -173,7 +164,7 @@ export async function fetchWithEmptyStreamRecovery(
 
       // Empty — replay if we haven't exhausted this endpoint's budget
       if (replay < replaysAllowed) {
-        const delay = backoffMs(replay, baseDelay);
+        const delay = fallbackRetryDelayMs(replay);
         try {
           await sleep(delay, deps.signal);
         } catch (error) {

package/src/transport/failure-policy.ts

@@ -884,10 +884,30 @@ export function isRetryableFailure(error: unknown): boolean {
   return classifyUpstreamFailure(error).retryable;
 }
 
+/**
+ * Minimum wall-clock budget a follow-on attempt needs to be worth starting.
+ *
+ * A retry repeats the whole pre-dispatch phase — credential resolution,
+ * admission, pool slot, request preparation — so it needs at least this much
+ * headroom on top of whatever the upstream itself takes. Below this, the
+ * attempt is killed by the deadline before it can return anything usable, and
+ * starting it replaces the first attempt's real error with a second one's
+ * timeout.
+ *
+ * Owned here so the attempt loop, the empty-stream replay, and the Codex
+ * retry budget cannot drift apart; each previously declared its own copy of
+ * the constant.
+ */
+export const MIN_RETRY_BUDGET_MS = 15_000;
+
 /**
  * Capped exponential backoff with full jitter for a zero-based attempt index.
  * The base and cap are operator-tunable (`CARTETHYIA_FALLBACK_RETRY_BASE_MS`,
  * `CARTETHYIA_FALLBACK_RETRY_CAP_MS`) and default to 100ms / 2000ms.
+ *
+ * Used for every retry delay, including the empty-stream replay: jitter keeps
+ * concurrent clients from resynchronizing, and the cap keeps a provider that
+ * returns 200-with-no-events from driving an unbounded wait.
  */
 export function fallbackRetryDelayMs(attemptIndex: number): number {
   const exp = Math.min(resolveFallbackRetryCapMs(), resolveFallbackRetryBaseMs() * 2 ** attemptIndex);

package/src/transport/routing/route-catalog.ts

@@ -16,8 +16,6 @@ import {
   cliToolSettings,
 } from "../../persistence/schema";
 import { DEFAULT_PROVIDER_MAX_INFLIGHT } from "../../persistence/schema";
-import "../../providers/integrations/claude/claude-oauth";
-import "../../providers/integrations/codex/codex-oauth";
 import { resolveTenantOverride } from "../../persistence/tenant-scope";
 import {
   type RouteCandidate,
@@ -149,6 +147,42 @@ export function buildCapabilityProfile(row: {
   };
 }
 
+/**
+ * The capability profile for one model row, memoized across rebuilds.
+ *
+ * Bounded LRU keyed by `providerId/modelId`: the value is a pure function of
+ * the row's metadata, so two rebuilds that see the same row get the same object
+ * instead of two identical ones. The bound keeps a long-lived process from
+ * pinning one profile per row it has ever seen — a model deleted from the
+ * catalog must not leave its profile behind forever.
+ */
+const CAPABILITY_PROFILE_CACHE_MAX_ENTRIES = 4096;
+const capabilityProfileCache = new Map<string, Record<string, boolean>>();
+
+function capabilityProfileFor(row: {
+  modalities: unknown;
+  reasoning: boolean;
+  toolCall: boolean;
+  providerId: string;
+  modelId: string;
+}): Record<string, boolean> {
+  const key = `${row.providerId}/${row.modelId}`;
+  const cached = capabilityProfileCache.get(key);
+  if (cached !== undefined) return cached;
+  const profile = buildCapabilityProfile(row);
+  if (capabilityProfileCache.size >= CAPABILITY_PROFILE_CACHE_MAX_ENTRIES) {
+    const oldest = capabilityProfileCache.keys().next().value;
+    if (oldest !== undefined) capabilityProfileCache.delete(oldest);
+  }
+  capabilityProfileCache.set(key, profile);
+  return profile;
+}
+
+/** Live memo size, for tests and the metrics gauge. */
+export function capabilityProfileCacheSize(): number {
+  return capabilityProfileCache.size;
+}
+
 /** Resolves route identity only for bundled adapters without a native User-Agent builder. */
 export function resolveRouteUserAgent(
   providerId: string,
@@ -527,7 +561,12 @@ class RouteCatalogRepository {
       const providerTenantId = providerTenantById.get(model.providerId);
       if (providerTenantId === undefined) continue;
       const accounts = accountsByProvider.get(model.providerId) ?? [];
-      const capabilityProfile = buildCapabilityProfile(model);
+      // One profile per model row, memoized across snapshot rebuilds. The
+      // profile is derived purely from the row's metadata, is never mutated
+      // (grep finds no write to `capability_profile`), and is shared by every
+      // candidate this row fans out to — so a rebuild no longer constructs a
+      // fresh object per model on top of the fan-out it already had.
+      const capabilityProfile = capabilityProfileFor(model);
       if (accounts.length === 0) {
         const providerRequiresAccount = requiresAccountById.get(model.providerId) ?? true;
         if (!providerRequiresAccount) {

package/src/transport/surface/chat/encode.ts

@@ -1,4 +1,5 @@
 import type { CanonicalEvent, CanonicalStopReason } from "../../../protocol/canonical-model";
+import { jsonrepair } from "jsonrepair";
 import { reasoningSummaryIdentity, reasoningSummarySeparator, type ReasoningSummaryIdentity } from "../reasoning-summary";
 import { eventText } from "../adapters";
 import { isRecord } from "../../../protocol/codecs";
@@ -20,50 +21,36 @@ import type { ChatEncodeOptions, ChunkBase, JsonObject } from "./parse";
  * a raw control character inside a string, a trailing comma, an unquoted key.
  * The client parses the assembled string with `JSON.parse` and, on failure,
  * reports the call as `Tool <name> not found` with the parser's message
- * (`Unexpected trailing characters`, `Invalid number`). The repair is the same
- * one oh-my-pi applies before a tool runs: escape what strict JSON forbids,
- * then drop a trailing comma. A value that still does not parse is returned
- * unchanged — a half-repaired call is worse than the original error.
+ * (`Unexpected trailing characters`, `Invalid number`).
+ *
+ * Repairing is delegated to `jsonrepair`, which handles the whole family of
+ * near-JSON shapes (truncated objects, unquoted keys, single quotes, trailing
+ * commas) instead of the two cases a hand-rolled scanner covered.
+ *
+ * The policy around it is unchanged and is the load-bearing part: the result
+ * is parsed only to validate, and anything that does not parse *to an object*
+ * is discarded in favour of the original text — a half-repaired call is worse
+ * than the original error. The object check matters because `jsonrepair` will
+ * happily turn arbitrary prose into a quoted JSON string, which parses but is
+ * not a tool-argument object.
  */
 export function repairToolArguments(raw: string): string {
   if (raw.length === 0) return "{}";
   const repaired = repairToolArgumentText(raw);
   try {
-    JSON.parse(repaired);
+    const parsed: unknown = JSON.parse(repaired);
+    if (parsed === null || typeof parsed !== "object" || Array.isArray(parsed)) return raw;
     return repaired;
   } catch {
     return raw;
   }
 }
 
+/** Repairs near-JSON text into strict JSON. Throws when the text is unrepairable. */
 function repairToolArgumentText(json: string): string {
-  const parts: string[] = [];
-  let last = 0;
-  let inString = false;
-  for (let i = 0; i < json.length; i++) {
-    const code = json.charCodeAt(i);
-    if (!inString) {
-      if (code === 0x22) inString = true;
-      continue;
-    }
-    if (code === 0x22) {
-      inString = false;
-      continue;
-    }
-    if (code === 0x5c) {
-      i++;
-      continue;
-    }
-    if (code < 0x20) {
-      const escape =
-        code === 0x0a ? "\\n" : code === 0x0d ? "\\r" : code === 0x09 ? "\\t" : `\\u${code.toString(16).padStart(4, "0")}`;
-      parts.push(json.slice(last, i), escape);
-      last = i + 1;
-    }
-  }
-  const escaped = parts.length === 0 ? json : parts.join("") + json.slice(last);
-  return escaped.replace(/,(\s*[}\]])/g, "$1");
+  return jsonrepair(json);
 }
+
 export function bytesToString(value: string | Uint8Array): string {
   return typeof value === "string" ? value : new TextDecoder().decode(value);
 }

package/src/transport/surface/messages/stream.ts

@@ -6,6 +6,7 @@ import {
   type ReasoningSummaryIdentity,
 } from "../reasoning-summary";
 import {
+  argumentsFrom,
   createToolCallTracker,
   resetToolCallTracker,
   toolIdentityKey,
@@ -96,7 +97,7 @@ export class MessagesStreamEncoder extends SurfaceStreamEncoder<CanonicalEvent,
     const index = existing ?? this.nextIndex++;
     this.tools.indexById.set(callId, index);
     const sent = this.emittedArguments.get(callId) ?? 0;
-    const pending = entry.arguments.slice(sent);
+    const pending = argumentsFrom(entry, sent);
     if (!this.openedToolCalls.has(callId)) {
       this.openedToolCalls.add(callId);
       out.push(...this.closeOpenBlock());
@@ -120,7 +121,7 @@ export class MessagesStreamEncoder extends SurfaceStreamEncoder<CanonicalEvent,
         index,
         delta: { type: "input_json_delta", partial_json: pending },
       });
-      this.emittedArguments.set(callId, entry.arguments.length);
+      this.emittedArguments.set(callId, sent + pending.length);
     }
     return out;
   }