@yansigit/opencodex 2.31.1 → 2.31.3

package/src/adapters/cursor/thread-continuity.ts

@@ -65,3 +65,74 @@ export function lookupCursorThreadConversation(
 export function clearCursorThreadContinuityForTests(): void {
   overrides.clear();
 }
+
+/** Max conversation-id remints after the first surfaced overflow (senpi cap). */
+export const CURSOR_OVERFLOW_REMINT_MAX = 3;
+
+type OverflowRemintState = {
+  surfaced: boolean;
+  remintCount: number;
+  skip: boolean;
+};
+
+const overflowRemintByScope = new Map<string, OverflowRemintState>();
+
+function overflowRemintEntry(scopeKey: string): OverflowRemintState {
+  const existing = overflowRemintByScope.get(scopeKey);
+  if (existing) return existing;
+  const fresh: OverflowRemintState = { surfaced: false, remintCount: 0, skip: false };
+  overflowRemintByScope.set(scopeKey, fresh);
+  return fresh;
+}
+
+/**
+ * Stable scope for overflow remint accounting. Thread-identified clients key by
+ * thread + identity; conversation-only clients key by the base conversation id
+ * captured before any remint (wire id may rotate).
+ */
+export function cursorOverflowRemintScopeKey(
+  parsed: {
+    _clientThreadId?: string;
+    _cursorIdentityScope?: string;
+  },
+  baseConversationId?: string,
+): string | null {
+  if (parsed._clientThreadId) {
+    return `overflow\0${cursorThreadScopeKey(parsed._clientThreadId, parsed._cursorIdentityScope)}`;
+  }
+  const base = baseConversationId?.trim();
+  if (!base) return null;
+  const scope = parsed._cursorIdentityScope?.trim() || "local";
+  return `overflow\0${scope}\0conv\0${base}`;
+}
+
+/** True until the first overflow for this scope has been surfaced for Codex compact. */
+export function shouldSurfaceCursorOverflowFirst(scopeKey: string): boolean {
+  return overflowRemintEntry(scopeKey).surfaced !== true;
+}
+
+export function markCursorOverflowSurfaced(scopeKey: string): void {
+  const entry = overflowRemintEntry(scopeKey);
+  entry.surfaced = true;
+}
+
+export function shouldSkipCursorOverflowRemint(scopeKey: string): boolean {
+  const entry = overflowRemintByScope.get(scopeKey);
+  if (!entry) return false;
+  return entry.skip === true || entry.remintCount >= CURSOR_OVERFLOW_REMINT_MAX;
+}
+
+/** Record one overflow remint; returns false when the cap is exhausted. */
+export function recordCursorOverflowRemint(scopeKey: string): boolean {
+  const entry = overflowRemintEntry(scopeKey);
+  if (entry.skip || entry.remintCount >= CURSOR_OVERFLOW_REMINT_MAX) {
+    entry.skip = true;
+    return false;
+  }
+  entry.remintCount += 1;
+  return true;
+}
+
+export function clearCursorOverflowRemintForTests(): void {
+  overflowRemintByScope.clear();
+}

package/src/adapters/cursor.ts

@@ -1,9 +1,15 @@
 import { createHash } from "node:crypto";
-import type { AdapterEvent, OcxProviderConfig } from "../types";
+import type { AdapterEvent, OcxParsedRequest, OcxProviderConfig } from "../types";
 import type { ProviderAdapter } from "./base";
 import { isTranslatorBudgetExceededError } from "../lib/translator-budget";
 import { cursorExecDeniedMessage, cursorRequestDeclaresFullAccess } from "./cursor/exec-policy";
-import { isCursorBenignCancelError, isCursorInvalidArgumentError, safeCursorErrorMessage, type CursorSizeContext } from "./cursor/cursor-errors";
+import {
+  isCursorBenignCancelError,
+  isCursorInvalidArgumentError,
+  isCursorOverflowRemintCandidate,
+  safeCursorErrorMessage,
+  type CursorSizeContext,
+} from "./cursor/cursor-errors";
 import { cursorCheckpointModelAffinityId, inferCursorContextWindow, isCursorExternalWireModel } from "./cursor/discovery";
 import { createCursorKvStore, type CursorKvStore } from "./cursor/kv-store";
 import { mapCursorServerMessage } from "./cursor/message-mapper";
@@ -26,7 +32,14 @@ import {
 } from "./cursor/checkpoint-store";
 import { debugProviderDiagnostic } from "../lib/debug";
 import { estimateTokens } from "../lib/token-estimate";
-import { rememberCursorThreadConversation } from "./cursor/thread-continuity";
+import {
+  cursorOverflowRemintScopeKey,
+  markCursorOverflowSurfaced,
+  recordCursorOverflowRemint,
+  rememberCursorThreadConversation,
+  shouldSkipCursorOverflowRemint,
+  shouldSurfaceCursorOverflowFirst,
+} from "./cursor/thread-continuity";
 import { runCursorTurnWithRetry } from "./cursor/transport-retry";
 import {
   createDisabledCursorTransport,
@@ -77,10 +90,18 @@ function cursorRequestSizeContext(request: { modelId: string; system: string[];
   };
 }
 
+function assertCursorRequestSupported(parsed: OcxParsedRequest): void {
+  if (parsed.options.textFormat !== undefined || parsed._structuredOutput === true) {
+    throw new Error("Cursor does not support structured output");
+  }
+}
+
 export function createCursorAdapter(provider: OcxProviderConfig, deps: CursorAdapterDeps = {}): ProviderAdapter {
   return {
     name: "cursor",
 
+    validateRequest: assertCursorRequestSupported,
+
     buildRequest() {
       return {
         url: provider.baseUrl || CURSOR_API_URL,
@@ -98,6 +119,7 @@ export function createCursorAdapter(provider: OcxProviderConfig, deps: CursorAda
     },
 
     async runTurn(_parsed, incoming, emit) {
+      assertCursorRequestSupported(_parsed);
       if (incoming.abortSignal?.aborted) {
         emit({ type: "error", message: "Cursor turn was aborted before start." });
         return;
@@ -243,39 +265,79 @@ export function createCursorAdapter(provider: OcxProviderConfig, deps: CursorAda
           );
         };
 
-        try {
-          await runOnce(request);
-        } catch (err) {
-          // One-shot fallback for external-model Connect invalid_argument before any
-          // non-heartbeat output. Retries apply only to safe plain-user turns; tool-result
-          // resumes, local exec/MCP side effects, and already-emitted output fail closed.
-          if (
-            !isCursorInvalidArgumentError(err)
-            || !isCursorExternalWireModel(request.modelId)
-            || lastRawIsToolResult
-            || emittedOutput
-            || replayUnsafe
-            || incoming.abortSignal?.aborted
-          ) {
-            throw err;
-          }
-          const failedConversationId = request.conversationId;
+        const overflowRemintBaseId = _parsed._clientThreadId
+          ? undefined
+          : (previousConversationId ?? _parsed._cursorConversationId);
+
+        const remintConversationId = (failedConversationId: string) => {
           lastTransport = undefined;
           _parsed._cursorConversationId = undefined;
-          request = createCursorRequest(_parsed, { forceFreshConversation: true });
-          rekeyContextUsage(failedConversationId, request.conversationId);
-          _parsed._cursorConversationId = request.conversationId;
-          // Persist recovery for store:false clients that only send a parent thread id, so the
-          // next turn does not recompute the stale deterministic thread hash. Isolated helper /
-          // compaction turns must not park their throwaway id under the parent thread key.
+          const next = createCursorRequest(_parsed, { forceFreshConversation: true });
+          rekeyContextUsage(failedConversationId, next.conversationId);
+          _parsed._cursorConversationId = next.conversationId;
           if (_parsed._clientThreadId && _parsed._cursorIsolateConversation !== true) {
             rememberCursorThreadConversation(
               _parsed._clientThreadId,
-              request.conversationId,
+              next.conversationId,
               _parsed._cursorIdentityScope,
             );
           }
-          await runOnce(request);
+          return next;
+        };
+
+        for (;;) {
+          try {
+            await runOnce(request);
+            break;
+          } catch (err) {
+            const overflowRemintSafe =
+              !lastRawIsToolResult
+              && !emittedOutput
+              && !replayUnsafe
+              && !incoming.abortSignal?.aborted;
+            const overflowScopeKey = cursorOverflowRemintScopeKey(
+              _parsed,
+              overflowRemintBaseId ?? request.conversationId,
+            );
+
+            if (
+              overflowScopeKey
+              && overflowRemintSafe
+              && isCursorOverflowRemintCandidate(err, requestSizeContext)
+            ) {
+              if (shouldSkipCursorOverflowRemint(overflowScopeKey)) {
+                throw err;
+              }
+              if (shouldSurfaceCursorOverflowFirst(overflowScopeKey)) {
+                markCursorOverflowSurfaced(overflowScopeKey);
+                throw err;
+              }
+              if (!recordCursorOverflowRemint(overflowScopeKey)) {
+                throw err;
+              }
+              const failedConversationId = request.conversationId;
+              if (inheritedCheckpointRef) invalidateCursorCheckpoint(inheritedCheckpointRef);
+              request = remintConversationId(failedConversationId);
+              continue;
+            }
+
+            // One-shot fallback for external-model Connect invalid_argument before any
+            // non-heartbeat output. Retries apply only to safe plain-user turns; tool-result
+            // resumes, local exec/MCP side effects, and already-emitted output fail closed.
+            if (
+              !isCursorInvalidArgumentError(err)
+              || !isCursorExternalWireModel(request.modelId)
+              || lastRawIsToolResult
+              || emittedOutput
+              || replayUnsafe
+              || incoming.abortSignal?.aborted
+            ) {
+              throw err;
+            }
+            request = remintConversationId(request.conversationId);
+            await runOnce(request);
+            break;
+          }
         }
         if (
           request.checkpointInvalidationReason

package/src/adapters/google-http.ts

@@ -5,7 +5,7 @@ import {
   retryableGoogleStatus,
   safeGoogleHttpErrorMessage,
 } from "./google-errors";
-import { repairGoogleInvalidRequestBody } from "./google-wire-compiler";
+import { isGoogleMixedBuiltinToolError, repairGoogleInvalidRequestBody, stripGoogleBuiltinToolsFromWireBody } from "./google-wire-compiler";
 import { normalizeUpstreamHttpErrorResponse, readDisplaySafeErrorPayloadText } from "./upstream-http-error";
 import { recordAntigravityCooldown } from "../oauth/antigravity-routing";
 import {
@@ -378,7 +378,17 @@ async function fetchGoogleWithRetryInternal(
         } catch (error) {
           if (ctx.abortSignal?.aborted) throw error;
         }
-        const repairedBody = repairGoogleInvalidRequestBody(activeRequest.body, payloadText);
+        // Mixed built-in + function tools must win over schema repair: those 400s often mention
+        // function_declarations, which would otherwise empty parameters and leave google_search attached.
+        let repairedBody: string | undefined;
+        if (isGoogleMixedBuiltinToolError(payloadText)) {
+          repairedBody = stripGoogleBuiltinToolsFromWireBody(activeRequest.body);
+          if (repairedBody === undefined) {
+            repairedBody = repairGoogleInvalidRequestBody(activeRequest.body, payloadText);
+          }
+        } else {
+          repairedBody = repairGoogleInvalidRequestBody(activeRequest.body, payloadText);
+        }
         if (repairedBody !== undefined) {
           compatibilityReplayUsed = true;
           activeRequest = { ...activeRequest, body: repairedBody };

package/src/adapters/google-wire-compiler.ts

@@ -94,10 +94,35 @@ function compileContents(value: unknown, toWireName: (name: string) => string):
   });
 }
 
+const GOOGLE_BUILTIN_TOOL_KEYS = new Set([
+  "googleSearch", "google_search",
+  "urlContext", "url_context",
+  "codeExecution", "code_execution",
+]);
+
+function isGoogleBuiltinToolObject(rawTool: unknown): boolean {
+  if (!isObject(rawTool)) return false;
+  const keys = Object.keys(rawTool);
+  return keys.length > 0 && keys.every(key => GOOGLE_BUILTIN_TOOL_KEYS.has(key));
+}
+
+function passthroughGoogleBuiltinTools(rawTool: unknown): unknown[] {
+  if (!isObject(rawTool) || Array.isArray(rawTool.functionDeclarations)) return [];
+  if (!isGoogleBuiltinToolObject(rawTool)) return [];
+  const out: Record<string, unknown> = {};
+  for (const key of Object.keys(rawTool)) {
+    if (key === "googleSearch" || key === "google_search") out.google_search = {};
+    else if (key === "urlContext" || key === "url_context") out.url_context = {};
+    else if (key === "codeExecution" || key === "code_execution") out.code_execution = rawTool[key] ?? {};
+  }
+  return Object.keys(out).length > 0 ? [out] : [];
+}
+
 function compileTools(value: unknown, toWireName: (name: string) => string): unknown[] | undefined {
   if (!Array.isArray(value)) return undefined;
   const tools = value.flatMap(rawTool => {
-    if (!isObject(rawTool) || !Array.isArray(rawTool.functionDeclarations)) return [];
+    const builtins = passthroughGoogleBuiltinTools(rawTool);
+    if (!isObject(rawTool) || !Array.isArray(rawTool.functionDeclarations)) return builtins;
     const functionDeclarations = rawTool.functionDeclarations.flatMap(rawDeclaration => {
       if (!isObject(rawDeclaration) || typeof rawDeclaration.name !== "string") return [];
       return [{
@@ -106,7 +131,10 @@ function compileTools(value: unknown, toWireName: (name: string) => string): unk
         parameters: sanitizeGeminiToolParameters(rawDeclaration.parameters),
       }];
     });
-    return functionDeclarations.length > 0 ? [{ functionDeclarations }] : [];
+    return [
+      ...builtins,
+      ...(functionDeclarations.length > 0 ? [{ functionDeclarations }] : []),
+    ];
   });
   return tools.length > 0 ? tools : undefined;
 }
@@ -141,6 +169,14 @@ function compileGenerationConfig(value: unknown): JsonObject | undefined {
     const valid = value.responseModalities.filter((m): m is string => typeof m === "string" && ["TEXT", "IMAGE", "AUDIO"].includes(m));
     if (valid.length > 0) out.responseModalities = valid;
   }
+  if (value.responseMimeType === "application/json") out.responseMimeType = value.responseMimeType;
+  if (isObject(value.responseSchema)) {
+    const responseSchema = sanitizeGeminiToolParameters(value.responseSchema);
+    const properties = isObject(responseSchema.properties) ? responseSchema.properties : undefined;
+    const hasProperties = properties !== undefined && Object.keys(properties).length > 0;
+    const hasRequired = Array.isArray(responseSchema.required) && responseSchema.required.length > 0;
+    if (hasProperties || hasRequired) out.responseSchema = responseSchema;
+  }
   return Object.keys(out).length > 0 ? out : undefined;
 }
 
@@ -230,3 +266,56 @@ export function repairGoogleInvalidRequestBody(body: string, errorPayload: strin
   }
   return changed ? JSON.stringify(parsed) : undefined;
 }
+
+function stripBuiltinToolsFromRoot(root: JsonObject): boolean {
+  if (!Array.isArray(root.tools)) return false;
+  const before = root.tools.length;
+  const filtered = root.tools.filter(rawTool => !isGoogleBuiltinToolObject(rawTool));
+  root.tools = filtered;
+  return filtered.length !== before;
+}
+
+/** One mixed-tool 400 replay: drop known built-in siblings and keep functionDeclarations. */
+export function stripGoogleBuiltinToolsFromWireBody(body: string): string | undefined {
+  let parsed: unknown;
+  try {
+    parsed = JSON.parse(body) as unknown;
+  } catch {
+    return undefined;
+  }
+  if (!isObject(parsed)) return undefined;
+  const root = isObject(parsed.request) ? parsed.request : parsed;
+  if (!stripBuiltinToolsFromRoot(root)) return undefined;
+  return JSON.stringify(parsed);
+}
+
+export function isGoogleMixedBuiltinToolError(errorPayload: string): boolean {
+  const mentionsBuiltin = /\b(?:google[_ ]?search|url[_ ]?context|code[_ ]?execution|built[- ]?in(?:\s+tools?)?)\b/i.test(errorPayload);
+  if (!mentionsBuiltin) return false;
+
+  // A mixed-tool error names a builtin AND a function/tool term AND a coexistence verb.
+  // Builtin mention is gated above; each pattern below requires a coexistence verb to
+  // appear within a bounded window of a tool/function/declaration term (or the phrase
+  // itself implies coexistence, e.g. "mutually exclusive"). Bare "coexist"/"alongside"
+  // without a nearby tool/function term is NOT enough — a schema error can say fields
+  // "coexist" while merely mentioning a builtin.
+  const describesIncompatibleCoexistence = [
+    /\bmix\w*\b[^\n.!?]{0,80}\b(?:tool\w*|function(?:[_ ]declarations?)?|declaration\w*)\b/i,
+    /\b(?:tool\w*|function(?:[_ ]declarations?)?|declaration\w*)\b[^\n.!?]{0,80}\bmix\w*\b/i,
+    /\bcombin\w*\b[^\n.!?]{0,80}\bwith\b/i,
+    /\bcoexist\w*\b[^\n.!?]{0,80}\b(?:tool\w*|function(?:[_ ]declarations?)?|declaration\w*)\b/i,
+    /\b(?:tool\w*|function(?:[_ ]declarations?)?|declaration\w*)\b[^\n.!?]{0,80}\bcoexist\w*\b/i,
+    /\balongside\b[^\n.!?]{0,80}\b(?:tool\w*|function(?:[_ ]declarations?)?|declaration\w*)\b/i,
+    /\b(?:tool\w*|function(?:[_ ]declarations?)?|declaration\w*)\b[^\n.!?]{0,80}\balongside\b/i,
+    /\buse\w*\b[^\n.!?]{0,80}\btogether\b/i,
+    /\btogether\b[^\n.!?]{0,80}\b(?:tool\w*|function(?:[_ ]declarations?)?|declaration\w*)\b/i,
+    /\buse\w*\b[^\n.!?]{0,80}\bwith\b[^\n.!?]{0,80}\b(?:tool\w*|function(?:[_ ]declarations?)?|declaration\w*)\b/i,
+    /\b(?:tool\w*|function(?:[_ ]declarations?)?|declaration\w*)\b[^\n.!?]{0,80}\bwith\b[^\n.!?]{0,80}\buse\w*\b/i,
+    /\bnot supported with\b[^\n.!?]{0,80}\b(?:tool\w*|function(?:[_ ]declarations?)?|declaration\w*)\b/i,
+    /\bmutually exclusive\b/i,
+    /\bincompatib\w*\b[^\n.!?]{0,80}\b(?:coexist\w*|combin\w*|alongside|used together|mutually exclusive)\b/i,
+    /\b(?:coexist\w*|combin\w*|alongside|used together|mutually exclusive)\b[^\n.!?]{0,80}\bincompatib\w*\b/i,
+  ].some(pattern => pattern.test(errorPayload));
+
+  return describesIncompatibleCoexistence;
+}

package/src/adapters/google.ts

@@ -24,9 +24,16 @@ import { ANTIGRAVITY_REQUEST_UA, antigravitySessionId, isLikelyRealThoughtSignat
 import { repairGoogleToolPairs, stripTrailingClaudePrefill } from "./google-antigravity-tools";
 import { canonicalAntigravityHttpsHost, isAntigravityHttpsHost } from "./google-antigravity-hosts";
 import { compileGoogleWireBody } from "./google-wire-compiler";
+import { sanitizeGeminiToolParameters } from "./google-tool-schema";
 import { identifyRoutedModel } from "./identity";
 import { antigravityUsesReplayCache, applyAntigravityReplay, clearAntigravityReplay, observeAntigravityReplay } from "./google-antigravity-replay";
 import { resolveAntigravityEffortWireModel } from "../providers/antigravity-models";
+import {
+  extractCcaGroundingSources,
+  formatCcaGroundingSourcesAppendix,
+  isCcaSearchSuggestionHtml,
+} from "../web-search/gemini-executor";
+import type { WebSearchSource } from "../web-search/parse";
 import { googleVertexLocationConfigError } from "../providers/google-vertex-location";
 import { lookupReplayThoughtSignature } from "../responses/thought-signature-replay";
 import {
@@ -334,22 +341,29 @@ function messagesToGeminiFormat(
   return { systemInstruction, contents };
 }
 
-function toolsToGeminiFormat(parsed: OcxParsedRequest): unknown[] | undefined {
-  if (!parsed.context.tools?.length) return undefined;
+function toolsToGeminiFormat(
+  parsed: OcxParsedRequest,
+  wireModelId: string,
+): unknown[] | undefined {
+  const grounding = parsed._ccaInTurnGrounding;
   const allowed = isAllowedToolChoice(parsed.options.toolChoice)
     ? new Set(parsed.options.toolChoice.allowedTools)
     : undefined;
   const tools = allowed
-    ? parsed.context.tools.filter(t => toolAllowedByChoice(t, allowed, parsed.context.tools))
-    : parsed.context.tools;
-  if (tools.length === 0) return undefined;
-  return [{
-    functionDeclarations: tools.map(t => ({
-      name: namespacedToolName(t.namespace, t.name),
-      description: t.description,
-      parameters: t.parameters,
-    })),
-  }];
+    ? parsed.context.tools?.filter(t => toolAllowedByChoice(t, allowed, parsed.context.tools)) ?? []
+    : parsed.context.tools ?? [];
+  const functionDeclarations = tools.map(t => ({
+    name: namespacedToolName(t.namespace, t.name),
+    description: t.description,
+    parameters: t.parameters,
+  }));
+  const wireTools: unknown[] = [];
+  if (functionDeclarations.length > 0) wireTools.push({ functionDeclarations });
+  if (grounding && !/claude/i.test(wireModelId)) {
+    if (grounding.search) wireTools.push({ google_search: {} });
+    if (grounding.urlContext) wireTools.push({ url_context: {} });
+  }
+  return wireTools.length > 0 ? wireTools : undefined;
 }
 
 /**
@@ -430,6 +444,30 @@ function isImageCapableModel(modelId: string): boolean {
   return IMAGE_CAPABLE_MODELS.has(modelId);
 }
 
+function applyGeminiStructuredOutput(
+  generationConfig: Record<string, unknown>,
+  parsed: OcxParsedRequest,
+  wireModelId: string,
+): void {
+  const textFormat = parsed.options.textFormat;
+  if (!textFormat) return;
+  if (Array.isArray(parsed.context.tools) && parsed.context.tools.length > 0) return;
+  if (/claude/i.test(wireModelId) || /claude/i.test(parsed.modelId)) return;
+  if (isImageCapableModel(parsed.modelId)) return;
+
+  generationConfig.responseMimeType = "application/json";
+  if (textFormat.type !== "json_schema" || textFormat.schema === undefined) return;
+
+  const sanitized = sanitizeGeminiToolParameters(textFormat.schema);
+  const props = sanitized.properties;
+  const propKeys = props !== null && typeof props === "object" && !Array.isArray(props)
+    ? Object.keys(props)
+    : [];
+  const required = Array.isArray(sanitized.required) ? sanitized.required : [];
+  if (propKeys.length === 0 && required.length === 0) return;
+  generationConfig.responseSchema = sanitized;
+}
+
 /**
  * Model-visible markdown link for a materialized artifact. Uses the authenticated
  * opaque HTTP route so remote/container clients can fetch the image without host
@@ -484,11 +522,12 @@ function googleToolCallMetadataFromPart(
  * Keep that provider visibility bit authoritative here so the streaming and buffered parsers
  * cannot accidentally expose the same hidden reasoning through different event types.
  */
-function googlePartTextEvent(part: GoogleResponsePart): AdapterEvent | undefined {
+function googlePartTextEvent(part: GoogleResponsePart, filterCcaSearchSuggestionHtml = false): AdapterEvent | undefined {
   // A malformed scalar/object is not text and must not cross the AdapterEvent boundary. Dropping
   // only this optional field preserves the rest of the part without inventing assistant output by
   // coercion; an empty string keeps its existing no-event behavior.
   if (typeof part.text !== "string" || part.text.length === 0) return undefined;
+  if (filterCcaSearchSuggestionHtml && isCcaSearchSuggestionHtml(part.text)) return undefined;
   return part.thought === true
     ? { type: "reasoning_raw_delta", text: part.text }
     : { type: "text_delta", text: part.text };
@@ -644,6 +683,7 @@ export function createGoogleAdapter(provider: OcxProviderConfig): ProviderAdapte
   let vertexReplayModel: string | undefined;
   let vertexReplaySession: string | undefined;
   let restoreGoogleToolName = (name: string): string => name;
+  const emitInTurnGroundingSourcesQueue: boolean[] = [];
   return {
     name: "google",
 
@@ -677,7 +717,7 @@ export function createGoogleAdapter(provider: OcxProviderConfig): ProviderAdapte
         identityModelId,
         provider.googleMode === "cloud-code-assist",
       );
-      const tools = toolsToGeminiFormat(parsed);
+      const tools = toolsToGeminiFormat(parsed, routedModelId);
 
       const body: Record<string, unknown> = { contents };
       if (systemInstruction) body.systemInstruction = systemInstruction;
@@ -711,6 +751,7 @@ export function createGoogleAdapter(provider: OcxProviderConfig): ProviderAdapte
       if (!generationConfig.thinkingConfig && isImageCapableModel(parsed.modelId)) {
         generationConfig.responseModalities = ["TEXT", "IMAGE"];
       }
+      applyGeminiStructuredOutput(generationConfig, parsed, routedModelId);
       if (Object.keys(generationConfig).length > 0) body.generationConfig = generationConfig;
 
       const ccaAlwaysSse = provider.googleMode === "cloud-code-assist";
@@ -810,6 +851,7 @@ export function createGoogleAdapter(provider: OcxProviderConfig): ProviderAdapte
         if (/claude/i.test(wireModelId)) {
           headers["anthropic-beta"] = "interleaved-thinking-2025-05-14";
         }
+        emitInTurnGroundingSourcesQueue.push(!!parsed._ccaInTurnGrounding);
         return { url, method: "POST", headers, body: JSON.stringify(envelope) };
       }
 
@@ -835,6 +877,7 @@ export function createGoogleAdapter(provider: OcxProviderConfig): ProviderAdapte
         if (apiKey) {
           const url = `https://aiplatform.googleapis.com/v1/publishers/google/models/${parsed.modelId}:${method}${streamParam}`;
           headers["x-goog-api-key"] = apiKey;
+          emitInTurnGroundingSourcesQueue.push(!!parsed._ccaInTurnGrounding);
           return { url, method: "POST", headers, body: JSON.stringify(compiled.body) };
         }
         const project = provider.project || process.env.GOOGLE_CLOUD_PROJECT || process.env.GCLOUD_PROJECT;
@@ -847,6 +890,7 @@ export function createGoogleAdapter(provider: OcxProviderConfig): ProviderAdapte
         const url = `https://${host}/v1/projects/${project}/locations/${location}/publishers/google/models/${parsed.modelId}:${method}${streamParam}`;
         const token = await getVertexAccessToken();
         headers["Authorization"] = `Bearer ${token}`;
+        emitInTurnGroundingSourcesQueue.push(!!parsed._ccaInTurnGrounding);
         return { url, method: "POST", headers, body: JSON.stringify(compiled.body) };
       }
 
@@ -858,10 +902,14 @@ export function createGoogleAdapter(provider: OcxProviderConfig): ProviderAdapte
 
       const compiled = compileGoogleWireBody(body);
       restoreGoogleToolName = compiled.restoreToolName;
+      emitInTurnGroundingSourcesQueue.push(!!parsed._ccaInTurnGrounding);
       return { url, method: "POST", headers, body: JSON.stringify(compiled.body) };
     },
 
     async *parseStream(response: Response, budget: TranslatorBudget): AsyncGenerator<AdapterEvent> {
+      const emitInTurnGroundingSources = emitInTurnGroundingSourcesQueue.shift() ?? false;
+      const filterCcaSearchSuggestionHtml =
+        provider.googleMode === "cloud-code-assist" && emitInTurnGroundingSources;
       if (!response.body) {
         yield { type: "error", message: "No response body" };
         return;
@@ -886,6 +934,14 @@ export function createGoogleAdapter(provider: OcxProviderConfig): ProviderAdapte
       let sawAnyFrame = false;
       let sawTerminalSignal = false;
       let pendingStreamThoughtSig: string | undefined;
+      const groundingSources: WebSearchSource[] = [];
+      let groundingSourcesEmitted = false;
+
+      const mergeGroundingSources = (groundingMetadata: unknown): void => {
+        for (const source of extractCcaGroundingSources(groundingMetadata)) {
+          if (!groundingSources.some(existing => existing.url === source.url)) groundingSources.push(source);
+        }
+      };
 
       const handleDataLine = async function* (line: string): AsyncGenerator<AdapterEvent, "continue" | "content" | "terminate"> {
         const payload = line.slice(5).trim();
@@ -980,8 +1036,13 @@ export function createGoogleAdapter(provider: OcxProviderConfig): ProviderAdapte
         const candidate = rawCandidate as {
           content?: unknown;
           finishReason?: string;
+          groundingMetadata?: unknown;
         };
 
+        if (emitInTurnGroundingSources && candidate.groundingMetadata) {
+          mergeGroundingSources(candidate.groundingMetadata);
+        }
+
         if (typeof candidate.finishReason === "string" && candidate.finishReason) {
           lastFinishReason = candidate.finishReason;
           sawTerminalSignal = true;
@@ -1029,7 +1090,7 @@ export function createGoogleAdapter(provider: OcxProviderConfig): ProviderAdapte
             if (part.thought === true && sig && isLikelyRealThoughtSignature(sig)) {
               pendingStreamThoughtSig = sig;
             }
-            const textEvent = googlePartTextEvent(part);
+            const textEvent = googlePartTextEvent(part, filterCcaSearchSuggestionHtml);
             if (textEvent) {
               emittedContentEvent = true;
               yield textEvent;
@@ -1140,6 +1201,13 @@ export function createGoogleAdapter(provider: OcxProviderConfig): ProviderAdapte
           yield { type: "error", message: "upstream stream ended without a terminal signal — possible truncation" };
           return;
         }
+        if (emitInTurnGroundingSources && !groundingSourcesEmitted && groundingSources.length > 0) {
+          const appendix = formatCcaGroundingSourcesAppendix(groundingSources);
+          if (appendix) {
+            groundingSourcesEmitted = true;
+            yield { type: "text_delta", text: appendix };
+          }
+        }
         const stopReason = lastFinishReason === "MAX_TOKENS"
           ? "max_tokens"
           : ["SAFETY", "RECITATION", "BLOCKLIST", "PROHIBITED_CONTENT", "SPII"].includes(lastFinishReason ?? "")

package/src/config.ts

@@ -735,6 +735,8 @@ const providerConfigSchema = z.object({
   // accepted, persisted, and then silently resolved to the `code_mode_only` default — the
   // operator asked for shell mode, got code mode, and was told nothing (#2106).
   codexToolMode: z.enum(["code_mode_only", "shell"]).optional(),
+  // Validated rather than passed through: same rationale as codexToolMode above.
+  projectContext: z.enum(["off", "on"]).optional(),
   responsesItemIdRepair: z.object({
     message: z.array(z.string().min(1)).optional(),
     reasoning: z.array(z.string().min(1)).optional(),