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

@bitkyc08/opencodex 2.11.1 → 2.12.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 (175) hide show

package/README.md +1 -1
package/bin/ocx.mjs +4 -0
package/gui/dist/assets/index-BNVYzdn0.css +1 -0
package/gui/dist/assets/index-Cw1_mxO8.js +70 -0
package/gui/dist/index.html +2 -2
package/package.json +1 -1
package/src/adapters/command-code.ts +94 -5
package/src/adapters/cursor/live-transport.ts +14 -1
package/src/adapters/google-tool-schema.ts +80 -15
package/src/adapters/google.ts +24 -7
package/src/adapters/openai-chat.ts +233 -305
package/src/adapters/openai-responses.ts +62 -0
package/src/adapters/tool-catalog-nudge.ts +2 -11
package/src/claude/outbound.ts +42 -14
package/src/cli/claude.ts +61 -9
package/src/cli/codex-shim-autorestore.ts +2 -0
package/src/cli/codex-shim-readiness.ts +8 -1
package/src/cli/config-command.ts +4 -1
package/src/cli/doctor.ts +10 -0
package/src/cli/help.ts +15 -0
package/src/cli/index.ts +27 -11
package/src/cli/lab.ts +367 -0
package/src/cli/provider.ts +9 -1
package/src/clients/config-export.ts +100 -3
package/src/codex/app-server-processes.ts +11 -8
package/src/codex/auth-api.ts +92 -28
package/src/codex/auth-collision.ts +5 -3
package/src/codex/catalog/metadata.ts +7 -3
package/src/codex/catalog/provider-fetch.ts +191 -47
package/src/codex/catalog.ts +2 -2
package/src/codex/history-job.ts +83 -18
package/src/codex/history-migration-guardian.ts +9 -16
package/src/codex/history-provider.ts +178 -1
package/src/codex/history-transition.ts +5 -5
package/src/codex/history-worker.ts +22 -2
package/src/codex/native-profile-store.ts +1 -1
package/src/codex/plan.ts +15 -0
package/src/codex/quota.ts +6 -6
package/src/codex/routing.ts +3 -3
package/src/codex/subagent-model-fallback.ts +246 -22
package/src/codex/user-identity.ts +63 -12
package/src/config.ts +265 -32
package/src/images/loop.ts +3 -1
package/src/images/plan.ts +23 -13
package/src/integrations/omp-yaml-source.ts +225 -0
package/src/integrations/ownership.ts +5 -5
package/src/integrations/state.ts +45 -6
package/src/integrations/writer.ts +38 -3
package/src/lab/artifacts/sanitize.ts +586 -0
package/src/lab/artifacts/secure-fs.ts +475 -0
package/src/lab/artifacts/store.ts +310 -0
package/src/lab/conformance/assertion.ts +325 -0
package/src/lab/conformance/digest.ts +22 -0
package/src/lab/conformance/executor.ts +741 -0
package/src/lab/conformance/fixture-provider.ts +27 -0
package/src/lab/conformance/fixtures/live-v1-cases.json +175 -0
package/src/lab/conformance/fixtures/protocol-v1-cases.json +461 -0
package/src/lab/conformance/harness-budget.ts +47 -0
package/src/lab/conformance/index.ts +5 -0
package/src/lab/conformance/jcs.ts +24 -0
package/src/lab/conformance/json-pointer.ts +39 -0
package/src/lab/conformance/manifest.ts +180 -0
package/src/lab/conformance/mcp-stub.ts +179 -0
package/src/lab/conformance/negative-controls.ts +160 -0
package/src/lab/conformance/observation.ts +355 -0
package/src/lab/conformance/runner.ts +57 -0
package/src/lab/conformance/sse-normalize.ts +59 -0
package/src/lab/conformance/suite-manifest.ts +78 -0
package/src/lab/conformance/types.ts +191 -0
package/src/lab/constants.ts +126 -0
package/src/lab/digest.ts +64 -0
package/src/lab/events/errors.ts +9 -0
package/src/lab/events/limits.ts +117 -0
package/src/lab/events/types.ts +228 -0
package/src/lab/events/validate.ts +780 -0
package/src/lab/index.ts +36 -0
package/src/lab/ledger/artifact-refs.ts +127 -0
package/src/lab/ledger/invalidation.ts +136 -0
package/src/lab/ledger/purge.ts +241 -0
package/src/lab/ledger/store.ts +263 -0
package/src/lab/live/credential-lease.ts +53 -0
package/src/lab/live/destination.ts +155 -0
package/src/lab/live/executor.ts +311 -0
package/src/lab/live/inert-tools.ts +56 -0
package/src/lab/live/manifest.ts +85 -0
package/src/lab/live/mcp-loopback.ts +57 -0
package/src/lab/live/runner.ts +19 -0
package/src/lab/live/sandbox.ts +61 -0
package/src/lab/live/suite-manifest.ts +41 -0
package/src/lab/live/transport.ts +116 -0
package/src/lab/live/types.ts +197 -0
package/src/lab/observe/from-conformance.ts +344 -0
package/src/lab/observe/from-live.ts +103 -0
package/src/lab/paths.ts +65 -0
package/src/lab/projection/rebuild.ts +477 -0
package/src/lab/projection/schema.ts +122 -0
package/src/lab/projection/verdicts.ts +438 -0
package/src/lab/projection/verification.ts +332 -0
package/src/lab/query/catalog.ts +72 -0
package/src/lab/query/connection.ts +107 -0
package/src/lab/query/constants.ts +4 -0
package/src/lab/query/cursor.ts +132 -0
package/src/lab/query/dto-map.ts +277 -0
package/src/lab/query/errors.ts +22 -0
package/src/lab/query/index.ts +34 -0
package/src/lab/query/queries.ts +444 -0
package/src/lab/query/types.ts +266 -0
package/src/lab/subject/behavior-fingerprint.ts +77 -0
package/src/lab/subject/installation-salt.ts +81 -0
package/src/lab/subject/route-subject.ts +73 -0
package/src/lib/bounded-body.ts +104 -0
package/src/lib/lab-live-execution-authority.ts +13 -0
package/src/lib/lab-live-host.ts +30 -0
package/src/lib/lab-live-pinned-sender.ts +45 -0
package/src/lib/pinned-http.ts +36 -7
package/src/oauth/index.ts +20 -1
package/src/oauth/local-token-detect.ts +11 -2
package/src/oauth/login-cli.ts +38 -4
package/src/providers/alibaba-region-migration.ts +1 -1
package/src/providers/codex-capacity.ts +7 -4
package/src/providers/command-code-efforts.ts +5 -2
package/src/providers/derive.ts +105 -0
package/src/providers/label.ts +1 -1
package/src/providers/openai-tiers.ts +59 -3
package/src/providers/opencode-zen-rate-limit.ts +102 -0
package/src/providers/quota.ts +67 -21
package/src/providers/registry.ts +118 -5
package/src/router.ts +15 -1
package/src/routing/analytics.ts +8 -7
package/src/routing/evaluator.ts +51 -5
package/src/routing/profile.ts +10 -1
package/src/routing/trace.ts +42 -6
package/src/server/auth-cors.ts +15 -0
package/src/server/background-lifecycle.ts +169 -0
package/src/server/chat-completions.ts +18 -3
package/src/server/claude-messages.ts +1 -0
package/src/server/images.ts +78 -11
package/src/server/index.ts +72 -18
package/src/server/lifecycle.ts +6 -0
package/src/server/live.ts +5 -1
package/src/server/management/agent-settings-routes.ts +41 -24
package/src/server/management/body.ts +6 -0
package/src/server/management/config-routes.ts +51 -8
package/src/server/management/lab-routes.ts +388 -0
package/src/server/management/logs-usage-routes.ts +19 -1
package/src/server/management/model-rows.ts +25 -11
package/src/server/management/native-integration-routes.ts +3 -3
package/src/server/management/provider-routes.ts +5 -0
package/src/server/management/shared.ts +8 -1
package/src/server/management/usage-summary-cache.ts +2 -0
package/src/server/management/vision-sidecar-options.ts +125 -0
package/src/server/management-api.ts +2 -0
package/src/server/request-decompress.ts +106 -5
package/src/server/responses/collaboration.ts +4 -1
package/src/server/responses/core.ts +117 -31
package/src/server/responses-json-events.ts +50 -12
package/src/server/search.ts +23 -7
package/src/server/ws-bridge.ts +3 -1
package/src/service.ts +40 -20
package/src/types.ts +74 -0
package/src/update/job.ts +10 -2
package/src/usage/cost.ts +0 -0
package/src/usage/expected-prices.ts +9 -0
package/src/usage/log.ts +9 -9
package/src/usage/user-cost-overlay-reconciler.ts +313 -0
package/src/usage/user-cost-overlays.ts +314 -0
package/src/vision/describe.ts +2 -2
package/src/vision/eligibility.ts +229 -0
package/src/vision/index.ts +20 -2
package/src/web-search/executor.ts +2 -2
package/src/web-search/index.ts +4 -2
package/src/web-search/loop.ts +3 -1
package/src/web-search/parse.ts +72 -3
package/gui/dist/assets/index-BA1dgo4q.css +0 -1
package/gui/dist/assets/index-DDZpgzKk.js +0 -70

package/gui/dist/index.html CHANGED Viewed

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

package/package.json CHANGED Viewed

@@ -1,6 +1,6 @@
 {
   "name": "@bitkyc08/opencodex",
-  "version": "2.11.1",
+  "version": "2.12.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/command-code.ts CHANGED Viewed

@@ -21,6 +21,10 @@ const COMMAND_CODE_MODEL_ALIASES: Readonly<Record<string, string>> = {
   "glm-5.2": "zai-org/GLM-5.2",
 };
+function canonicalCommandCodeModelId(modelId: string): string {
+  return Object.hasOwn(COMMAND_CODE_MODEL_ALIASES, modelId) ? COMMAND_CODE_MODEL_ALIASES[modelId]! : modelId;
+}
 /** Flatten tool-result content for the text-only wire output, keeping an `[image]` marker per image part in content order. */
 function toolResultText(content: string | OcxContentPart[]): string {
   if (typeof content === "string") return content;
@@ -44,20 +48,79 @@ function wireImagePart(imageUrl: string): Record<string, unknown> {
   return { type: "image", image: imageUrl, ...(mediaType ? { mediaType } : {}) };
 }
+/**
+ * The /alpha/generate wire pairs every assistant `tool-call` with a following `tool` message
+ * whose `tool-result.toolCallId` matches it. Codex history is not guaranteed to carry that
+ * pairing (interrupted turns, compacted threads, and multi-step tool rounds all can leave an
+ * assistant call with no recorded result), and the upstream rejects an unpaired call with
+ * `Tool result is missing for tool call <id>`, which currently surfaces as a generic 502
+ * (#1383). This builder keeps the pairing invariant:
+ *
+ * - a `toolResult` that matches a declared assistant call emits the native `tool-result`;
+ * - a `toolResult` with no matching declared call degrades to a text carrier so the model
+ *   still sees the outcome without a 400-prone standalone `tool` message;
+ * - every declared assistant call that never received a result gets an explicit error
+ *   `tool-result`, so the upstream never sees an unpaired call.
+ */
 function wireMessages(messages: OcxMessage[]): Array<Record<string, unknown>> {
   const out: Array<Record<string, unknown>> = [];
+  const pendingCalls: Array<{ id: string; name: string }> = [];
+  // Image parts returned by a tool cannot live inside the text-only `tool-result` wire
+  // output. They ride a follow-up user message, but that user message must not break the
+  // adjacency of the assistant turn's tool results, so carriers are buffered and flushed
+  // only after every declared call has its native or synthesized result.
+  const pendingImageCarriers: Array<Record<string, unknown>> = [];
+  // The /alpha/generate wire requires every assistant tool-call to be closed by a matching
+  // `tool-result` immediately after the declaring assistant message. Close any declared call
+  // that never received a result before a non-toolResult message moves the turn forward, so a
+  // synthesized `tool` message never lands after a user message or a new assistant turn.
+  const closePendingCalls = (): void => {
+    for (const call of pendingCalls) {
+      out.push({ role: "tool", content: [{
+        type: "tool-result",
+        toolCallId: call.id,
+        toolName: call.name,
+        output: { type: "error-text", value: "[ocx] no tool result was recorded for this tool call; execution status unknown." },
+      }] });
+    }
+    pendingCalls.length = 0;
+    if (pendingImageCarriers.length > 0) {
+      out.push(...pendingImageCarriers);
+      pendingImageCarriers.length = 0;
+    }
+  };
   for (const message of messages) {
     if (message.role === "assistant") {
+      closePendingCalls();
       const content: Array<Record<string, unknown>> = [];
       for (const part of message.content) {
         if (part.type === "text") content.push({ type: "text", text: part.text });
         else if (part.type === "thinking") content.push({ type: "reasoning", text: part.thinking });
-        else content.push({ type: "tool-call", toolCallId: part.id, toolName: namespacedToolName(part.namespace, part.name), input: part.arguments });
+        else {
+          const wireName = namespacedToolName(part.namespace, part.name);
+          content.push({ type: "tool-call", toolCallId: part.id, toolName: wireName, input: part.arguments });
+          pendingCalls.push({ id: part.id, name: wireName });
+        }
       }
       out.push({ role: "assistant", content });
       continue;
     }
     if (message.role === "toolResult") {
+      const callIndex = pendingCalls.findIndex(call => call.id === message.toolCallId);
+      const paired = callIndex >= 0;
+      if (paired) pendingCalls.splice(callIndex, 1);
+      if (!paired) {
+        // Pending calls from an earlier assistant turn must still be closed before any user
+        // message lands, or their synthesized results would follow the orphan carrier.
+        closePendingCalls();
+        // The upstream rejects a standalone tool message whose call was never declared by an
+        // assistant turn. Preserve the outcome as text so the model can still act on it.
+        const label = message.toolName ? `${message.toolName} (${message.toolCallId})` : message.toolCallId;
+        const text = toolResultText(message.content);
+        // The orphan result cannot ride a `tool` message; carry it in a user message instead.
+        out.push({ role: "user", content: [{ type: "text", text: `[tool result without adjacent tool call: ${label}]\n${text}` }] });
+        continue;
+      }
       out.push({ role: "tool", content: [{
         type: "tool-result",
         toolCallId: message.toolCallId,
@@ -69,10 +132,12 @@ function wireMessages(messages: OcxMessage[]): Array<Record<string, unknown>> {
       // message using the same image encoding as the user branch so the bytes reach the model.
       const images = typeof message.content === "string" ? [] : message.content.filter(part => part.type === "image");
       if (images.length > 0) {
-        out.push({ role: "user", content: images.map(part => wireImagePart((part as { imageUrl: string }).imageUrl)) });
+        pendingImageCarriers.push({ role: "user", content: images.map(part => wireImagePart((part as { imageUrl: string }).imageUrl)) });
       }
       continue;
     }
+    // User/developer message: no pending tool results may follow it on the wire.
+    closePendingCalls();
     const content: Array<Record<string, unknown>> = [];
     if (typeof message.content === "string") content.push({ type: "text", text: message.content });
     else for (const part of message.content) {
@@ -81,6 +146,7 @@ function wireMessages(messages: OcxMessage[]): Array<Record<string, unknown>> {
     }
     out.push({ role: "user", content });
   }
+  closePendingCalls();
   return out;
 }
@@ -237,6 +303,18 @@ function eventError(value: unknown): string {
   return "Command Code stream error";
 }
+/**
+ * True when the upstream rejected a tool-result continuation because an assistant tool call
+ * had no matching result (`Tool result is missing for tool call <id>`). The proxy now keeps
+ * that pairing invariant before sending, so this error is a distinct provider-side
+ * validation failure rather than a generic stream fault; classify it as such for the
+ * dashboard/logs instead of a plain upstream 502.
+ */
+function isMissingToolResultError(value: unknown): boolean {
+  const text = eventError(value).toLowerCase();
+  return text.includes("tool result is missing") || text.includes("tool_result is missing");
+}
 async function*ndjson(response: Response, budget: TranslatorBudget): AsyncGenerator<Record<string, unknown>> {
   if (!response.body) throw new Error("Command Code response body missing");
   const reader = response.body.getReader();
@@ -318,7 +396,7 @@ function supportedCommandCodeEffort(provider: OcxProviderConfig, modelId: string
   // Compatibility ids (deepseek-v4-flash / glm-5.2) must resolve to their canonical
   // Command Code id before the effort lookup, or legacy requests silently lose the
   // reasoning effort because the official table is keyed by the canonical ids.
-  const canonicalId = COMMAND_CODE_MODEL_ALIASES[modelId] ?? modelId;
+  const canonicalId = canonicalCommandCodeModelId(modelId);
   const supported = commandCodeReasoningEfforts(canonicalId) ?? configuredReasoningEfforts(provider, canonicalId);
   if (!supported) return undefined;
   // Command Code's official profiles describe xhigh and ultra as the CLI labels that map to
@@ -347,7 +425,7 @@ export function createCommandCodeAdapter(provider: OcxProviderConfig): ProviderA
         config: await commandCodeConfig(cwd), memory: "", taste: null, skills: null,
         permissionMode: "standard", mode: "agent",
         params: {
-          model: COMMAND_CODE_MODEL_ALIASES[parsed.modelId] ?? parsed.modelId,
+          model: canonicalCommandCodeModelId(parsed.modelId),
           messages: wireMessages(parsed.context.messages),
           tools: wireTools(tools),
           system,
@@ -437,7 +515,18 @@ export function createCommandCodeAdapter(provider: OcxProviderConfig): ProviderA
             yield { type: "done", usage: usage(usageValue), stopReason };
             break;
           }
-          case "error": yield { type: "error", message: eventError(event.error), status: 502 }; break;
+          case "error": {
+            const message = eventError(event.error);
+            if (isMissingToolResultError(message)) {
+              // Provider-side tool-result validation: the request carried an assistant tool
+              // call the upstream refused to accept. This is not a network/stream stall; the
+              // proxy normally prevents it by pairing every call, so flag it distinctly.
+              yield { type: "error", message, status: 502, errorType: "upstream_error", code: "missing_tool_result" };
+            } else {
+              yield { type: "error", message, status: 502 };
+            }
+            break;
+          }
         }
       }
       // A stream that ends without a finish event still needs a terminal done so the

package/src/adapters/cursor/live-transport.ts CHANGED Viewed

@@ -1086,12 +1086,25 @@ class LiveCursorTransport implements CursorTransport {
       }
       return;
     }
+    // A completion may carry only callId. Capture its ownership before mapping removes the open
+    // call, because the embedded-tool classifier cannot identify that valid compact frame.
+    const update = message.message.case === "interactionUpdate" ? message.message.value.message : undefined;
+    const completesOpenClientTool = update?.case === "toolCallCompleted"
+      && state.openToolCalls.has(update.value.callId);
     const mapped = mapCursorProtobufServerMessage(message, state);
     if (mapped.length > 0) {
       // A client tool call announced/committed via interactionUpdate (toolCallStarted/partialToolCall/
       // toolCallCompleted) changes the call set, so revoke any finalize armed by an earlier drain.
-      if (isClientToolFrame(message)) this.noteClientToolActivity();
+      // A completion can also commit and drain a late call without a following mcpArgs frame; in
+      // that case re-arm finalization here so the Responses bridge does not wait forever.
+      const clientToolFrame = completesOpenClientTool || isClientToolFrame(message);
+      if (clientToolFrame) this.noteClientToolActivity();
       for (const event of mapped) push(event);
+      if (
+        clientToolFrame
+        && state.openToolCalls.size === 0
+        && mapped.some(event => event.type === "tool_call_end")
+      ) this.scheduleClientToolFinalize(state, push);
       return;
     }
     // The frame produced no outward Responses event (e.g. toolCallStarted / partialToolCall args

package/src/adapters/google-tool-schema.ts CHANGED Viewed

@@ -7,6 +7,27 @@ type Schema = Record<string, unknown>;
 const ALLOWED_TYPES = new Set(["string", "integer", "number", "boolean", "array", "object"]);
 const MAX_SCHEMA_DEPTH = 24; // Google's documented nesting limit is 32; leave headroom for CCA.
 const MAX_DEREF_DEPTH = 16;
+const MAX_SCHEMA_NODES = 1_024;
+const BUDGET_EXHAUSTED = Symbol("schema-budget-exhausted");
+const MERGED_SCHEMA_KEYS = [
+  "type",
+  "nullable",
+  "description",
+  "format",
+  "enum",
+  "const",
+  "properties",
+  "items",
+  "required",
+  "anyOf",
+] as const;
+type SanitizeResult = Schema | typeof BUDGET_EXHAUSTED;
+interface SanitizeState {
+  activeRefs: Set<string>;
+  remainingNodes: number;
+}
 function isRecord(value: unknown): value is Schema {
   return !!value && typeof value === "object" && !Array.isArray(value);
@@ -34,6 +55,16 @@ function collectDefs(root: unknown, defs: Map<string, unknown>): void {
   }
 }
+function mergeRefTarget(target: Schema, overlay: Schema): Schema {
+  const merged: Schema = {};
+  if (Object.hasOwn(target, "$ref")) merged.$ref = target.$ref;
+  for (const key of MERGED_SCHEMA_KEYS) {
+    if (Object.hasOwn(overlay, key)) merged[key] = overlay[key];
+    else if (Object.hasOwn(target, key)) merged[key] = target[key];
+  }
+  return merged;
+}
 function normalizeType(value: unknown, out: Schema, preserveNullType: boolean): void {
   const candidates = Array.isArray(value) ? value : [value];
   let sawNull = false;
@@ -65,9 +96,16 @@ function normalizeAnyOf(
   defs: Map<string, unknown>,
   depth: number,
   refDepth: number,
+  state: SanitizeState,
 ): Schema {
   if (!Array.isArray(value) || value.length === 0) return {};
-  const schemas = value.map(item => sanitizeSchema(item, defs, depth + 1, refDepth, true));
+  const schemas: Schema[] = [];
+  for (let index = 0; index < value.length; index++) {
+    if (state.remainingNodes <= 0) return {};
+    const schema = sanitizeSchema(value[index], defs, depth + 1, refDepth, true, state);
+    if (schema === BUDGET_EXHAUSTED) return {};
+    schemas.push(schema);
+  }
   const nonNullSchemas = schemas.filter(schema => schema.type !== "null");
   const nullSchemas = schemas.filter(schema => schema.type === "null");
@@ -100,12 +138,17 @@ function sanitizeProperties(
   defs: Map<string, unknown>,
   depth: number,
   refDepth: number,
+  state: SanitizeState,
 ): Record<string, Schema> | undefined {
   if (!isRecord(value)) return undefined;
   const properties: Record<string, Schema> = Object.create(null) as Record<string, Schema>;
-  for (const [name, schema] of Object.entries(value)) {
+  for (const name in value) {
+    if (!Object.hasOwn(value, name)) continue;
+    if (state.remainingNodes <= 0) break;
     // Property names form a name bag and must never be interpreted as schema keywords.
-    properties[name] = sanitizeSchema(schema, defs, depth + 1, refDepth, false);
+    const schema = sanitizeSchema(value[name], defs, depth + 1, refDepth, false, state);
+    if (schema === BUDGET_EXHAUSTED) break;
+    properties[name] = schema;
   }
   return properties;
 }
@@ -116,17 +159,25 @@ function sanitizeSchema(
   depth: number,
   refDepth: number,
   preserveNullType: boolean,
-): Schema {
+  state: SanitizeState,
+): SanitizeResult {
+  if (state.remainingNodes <= 0) return BUDGET_EXHAUSTED;
+  state.remainingNodes -= 1;
   if (depth >= MAX_SCHEMA_DEPTH || !isRecord(node)) return {};
   if (typeof node.$ref === "string" && refDepth < MAX_DEREF_DEPTH) {
     const target = resolveRef(node.$ref, defs);
     if (isRecord(target)) {
-      const merged: Schema = { ...target };
-      for (const [key, value] of Object.entries(node)) {
-        if (key !== "$ref") merged[key] = value;
+      if (state.activeRefs.has(node.$ref)) return {};
+      state.activeRefs.add(node.$ref);
+      // Select only inputs the sanitizer can consume. Spreading an untrusted definition here would
+      // enumerate and allocate every unsupported annotation before the node budget can stop work.
+      const merged = mergeRefTarget(target, node);
+      try {
+        return sanitizeSchema(merged, defs, depth, refDepth + 1, preserveNullType, state);
+      } finally {
+        state.activeRefs.delete(node.$ref);
       }
-      return sanitizeSchema(merged, defs, depth, refDepth + 1, preserveNullType);
     }
   }
@@ -140,18 +191,27 @@ function sanitizeSchema(
   const enumValues = sanitizeEnum(node.enum ?? (typeof node.const === "string" ? [node.const] : undefined));
   if (enumValues) out.enum = enumValues;
-  const properties = sanitizeProperties(node.properties, defs, depth, refDepth);
+  const properties = sanitizeProperties(node.properties, defs, depth, refDepth, state);
   if (properties) out.properties = properties;
-  if (isRecord(node.items)) {
-    out.items = sanitizeSchema(node.items, defs, depth + 1, refDepth, false);
+  if (properties && Array.isArray(node.required)) {
+    const required = [...new Set(node.required.filter((item): item is string => (
+      typeof item === "string" && Object.hasOwn(properties, item)
+    )))];
+    if (required.length > 0) out.required = required;
   }
-  if (Array.isArray(node.required)) {
-    out.required = [...new Set(node.required.filter((item): item is string => typeof item === "string"))];
+  if (state.remainingNodes <= 0) return out;
+  if (isRecord(node.items)) {
+    const items = sanitizeSchema(node.items, defs, depth + 1, refDepth, false, state);
+    if (items !== BUDGET_EXHAUSTED) out.items = items;
   }
-  if (node.anyOf !== undefined) Object.assign(out, normalizeAnyOf(node.anyOf, defs, depth, refDepth));
+  if (state.remainingNodes <= 0) return out;
+  if (node.anyOf !== undefined) {
+    Object.assign(out, normalizeAnyOf(node.anyOf, defs, depth, refDepth, state));
+  }
   return out;
 }
@@ -159,7 +219,12 @@ export function sanitizeGeminiToolParameters(parameters: unknown): Record<string
   try {
     const defs = new Map<string, unknown>();
     collectDefs(parameters, defs);
-    const root = sanitizeSchema(parameters, defs, 0, 0, false);
+    const state: SanitizeState = {
+      activeRefs: new Set(),
+      remainingNodes: MAX_SCHEMA_NODES,
+    };
+    const sanitized = sanitizeSchema(parameters, defs, 0, 0, false, state);
+    const root = sanitized === BUDGET_EXHAUSTED ? {} : sanitized;
     // Function arguments are always an object. Claude additionally rejects root composition and a
     // missing root type even when those forms are valid general-purpose JSON Schema.

package/src/adapters/google.ts CHANGED Viewed

@@ -54,8 +54,8 @@ function resolveVertexApiKey(optKey?: string): string | undefined {
 /** Prefer Codex's stable opaque thread key; retain the existing deterministic fallback for clients
  * that omit it. The replay store hashes this value and never retains the raw session identifier. */
 function vertexReplaySessionId(parsed: OcxParsedRequest): string {
-  const promptCacheKey = parsed.options.promptCacheKey?.trim();
-  return promptCacheKey || antigravitySessionId(parsed);
+  const threadId = parsed._clientThreadId?.trim();
+  return threadId || antigravitySessionId(parsed);
 }
 /**
@@ -577,15 +577,32 @@ export function createGoogleAdapter(provider: OcxProviderConfig): ProviderAdapte
           pendingUsage = usageFromGemini(usageMeta);
           sawTerminalSignal = true;
         }
-        const candidates = root.candidates as { content?: { parts?: unknown[] }; finishReason?: string }[] | undefined;
-        if (!candidates?.length) return "continue";
+        const rawCandidates = root.candidates;
+        if (rawCandidates === undefined) return "continue";
+        if (!Array.isArray(rawCandidates)) {
+          yield { type: "error", message: "google response contained invalid candidates" };
+          return "terminate";
+        }
+        if (rawCandidates.length === 0) return "continue";
+        const rawCandidate = rawCandidates[0];
+        if (rawCandidate === null || typeof rawCandidate !== "object" || Array.isArray(rawCandidate)) {
+          // Unlike a root `data: null` keepalive, this is a claimed response candidate. Treat it
+          // as terminal protocol corruption so the turn cannot complete after silently losing
+          // a candidate or tool call (#1325).
+          yield { type: "error", message: "google response contained invalid candidates" };
+          return "terminate";
+        }
+        const candidate = rawCandidate as {
+          content?: { parts?: unknown[] };
+          finishReason?: string;
+        };
-        if (typeof candidates[0].finishReason === "string" && candidates[0].finishReason) {
-          lastFinishReason = candidates[0].finishReason;
+        if (typeof candidate.finishReason === "string" && candidate.finishReason) {
+          lastFinishReason = candidate.finishReason;
           sawTerminalSignal = true;
         }
-        const parts = candidates[0].content?.parts as { text?: string; functionCall?: { name: string; args: unknown } }[] | undefined;
+        const parts = candidate.content?.parts as { text?: string; functionCall?: { name: string; args: unknown } }[] | undefined;
         // Record Gemini thought signatures for the next stateless tool-result turn. Vertex and
         // Antigravity use separate model namespaces so opaque provider state cannot cross routes.
         const replayModel = provider.googleMode === "cloud-code-assist" ? antigravityModel : vertexReplayModel;