@bitkyc08/opencodex 2.8.0 → 2.9.0

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

@@ -1,3 +1,5 @@
+import { enforceAppOwnedMemoryBudget } from "../lib/app-owned-memory";
+
 /**
  * Antigravity (Cloud Code Assist) thoughtSignature reasoning-replay cache.
  *
@@ -10,18 +12,47 @@
  * Claude-on-Antigravity uses inline signature sanitization instead (see google-antigravity-wire).
  */
 
+interface ReplayCall {
+  signature: string;
+  sizeBytes: number;
+  touchedAtMs: number;
+}
+
 interface ReplayEntry {
   /** thoughtSignature keyed by functionCall identity (name + canonical args). */
-  byCall: Map<string, string>;
+  byCall: Map<string, ReplayCall>;
+  bytes: number;
   expiresAtMs: number;
+  oldestAtMs: number | null;
 }
 
 const MIN_SIGNATURE_LEN = 16;
 const REPLAY_TTL_MS = 60 * 60 * 1000; // 1h
-const REPLAY_MAX_ENTRIES = 10_240;
+export const ANTIGRAVITY_REPLAY_MAX_ENTRIES = 10_240;
 const REPLAY_EVICT_BATCH = 128;
+const REPLAY_MAX_CALLS_PER_SESSION = 256;
+export const ANTIGRAVITY_REPLAY_MAX_BYTES_PER_SESSION = 2 * 1024 * 1024;
+export const ANTIGRAVITY_REPLAY_MAX_TOTAL_BYTES = 64 * 1024 * 1024;
+const REPLAY_MAX_SIGNATURE_BYTES = 64 * 1024;
+
+interface ReplayLimits {
+  maxCallsPerSession: number;
+  maxBytesPerSession: number;
+  maxSignatureBytes: number;
+}
+
+const DEFAULT_REPLAY_LIMITS: ReplayLimits = {
+  maxCallsPerSession: REPLAY_MAX_CALLS_PER_SESSION,
+  maxBytesPerSession: ANTIGRAVITY_REPLAY_MAX_BYTES_PER_SESSION,
+  maxSignatureBytes: REPLAY_MAX_SIGNATURE_BYTES,
+};
 
 const replayCache = new Map<string, ReplayEntry>();
+const utf8 = new TextEncoder();
+let replayLimits = { ...DEFAULT_REPLAY_LIMITS };
+let replayBytes = 0;
+let replayOldestSessionKey: string | undefined;
+let replayOldestAt: number | null = null;
 
 function replayKey(model: string, sessionId: string): string {
   return `${model}::session:${sessionId}`;
@@ -57,12 +88,80 @@ function extractSignature(part: Record<string, unknown>): string | undefined {
   return undefined;
 }
 
+function deleteReplaySession(key: string): number {
+  const entry = replayCache.get(key);
+  if (!entry) return 0;
+  replayCache.delete(key);
+  replayBytes -= entry.bytes;
+  if (replayOldestSessionKey === key) recomputeReplayOldestCandidate();
+  return entry.bytes;
+}
+
+function recomputeReplayOldestCandidate(): void {
+  replayOldestSessionKey = undefined;
+  replayOldestAt = null;
+  for (const [key, entry] of replayCache) {
+    if (entry.oldestAtMs === null || (replayOldestAt !== null && entry.oldestAtMs >= replayOldestAt)) continue;
+    replayOldestSessionKey = key;
+    replayOldestAt = entry.oldestAtMs;
+  }
+}
+
+function refreshReplaySessionCandidate(key: string, entry: ReplayEntry): void {
+  entry.oldestAtMs = entry.byCall.values().next().value?.touchedAtMs ?? null;
+  if (replayOldestSessionKey === key) {
+    recomputeReplayOldestCandidate();
+    return;
+  }
+  if (entry.oldestAtMs !== null && (replayOldestAt === null || entry.oldestAtMs < replayOldestAt)) {
+    replayOldestSessionKey = key;
+    replayOldestAt = entry.oldestAtMs;
+  }
+}
+
+function deleteExpiredReplaySessions(now: number): void {
+  for (const [key, entry] of replayCache) if (entry.expiresAtMs <= now) deleteReplaySession(key);
+}
+
+export function sweepExpiredAntigravityReplay(now = Date.now()): number {
+  const before = replayCache.size;
+  deleteExpiredReplaySessions(now);
+  return before - replayCache.size;
+}
+
+function deleteReplayCall(entry: ReplayEntry, callKey: string): number {
+  const call = entry.byCall.get(callKey);
+  if (!call) return 0;
+  entry.byCall.delete(callKey);
+  entry.bytes -= call.sizeBytes;
+  replayBytes -= call.sizeBytes;
+  return call.sizeBytes;
+}
+
+function evictInnerCalls(entry: ReplayEntry): void {
+  while (
+    entry.byCall.size > replayLimits.maxCallsPerSession
+    || entry.bytes > replayLimits.maxBytesPerSession
+  ) {
+    const oldest = entry.byCall.keys().next().value;
+    if (oldest === undefined) break;
+    deleteReplayCall(entry, oldest);
+  }
+}
+
 function evictIfNeeded(): void {
-  if (replayCache.size <= REPLAY_MAX_ENTRIES) return;
-  const oldest = [...replayCache.entries()]
-    .sort((a, b) => a[1].expiresAtMs - b[1].expiresAtMs)
-    .slice(0, REPLAY_EVICT_BATCH);
-  for (const [key] of oldest) replayCache.delete(key);
+  if (replayCache.size > ANTIGRAVITY_REPLAY_MAX_ENTRIES) {
+    const oldest = [...replayCache.entries()]
+      .sort((a, b) => a[1].expiresAtMs - b[1].expiresAtMs)
+      .slice(0, REPLAY_EVICT_BATCH);
+    for (const [key] of oldest) deleteReplaySession(key);
+  }
+  while (replayBytes > ANTIGRAVITY_REPLAY_MAX_TOTAL_BYTES) {
+    const oldestKey = [...replayCache.entries()]
+      .sort((a, b) => a[1].expiresAtMs - b[1].expiresAtMs)[0]?.[0];
+    if (oldestKey === undefined) return;
+    deleteReplaySession(oldestKey);
+  }
 }
 
 /** Gemini/Flash/Agent use the replay cache; Claude does not (inline sanitization instead). */
@@ -78,9 +177,16 @@ 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;
+  const now = Date.now();
+  deleteExpiredReplaySessions(now);
   const key = replayKey(model, sessionId);
-  const entry = replayCache.get(key) ?? { byCall: new Map<string, string>(), expiresAtMs: 0 };
-  let changed = false;
+  const entry = replayCache.get(key) ?? {
+    byCall: new Map<string, ReplayCall>(),
+    bytes: 0,
+    expiresAtMs: 0,
+    oldestAtMs: null,
+  };
+  let inserted = false;
   for (const raw of parts) {
     if (!raw || typeof raw !== "object") continue;
     const part = raw as Record<string, unknown>;
@@ -89,12 +195,22 @@ export function observeAntigravityReplay(model: string, sessionId: string, parts
     const fc = part.functionCall as { name?: unknown; args?: unknown } | undefined;
     const ck = fc ? functionCallKey(fc.name, fc.args) : undefined;
     if (!ck) continue; // only function-call signatures are replayable by identity
-    if (entry.byCall.get(ck) !== sig) { entry.byCall.set(ck, sig); changed = true; }
+    const signatureBytes = utf8.encode(sig).byteLength;
+    const sizeBytes = utf8.encode(ck).byteLength + signatureBytes;
+    if (signatureBytes > replayLimits.maxSignatureBytes || sizeBytes > replayLimits.maxBytesPerSession) continue;
+    deleteReplayCall(entry, ck);
+    entry.byCall.set(ck, { signature: sig, sizeBytes, touchedAtMs: now });
+    entry.bytes += sizeBytes;
+    replayBytes += sizeBytes;
+    inserted = true;
   }
-  if (!changed && replayCache.has(key)) return;
-  entry.expiresAtMs = Date.now() + REPLAY_TTL_MS;
+  if (!inserted) return;
+  evictInnerCalls(entry);
+  entry.expiresAtMs = now + REPLAY_TTL_MS;
   replayCache.set(key, entry);
+  refreshReplaySessionCandidate(key, entry);
   evictIfNeeded();
+  enforceAppOwnedMemoryBudget();
 }
 
 /**
@@ -104,11 +220,13 @@ 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;
+  const now = Date.now();
+  deleteExpiredReplaySessions(now);
   const entry = replayCache.get(replayKey(model, sessionId));
-  if (!entry || entry.expiresAtMs <= Date.now()) {
-    if (entry) replayCache.delete(replayKey(model, sessionId));
+  if (!entry) {
     return contents;
   }
+  let touched = false;
   for (const c of contents as { role?: string; parts?: unknown[] }[]) {
     if (!c || typeof c !== "object" || c.role !== "model" || !Array.isArray(c.parts)) continue;
     for (const raw of c.parts) {
@@ -118,19 +236,68 @@ export function applyAntigravityReplay(model: string, sessionId: string, content
       if (!fc) continue;
       if (part.thoughtSignature !== undefined || part.thought_signature !== undefined) continue;
       const ck = functionCallKey(fc.name, fc.args);
-      const sig = ck ? entry.byCall.get(ck) : undefined;
-      if (sig) part.thoughtSignature = sig;
+      const call = ck ? entry.byCall.get(ck) : undefined;
+      if (call && ck) {
+        part.thoughtSignature = call.signature;
+        entry.byCall.delete(ck);
+        entry.byCall.set(ck, { ...call, touchedAtMs: now });
+        touched = true;
+      }
     }
   }
+  if (touched) refreshReplaySessionCandidate(replayKey(model, sessionId), entry);
   return contents;
 }
 
 /** Drop the cache entry when upstream rejects a signature (clear-on-invalid). */
 export function clearAntigravityReplay(model: string, sessionId: string): void {
-  replayCache.delete(replayKey(model, sessionId));
+  deleteReplaySession(replayKey(model, sessionId));
+}
+
+export function antigravityReplayMetrics(): {
+  sessions: number;
+  calls: number;
+  totalBytes: number;
+  largestSessionBytes: number;
+} {
+  let calls = 0;
+  let largestSessionBytes = 0;
+  for (const entry of replayCache.values()) {
+    calls += entry.byCall.size;
+    largestSessionBytes = Math.max(largestSessionBytes, entry.bytes);
+  }
+  return { sessions: replayCache.size, calls, totalBytes: replayBytes, largestSessionBytes };
+}
+
+export function antigravityReplayRetainedStoreSnapshot(): {
+  count: number;
+  bytes: number;
+  evictableBytes: number;
+  pinnedBytes: number;
+  oldestAt: number | null;
+} {
+  return {
+    count: replayCache.size,
+    bytes: replayBytes,
+    evictableBytes: replayBytes,
+    pinnedBytes: 0,
+    oldestAt: replayOldestAt,
+  };
+}
+
+export function evictOldestAntigravityReplayForBudget(): number {
+  return replayOldestSessionKey === undefined ? 0 : deleteReplaySession(replayOldestSessionKey);
+}
+
+export function setAntigravityReplayLimitsForTests(limits?: Partial<ReplayLimits>): void {
+  __resetAntigravityReplayCache();
+  replayLimits = limits ? { ...DEFAULT_REPLAY_LIMITS, ...limits } : { ...DEFAULT_REPLAY_LIMITS };
 }
 
 /** Test seam. */
 export function __resetAntigravityReplayCache(): void {
   replayCache.clear();
+  replayBytes = 0;
+  replayOldestSessionKey = undefined;
+  replayOldestAt = null;
 }

package/src/adapters/google.ts

@@ -23,6 +23,11 @@ import { compileGoogleWireBody } from "./google-wire-compiler";
 import { neutralizeIdentity } from "./identity";
 import { antigravityUsesReplayCache, applyAntigravityReplay, clearAntigravityReplay, observeAntigravityReplay } from "./google-antigravity-replay";
 import { resolveAntigravityEffortWireModel } from "../providers/antigravity-models";
+import {
+  isTranslatorBudgetExceededError,
+  retainTranslatedEventBatch,
+  type TranslatorBudget,
+} from "../lib/translator-budget";
 import { buildNonOpenAIToolCatalogNudgeForTools } from "./tool-catalog-nudge";
 import { mapReasoningEffort } from "../reasoning-effort";
 
@@ -408,7 +413,7 @@ export function createGoogleAdapter(provider: OcxProviderConfig): ProviderAdapte
       return { url, method: "POST", headers, body: JSON.stringify(compiled.body) };
     },
 
-    async *parseStream(response: Response): AsyncGenerator<AdapterEvent> {
+    async *parseStream(response: Response, budget: TranslatorBudget): AsyncGenerator<AdapterEvent> {
       if (!response.body) {
         yield { type: "error", message: "No response body" };
         return;
@@ -420,7 +425,9 @@ export function createGoogleAdapter(provider: OcxProviderConfig): ProviderAdapte
 
       const reader = response.body.getReader();
       const decoder = new TextDecoder();
+      const budgetEncoder = new TextEncoder();
       let buffer = "";
+      let bufferBytes = 0;
       let pendingUsage: OcxUsage | undefined;
       let toolCallsStarted = 0;
       let lastFinishReason: string | undefined;
@@ -529,7 +536,13 @@ export function createGoogleAdapter(provider: OcxProviderConfig): ProviderAdapte
         while (true) {
           const { done, value } = await reader.read();
           if (done) break;
-          buffer += decoder.decode(value, { stream: true });
+          const nextBuffer = buffer + decoder.decode(value, { stream: true });
+          const nextBufferBytes = budgetEncoder.encode(nextBuffer).byteLength;
+          const appendReservation = budget.reserveTransient(nextBufferBytes, { kind: "live_transient" });
+          buffer = nextBuffer;
+          appendReservation.commitRetained();
+          budget.releaseRetained(bufferBytes, { kind: "live_transient" });
+          bufferBytes = nextBufferBytes;
           // Cap incomplete frames before waiting for a newline — otherwise a single
           // unterminated data: payload can grow without bound.
           if (buffer.length > MAX_SSE_FRAME_BYTES) {
@@ -540,6 +553,11 @@ export function createGoogleAdapter(provider: OcxProviderConfig): ProviderAdapte
 
           const lines = buffer.split("\n");
           buffer = lines.pop() ?? "";
+          const residualBytes = budgetEncoder.encode(buffer).byteLength;
+          const residualReservation = budget.reserveTransient(residualBytes, { kind: "live_transient" });
+          residualReservation.commitRetained();
+          budget.releaseRetained(bufferBytes, { kind: "live_transient" });
+          bufferBytes = residualBytes;
 
           let sawLiveness = false;
           let sawContentEvent = false;
@@ -587,12 +605,23 @@ export function createGoogleAdapter(provider: OcxProviderConfig): ProviderAdapte
           usage: pendingUsage,
           ...(stopReason ? { stopReason } : {}),
         };
+      } catch (error) {
+        if (!isTranslatorBudgetExceededError(error)) throw error;
+        try { await reader.cancel(error); } catch { /* already closed */ }
+        yield {
+          type: "error",
+          status: 502,
+          errorType: "upstream_error",
+          code: "translation_buffer_limit",
+          message: "upstream translation buffer exceeded the safe limit",
+        };
       } finally {
+        budget.releaseRetained(bufferBytes, { kind: "live_transient" });
         reader.releaseLock();
       }
     },
 
-    async parseResponse(response: Response): Promise<AdapterEvent[]> {
+    async parseResponse(response: Response, budget: TranslatorBudget): Promise<AdapterEvent[]> {
       // Reject oversized responses before JSON parse. Prefer Content-Length when
       // present and truthful; always stream-read with a hard byte cap so a missing
       // or lying Content-Length cannot force a full in-memory buffer + parse.
@@ -602,6 +631,7 @@ export function createGoogleAdapter(provider: OcxProviderConfig): ProviderAdapte
         return [{ type: "error", message: `google response too large (content-length ${contentLength} exceeds ${MAX_RESPONSE_BYTES} bytes)` }];
       }
       let rawText: string;
+      let rawTextBytes = 0;
       try {
         const reader = response.body?.getReader();
         if (!reader) return [{ type: "error", message: "google response had no body" }];
@@ -616,38 +646,58 @@ export function createGoogleAdapter(provider: OcxProviderConfig): ProviderAdapte
               await reader.cancel().catch(() => {});
               return [{ type: "error", message: `google response too large (exceeded ${MAX_RESPONSE_BYTES} bytes)` }];
             }
+            budget.chargeRetained(value.byteLength, { kind: "retained_collectors" });
             chunks.push(value);
           }
         } finally {
           try { await reader.cancel(); } catch { /* ignore */ }
           reader.releaseLock();
         }
+        const bytesReservation = budget.reserveTransient(total, { kind: "retained_collectors" });
         const bytes = new Uint8Array(total);
         let offset = 0;
         for (const chunk of chunks) {
           bytes.set(chunk, offset);
           offset += chunk.byteLength;
         }
+        bytesReservation.commitRetained();
+        budget.releaseRetained(total, { kind: "retained_collectors" });
         rawText = new TextDecoder().decode(bytes);
+        rawTextBytes = new TextEncoder().encode(rawText).byteLength;
+        const textReservation = budget.reserveTransient(rawTextBytes, { kind: "retained_collectors" });
+        textReservation.commitRetained();
+        budget.releaseRetained(total, { kind: "retained_collectors" });
       } catch (err) {
         return [{ type: "error", message: err instanceof Error ? err.message : "failed to read google response body" }];
       }
       let raw: Record<string, unknown>;
+      let rawBytes = 0;
       try {
         raw = JSON.parse(rawText) as Record<string, unknown>;
+        rawBytes = new TextEncoder().encode(JSON.stringify(raw)).byteLength;
+        const rawReservation = budget.reserveTransient(rawBytes, { kind: "retained_collectors" });
+        rawReservation.commitRetained();
+        budget.releaseRetained(rawTextBytes, { kind: "retained_collectors" });
       } catch {
+        budget.releaseRetained(rawTextBytes, { kind: "retained_collectors" });
         return [{ type: "error", message: "google response was not valid JSON" }];
       }
+      const finish = (events: AdapterEvent[]): AdapterEvent[] => {
+        retainTranslatedEventBatch(events, budget);
+        budget.releaseRetained(rawBytes, { kind: "retained_collectors" });
+        rawBytes = 0;
+        return events;
+      };
       if (raw.error) {
         const err = raw.error as { message?: string };
-        return [{ type: "error", message: err.message ?? "upstream error" }];
+        return finish([{ type: "error", message: err.message ?? "upstream error" }]);
       }
       // Antigravity (CCA) nests the standard Gemini payload under `response`; unwrap it.
       let json = raw;
       if (provider.googleMode === "cloud-code-assist") {
         const wrapped = raw.response;
         if (!wrapped || typeof wrapped !== "object" || Array.isArray(wrapped)) {
-          return [{ type: "error", message: "google-antigravity response missing response wrapper" }];
+          return finish([{ type: "error", message: "google-antigravity response missing response wrapper" }]);
         }
         json = wrapped as Record<string, unknown>;
       }
@@ -655,7 +705,7 @@ export function createGoogleAdapter(provider: OcxProviderConfig): ProviderAdapte
 
       const candidates = json.candidates as { content?: { parts?: { text?: string; functionCall?: { name: string; args: unknown } }[] }; finishReason?: string }[] | undefined;
       if (!candidates?.length) {
-        return [{ type: "error", message: "google response contained no candidates" }];
+        return finish([{ type: "error", message: "google response contained no candidates" }]);
       }
       let toolCallsStarted = 0;
       const imageBudget = createImageBudget();
@@ -694,7 +744,7 @@ export function createGoogleAdapter(provider: OcxProviderConfig): ProviderAdapte
       // (MAX_TOKENS / MALFORMED_FUNCTION_CALL) surfaces an error instead of a silent done.
       if ((provider.googleMode === "vertex" || provider.googleMode === "cloud-code-assist")
         && toolCallsStarted > 0 && isVertexTruncationReason(candidates?.[0]?.finishReason)) {
-        return [{ type: "error", message: vertexTruncationErrorMessage(candidates?.[0]?.finishReason) }];
+        return finish([{ type: "error", message: vertexTruncationErrorMessage(candidates?.[0]?.finishReason) }]);
       }
 
       const usage = json.usageMetadata as Record<string, number> | undefined;
@@ -702,7 +752,7 @@ export function createGoogleAdapter(provider: OcxProviderConfig): ProviderAdapte
         type: "done",
         usage: usageFromGemini(usage),
       });
-      return events;
+      return finish(events);
     },
   };
 }

package/src/adapters/kiro-thinking.ts

@@ -1,4 +1,5 @@
 import type { AdapterEvent } from "../types";
+import type { TranslatorBudget } from "../lib/translator-budget";
 
 type ThinkingTag = "<thinking>" | "<think>" | "<reasoning>";
 type ParserState = "pre" | "thinking" | "streaming";
@@ -21,40 +22,53 @@ export class KiroThinkingParser {
   private thinkingBuffer = "";
   private closeTag = "";
 
+  constructor(private readonly budget?: TranslatorBudget) {}
+
+  private replaceCarry(field: "preBuffer" | "thinkingBuffer", next: string): void {
+    const previous = this[field];
+    if (previous === next) return;
+    const previousBytes = Buffer.byteLength(previous);
+    const nextBytes = Buffer.byteLength(next);
+    const reservation = this.budget?.reserveTransient(nextBytes, { kind: "reasoning" });
+    this[field] = next;
+    reservation?.commitRetained();
+    this.budget?.releaseRetained(previousBytes, { kind: "reasoning" });
+  }
+
   feed(text: string): AdapterEvent[] {
     if (!text) return [];
     if (this.state === "streaming") return [{ type: "text_delta", text }];
     if (this.state === "thinking") {
-      this.thinkingBuffer += text;
+      this.replaceCarry("thinkingBuffer", this.thinkingBuffer + text);
       return this.drainThinking();
     }
-    this.preBuffer += text;
+    this.replaceCarry("preBuffer", this.preBuffer + text);
     const stripped = this.preBuffer.trimStart();
     const openTag = OPEN_TAGS.find(tag => stripped.startsWith(tag));
     if (openTag) {
       this.state = "thinking";
       this.closeTag = closeTagFor(openTag);
-      this.thinkingBuffer = stripped.slice(openTag.length);
-      this.preBuffer = "";
+      this.replaceCarry("thinkingBuffer", stripped.slice(openTag.length));
+      this.replaceCarry("preBuffer", "");
       return this.drainThinking();
     }
     if (stripped.length <= MAX_OPEN_TAG && isPossibleOpenTagPrefix(stripped)) return [];
     this.state = "streaming";
     const out = this.preBuffer;
-    this.preBuffer = "";
+    this.replaceCarry("preBuffer", "");
     return out ? [{ type: "text_delta", text: out }] : [];
   }
 
   flush(): AdapterEvent[] {
     if (this.state === "thinking") {
       const out = this.thinkingBuffer;
-      this.thinkingBuffer = "";
+      this.replaceCarry("thinkingBuffer", "");
       this.state = "streaming";
       return out ? [{ type: "reasoning_raw_delta", text: out }] : [];
     }
     if (this.preBuffer) {
       const out = this.preBuffer;
-      this.preBuffer = "";
+      this.replaceCarry("preBuffer", "");
       this.state = "streaming";
       return [{ type: "text_delta", text: out }];
     }
@@ -67,7 +81,7 @@ export class KiroThinkingParser {
     if (idx >= 0) {
       const thinking = this.thinkingBuffer.slice(0, idx);
       const after = this.thinkingBuffer.slice(idx + close.length).trimStart();
-      this.thinkingBuffer = "";
+      this.replaceCarry("thinkingBuffer", "");
       this.state = "streaming";
       const events: AdapterEvent[] = [];
       if (thinking) events.push({ type: "reasoning_raw_delta", text: thinking });
@@ -76,7 +90,7 @@ export class KiroThinkingParser {
     }
     if (this.thinkingBuffer.length <= MAX_CLOSE_TAG) return [];
     const send = this.thinkingBuffer.slice(0, -MAX_CLOSE_TAG);
-    this.thinkingBuffer = this.thinkingBuffer.slice(-MAX_CLOSE_TAG);
+    this.replaceCarry("thinkingBuffer", this.thinkingBuffer.slice(-MAX_CLOSE_TAG));
     return send ? [{ type: "reasoning_raw_delta", text: send }] : [];
   }
 }

package/src/adapters/kiro-tools.ts

@@ -1,10 +1,15 @@
-import type { OcxParsedRequest } from "../types";
+import type { OcxParsedRequest, OcxTool } from "../types";
 import { namespacedToolName } from "../types";
 import { normalizeKiroModelId } from "../providers/kiro-models";
 import { createKiroToolNameRegistry, type KiroToolNameRegistry } from "./kiro-wire";
 
 const MAX_KIRO_TOOL_DESCRIPTION_UNVERIFIED = 1024;
 const MAX_KIRO_TOOL_DESCRIPTION_GPT_56_SOL = 9_216;
+// Issue #719's successful Kiro probe used 49 outbound tools at about 108 KiB. Leave one of those
+// slots for Kiro's private completion tool and headroom for the enclosing request/message fields.
+export const MAX_KIRO_TOOL_COUNT = 48;
+export const MAX_KIRO_TOOL_CATALOG_BYTES = 96_000;
+const textEncoder = new TextEncoder();
 
 // JSON Schema validation/annotation keywords that Kiro's runtimeservice tool-spec validator
 // rejects ("ValidationException: Invalid tool use format."). Codex's built-in tools omit these,
@@ -147,6 +152,17 @@ function truncateDescription(description: string, limit: number): string {
   return `${description.slice(0, limit - 1)}…`;
 }
 
+function serializedToolCatalogBytes(tools: readonly unknown[]): number {
+  return textEncoder.encode(JSON.stringify(tools)).byteLength;
+}
+
+function omittedToolCatalogNotice(kept: number, omitted: readonly OcxTool[], registry: KiroToolNameRegistry): string {
+  const names = omitted.slice(0, 12).map(tool => registry.alias(namespacedToolName(tool.namespace, tool.name)));
+  const remainder = omitted.length - names.length;
+  const summary = `${names.join(", ")}${remainder > 0 ? `, and ${remainder} more` : ""}`;
+  return `[opencodex] Kiro's outbound catalog budget allows ${kept} of ${kept + omitted.length} client tools this turn. Omitted and unavailable this turn: ${summary}.`;
+}
+
 export function convertKiroToolContext(
   parsed: OcxParsedRequest,
   registry: KiroToolNameRegistry = createKiroToolNameRegistry(),
@@ -156,24 +172,39 @@ export function convertKiroToolContext(
   // Validate every listed name even when tool_choice:none emulates a tool-free turn.
   for (const tool of tools) registry.alias(namespacedToolName(tool.namespace, tool.name));
   const effectiveTools = parsed.options.toolChoice === "none" ? [] : tools;
+  const convertedTools: unknown[] = [];
+  let omittedAt = effectiveTools.length;
+  for (const [index, tool] of effectiveTools.entries()) {
+    const description = tool.description || `Tool: ${tool.name}`;
+    // Send the full namespaced wire name (e.g. mcp__chrome-devtools__navigate_page) so Kiro echoes
+    // it back; the bridge's toolNsMap is keyed by this name and restores the MCP namespace Codex
+    // routes by. Kiro's runtimeservice rejects names with spaces or >64 chars, so normalize to a
+    // safe form and remember the mapping; the response parser restores the original wire name.
+    const wireName = namespacedToolName(tool.namespace, tool.name);
+    const toolName = registry.alias(wireName);
+    const converted = {
+      toolSpecification: {
+        name: toolName,
+        description: truncateDescription(description, descriptionLimit),
+        inputSchema: { json: ensureRootObjectType(sanitizeKiroSchema(tool.parameters ?? {})) },
+      },
+    };
+    // Preserve declaration order and only omit a suffix. Ranking tools would make a catalog change
+    // silently alter which capability disappears; this deterministic policy is paired with a
+    // model-visible omission notice so unavailable tools are explicit rather than assumed absent.
+    if (
+      convertedTools.length >= MAX_KIRO_TOOL_COUNT
+      || serializedToolCatalogBytes([...convertedTools, converted]) > MAX_KIRO_TOOL_CATALOG_BYTES
+    ) {
+      omittedAt = index;
+      break;
+    }
+    convertedTools.push(converted);
+  }
+  const omittedTools = effectiveTools.slice(omittedAt);
   return {
-    tools: effectiveTools.map(t => {
-      const description = t.description || `Tool: ${t.name}`;
-      // Send the full namespaced wire name (e.g. mcp__chrome-devtools__navigate_page) so Kiro echoes
-      // it back; the bridge's toolNsMap is keyed by this name and restores the MCP namespace Codex
-      // routes by. Kiro's runtimeservice rejects names with spaces or >64 chars, so normalize to a
-      // safe form and remember the mapping; the response parser restores the original wire name.
-      const wireName = namespacedToolName(t.namespace, t.name);
-      const toolName = registry.alias(wireName);
-      return {
-        toolSpecification: {
-          name: toolName,
-          description: truncateDescription(description, descriptionLimit),
-          inputSchema: { json: ensureRootObjectType(sanitizeKiroSchema(t.parameters ?? {})) },
-        },
-      };
-    }),
-    systemAdditions: [],
+    tools: convertedTools,
+    systemAdditions: omittedTools.length > 0 ? [omittedToolCatalogNotice(convertedTools.length, omittedTools, registry)] : [],
     nameMap: registry.nameMap,
     registry,
   };