@iislee/opencodex 2.11.0

package/src/lib/sse-decoder.ts

@@ -0,0 +1,323 @@
+import {
+  TRANSLATOR_MAX_SSE_EVENT_BYTES,
+  TranslatorBudgetExceededError,
+  type TranslatorBudget,
+} from "./translator-budget";
+
+export interface ServerSentEvent {
+  event?: string;
+  data: string;
+}
+
+export type SseRecord =
+  | { kind: "event"; event?: string; data: string }
+  | { kind: "comment"; comment: string };
+
+/**
+ * Decode text/event-stream records across arbitrary fetch chunk boundaries.
+ *
+ * The final record is dispatched at EOF even when the upstream omits the trailing blank line or
+ * final newline. That matters for compatible APIs that place a terminal event in the last bytes of
+ * the body: dropping that record turns a successful response into an adapter_eof failure.
+ */
+export function decodeServerSentEvents(
+  source: ReadableStream<Uint8Array>,
+  options: { includeComments: true; signal?: AbortSignal; translatorBudget: TranslatorBudget },
+): AsyncGenerator<SseRecord>;
+export function decodeServerSentEvents(
+  source: ReadableStream<Uint8Array>,
+  options: { includeComments?: false; signal?: AbortSignal; translatorBudget: TranslatorBudget },
+): AsyncGenerator<ServerSentEvent>;
+export async function* decodeServerSentEvents(
+  source: ReadableStream<Uint8Array>,
+  options: { includeComments?: boolean; signal?: AbortSignal; translatorBudget: TranslatorBudget },
+): AsyncGenerator<ServerSentEvent | SseRecord> {
+  const translatorBudget = options.translatorBudget;
+  const reader = source.getReader();
+  const decoder = new TextDecoder();
+  let lineBuffer = "";
+  let lineRawBytes = 0;
+  let lineRetainedBytes = 0;
+  let event: string | undefined;
+  let eventBytes = 0;
+  let dataLines: string[] = [];
+  let dataLinesBytes = 0;
+  const scope = { kind: "live_transient" as const };
+
+  const utf8SliceBytes = (value: string, start: number, end: number): number => {
+    let bytes = 0;
+    for (let index = start; index < end; index++) {
+      const codePoint = value.codePointAt(index)!;
+      if (codePoint <= 0x7f) bytes += 1;
+      else if (codePoint <= 0x7ff) bytes += 2;
+      else if (codePoint <= 0xffff) bytes += 3;
+      else {
+        bytes += 4;
+        index += 1;
+      }
+    }
+    return bytes;
+  };
+
+  const linePrefixAfter = (sourceValue: string, start: number, end: number): string => {
+    if (lineBuffer.length >= 6) return lineBuffer.slice(0, 6);
+    return (lineBuffer + sourceValue.slice(start, Math.min(end, start + 6 - lineBuffer.length))).slice(0, 6);
+  };
+
+  const accountedLineBytes = (rawBytes: number, prefix: string): number => {
+    if (prefix.length < 5 && "data:".startsWith(prefix)) return 0;
+    if (!prefix.startsWith("data:")) return rawBytes;
+    return Math.max(0, rawBytes - (prefix[5] === " " ? 6 : 5));
+  };
+
+  const appendLine = (sourceValue: string, start: number, end: number): void => {
+    if (start >= end) return;
+    const nextRawBytes = lineRawBytes + utf8SliceBytes(sourceValue, start, end);
+    const prefix = linePrefixAfter(sourceValue, start, end);
+    const nextRetainedBytes = accountedLineBytes(nextRawBytes, prefix);
+    if (prefix.startsWith("data:")) {
+      const logicalEventBytes = dataLinesBytes + dataLines.length + nextRetainedBytes;
+      if (logicalEventBytes > TRANSLATOR_MAX_SSE_EVENT_BYTES) {
+        throw new TranslatorBudgetExceededError("live_transient", TRANSLATOR_MAX_SSE_EVENT_BYTES);
+      }
+    }
+    const reservation = translatorBudget.reserveTransient(nextRawBytes, scope);
+    try {
+      const fragment = sourceValue.slice(start, end);
+      lineBuffer += fragment;
+      reservation.commitRetained();
+      translatorBudget.releaseRetained(lineRetainedBytes, scope);
+      lineRawBytes = nextRawBytes;
+      lineRetainedBytes = nextRawBytes;
+    } catch (error) {
+      reservation.release();
+      throw error;
+    }
+  };
+  // Prompt cancellation channel: an abort cancels the underlying reader directly, which
+  // settles any in-flight read() so a consumer's iterator.return() cannot hang behind an
+  // idle upstream (a plain generator return waits for the pending await first).
+  const signal = options?.signal;
+  const onAbort = () => { reader.cancel(signal?.reason).catch(() => { /* already closed */ }); };
+  if (signal?.aborted) onAbort();
+  else signal?.addEventListener("abort", onAbort, { once: true });
+
+  const includeComments = options?.includeComments === true;
+
+  const dispatch = (): { record: ServerSentEvent | SseRecord; bytes: number } | undefined => {
+    if (dataLines.length === 0) {
+      translatorBudget.releaseRetained(eventBytes, scope);
+      event = undefined;
+      eventBytes = 0;
+      return undefined;
+    }
+    const payloadBytes = dataLinesBytes + Math.max(0, dataLines.length - 1);
+    if (payloadBytes > TRANSLATOR_MAX_SSE_EVENT_BYTES) {
+      throw new TranslatorBudgetExceededError("live_transient", TRANSLATOR_MAX_SSE_EVENT_BYTES);
+    }
+    let data: string;
+    if (dataLines.length === 1) {
+      data = dataLines[0]!;
+    } else {
+      const reservation = translatorBudget.reserveTransient(payloadBytes, scope);
+      try {
+        data = dataLines.join("\n");
+        reservation.commitRetained();
+        translatorBudget.releaseRetained(dataLinesBytes, scope);
+      } catch (error) {
+        reservation.release();
+        throw error;
+      }
+    }
+    const record = { ...(event ? { event } : {}), data };
+    const retainedRecordBytes = payloadBytes + eventBytes;
+    event = undefined;
+    eventBytes = 0;
+    dataLines = [];
+    dataLinesBytes = 0;
+    return {
+      record: includeComments ? { kind: "event", ...record } : record,
+      bytes: retainedRecordBytes,
+    };
+  };
+
+  const acceptLine = (): { record: ServerSentEvent | SseRecord; bytes: number } | undefined => {
+    let line = lineBuffer;
+    let retainedLineBytes = lineRetainedBytes;
+    let lineOwned = true;
+    const releaseLine = (): void => {
+      if (!lineOwned) return;
+      lineOwned = false;
+      translatorBudget.releaseRetained(retainedLineBytes, scope);
+    };
+    lineBuffer = "";
+    lineRawBytes = 0;
+    lineRetainedBytes = 0;
+    try {
+      if (line.endsWith("\r")) {
+        const nextLineBytes = retainedLineBytes - 1;
+        const reservation = translatorBudget.reserveTransient(nextLineBytes, scope);
+        try {
+          const nextLine = line.slice(0, -1);
+          reservation.commitRetained();
+          translatorBudget.releaseRetained(retainedLineBytes, scope);
+          line = nextLine;
+          retainedLineBytes = nextLineBytes;
+        } catch (error) {
+          reservation.release();
+          throw error;
+        }
+      }
+      if (line === "") {
+        releaseLine();
+        return dispatch();
+      }
+      if (line.startsWith(":")) {
+        if (!includeComments) {
+          releaseLine();
+          return undefined;
+        }
+        const commentStart = line[1] === " " ? 2 : 1;
+        const commentBytes = utf8SliceBytes(line, commentStart, line.length);
+        translatorBudget.chargeRetained(commentBytes, scope);
+        try {
+          const comment = line.slice(commentStart);
+          releaseLine();
+          return { record: { kind: "comment", comment }, bytes: commentBytes };
+        } catch (error) {
+          translatorBudget.releaseRetained(commentBytes, scope);
+          throw error;
+        }
+      }
+
+      const colon = line.indexOf(":");
+      const fieldEnd = colon < 0 ? line.length : colon;
+      const fieldBytes = utf8SliceBytes(line, 0, fieldEnd);
+      const fieldReservation = translatorBudget.reserveTransient(fieldBytes, scope);
+      let field = "";
+      try {
+        field = line.slice(0, fieldEnd);
+        fieldReservation.commitRetained();
+      } catch (error) {
+        fieldReservation.release();
+        throw error;
+      }
+      try {
+        let valueStart = colon < 0 ? line.length : colon + 1;
+        if (line[valueStart] === " ") valueStart += 1;
+        const valueBytes = utf8SliceBytes(line, valueStart, line.length);
+
+        if (field === "event") {
+          const reservation = translatorBudget.reserveTransient(valueBytes, scope);
+          try {
+            const value = line.slice(valueStart);
+            reservation.commitRetained();
+            translatorBudget.releaseRetained(eventBytes, scope);
+            event = value;
+            eventBytes = valueBytes;
+            releaseLine();
+          } catch (error) {
+            reservation.release();
+            throw error;
+          }
+        }
+        else if (field === "data") {
+          const nextEventBytes = dataLinesBytes + valueBytes + dataLines.length;
+          if (nextEventBytes > TRANSLATOR_MAX_SSE_EVENT_BYTES) {
+            throw new TranslatorBudgetExceededError("live_transient", TRANSLATOR_MAX_SSE_EVENT_BYTES);
+          }
+          // The extracted value is a distinct retained allocation while the source line is still
+          // live. Admit that insertion before slicing/pushing, then release the source owner.
+          translatorBudget.chargeRetained(valueBytes, scope);
+          try {
+            const value = line.slice(valueStart);
+            dataLines.push(value);
+            dataLinesBytes += valueBytes;
+            releaseLine();
+          } catch (error) {
+            translatorBudget.releaseRetained(valueBytes, scope);
+            throw error;
+          }
+        } else {
+          releaseLine();
+        }
+      } finally {
+        translatorBudget.releaseRetained(fieldBytes, scope);
+      }
+      return undefined;
+    } catch (error) {
+      releaseLine();
+      throw error;
+    }
+  };
+
+  const consumeDecoded = async function* (
+    decoded: string,
+  ): AsyncGenerator<ServerSentEvent | SseRecord> {
+    let offset = 0;
+    while (offset < decoded.length) {
+      const newline = decoded.indexOf("\n", offset);
+      if (newline < 0) {
+        appendLine(decoded, offset, decoded.length);
+        return;
+      }
+      appendLine(decoded, offset, newline);
+      const accepted = acceptLine();
+      if (accepted) {
+        try {
+          yield accepted.record;
+        } finally {
+          translatorBudget.releaseRetained(accepted.bytes, scope);
+        }
+      }
+      offset = newline + 1;
+    }
+  };
+
+  try {
+    while (true) {
+      const { done, value } = await reader.read();
+      if (value) {
+        const sourceBytes = value.byteLength;
+        const sourceReservation = translatorBudget.reserveTransient(sourceBytes, scope);
+        let sourceCommitted = false;
+        try {
+          const decoded = decoder.decode(value, { stream: !done });
+          sourceReservation.commitRetained();
+          sourceCommitted = true;
+          yield* consumeDecoded(decoded);
+        } finally {
+          if (sourceCommitted) translatorBudget.releaseRetained(sourceBytes, scope);
+          else sourceReservation.release();
+        }
+      }
+      if (!done) continue;
+      const finalDecoded = decoder.decode();
+      yield* consumeDecoded(finalDecoded);
+      if (lineBuffer.length > 0) {
+        const accepted = acceptLine();
+        if (accepted) {
+          try {
+            yield accepted.record;
+          } finally {
+            translatorBudget.releaseRetained(accepted.bytes, scope);
+          }
+        }
+      }
+      const finalRecord = dispatch();
+      if (finalRecord) {
+        try {
+          yield finalRecord.record;
+        } finally {
+          translatorBudget.releaseRetained(finalRecord.bytes, scope);
+        }
+      }
+      break;
+    }
+  } finally {
+    translatorBudget.releaseRetained(lineRetainedBytes + dataLinesBytes + eventBytes, scope);
+    signal?.removeEventListener("abort", onAbort);
+    try { await reader.cancel(); } catch { /* already closed/errored */ }
+    try { reader.releaseLock(); } catch { /* already released */ }
+  }
+}

package/src/lib/state-store-registrations.ts

@@ -0,0 +1,109 @@
+import {
+  getConfigDir,
+  reconcileConfigWarningMemos,
+  sweepDeadOcxStartProcessCache,
+} from "../config";
+import { reconcileCodexReauthState } from "../codex/account-runtime-state";
+import { reconcileCatalogWarningMemos } from "../codex/catalog/aggregation";
+import { reconcileProviderFetchWarnings } from "../codex/catalog/provider-fetch";
+import { reconcileModelCacheGeneration } from "../codex/model-cache";
+import { reconcilePoolRotationState } from "../codex/pool-rotation";
+import { reconcileCodexQuotaAccounts } from "../codex/quota";
+import {
+  listLiveCodexAccountIds,
+  reconcileCodexRoutingHealth,
+} from "../codex/routing";
+import { sweepExpiredSubagentModelHealth } from "../codex/subagent-model-fallback";
+import {
+  reconcileComboTargetCooldowns,
+  sweepExpiredComboTargetCooldowns,
+} from "../combos/failover";
+import { reconcileComboWarningMemos } from "../combos/request";
+import { reconcileComboRotationState } from "../combos/resolve";
+import { listLiveComboTargetKeys } from "../combos/types";
+import {
+  listLiveConfigOwnershipRoots,
+  reconcileConfigOwnershipRoots,
+} from "./config-ownership";
+import { reconcileGcpAdcTokens, sweepExpiredGcpAdcTokens } from "./gcp-adc";
+import {
+  reconcileOAuthFlowState,
+  sweepExpiredXaiPermanentFailureVerdicts,
+} from "../oauth";
+import { sweepExpiredAnthropicRoutingHealth } from "../oauth/anthropic-routing";
+import { listLiveOAuthAccountKeys, reconcileOAuthReauthState } from "../oauth/store";
+import { reconcileGuardianBackoff } from "../oauth/token-guardian";
+import { sweepExpiredApiKeyCooldowns } from "../providers/key-failover";
+import { sweepExpiredResponseStates } from "../responses/state";
+import { sweepExpiredAntigravityReplay } from "../adapters/google-antigravity-replay";
+import { reconcileProviderAccountQuotaRows } from "../providers/quota";
+import { reconcileRouterWarningMemos } from "../router";
+import type { OcxConfig } from "../types";
+import {
+  type GenerationContext,
+  reconcileStateGeneration,
+  registerStateStore,
+  setGenerationContextBuilder,
+  type StateStoreRegistration,
+} from "./state-store-sweeper";
+
+let liveServerConfig: OcxConfig | null = null;
+
+export function setLiveStateStoreConfig(config: OcxConfig): void {
+  liveServerConfig = config;
+}
+
+export function reconcileLiveStateStores() {
+  if (!liveServerConfig) return { storesVisited: 0, rowsRemoved: 0 };
+  return reconcileStateGeneration(buildGenerationContext());
+}
+
+export function buildGenerationContext(): GenerationContext {
+  if (!liveServerConfig) throw new Error("live server config is not installed");
+  const providerNames = new Set(Object.keys(liveServerConfig.providers));
+  return {
+    generation: 0,
+    providerNames,
+    comboIds: new Set(Object.keys(liveServerConfig.combos ?? {})),
+    comboTargets: listLiveComboTargetKeys(liveServerConfig),
+    codexAccountIds: listLiveCodexAccountIds(liveServerConfig),
+    oauthAccountKeys: listLiveOAuthAccountKeys(providerNames),
+    configRoots: listLiveConfigOwnershipRoots(getConfigDir()),
+  };
+}
+
+export const STATE_STORE_REGISTRATIONS = [
+  { name: "subagent-model-health", sweepExpired: sweepExpiredSubagentModelHealth },
+  { name: "api-key-cooldowns", sweepExpired: sweepExpiredApiKeyCooldowns },
+  {
+    name: "combo-target-cooldowns",
+    sweepExpired: sweepExpiredComboTargetCooldowns,
+    reconcileGeneration: reconcileComboTargetCooldowns,
+  },
+  { name: "anthropic-routing-health", sweepExpired: sweepExpiredAnthropicRoutingHealth },
+  { name: "xai-refresh-verdicts", sweepExpired: sweepExpiredXaiPermanentFailureVerdicts },
+  { name: "responses-continuation", sweepExpired: sweepExpiredResponseStates },
+  { name: "antigravity-replay", sweepExpired: sweepExpiredAntigravityReplay },
+  { name: "config-warning-memos", reconcileGeneration: (context: GenerationContext) => reconcileConfigWarningMemos(context.generation) },
+  { name: "catalog-warning-memos", reconcileGeneration: (context: GenerationContext) => reconcileCatalogWarningMemos(context.generation) },
+  { name: "provider-fetch-warning-memos", reconcileGeneration: (context: GenerationContext) => reconcileProviderFetchWarnings(context.generation) },
+  { name: "combo-warning-memos", reconcileGeneration: (context: GenerationContext) => reconcileComboWarningMemos(context.generation) },
+  { name: "router-warning-memos", reconcileGeneration: (context: GenerationContext) => reconcileRouterWarningMemos(context.generation) },
+  { name: "codex-quota", reconcileGeneration: reconcileCodexQuotaAccounts },
+  { name: "provider-quota-history", reconcileGeneration: reconcileProviderAccountQuotaRows },
+  { name: "codex-routing-health", reconcileGeneration: reconcileCodexRoutingHealth },
+  { name: "model-cache-history", reconcileGeneration: reconcileModelCacheGeneration },
+  { name: "pool-rotation", reconcileGeneration: reconcilePoolRotationState },
+  { name: "combo-rotation", reconcileGeneration: reconcileComboRotationState },
+  { name: "guardian-backoff", reconcileGeneration: reconcileGuardianBackoff },
+  { name: "codex-reauth", reconcileGeneration: reconcileCodexReauthState },
+  { name: "oauth-reauth", reconcileGeneration: reconcileOAuthReauthState },
+  { name: "gcp-adc", sweepExpired: sweepExpiredGcpAdcTokens, reconcileGeneration: reconcileGcpAdcTokens },
+  { name: "config-ownership", reconcileGeneration: reconcileConfigOwnershipRoots },
+  { name: "oauth-flow-state", reconcileGeneration: reconcileOAuthFlowState },
+  { name: "ocx-start-process-cache", sweepLiveness: sweepDeadOcxStartProcessCache },
+] satisfies readonly StateStoreRegistration[];
+
+for (const registration of STATE_STORE_REGISTRATIONS) registerStateStore(registration);
+
+setGenerationContextBuilder(buildGenerationContext);

package/src/lib/state-store-sweeper.ts

@@ -0,0 +1,184 @@
+export const STATE_SWEEP_INTERVAL_MS = 60_000;
+
+export interface GenerationContext {
+  generation: number;
+  providerNames: ReadonlySet<string>;
+  comboIds: ReadonlySet<string>;
+  comboTargets: ReadonlySet<string>;
+  codexAccountIds: ReadonlySet<string>;
+  oauthAccountKeys: ReadonlySet<string>;
+  configRoots: ReadonlySet<string>;
+}
+
+export interface StateStoreRegistration {
+  name: string;
+  sweepExpired?: (now: number) => number;
+  sweepLiveness?: () => number;
+  reconcileGeneration?: (context: GenerationContext) => number;
+}
+
+export interface StateSweepAfterTickRegistration {
+  name: string;
+  afterTick(): void;
+}
+
+export interface StateSweepResult {
+  storesVisited: number;
+  rowsRemoved: number;
+}
+
+export interface StateStoreSweeperOptions {
+  /** Override the 60 s interval (tests only; production uses the default). */
+  intervalMs?: number;
+  /** Injectable clock for tests. */
+  now?: () => number;
+}
+
+const registrations = new Map<string, StateStoreRegistration>();
+const afterTickRegistrations = new Map<string, StateSweepAfterTickRegistration>();
+let configGeneration = 0;
+let attemptSequence = 0;
+let generationContextBuilder: (() => GenerationContext) | null = null;
+let reconciliationRetryPending = false;
+let interval: ReturnType<typeof setInterval> | null = null;
+
+function logCallbackFailure(name: string): void {
+  console.warn(`[state-store-sweeper] ${name} failed`);
+}
+
+export function registerStateStore(registration: StateStoreRegistration): () => void {
+  registrations.set(registration.name, registration);
+  return () => {
+    if (registrations.get(registration.name) === registration) {
+      registrations.delete(registration.name);
+    }
+  };
+}
+
+export function registerStateSweepAfterTick(registration: StateSweepAfterTickRegistration): () => void {
+  afterTickRegistrations.set(registration.name, registration);
+  return () => {
+    if (afterTickRegistrations.get(registration.name) === registration) {
+      afterTickRegistrations.delete(registration.name);
+    }
+  };
+}
+
+function runCallbacks(
+  callback: (registration: StateStoreRegistration) => (() => number) | undefined,
+): StateSweepResult {
+  let storesVisited = 0;
+  let rowsRemoved = 0;
+  for (const registration of registrations.values()) {
+    const invoke = callback(registration);
+    if (!invoke) continue;
+    storesVisited += 1;
+    try {
+      rowsRemoved += invoke();
+    } catch {
+      logCallbackFailure(registration.name);
+    }
+  }
+  return { storesVisited, rowsRemoved };
+}
+
+export function sweepExpired(now = Date.now()): StateSweepResult {
+  return runCallbacks(registration => registration.sweepExpired
+    ? () => registration.sweepExpired!(now)
+    : undefined);
+}
+
+export function sweepExpiredOnWrite(now = Date.now()): StateSweepResult {
+  const result = sweepExpired(now);
+  if (reconciliationRetryPending && generationContextBuilder) {
+    try {
+      reconcileStateGeneration(generationContextBuilder());
+    } catch {
+      // The builder reads authoritative live owners. Keep the single retry pending
+      // until a later successful owner write can obtain a complete context.
+    }
+  }
+  return result;
+}
+
+export function sweepLiveness(): StateSweepResult {
+  return runCallbacks(registration => registration.sweepLiveness);
+}
+
+function runAfterTickCallbacks(): void {
+  for (const registration of afterTickRegistrations.values()) {
+    try {
+      registration.afterTick();
+    } catch {
+      logCallbackFailure(registration.name);
+    }
+  }
+}
+
+export function captureConfigGeneration(): number {
+  return configGeneration;
+}
+
+export function setGenerationContextBuilder(build: () => GenerationContext): void {
+  generationContextBuilder = build;
+}
+
+export function reconcileStateGeneration(context: GenerationContext): StateSweepResult {
+  const candidateGeneration = ++attemptSequence;
+  const candidateContext: GenerationContext = {
+    ...context,
+    generation: candidateGeneration,
+  };
+
+  let storesVisited = 0;
+  let rowsRemoved = 0;
+  let failed = false;
+  for (const registration of registrations.values()) {
+    if (!registration.reconcileGeneration) continue;
+    storesVisited += 1;
+    try {
+      rowsRemoved += registration.reconcileGeneration(candidateContext);
+    } catch {
+      failed = true;
+      logCallbackFailure(registration.name);
+    }
+  }
+  if (failed) {
+    reconciliationRetryPending = true;
+  } else {
+    configGeneration = candidateGeneration;
+    reconciliationRetryPending = false;
+  }
+  return { storesVisited, rowsRemoved };
+}
+
+export function startStateStoreSweeper(
+  options: StateStoreSweeperOptions = {},
+): { stop(): void } {
+  stopStateStoreSweeper();
+  const now = options.now ?? Date.now;
+  interval = setInterval(() => {
+    sweepExpired(now());
+    sweepLiveness();
+    runAfterTickCallbacks();
+  }, options.intervalMs ?? STATE_SWEEP_INTERVAL_MS);
+  interval.unref?.();
+  return { stop: stopStateStoreSweeper };
+}
+
+export function stopStateStoreSweeper(): void {
+  if (!interval) return;
+  clearInterval(interval);
+  interval = null;
+}
+
+/** Test-only reset for module-global registrations, generation, and lifecycle state. */
+export function resetStateStoreSweeperForTests(): void {
+  stopStateStoreSweeper();
+  registrations.clear();
+  afterTickRegistrations.clear();
+  configGeneration = 0;
+  attemptSequence = 0;
+  generationContextBuilder = null;
+  reconciliationRetryPending = false;
+}