@bitkyc08/opencodex 2.84.0 → 2.86.0

package/src/routing/history/ingest.ts

@@ -0,0 +1,238 @@
+/**
+ * Ingest of canonical `usage.jsonl` rows into a request-history index file.
+ *
+ * Shared by the serving thread (tails, small rebuilds) and the rebuild worker
+ * (large rebuilds, #6990), so both produce identical rows and meta. This
+ * module imports no config or indexer state; the worker loads it on its own.
+ */
+
+import type { Database } from "bun:sqlite";
+import { closeSync, fstatSync, openSync, readSync } from "node:fs";
+import {
+  encodePersistedRequestedModel,
+  type PersistedUsageEntry,
+  type UsageLogRevision,
+} from "../../usage/log";
+import { HISTORY_DDL, HISTORY_META_KEYS, HISTORY_SCHEMA_VERSION } from "./schema";
+
+export const REQUEST_HISTORY_INSERT_BATCH = 500;
+export const REQUEST_HISTORY_READ_CHUNK_BYTES = 64 * 1024;
+// The SQLite index is a disposable projection. Complete JSONL records above
+// this bound are omitted from the projection; the canonical usage.jsonl is
+// never truncated or rewritten by the indexer.
+export const REQUEST_HISTORY_MAX_RECORD_BYTES = 1024 * 1024;
+
+/** The ledger at the recorded path is no longer the file the rebuild started from. */
+export class RequestHistoryIndexStaleError extends Error {
+  constructor(message: string) {
+    super(message);
+    this.name = "RequestHistoryIndexStaleError";
+  }
+}
+
+export function metaValue(dbHandle: Database, key: string): string | null {
+  const row = dbHandle.query("SELECT value FROM schema_meta WHERE key = ?").get(key) as
+    | { value: string }
+    | undefined;
+  return row?.value ?? null;
+}
+
+export function setMeta(dbHandle: Database, key: string, value: string | number): void {
+  dbHandle.query(
+    "INSERT INTO schema_meta (key, value) VALUES (?, ?) ON CONFLICT(key) DO UPDATE SET value = excluded.value",
+  ).run(key, String(value));
+}
+
+function metaNumber(dbHandle: Database, key: string): number {
+  const value = metaValue(dbHandle, key);
+  const parsed = value === null ? NaN : Number(value);
+  return Number.isFinite(parsed) ? parsed : 0;
+}
+
+export function resetAndCreateSchema(dbHandle: Database): void {
+  dbHandle.exec("DROP TABLE IF EXISTS requests");
+  dbHandle.exec("DROP TABLE IF EXISTS schema_meta");
+  dbHandle.exec(HISTORY_DDL);
+  setMeta(dbHandle, HISTORY_META_KEYS.schemaVersion, HISTORY_SCHEMA_VERSION);
+  setMeta(dbHandle, HISTORY_META_KEYS.indexedOffset, 0);
+  setMeta(dbHandle, HISTORY_META_KEYS.indexedRows, 0);
+  setMeta(dbHandle, HISTORY_META_KEYS.builtAtMs, Date.now());
+  setMeta(dbHandle, HISTORY_META_KEYS.lastError, "rebuilt");
+}
+
+export function recordSourceMeta(dbHandle: Database, revision: UsageLogRevision | null): void {
+  setMeta(dbHandle, HISTORY_META_KEYS.sourcePath, revision?.path ?? "");
+  setMeta(dbHandle, HISTORY_META_KEYS.sourceDev, revision?.dev ?? 0);
+  setMeta(dbHandle, HISTORY_META_KEYS.sourceIno, revision?.ino ?? 0);
+  setMeta(dbHandle, HISTORY_META_KEYS.sourceBirthtimeMs, revision?.birthtimeMs ?? 0);
+  setMeta(dbHandle, HISTORY_META_KEYS.sourceSize, revision?.size ?? 0);
+  setMeta(dbHandle, HISTORY_META_KEYS.sourceMtimeMs, revision?.mtimeMs ?? 0);
+}
+
+/** Extract the `requests` row columns from a canonical persisted entry. */
+function extractRow(entry: PersistedUsageEntry): Array<string | number | null> {
+  const attempts = entry.attempts;
+  return [
+    entry.requestId,
+    entry.timestamp,
+    entry.provider,
+    entry.model,
+    // Old canonical JSONL rows can predate bounded selector persistence. Encode
+    // the disposable projection on rebuild so exact filters match across versions.
+    typeof entry.requestedModel === "string" ? encodePersistedRequestedModel(entry.requestedModel) : null,
+    entry.status,
+    entry.surface ?? null,
+    entry.inboundProtocol ?? null,
+    entry.apiKeyId ?? null,
+    entry.conversationId ?? null,
+    entry.routeDecision?.routeKind ?? null,
+    entry.routeDecision?.profile?.id ?? null,
+    entry.routeDecision?.profile?.revision ?? null,
+    (attempts?.length ?? 0) > 1 ? 1 : 0,
+    entry.durationMs,
+    entry.firstOutputMs ?? null,
+    entry.usageStatus,
+    entry.usage ? JSON.stringify(entry.usage) : null,
+    entry.totalTokens ?? null,
+    entry.errorCode ?? null,
+    entry.terminalStatus ?? null,
+    entry.closeReason ?? null,
+    attempts?.length ?? 1,
+    entry.routeDecision ? JSON.stringify(entry.routeDecision) : null,
+    JSON.stringify(entry),
+  ];
+}
+
+const ROW_INSERT = `
+INSERT OR IGNORE INTO requests (
+  request_id, timestamp, provider, model, requested_model, status, surface,
+  inbound_protocol, api_key_id, conversation_id, route_kind, profile_id,
+  profile_revision, fallback, duration_ms, first_output_ms, usage_status,
+  usage_json, total_tokens, error_code, terminal_status, close_reason,
+  attempt_count, decision_json, row_json
+) VALUES (
+  ?, ?, ?, ?, ?, ?, ?,
+  ?, ?, ?, ?, ?, ?,
+  ?, ?, ?, ?, ?, ?, ?,
+  ?, ?, ?, ?, ?
+)`;
+
+function parsedEntryFromLine(line: string): PersistedUsageEntry | null {
+  if (!line.trim()) return null;
+  try {
+    const parsed = JSON.parse(line) as PersistedUsageEntry;
+    if (parsed && typeof parsed === "object"
+      && typeof parsed.requestId === "string"
+      && typeof parsed.timestamp === "number"
+      && typeof parsed.provider === "string"
+      && typeof parsed.model === "string"
+      && typeof parsed.status === "number"
+      && typeof parsed.durationMs === "number") {
+      return parsed;
+    }
+  } catch {
+    /* skip partial / hand-edited lines, same as every other reader */
+  }
+  return null;
+}
+
+export interface IngestOptions {
+  /** Ledger file the caller recorded; a different file at the path makes the ingest stale. */
+  expected?: Pick<UsageLogRevision, "dev" | "ino">;
+  /**
+   * Stop at this byte offset instead of the size observed when the ingest
+   * opens the ledger, so a worker rebuild indexes the snapshot its refresh
+   * recorded and the next refresh picks up later appends as a tail.
+   */
+  endOffset?: number;
+}
+
+export function ingestSourceTail(
+  dbHandle: Database,
+  path: string,
+  fromOffset: number,
+  options: IngestOptions = {},
+): number {
+  let inserted = 0;
+  let pending: Array<Array<string | number | null>> = [];
+  const insert = dbHandle.prepare(ROW_INSERT);
+  let fd: number | undefined;
+  try {
+    const commitBatch = () => {
+      dbHandle.transaction((rows: Array<Array<string | number | null>>) => {
+        for (const row of rows) {
+          // `changes` counts real inserts only; INSERT OR IGNORE replays add 0.
+          inserted += insert.run(...row).changes;
+        }
+      })(pending);
+      pending = [];
+    };
+    const ingestLine = (line: Buffer) => {
+      const entry = parsedEntryFromLine(line.toString("utf-8"));
+      if (!entry) return;
+      pending.push(extractRow(entry));
+      if (pending.length >= REQUEST_HISTORY_INSERT_BATCH) commitBatch();
+    };
+
+    fd = openSync(path, "r");
+    const stat = fstatSync(fd);
+    const expected = options.expected;
+    if (expected && (Number(stat.dev) !== Number(expected.dev) || Number(stat.ino) !== Number(expected.ino))) {
+      throw new RequestHistoryIndexStaleError("usage log changed before indexing");
+    }
+    const size = options.endOffset === undefined
+      ? Number(stat.size)
+      : Math.min(Number(stat.size), options.endOffset);
+    const readBuffer = Buffer.allocUnsafe(REQUEST_HISTORY_READ_CHUNK_BYTES);
+    let position = fromOffset;
+    let nextOffset = fromOffset;
+    let fragments: Buffer[] = [];
+    let fragmentBytes = 0;
+    let oversized = false;
+    while (position < size) {
+      const requested = Math.min(readBuffer.length, size - position);
+      const bytesRead = readSync(fd, readBuffer, 0, requested, position);
+      if (bytesRead === 0) throw new RequestHistoryIndexStaleError("usage log changed while indexing");
+      let lineStart = 0;
+      for (let index = 0; index < bytesRead; index++) {
+        if (readBuffer[index] !== 0x0a) continue;
+        const segment = readBuffer.subarray(lineStart, index);
+        if (!oversized && fragmentBytes + segment.length <= REQUEST_HISTORY_MAX_RECORD_BYTES) {
+          const line = fragments.length === 0
+            ? segment
+            : Buffer.concat([...fragments, segment], fragmentBytes + segment.length);
+          ingestLine(line);
+        }
+        fragments = [];
+        fragmentBytes = 0;
+        oversized = false;
+        lineStart = index + 1;
+        nextOffset = position + index + 1;
+      }
+      const remainder = readBuffer.subarray(lineStart, bytesRead);
+      if (!oversized && fragmentBytes + remainder.length <= REQUEST_HISTORY_MAX_RECORD_BYTES) {
+        // Copy because readBuffer is reused on the next iteration.
+        fragments.push(Buffer.from(remainder));
+        fragmentBytes += remainder.length;
+      } else if (remainder.length > 0) {
+        fragments = [];
+        fragmentBytes = 0;
+        oversized = true;
+      }
+      position += bytesRead;
+    }
+    if (pending.length > 0) commitBatch();
+    const indexedRows = metaNumber(dbHandle, HISTORY_META_KEYS.indexedRows);
+    setMeta(dbHandle, HISTORY_META_KEYS.indexedOffset, nextOffset);
+    setMeta(dbHandle, HISTORY_META_KEYS.indexedRows, indexedRows + inserted);
+    setMeta(dbHandle, HISTORY_META_KEYS.sourceSize, size);
+    setMeta(dbHandle, HISTORY_META_KEYS.sourceMtimeMs, Number(stat.mtimeMs));
+    setMeta(dbHandle, HISTORY_META_KEYS.builtAtMs, Date.now());
+    return inserted;
+  } finally {
+    if (fd !== undefined) closeSync(fd);
+    // Windows file locks: an unterminated prepared statement keeps the DB
+    // file busy after close (verified on Bun 1.3.14). Finalize always.
+    insert.finalize();
+  }
+}

package/src/routing/history/rebuild-job.ts

@@ -0,0 +1,111 @@
+/**
+ * The indexer's side of one rebuild worker (#6990): spawn it, send the build
+ * request, and take it down again. Every exit settles: a worker that errors or
+ * exits rejects the pending build. dispose() is bounded; afterExit() runs
+ * cleanup only once the thread has really exited, so build files the thread
+ * may still hold are never removed under it.
+ */
+
+import { spawnWorker } from "../../lib/worker-embed";
+import { storageWorkerOsJoinSettleMs } from "../../storage/worker-lifecycle";
+import type { UsageLogRevision } from "../../usage/log";
+import { RequestHistoryIndexStaleError } from "./ingest";
+import type { RebuildWorkerReply, RebuildWorkerRequest } from "./rebuild-protocol";
+
+const CLOSE_TIMEOUT_MS = 5_000;
+
+function delay(ms: number): Promise<void> {
+  return new Promise(resolve => setTimeout(resolve, ms));
+}
+
+/** True when `promise` settles within `ms`; the timer is cleared either way so it never keeps a process alive. */
+function settlesWithin(promise: Promise<unknown>, ms: number): Promise<boolean> {
+  let timer: ReturnType<typeof setTimeout> | undefined;
+  const expired = new Promise<boolean>(resolve => { timer = setTimeout(() => resolve(false), ms); });
+  return Promise.race([promise.then(() => true, () => true), expired]).finally(() => clearTimeout(timer));
+}
+
+function errorFromReply(reply: Extract<RebuildWorkerReply, { type: "error" }>): Error {
+  if (reply.name === "RequestHistoryIndexStaleError") return new RequestHistoryIndexStaleError(reply.message);
+  const error = new Error(reply.message);
+  error.name = reply.name;
+  return error;
+}
+
+export class RebuildWorkerJob {
+  private readonly worker: Worker;
+  private pending: { resolve: (rows: number) => void; reject: (error: unknown) => void } | null = null;
+  private exited = false;
+  private exitedCleanly = false;
+  private disposal: Promise<void> | null = null;
+  private readonly closed: Promise<void>;
+
+  constructor() {
+    this.worker = spawnWorker(new URL("./rebuild-worker.ts", import.meta.url).href, "request-history-rebuild-worker");
+    let markClosed!: () => void;
+    this.closed = new Promise(resolve => { markClosed = resolve; });
+    this.worker.addEventListener("message", (event: MessageEvent<RebuildWorkerReply>) => {
+      const pending = this.pending;
+      this.pending = null;
+      if (!pending) return;
+      const reply = event.data;
+      if (reply.type === "built") pending.resolve(reply.rows);
+      else pending.reject(errorFromReply(reply));
+    });
+    this.worker.addEventListener("error", (event: Event) => {
+      this.fail(new Error((event as ErrorEvent).message || "request-history rebuild worker failed"));
+    });
+    this.worker.addEventListener("close", () => {
+      this.exited = true;
+      this.fail(new Error("request-history rebuild worker exited"));
+      markClosed();
+    }, { once: true });
+  }
+
+  private fail(error: unknown): void {
+    const pending = this.pending;
+    this.pending = null;
+    pending?.reject(error);
+  }
+
+  /** Build the complete private file; resolves with the ingested row count. */
+  build(indexPath: string, buildPath: string, reason: string, revision: UsageLogRevision): Promise<number> {
+    if (this.exited || this.disposal) return Promise.reject(new Error("request-history rebuild worker is not running"));
+    if (this.pending) return Promise.reject(new Error("request-history rebuild worker is busy"));
+    return new Promise((resolve, reject) => {
+      this.pending = { resolve, reject };
+      this.worker.postMessage({ type: "build", indexPath, buildPath, reason, revision } satisfies RebuildWorkerRequest);
+    });
+  }
+
+  /** Stop the thread; waits a bounded time for it to exit. */
+  dispose(): Promise<void> {
+    this.disposal ??= this.shutDown();
+    return this.disposal;
+  }
+
+  /**
+   * Dispose, then run `cleanup` once the thread has exited. A thread that
+   * overran the bound (blocked in native I/O) gets its cleanup when it does
+   * exit; the returned promise does not wait for that.
+   */
+  async afterExit(cleanup: () => void): Promise<void> {
+    await this.dispose();
+    if (this.exitedCleanly) {
+      cleanup();
+      return;
+    }
+    void this.closed.then(() => delay(storageWorkerOsJoinSettleMs())).then(cleanup).catch(() => undefined);
+  }
+
+  private async shutDown(): Promise<void> {
+    this.fail(new Error("request-history rebuild worker stopped"));
+    try { this.worker.terminate(); } catch { /* already gone */ }
+    if (!await settlesWithin(this.closed, CLOSE_TIMEOUT_MS)) return;
+    // Bun does not expose the OS thread join; Windows needs this gap before
+    // files a terminated thread held can be removed.
+    const settleMs = storageWorkerOsJoinSettleMs();
+    if (settleMs > 0) await delay(settleMs);
+    this.exitedCleanly = true;
+  }
+}

package/src/routing/history/rebuild-protocol.ts

@@ -0,0 +1,15 @@
+/** Messages between the indexer and its rebuild worker (#6990). Types only. */
+
+import type { UsageLogRevision } from "../../usage/log";
+
+export type RebuildWorkerRequest = {
+  type: "build";
+  indexPath: string;
+  buildPath: string;
+  reason: string;
+  revision: UsageLogRevision;
+};
+
+export type RebuildWorkerReply =
+  | { type: "built"; rows: number }
+  | { type: "error"; name: string; message: string };

package/src/routing/history/rebuild-worker.ts

@@ -0,0 +1,34 @@
+/**
+ * Rebuild worker for the request-history index (#6990).
+ *
+ * A full rebuild reads the whole ledger and commits every row; one rebuild of
+ * a 2.34 GB ledger held the serving event loop for 487 s. This thread does
+ * that work instead: it sweeps abandoned builds, creates the private build,
+ * ingests the ledger snapshot the refresh recorded, switches it to WAL and
+ * closes it. The serving thread then swaps the finished file in.
+ */
+
+import { buildIndexFile, removeAbandonedBuilds } from "./build-file";
+import type { RebuildWorkerReply, RebuildWorkerRequest } from "./rebuild-protocol";
+
+declare const self: Worker;
+
+function handle(request: RebuildWorkerRequest): RebuildWorkerReply {
+  removeAbandonedBuilds(request.indexPath);
+  const rows = buildIndexFile(request.buildPath, request.reason, request.revision);
+  return { type: "built", rows };
+}
+
+self.onmessage = (event: MessageEvent<RebuildWorkerRequest>) => {
+  let reply: RebuildWorkerReply;
+  try {
+    reply = handle(event.data);
+  } catch (error) {
+    reply = {
+      type: "error",
+      name: error instanceof Error ? error.name : "Error",
+      message: error instanceof Error ? error.message : String(error),
+    };
+  }
+  self.postMessage(reply);
+};

package/src/server/admission-model-scope.ts

@@ -1,5 +1,6 @@
 import type { DataPlaneAdmission } from "./auth-cors";
 import type { OcxApiKeyEntry, OcxConfig } from "../types";
+import { markResponseNonReplayable } from "../lib/upstream-retry";
 
 /**
  * Per-admission-key model and provider scope.
@@ -155,10 +156,12 @@ export function admissionModelDeniedBody(error: AdmissionModelDeniedError): {
  * indistinguishable from a typo in the model name.
  */
 export function admissionModelDeniedResponse(error: AdmissionModelDeniedError): Response {
-  return new Response(JSON.stringify(admissionModelDeniedBody(error)), {
+  const response = new Response(JSON.stringify(admissionModelDeniedBody(error)), {
     status: 403,
     headers: { "Content-Type": "application/json" },
   });
+  markResponseNonReplayable(response);
+  return response;
 }
 
 /**

package/src/server/antigravity-direct-eligibility.ts

@@ -0,0 +1,208 @@
+/**
+ * Whether a settled Chat or Messages route may take the Antigravity direct lane.
+ *
+ * On that lane the ingress hands the Responses core a body that carries only the request
+ * settings (model, stream, reasoning, limits, tool choice, tier) and decodes the conversation
+ * straight from the client body into the IR at the parse seam (`src/protocols/codecs/chat-ir.ts`,
+ * `messages-ir.ts`), so the Google adapter compiles from the caller's own messages. Everything
+ * that is decided from those settings keeps its current owner in the core: routing, account
+ * rotation, effort policy, usage and logging.
+ *
+ * PURE: reads the route, the body's structure and config. The ingresses and the protocol planner
+ * (`src/protocols/plan-snapshot.ts`) both ask here, so a preview and the real send cannot
+ * disagree about the lane.
+ */
+import { chatBodyCarriesImage } from "../chat/image-parts";
+import { contentToText } from "../chat/inbound";
+import { isClaudeWebSearchToolName } from "../claude/outbound";
+import { isShadowSourceModel } from "../lib/shadow-call";
+import type { ProtocolReasonCode } from "../protocols/contract";
+import { resolveProtocolSettings } from "../protocols/settings";
+import { effectiveGoogleMode } from "../providers/registry";
+import type { RouteResult } from "../router";
+import type { OcxConfig } from "../types";
+import { requiresVisionPreprocessing } from "../vision";
+
+/** Why the Antigravity direct lane declines a route, as a protocol reason code. */
+export type AntigravityDirectDeclineReason = Extract<
+  ProtocolReasonCode,
+  | "rollout-disabled"
+  | "not-migrated"
+  | "combo-or-policy-route"
+  | "hosted-tool"
+  | "vision-preprocessing"
+  | "bridge-only-policy"
+>;
+
+type Rec = Record<string, unknown>;
+function isRec(value: unknown): value is Rec {
+  return value !== null && typeof value === "object" && !Array.isArray(value);
+}
+
+type RouteShape = Pick<RouteResult, "providerName" | "modelId" | "provider" | "combo" | "routeKind">;
+
+/** A Google adapter route in Cloud Code Assist mode: the Antigravity wire. */
+export function isAntigravityRoute(route: Pick<RouteResult, "providerName" | "provider">): boolean {
+  return effectiveGoogleMode(route.providerName, route.provider) === "cloud-code-assist";
+}
+
+/**
+ * A hosted web-search tool the bridge would hand to the web-search sidecar. The sidecar reads
+ * the hosted tool from the parsed Responses body, which this lane does not build.
+ */
+function declaresHostedWebSearch(body: Readonly<Rec>): boolean {
+  return Array.isArray(body.tools)
+    && body.tools.some(tool => isRec(tool) && (tool.type === "web_search" || tool.type === "web_search_preview"));
+}
+
+/**
+ * The shadow-call intercept rewrites the model to another target (often a combo) before the
+ * core parses the body, so the request would leave the route this lane was decided for.
+ */
+function shadowInterceptMayApply(model: unknown, config: OcxConfig): boolean {
+  const intercept = config.shadowCallIntercept;
+  return intercept?.enabled === true && typeof intercept.model === "string" && intercept.model.length > 0
+    && typeof model === "string" && isShadowSourceModel(model, intercept.sourceModels);
+}
+
+const SKILLS_CATALOG_MARKER = "<skills_instructions>";
+const GENERATED_IMAGE_LINK = "![Generated image](<";
+
+/**
+ * Text the Responses core rewrites on the bridge body before parsing: a skills catalog in an
+ * instruction (the per-session skills snapshot substitutes a stored block) and a generated-image
+ * link in assistant history (hosted display paths are redacted to the artifact URL). The lane's
+ * settings-only body has neither, so such a request keeps the bridge.
+ */
+function carriesBridgeRewrittenText(body: Readonly<Rec>): boolean {
+  if (!Array.isArray(body.messages)) return false;
+  return body.messages.some(message => {
+    if (!isRec(message)) return false;
+    if (message.role === "system" || message.role === "developer") {
+      return contentToText(message.content).includes(SKILLS_CATALOG_MARKER);
+    }
+    if (message.role === "assistant") return contentToText(message.content).includes(GENERATED_IMAGE_LINK);
+    return false;
+  });
+}
+
+/** Request facts the body and config cannot carry, supplied by a caller that is about to send. */
+export interface AntigravityDirectRuntime {
+  /**
+   * The cache diagnostic recorder is observing inbound bodies. It records the body the core
+   * receives, which on the lane has no conversation, so the request keeps the bridge while it
+   * observes. The planner never supplies this.
+   */
+  cacheDiagnostics?: boolean;
+}
+
+/**
+ * The first rule that keeps a Chat request off the Antigravity direct lane, or `undefined` when
+ * the route is eligible.
+ *
+ * - the `protocols.rollout.antigravityDirect` switch is explicitly off (it defaults on);
+ * - the final adapter is not Google in Cloud Code Assist mode;
+ * - a combo or policy route owns multi-candidate execution in the Responses pipeline;
+ * - a hosted web-search tool would engage the sidecar, which reads the Responses body;
+ * - an image would reach a model the operator declared unable to read it (the vision sidecar
+ *   rewrites images on the Responses body as well as the IR);
+ * - the shadow-call intercept could move the request to another target before parsing.
+ * - the core would rewrite conversation text on the bridge body (a skills catalog, a generated
+ *   image link), or the cache diagnostic recorder is observing.
+ */
+export function antigravityDirectDeclineReason(
+  route: RouteShape,
+  body: Readonly<Rec>,
+  config: OcxConfig,
+  runtime: AntigravityDirectRuntime = {},
+): AntigravityDirectDeclineReason | undefined {
+  const routeDecline = antigravityRouteDeclineReason(route, config);
+  if (routeDecline) return routeDecline;
+  if (declaresHostedWebSearch(body)) return "hosted-tool";
+  if (chatBodyCarriesImage(body) && requiresVisionPreprocessing(config, route.provider, route.modelId, route.providerName)) {
+    return "vision-preprocessing";
+  }
+  if (shadowInterceptMayApply(body.model, config)) return "bridge-only-policy";
+  if (carriesBridgeRewrittenText(body) || runtime.cacheDiagnostics === true) return "bridge-only-policy";
+  return undefined;
+}
+
+/** The declines that read only the route and config, shared by both ingresses. */
+function antigravityRouteDeclineReason(route: RouteShape, config: OcxConfig): AntigravityDirectDeclineReason | undefined {
+  if (!resolveProtocolSettings(config).rollout.antigravityDirect) return "rollout-disabled";
+  if (!isAntigravityRoute(route)) return "not-migrated";
+  if (route.combo !== undefined || route.routeKind === "combo" || route.routeKind === "policy") return "combo-or-policy-route";
+  return undefined;
+}
+
+function anthropicBlocks(content: unknown): Rec[] {
+  return Array.isArray(content) ? content.filter(isRec) : [];
+}
+
+/** Text of an Anthropic `system` or message content: a string or its text blocks. */
+function anthropicText(content: unknown): string {
+  if (typeof content === "string") return content;
+  return anthropicBlocks(content)
+    .map(block => (block.type === "text" && typeof block.text === "string" ? block.text : ""))
+    .join("\n");
+}
+
+/** A Messages hosted web-search tool (or a forced WebSearch choice) would engage the sidecar. */
+function messagesDeclaresHostedWebSearch(body: Readonly<Rec>): boolean {
+  const tools = Array.isArray(body.tools)
+    && body.tools.some(tool => isRec(tool) && typeof tool.type === "string" && tool.type.startsWith("web_search"));
+  const choice = body.tool_choice;
+  return tools || (isRec(choice) && choice.type === "tool" && typeof choice.name === "string"
+    && isClaudeWebSearchToolName(choice.name));
+}
+
+/** An image block in a user turn or inside a tool result. */
+function messagesBodyCarriesImage(body: Readonly<Rec>): boolean {
+  if (!Array.isArray(body.messages)) return false;
+  return body.messages.some(message => isRec(message) && message.role === "user"
+    && anthropicBlocks(message.content).some(block => block.type === "image"
+      || (block.type === "tool_result" && anthropicBlocks(block.content).some(inner => inner.type === "image"))));
+}
+
+/** The Messages counterpart of `carriesBridgeRewrittenText`: system text and assistant history. */
+function messagesCarryBridgeRewrittenText(body: Readonly<Rec>): boolean {
+  if (anthropicText(body.system).includes(SKILLS_CATALOG_MARKER)) return true;
+  if (!Array.isArray(body.messages)) return false;
+  return body.messages.some(message => {
+    if (!isRec(message)) return false;
+    if (message.role === "system") return anthropicText(message.content).includes(SKILLS_CATALOG_MARKER);
+    if (message.role === "assistant") return anthropicText(message.content).includes(GENERATED_IMAGE_LINK);
+    return false;
+  });
+}
+
+/**
+ * The first rule that keeps a Messages request off the Antigravity direct lane, or `undefined`
+ * when the route is eligible. `model` is the resolved model the bridge body would carry, which is
+ * what the shadow-call intercept matches.
+ *
+ * The route and config rules are the Chat ones. The body rules are the Messages spellings of the
+ * same hazards: a hosted web-search tool (`web_search_*`) or forced WebSearch choice, an image
+ * (in a user turn or a tool result) for a model the operator declared unable to read it, a
+ * shadow-call intercept, a skills catalog in the system text or a generated-image link in
+ * assistant history, or an observing cache diagnostic recorder. Blocked-skill elision, the
+ * `stabilizePromptCache` relocation and the ocxr1 envelopes are reproduced by the decoder and
+ * decline nothing.
+ */
+export function antigravityMessagesDeclineReason(
+  route: RouteShape,
+  body: Readonly<Rec>,
+  model: string,
+  config: OcxConfig,
+  runtime: AntigravityDirectRuntime = {},
+): AntigravityDirectDeclineReason | undefined {
+  const routeDecline = antigravityRouteDeclineReason(route, config);
+  if (routeDecline) return routeDecline;
+  if (messagesDeclaresHostedWebSearch(body)) return "hosted-tool";
+  if (messagesBodyCarriesImage(body) && requiresVisionPreprocessing(config, route.provider, route.modelId, route.providerName)) {
+    return "vision-preprocessing";
+  }
+  if (shadowInterceptMayApply(model, config)) return "bridge-only-policy";
+  if (messagesCarryBridgeRewrittenText(body) || runtime.cacheDiagnostics === true) return "bridge-only-policy";
+  return undefined;
+}

package/src/server/auth-cors.ts

@@ -925,6 +925,8 @@ export function providerManagementConfigError(
   if (raw.xaiResponsesXSearch !== undefined && typeof raw.xaiResponsesXSearch !== "boolean") {
     return `provider ${name} xaiResponsesXSearch must be a boolean`;
   }
+  const minMaxOutputError = positiveIntegerConfigError(raw.minMaxOutputTokens, "minMaxOutputTokens");
+  if (minMaxOutputError) return `provider ${name} ${minMaxOutputError}`;
   const defaultMaxOutputError = positiveIntegerConfigError(raw.defaultMaxOutputTokens, "defaultMaxOutputTokens");
   if (defaultMaxOutputError) return `provider ${name} ${defaultMaxOutputError}`;
   const maxOutputError = positiveIntegerRecordConfigError(raw.modelMaxOutputTokens, "modelMaxOutputTokens");
@@ -1085,6 +1087,7 @@ const PROVIDER_CONFIG_FIELD_POLICY = {
   newModelPolicy: "editor",
   modelPreset: "editor",
   contextWindow: "editor",
+  inferContextWindow: "editor",
   modelContextWindows: "editor",
   modelContextTiers: "editor",
   modelInputModalities: "editor",
@@ -1092,6 +1095,7 @@ const PROVIDER_CONFIG_FIELD_POLICY = {
   modelMaxInputTokens: "runtime",
   modelAutoCompactTokenLimits: "editor",
   defaultMaxOutputTokens: "editor",
+  minMaxOutputTokens: "editor",
   modelMaxOutputTokens: "editor",
   modelCosts: "editor",
   headers: "redacted",