npm - @bitkyc08/opencodex - Versions diffs - 2.12.0 → 2.13.0 - Mend

@bitkyc08/opencodex 2.12.0 → 2.13.0

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (173) hide show

package/README.md +1 -1
package/gui/dist/assets/index-BHldBl6_.js +76 -0
package/gui/dist/index.html +1 -1
package/package.json +1 -1
package/src/adapters/anthropic-output-schema.ts +137 -0
package/src/adapters/anthropic.ts +15 -0
package/src/adapters/google-antigravity-replay.ts +269 -5
package/src/adapters/openai-chat.ts +25 -18
package/src/adapters/openai-responses.ts +63 -17
package/src/bridge.ts +11 -5
package/src/claude/inbound.ts +24 -3
package/src/cli/account-api.ts +2 -0
package/src/cli/account-extended.ts +262 -1
package/src/cli/account.ts +3 -1
package/src/cli/dispatch.ts +532 -0
package/src/cli/doctor.ts +26 -21
package/src/cli/help.ts +9 -278
package/src/cli/index.ts +45 -506
package/src/cli/lab.ts +171 -65
package/src/cli/registry.ts +384 -0
package/src/cli/root.ts +86 -0
package/src/cli/status.ts +9 -2
package/src/cli/v2.ts +37 -2
package/src/codex/account-label.ts +14 -1
package/src/codex/account-store.ts +12 -1
package/src/codex/admission.ts +2 -1
package/src/codex/auth-api.ts +3 -2
package/src/codex/catalog/metadata.ts +6 -4
package/src/codex/catalog/parsing.ts +31 -7
package/src/codex/catalog/provider-fetch.ts +2 -1
package/src/codex/catalog/sync.ts +65 -11
package/src/codex/features.ts +437 -31
package/src/codex/history-job.ts +6 -11
package/src/codex/history-provider.ts +10 -9
package/src/codex/inject.ts +14 -1
package/src/codex/native-profile-startup.ts +49 -3
package/src/codex/native-residue.ts +14 -2
package/src/codex/paths.ts +75 -1
package/src/codex/reset-credit-recovery.ts +1044 -0
package/src/codex/shim.ts +876 -16
package/src/codex/sync.ts +27 -2
package/src/config.ts +148 -10
package/src/generated/compatibility-version.json +2572 -0
package/src/images/loop.ts +1 -1
package/src/lab/artifacts/sanitize.ts +3 -3
package/src/lab/automation/budgets.ts +78 -0
package/src/lab/automation/config-persistence.ts +256 -0
package/src/lab/automation/constants.ts +39 -0
package/src/lab/automation/cooldown.ts +103 -0
package/src/lab/automation/dispatch.ts +211 -0
package/src/lab/automation/index.ts +13 -0
package/src/lab/automation/orchestrator.ts +480 -0
package/src/lab/automation/persistence.ts +512 -0
package/src/lab/automation/planner.ts +371 -0
package/src/lab/automation/policy.ts +136 -0
package/src/lab/automation/queue.ts +191 -0
package/src/lab/automation/recovery.ts +24 -0
package/src/lab/automation/route-context.ts +21 -0
package/src/lab/automation/run-key.ts +44 -0
package/src/lab/automation/runs-query.ts +34 -0
package/src/lab/automation/types.ts +160 -0
package/src/lab/conformance/types.ts +23 -0
package/src/lab/events/types.ts +2 -1
package/src/lab/events/validate.ts +2 -1
package/src/lab/fabric/constants.ts +40 -0
package/src/lab/fabric/executor.ts +492 -0
package/src/lab/fabric/index.ts +80 -0
package/src/lab/fabric/manifest.ts +222 -0
package/src/lab/fabric/observe.ts +454 -0
package/src/lab/fabric/patch.ts +79 -0
package/src/lab/fabric/producer-child.ts +139 -0
package/src/lab/fabric/producer-isolate.ts +276 -0
package/src/lab/fabric/producer-protocol.ts +61 -0
package/src/lab/fabric/scratch.ts +439 -0
package/src/lab/fabric/subject.ts +106 -0
package/src/lab/fabric/types.ts +134 -0
package/src/lab/fabric/verifier.ts +98 -0
package/src/lab/index.ts +2 -0
package/src/lab/ledger/store.ts +173 -0
package/src/lab/live/executor.ts +29 -4
package/src/lab/live/transport.ts +3 -1
package/src/lab/observe/from-conformance.ts +12 -57
package/src/lab/observe/from-live.ts +9 -1
package/src/lab/paths.ts +74 -9
package/src/lab/projection/schema.ts +14 -1
package/src/lab/projection/verdicts.ts +89 -53
package/src/lab/projection/verification.ts +83 -3
package/src/lab/query/catalog.ts +34 -5
package/src/lab/query/freshness.ts +53 -0
package/src/lab/query/index.ts +11 -0
package/src/lab/query/latest-observation.ts +59 -0
package/src/lab/query/passive-production.ts +159 -0
package/src/lab/subject/installation-salt.ts +24 -4
package/src/lab/subject/protocol-subject.ts +80 -0
package/src/lab/subject/route-subject.ts +2 -1
package/src/lib/fabric-task-execution-authority.ts +7 -0
package/src/lib/fabric-task-host.ts +29 -0
package/src/lib/lab-live-route-production.ts +130 -0
package/src/lib/local-management-capability.ts +100 -0
package/src/lib/server-resource-ownership.ts +71 -0
package/src/lib/windows-elevation.ts +8 -1
package/src/lib/windows-user-principal.ts +62 -2
package/src/lib/winsw.ts +8 -2
package/src/oauth/account-import/google-antigravity-adapter.ts +74 -0
package/src/oauth/account-import/index.ts +15 -0
package/src/oauth/account-import/parser.ts +83 -0
package/src/oauth/account-import/registry.ts +18 -0
package/src/oauth/account-import/service.ts +75 -0
package/src/oauth/account-import/types.ts +91 -0
package/src/oauth/anthropic.ts +12 -1
package/src/oauth/callback-server.ts +8 -2
package/src/oauth/chatgpt.ts +12 -1
package/src/oauth/google-antigravity.ts +27 -0
package/src/oauth/health.ts +12 -48
package/src/oauth/index.ts +122 -0
package/src/oauth/kimi.ts +16 -2
package/src/oauth/nous.ts +749 -0
package/src/oauth/store.ts +56 -3
package/src/providers/codex-capacity.ts +1 -0
package/src/providers/registry.ts +161 -16
package/src/responses/custom-tool-compat.ts +182 -0
package/src/responses/parser.ts +22 -0
package/src/responses/reasoning-replay-cache.ts +168 -11
package/src/responses/schema.ts +1 -1
package/src/router.ts +5 -20
package/src/routing/capability.ts +9 -3
package/src/routing/compatibility/assemble.ts +159 -0
package/src/routing/compatibility/behavior.ts +224 -0
package/src/routing/compatibility/catalog.ts +99 -0
package/src/routing/compatibility/endpoint.ts +52 -0
package/src/routing/compatibility/policy.ts +181 -0
package/src/routing/compatibility/reader.ts +110 -0
package/src/routing/compatibility/subject.ts +191 -0
package/src/routing/compatibility/types.ts +64 -0
package/src/routing/compatibility/version.ts +104 -0
package/src/routing/evaluator.ts +27 -32
package/src/routing/profile.ts +118 -4
package/src/routing/trace.ts +82 -28
package/src/server/auth-cors.ts +7 -0
package/src/server/background-lifecycle.ts +20 -7
package/src/server/chat-completions.ts +2 -2
package/src/server/claude-messages.ts +6 -3
package/src/server/direct-local-http.ts +343 -0
package/src/server/index.ts +80 -18
package/src/server/lifecycle.ts +12 -4
package/src/server/local-management-read-client.ts +90 -0
package/src/server/management/agent-settings-routes.ts +27 -3
package/src/server/management/lab-automation-routes.ts +206 -0
package/src/server/management/lab-routes.ts +13 -0
package/src/server/management/logs-usage-routes.ts +1 -0
package/src/server/management/oauth-account-routes.ts +57 -1
package/src/server/management/provider-routes.ts +16 -0
package/src/server/management/routing-profile-routes.ts +12 -24
package/src/server/management-api.ts +2 -0
package/src/server/management-auth.ts +68 -3
package/src/server/proxy-liveness.ts +3 -2
package/src/server/request-decompress.ts +9 -3
package/src/server/request-log.ts +53 -4
package/src/server/responses/collaboration.ts +93 -17
package/src/server/responses/compact.ts +3 -0
package/src/server/responses/core.ts +202 -15
package/src/server/responses/policy-fallback.ts +1 -0
package/src/server/responses-custom-tool-repair.ts +280 -0
package/src/server/responses-terminal-repair.ts +342 -0
package/src/server/startup-action-control.ts +8 -1
package/src/service.ts +278 -12
package/src/types.ts +49 -3
package/src/usage/expected-prices.ts +30 -0
package/src/usage/log.ts +30 -4
package/src/usage/summary.ts +153 -2
package/src/web-search/loop.ts +1 -1
package/gui/dist/assets/index-Cw1_mxO8.js +0 -70
package/src/cli/internal-dispatch.ts +0 -20

package/gui/dist/index.html CHANGED Viewed

@@ -16,7 +16,7 @@
         } catch (e) {}
       })();
     </script>
-    <script type="module" crossorigin src="/assets/index-Cw1_mxO8.js"></script>
+    <script type="module" crossorigin src="/assets/index-BHldBl6_.js"></script>
     <link rel="stylesheet" crossorigin href="/assets/index-BNVYzdn0.css">
   </head>
   <body>

package/package.json CHANGED Viewed

@@ -1,6 +1,6 @@
 {
   "name": "@bitkyc08/opencodex",
-  "version": "2.12.0",
+  "version": "2.13.0",
   "description": "Universal provider proxy for OpenAI Codex & Claude Code — use any LLM with Codex CLI/App/SDK and Claude Code",
   "type": "module",
   "main": "./bin/package-main.mjs",

package/src/adapters/anthropic-output-schema.ts ADDED Viewed

@@ -0,0 +1,137 @@
+// Based on Anthropic SDK's transformJSONSchema, preserving root $defs required by root $ref:
+// https://github.com/anthropics/anthropic-sdk-typescript/blob/main/src/lib/transform-json-schema.ts
+const SUPPORTED_STRING_FORMATS = new Set([
+  "date-time",
+  "time",
+  "date",
+  "duration",
+  "email",
+  "hostname",
+  "uri",
+  "ipv4",
+  "ipv6",
+  "uuid",
+]);
+function isRecord(value: unknown): value is Record<string, unknown> {
+  return value !== null && typeof value === "object" && !Array.isArray(value);
+}
+function take(schema: Record<string, unknown>, key: string): unknown {
+  const value = schema[key];
+  delete schema[key];
+  return value;
+}
+function normalizeSubschema(value: unknown): unknown {
+  return isRecord(value) ? normalizeSchema(value) : value;
+}
+function normalizeSchema(schema: Record<string, unknown>): Record<string, unknown> {
+  const normalized: Record<string, unknown> = {};
+  const defs = take(schema, "$defs");
+  if (isRecord(defs)) {
+    normalized.$defs = Object.fromEntries(
+      Object.entries(defs).map(([name, definition]) => [name, normalizeSubschema(definition)]),
+    );
+  }
+  const ref = take(schema, "$ref");
+  if (ref !== undefined) {
+    normalized.$ref = ref;
+    return normalized;
+  }
+  const type = take(schema, "type");
+  const anyOf = schema.anyOf;
+  const oneOf = schema.oneOf;
+  const allOf = schema.allOf;
+  if (Array.isArray(anyOf)) {
+    take(schema, "anyOf");
+    normalized.anyOf = anyOf.map(normalizeSubschema);
+  } else if (Array.isArray(oneOf)) {
+    take(schema, "oneOf");
+    normalized.anyOf = oneOf.map(normalizeSubschema);
+  } else if (Array.isArray(allOf)) {
+    take(schema, "allOf");
+    normalized.allOf = allOf.map(normalizeSubschema);
+  } else {
+    if (type === undefined) {
+      throw new Error("JSON schema must have a type defined if anyOf/oneOf/allOf are not used");
+    }
+    normalized.type = type;
+  }
+  const description = take(schema, "description");
+  if (description !== undefined) {
+    normalized.description = description;
+  }
+  const title = take(schema, "title");
+  if (title !== undefined) {
+    normalized.title = title;
+  }
+  if (type === "object") {
+    const properties = take(schema, "properties");
+    normalized.properties = isRecord(properties)
+      ? Object.fromEntries(
+          Object.entries(properties).map(([name, property]) => [name, normalizeSubschema(property)]),
+        )
+      : {};
+    take(schema, "additionalProperties");
+    normalized.additionalProperties = false;
+    const required = take(schema, "required");
+    if (required !== undefined) {
+      normalized.required = required;
+    }
+  } else if (type === "string") {
+    const format = take(schema, "format");
+    if (typeof format === "string" && SUPPORTED_STRING_FORMATS.has(format)) {
+      normalized.format = format;
+    } else if (format !== undefined) {
+      schema.format = format;
+    }
+  } else if (type === "array") {
+    const items = take(schema, "items");
+    if (items !== undefined) {
+      normalized.items = normalizeSubschema(items);
+    }
+    const minItems = take(schema, "minItems");
+    if (minItems === 0 || minItems === 1) {
+      normalized.minItems = minItems;
+    } else if (minItems !== undefined) {
+      schema.minItems = minItems;
+    }
+  }
+  const unsupported = Object.entries(schema);
+  if (unsupported.length > 0) {
+    const existingDescription =
+      typeof normalized.description === "string" ? `${normalized.description}\n\n` : "";
+    normalized.description = `${existingDescription}{${unsupported
+      .map(([key, value]) => `${key}: ${JSON.stringify(value)}`)
+      .join(", ")}}`;
+  }
+  return normalized;
+}
+export function normalizeAnthropicOutputSchema(
+  schema: Record<string, unknown>,
+): Record<string, unknown> {
+  return normalizeSchema(structuredClone(schema));
+}
+export function isAnthropicOutputSchema(schema: Record<string, unknown>): boolean {
+  try {
+    normalizeAnthropicOutputSchema(schema);
+    return true;
+  } catch {
+    return false;
+  }
+}

package/src/adapters/anthropic.ts CHANGED Viewed

@@ -18,6 +18,7 @@ import { ANTHROPIC_OAUTH_BETA, CLAUDE_CODE_SYSTEM_INSTRUCTION, applyClaudeToolPr
 import { parseDataUrl } from "./image";
 import { enforceAnthropicImageLimits } from "./anthropic-image-guard";
 import { normalizeAnthropicImages } from "./anthropic-image-normalize";
+import { normalizeAnthropicOutputSchema } from "./anthropic-output-schema";
 import { identifyRoutedModel } from "./identity";
 import { redactSecretString } from "../lib/redact";
 import { CLAUDE_CODE_HEADERS, claudeCodeSessionId } from "./client-fingerprint";
@@ -898,6 +899,20 @@ export function createAnthropicAdapter(provider: OcxProviderConfig, cacheRetenti
         delete body.top_p;
       }
+      const textFormat = parsed.options.textFormat;
+      if (textFormat?.type === "json_schema" && textFormat.schema) {
+        const outputConfig = body.output_config;
+        body.output_config = {
+          ...(outputConfig && typeof outputConfig === "object" && !Array.isArray(outputConfig)
+            ? outputConfig
+            : {}),
+          format: {
+            type: "json_schema",
+            schema: normalizeAnthropicOutputSchema(textFormat.schema),
+          },
+        };
+      }
       if (parsed.options.toolChoice && (tools || parsed.options.toolChoice === "none")) {
         const tc = parsed.options.toolChoice;
         if (tc === "auto") body.tool_choice = { type: "auto" };

package/src/adapters/google-antigravity-replay.ts CHANGED Viewed

@@ -1,4 +1,7 @@
 import { createHash } from "node:crypto";
+import { chmodSync, existsSync, mkdirSync, readFileSync, statSync } from "node:fs";
+import { dirname, join } from "node:path";
+import { atomicWriteFileAsync, getConfigDir, type AtomicWriteAsyncTestSeam } from "../config";
 import { enforceAppOwnedMemoryBudget } from "../lib/app-owned-memory";
 /**
@@ -26,6 +29,8 @@ interface ReplayEntry {
   bytes: number;
   expiresAtMs: number;
   oldestAtMs: number | null;
+  /** Most recent observe/apply activity; orders sessions under the snapshot cap. */
+  lastActiveAtMs: number;
 }
 const MIN_SIGNATURE_LEN = 16;
@@ -38,6 +43,16 @@ export const ANTIGRAVITY_REPLAY_MAX_TOTAL_BYTES = 64 * 1024 * 1024;
 const REPLAY_MAX_SIGNATURE_BYTES = 64 * 1024;
 /** Fixed 64-hex outer key length, counted once per session entry. */
 const REPLAY_SESSION_KEY_BYTES = 64;
+const REPLAY_SNAPSHOT_FILE = "antigravity-replay.json";
+const REPLAY_SNAPSHOT_VERSION = 1;
+const REPLAY_SNAPSHOT_DEBOUNCE_MS = 2_000;
+/** Upper bound on flush retries: mutations arriving faster than writes complete
+ * must not let shutdown hang; the last completed write is already on disk. */
+const REPLAY_FLUSH_MAX_ATTEMPTS = 8;
+/** Write bound for the durable snapshot (mirrors the responses-state cap). */
+const REPLAY_SNAPSHOT_MAX_BYTES = 24 * 1024 * 1024;
+/** Refuse-to-parse ceiling for an existing snapshot file. */
+const REPLAY_SNAPSHOT_REFUSE_BYTES = 32 * 1024 * 1024;
 interface ReplayLimits {
   maxCallsPerSession: number;
@@ -57,6 +72,216 @@ let replayLimits = { ...DEFAULT_REPLAY_LIMITS };
 let replayBytes = 0;
 let replayOldestSessionKey: string | undefined;
 let replayOldestAt: number | null = null;
+let replaySnapshotLoaded = false;
+let replaySnapshotPersistTimer: ReturnType<typeof setTimeout> | null = null;
+let replaySnapshotPersistGate: Promise<void> = Promise.resolve();
+/** Mutation generation: bumped on every cache change that needs persisting. */
+let replayMutationGeneration = 0;
+/** Generation of the data the last successful snapshot write actually captured. */
+let replayWrittenGeneration = 0;
+let replaySnapshotWriteSeam: AtomicWriteAsyncTestSeam | undefined;
+let replaySnapshotLoadDiscarded = false;
+let replaySnapshotMaxBytes = REPLAY_SNAPSHOT_MAX_BYTES;
+function replaySnapshotPath(): string {
+  return join(getConfigDir(), REPLAY_SNAPSHOT_FILE);
+}
+function loadReplaySnapshotEntry(key: string, value: unknown): void {
+  if (!/^[0-9a-f]{64}$/.test(key)) return;
+  if (!value || typeof value !== "object" || Array.isArray(value)) return;
+  const rec = value as { byCall?: unknown; expiresAtMs?: unknown; lastActiveAtMs?: unknown };
+  if (typeof rec.expiresAtMs !== "number" || !Number.isFinite(rec.expiresAtMs)) return;
+  // Expired sessions are dropped at load; a stale snapshot is self-healing.
+  if (rec.expiresAtMs <= Date.now()) {
+    replaySnapshotLoadDiscarded = true;
+    return;
+  }
+  if (!Array.isArray(rec.byCall)) return;
+  const byCall = new Map<string, ReplayCall>();
+  let bytes = REPLAY_SESSION_KEY_BYTES;
+  for (const pair of rec.byCall) {
+    if (!Array.isArray(pair) || pair.length !== 2 || typeof pair[0] !== "string") continue;
+    if (!/^[0-9a-f]{64}$/.test(pair[0])) continue;
+    const call = pair[1] as { signature?: unknown; touchedAtMs?: unknown } | null;
+    if (!call || typeof call !== "object" || Array.isArray(call)) continue;
+    if (typeof call.signature !== "string" || call.signature.length < MIN_SIGNATURE_LEN) continue;
+    if (typeof call.touchedAtMs !== "number" || !Number.isFinite(call.touchedAtMs)) continue;
+    // Never trust a serialized sizeBytes: a forged snapshot could claim a tiny
+    // size for a huge signature and bypass every byte cap. Recompute from the
+    // signature itself, exactly like the live write path.
+    const signatureBytes = utf8.encode(call.signature).byteLength;
+    if (signatureBytes > replayLimits.maxSignatureBytes) continue;
+    const callBytes = utf8.encode(pair[0]).byteLength + signatureBytes;
+    if (callBytes > replayLimits.maxBytesPerSession) continue;
+    // A duplicated call key would overstate entry.bytes (the map keeps only the
+    // last value) and could evict valid sessions; keep the first occurrence.
+    if (byCall.has(pair[0])) {
+      replaySnapshotLoadDiscarded = true;
+      continue;
+    }
+    byCall.set(pair[0], {
+      signature: call.signature,
+      sizeBytes: callBytes,
+      touchedAtMs: call.touchedAtMs,
+    });
+    bytes += callBytes;
+  }
+  if (byCall.size === 0) {
+    replaySnapshotLoadDiscarded = true;
+    return;
+  }
+  const lastActiveAtMs = typeof rec.lastActiveAtMs === "number" && Number.isFinite(rec.lastActiveAtMs)
+    ? rec.lastActiveAtMs
+    : rec.expiresAtMs;
+  const entry: ReplayEntry = { byCall, bytes, expiresAtMs: rec.expiresAtMs, oldestAtMs: null, lastActiveAtMs };
+  const loadedCallCount = entry.byCall.size;
+  // Account BEFORE trimming: evictInnerCalls decrements the global byte count
+  // through deleteReplayCall, so the entry must already be on the books.
+  replayCache.set(key, entry);
+  replayBytes += entry.bytes;
+  // Same per-session caps as live writes, in case limits changed across versions.
+  evictInnerCalls(entry);
+  if (entry.byCall.size < loadedCallCount) replaySnapshotLoadDiscarded = true;
+  if (entry.byCall.size === 0) {
+    deleteReplaySession(key);
+    return;
+  }
+  refreshReplaySessionCandidate(key, entry);
+}
+/**
+ * Lazy load of the durable snapshot on first cache access, so signatures observed
+ * before a proxy restart are available again once the session id re-derives to the
+ * same key (the session id is anchored on the first user message text). Load is
+ * best-effort: missing, corrupt, or oversized files start the cache empty.
+ */
+function ensureReplaySnapshotLoaded(): void {
+  if (replaySnapshotLoaded) return;
+  replaySnapshotLoaded = true;
+  replaySnapshotLoadDiscarded = false;
+  try {
+    const path = replaySnapshotPath();
+    if (!existsSync(path)) return;
+    const stat = statSync(path);
+    // Bound the read BEFORE parse: the 24 MiB write cap constrains snapshots this
+    // process wrote, not a pre-existing oversized file.
+    if (!stat.isFile() || stat.size > REPLAY_SNAPSHOT_REFUSE_BYTES) return;
+    const raw = JSON.parse(readFileSync(path, "utf8")) as { version?: unknown; sessions?: unknown };
+    if (raw.version !== REPLAY_SNAPSHOT_VERSION || !Array.isArray(raw.sessions)) return;
+    for (const entry of raw.sessions) {
+      if (!Array.isArray(entry) || entry.length !== 2 || typeof entry[0] !== "string") continue;
+      loadReplaySnapshotEntry(entry[0], entry[1]);
+    }
+  } catch {
+    // Missing/corrupt snapshot: start empty.
+  }
+  const sessionsAfterLoad = replayCache.size;
+  // Load-time admission must respect the same global caps as live writes.
+  evictIfNeeded();
+  if (replayCache.size < sessionsAfterLoad) replaySnapshotLoadDiscarded = true;
+  // Persist the cleaned state once: expired/over-limit sessions must not stay
+  // on disk and be re-parsed (and re-dropped) after every restart.
+  if (replaySnapshotLoadDiscarded) markReplayDirty();
+  enforceAppOwnedMemoryBudget();
+}
+function markReplayDirty(): void {
+  replayMutationGeneration += 1;
+  if (replaySnapshotPersistTimer) return;
+  replaySnapshotPersistTimer = setTimeout(() => {
+    void persistReplaySnapshotNow().catch(() => {
+      // Redacted static message only: never echo the underlying error, which
+      // can carry paths or other environment details.
+      console.warn("[antigravity] replay snapshot persist failed; cached signatures will not survive a restart");
+    });
+  }, REPLAY_SNAPSHOT_DEBOUNCE_MS);
+  (replaySnapshotPersistTimer as { unref?: () => void }).unref?.();
+}
+async function persistReplaySnapshotNow(): Promise<void> {
+  if (replaySnapshotPersistTimer) {
+    clearTimeout(replaySnapshotPersistTimer);
+    replaySnapshotPersistTimer = null;
+  }
+  // Serialize writers so a flush and a debounced write cannot race on temps/ACL.
+  const previous = replaySnapshotPersistGate;
+  let release!: () => void;
+  replaySnapshotPersistGate = new Promise<void>(resolve => { release = resolve; });
+  await previous;
+  const writeGeneration = replayMutationGeneration;
+  try {
+    const sessions: Array<[string, unknown]> = [];
+    // Account for the bytes actually written, not just the entries: the document
+    // is `{"version":N,"sessions":[...]}`, so the framing and the comma between
+    // entries count against the cap too. Summing per-entry sizes alone let the
+    // written file exceed replaySnapshotMaxBytes by a margin that grew with every
+    // additional session.
+    const prefix = `{"version":${JSON.stringify(REPLAY_SNAPSHOT_VERSION)},"sessions":[`;
+    const suffix = "]}";
+    const serialized: string[] = [];
+    let total = Buffer.byteLength(prefix, "utf8") + Buffer.byteLength(suffix, "utf8");
+    // Most-recently-active first so the sessions that survive the snapshot
+    // byte cap are the ones actually in use (Map order is insertion order).
+    for (const [key, entry] of [...replayCache].sort((a, b) => b[1].lastActiveAtMs - a[1].lastActiveAtMs)) {
+      const byCall = [...entry.byCall].map(([callKey, call]) => [
+        callKey,
+        { signature: call.signature, touchedAtMs: call.touchedAtMs },
+      ]);
+      const persistEntry: [string, unknown] = [key, {
+        byCall,
+        expiresAtMs: entry.expiresAtMs,
+        lastActiveAtMs: entry.lastActiveAtMs,
+      }];
+      const encoded = JSON.stringify(persistEntry);
+      const size = Buffer.byteLength(encoded, "utf8") + (serialized.length > 0 ? 1 : 0);
+      if (total + size > replaySnapshotMaxBytes) break;
+      total += size;
+      serialized.push(encoded);
+      sessions.push(persistEntry);
+    }
+    serialized.reverse();
+    const document = `${prefix}${serialized.join(",")}${suffix}`;
+    // Defensive: the admitted entries are what we serialize, so this can only
+    // trip if the accounting above and the payload below ever drift apart.
+    if (Buffer.byteLength(document, "utf8") > replaySnapshotMaxBytes) {
+      throw new Error("Antigravity replay snapshot exceeded its configured byte cap.");
+    }
+    mkdirSync(dirname(replaySnapshotPath()), { recursive: true, mode: 0o700 });
+    try { chmodSync(dirname(replaySnapshotPath()), 0o700); } catch { /* best-effort (e.g. Windows) */ }
+    await atomicWriteFileAsync(
+      replaySnapshotPath(),
+      document,
+      undefined,
+      replaySnapshotWriteSeam,
+    );
+    replayWrittenGeneration = writeGeneration;
+  } finally {
+    release();
+  }
+}
+/** Flush any pending debounced snapshot write (graceful shutdown / deterministic tests). */
+export async function flushAntigravityReplay(): Promise<void> {
+  // Persist until the durable generation catches up with the latest mutation:
+  // a change that lands while a writer is in flight must not be lost when
+  // shutdown exits right after the first write completes.
+  for (let attempt = 0; attempt < REPLAY_FLUSH_MAX_ATTEMPTS; attempt += 1) {
+    if (replaySnapshotPersistTimer || replayMutationGeneration > replayWrittenGeneration) {
+      await persistReplaySnapshotNow();
+    }
+    // No pending timer: still await any in-flight write so shutdown does not race it.
+    await replaySnapshotPersistGate;
+    if (replayMutationGeneration === replayWrittenGeneration && replaySnapshotPersistTimer === null) return;
+  }
+  // Budget exhausted without convergence. Resolving here would tell
+  // drainAndShutdown() the snapshot is durable while the latest thought
+  // signature may never have reached disk, so shutdown diagnostics would claim
+  // a durability we cannot demonstrate. Reject instead, with fixed text: the
+  // shutdown path logs this message, so it must not carry session, model, or
+  // signature detail.
+  throw new Error("Antigravity replay snapshot flush did not converge.");
+}
 /**
  * Fixed-size identity for a (model, sessionId) pair: SHA-256 over
@@ -372,6 +597,7 @@ export function antigravityUsesReplayCache(model: string): boolean {
  */
 export function observeAntigravityReplay(model: string, sessionId: string, parts: unknown[]): void {
   if (!antigravityUsesReplayCache(model) || !Array.isArray(parts) || parts.length === 0) return;
+  ensureReplaySnapshotLoaded();
   const now = Date.now();
   deleteExpiredReplaySessionsThrottled(now);
   const key = replayKey(model, sessionId);
@@ -381,6 +607,7 @@ export function observeAntigravityReplay(model: string, sessionId: string, parts
     bytes: REPLAY_SESSION_KEY_BYTES,
     expiresAtMs: 0,
     oldestAtMs: null,
+    lastActiveAtMs: 0,
   };
   let inserted = false;
   let pendingThoughtSig: string | undefined;
@@ -418,15 +645,21 @@ export function observeAntigravityReplay(model: string, sessionId: string, parts
     // The fixed session overhead can exceed the per-session cap on its own
     // (test-sized limits): an entry holding zero calls is unusable — drop it
     // instead of retaining an unevictable shell.
-    if (existing) deleteReplaySession(key);
-    else replayBytes -= REPLAY_SESSION_KEY_BYTES;
+    if (existing) {
+      deleteReplaySession(key);
+      markReplayDirty();
+    } else {
+      replayBytes -= REPLAY_SESSION_KEY_BYTES;
+    }
     return;
   }
   entry.expiresAtMs = now + REPLAY_TTL_MS;
+  entry.lastActiveAtMs = now;
   replayCache.set(key, entry);
   refreshReplaySessionCandidate(key, entry);
   evictIfNeeded();
   enforceAppOwnedMemoryBudget();
+  markReplayDirty();
 }
 /**
@@ -436,6 +669,7 @@ export function observeAntigravityReplay(model: string, sessionId: string, parts
  */
 export function applyAntigravityReplay(model: string, sessionId: string, contents: unknown[]): unknown[] {
   if (!antigravityUsesReplayCache(model) || !Array.isArray(contents)) return contents;
+  ensureReplaySnapshotLoaded();
   const now = Date.now();
   deleteExpiredReplaySessionsThrottled(now);
   const entry = replayCache.get(replayKey(model, sessionId));
@@ -461,13 +695,18 @@ export function applyAntigravityReplay(model: string, sessionId: string, content
       }
     }
   }
-  if (touched) refreshReplaySessionCandidate(replayKey(model, sessionId), entry);
+  if (touched) {
+    entry.lastActiveAtMs = now;
+    refreshReplaySessionCandidate(replayKey(model, sessionId), entry);
+    markReplayDirty();
+  }
   return contents;
 }
 /** Drop the cache entry when upstream rejects a signature (clear-on-invalid). */
 export function clearAntigravityReplay(model: string, sessionId: string): void {
-  deleteReplaySession(replayKey(model, sessionId));
+  ensureReplaySnapshotLoaded();
+  if (deleteReplaySession(replayKey(model, sessionId)) > 0) markReplayDirty();
 }
 export function antigravityReplayMetrics(): {
@@ -476,6 +715,7 @@ export function antigravityReplayMetrics(): {
   totalBytes: number;
   largestSessionBytes: number;
 } {
+  ensureReplaySnapshotLoaded();
   let calls = 0;
   let largestSessionBytes = 0;
   for (const entry of replayCache.values()) {
@@ -492,6 +732,7 @@ export function antigravityReplayRetainedStoreSnapshot(): {
   pinnedBytes: number;
   oldestAt: number | null;
 } {
+  ensureReplaySnapshotLoaded();
   return {
     count: replayCache.size,
     bytes: replayBytes,
@@ -502,7 +743,10 @@ export function antigravityReplayRetainedStoreSnapshot(): {
 }
 export function evictOldestAntigravityReplayForBudget(): number {
-  return replayOldestSessionKey === undefined ? 0 : deleteReplaySession(replayOldestSessionKey);
+  ensureReplaySnapshotLoaded();
+  const removed = replayOldestSessionKey === undefined ? 0 : deleteReplaySession(replayOldestSessionKey);
+  if (removed > 0) markReplayDirty();
+  return removed;
 }
 export function setAntigravityReplayLimitsForTests(limits?: Partial<ReplayLimits>): void {
@@ -510,11 +754,31 @@ export function setAntigravityReplayLimitsForTests(limits?: Partial<ReplayLimits
   replayLimits = limits ? { ...DEFAULT_REPLAY_LIMITS, ...limits } : { ...DEFAULT_REPLAY_LIMITS };
 }
+/** Test-only write seam (mirrors AtomicWriteAsyncTestSeam usage elsewhere). */
+export function setAntigravityReplayWriteSeamForTests(seam: AtomicWriteAsyncTestSeam | undefined): void {
+  replaySnapshotWriteSeam = seam;
+}
+/** Test-only snapshot byte cap (mirrors the limits seam). */
+export function setAntigravityReplaySnapshotMaxBytesForTests(maxBytes: number): void {
+  replaySnapshotMaxBytes = maxBytes;
+}
 /** Test seam. */
 export function __resetAntigravityReplayCache(): void {
+  if (replaySnapshotPersistTimer) {
+    clearTimeout(replaySnapshotPersistTimer);
+    replaySnapshotPersistTimer = null;
+  }
+  replaySnapshotLoaded = false;
   lastLazySweepAt = Number.NEGATIVE_INFINITY;
   replayCache.clear();
   replayBytes = 0;
   replayOldestSessionKey = undefined;
   replayOldestAt = null;
+  replayMutationGeneration = 0;
+  replayWrittenGeneration = 0;
+  replaySnapshotWriteSeam = undefined;
+  replaySnapshotLoadDiscarded = false;
+  replaySnapshotMaxBytes = REPLAY_SNAPSHOT_MAX_BYTES;
 }

package/src/adapters/openai-chat.ts CHANGED Viewed

@@ -226,7 +226,7 @@ function toolResultImageChatParts(content: string | OcxContentPart[]): unknown[]
 function messagesToChatFormat(parsed: OcxParsedRequest, provider: OcxProviderConfig): unknown[] {
   const out: unknown[] = [];
   const { context, options } = parsed;
-  const replayCacheScope = parsed._clientThreadId ?? "global";
+  const replayCacheScope = parsed._reasoningReplayScope;
   interface PendingToolCall { id: string; name: string }
   let pendingToolCalls: PendingToolCall[] = [];
@@ -813,19 +813,25 @@ export function createOpenAIChatAdapter(provider: OcxProviderConfig): ProviderAd
       if (provider.promptCacheKey && parsed.options.promptCacheKey !== undefined) {
         body.prompt_cache_key = parsed.options.promptCacheKey;
       }
-      const textFormat = parsed.options.textFormat;
-      if (textFormat?.type === "json_object") {
-        body.response_format = { type: "json_object" };
-      } else if (textFormat?.type === "json_schema") {
-        body.response_format = {
-          type: "json_schema",
-          json_schema: {
-            name: textFormat.name ?? "response",
-            ...(textFormat.description !== undefined ? { description: textFormat.description } : {}),
-            ...(textFormat.schema !== undefined ? { schema: textFormat.schema } : {}),
-            ...(textFormat.strict !== undefined ? { strict: textFormat.strict } : {}),
-          },
-        };
+      // Structured-output support varies by the physical upstream model even when one
+      // gateway exposes a uniform OpenAI-compatible endpoint. Keep the #1137 translation
+      // as the default, but let an exact model opt out instead of forcing a provider-wide
+      // rollback that would silently return prose for siblings that support JSON Schema.
+      if (!provider.noStructuredOutputModels?.includes(parsed.modelId)) {
+        const textFormat = parsed.options.textFormat;
+        if (textFormat?.type === "json_object") {
+          body.response_format = { type: "json_object" };
+        } else if (textFormat?.type === "json_schema") {
+          body.response_format = {
+            type: "json_schema",
+            json_schema: {
+              name: textFormat.name ?? "response",
+              ...(textFormat.description !== undefined ? { description: textFormat.description } : {}),
+              ...(textFormat.schema !== undefined ? { schema: textFormat.schema } : {}),
+              ...(textFormat.strict !== undefined ? { strict: textFormat.strict } : {}),
+            },
+          };
+        }
       }
       if (tools) {
@@ -969,10 +975,11 @@ export function createOpenAIChatAdapter(provider: OcxProviderConfig): ProviderAd
           }
           const rawToolCalls = delta.tool_calls;
-          if (rawToolCalls !== undefined) {
-            // A claimed tool-call payload is not benign padding. Dropping it can leave the
+          if (rawToolCalls !== undefined && rawToolCalls !== null) {
+            // A non-null claimed tool-call payload is not benign padding. Dropping it can leave the
             // matching result permanently orphaned, so malformed nested shapes fail closed
-            // through the adapter error channel instead of escaping as TypeError (#1325).
+            // through the adapter error channel instead of escaping as TypeError (#1325). Null is
+            // tolerated as absent because OpenAI-compatible providers may emit it as stream padding.
             if (!Array.isArray(rawToolCalls)) {
               return yield* terminateWithError(invalidToolCallsEvent(pendingUsage));
             }
@@ -1140,7 +1147,7 @@ export function createOpenAIChatAdapter(provider: OcxProviderConfig): ProviderAd
         if (reasoningText !== undefined) events.push({ type: "reasoning_raw_delta", text: reasoningText });
         if (typeof msg.content === "string") events.push({ type: "text_delta", text: msg.content });
         const rawToolCalls = msg.tool_calls;
-        if (rawToolCalls !== undefined) {
+        if (rawToolCalls !== undefined && rawToolCalls !== null) {
           if (!Array.isArray(rawToolCalls)) return [invalidToolCallsEvent(usage)];
           for (const rawToolCall of rawToolCalls) {
             if (!isRecord(rawToolCall) || !isRecord(rawToolCall.function)) {