@bitkyc08/opencodex 2.52.0 → 2.53.0-preview.20260913

package/src/adapters/devin.ts

@@ -7,14 +7,76 @@
  * streams CloudChatEvent into AdapterEvent.
  */
 import type { AdapterEvent, OcxAssistantMessage, OcxContentPart, OcxMessage, OcxParsedRequest, OcxProviderConfig, OcxTool, OcxToolCall, OcxToolResultMessage, OcxUsage } from "../types";
+import { namespacedToolName } from "../types";
 import type { IncomingMeta, ProviderAdapter } from "./base";
 import { streamChatEvents, allocateCascadeId, CloudChatError, type ChatHistoryItem, type ToolDef } from "./devin/cloud-direct";
 import { getCachedCatalog } from "./devin/cloud-direct/catalog";
+import { collapseDevinModelUid } from "./devin/live-models";
+import { buildNonOpenAIToolCatalogNudgeForTools } from "./tool-catalog-nudge";
 import { DEVIN_DEFAULT_API_SERVER, resolveDevinApiServer } from "../oauth/devin";
 
+/**
+ * Combine two usage frames from one turn by keeping the larger count per field.
+ *
+ * Devin's counters are cumulative within a turn, so a frame that reports less
+ * than an earlier one is reporting a subset, not a correction.
+ */
+export function mergeDevinUsage(previous: OcxUsage, next: OcxUsage): OcxUsage {
+  const keys = [
+    "inputTokens", "outputTokens",
+    "cachedInputTokens", "cacheReadInputTokens", "cacheCreationInputTokens",
+    "reasoningOutputTokens",
+  ] as const;
+  const merged: OcxUsage = { ...previous, ...next };
+  for (const key of keys) {
+    const a = previous[key];
+    const b = next[key];
+    if (typeof a === "number" && typeof b === "number") merged[key] = Math.max(a, b);
+    else if (typeof a === "number" && b === undefined) merged[key] = a;
+  }
+  // totalTokens is derived, not merged. Taking the max of two totals alongside
+  // per-field maxima can leave total !== input + output, and the cost and log
+  // paths read the total.
+  const total = (merged.inputTokens ?? 0) + (merged.outputTokens ?? 0);
+  if (total > 0) merged.totalTokens = total;
+  return merged;
+}
+
+/**
+ * The wording `isClientClosedMessage` recognises.
+ *
+ * "Devin turn was aborted." matched nothing, so a cancelled turn fell through to
+ * the default inference and was logged as a 502 upstream failure rather than as
+ * the client hanging up.
+ */
+const DEVIN_CLIENT_CLOSED_MESSAGE = "client closed request";
+
+/** Map a cloud-direct failure onto the structured fields the error event carries. */
+export function devinErrorClassification(error: unknown): { status?: number; errorType?: string; retryable?: boolean } {
+  const status = error instanceof CloudChatError ? error.status : undefined;
+  if (status === undefined) return {};
+  if (status === 401) return { status, errorType: "authentication_error", retryable: false };
+  if (status === 403) return { status, errorType: "permission_error", retryable: false };
+  if (status === 429) return { status, errorType: "rate_limit_error", retryable: true };
+  // 501 is the one 5xx that will never succeed on a second attempt: the service
+  // does not implement the call. Marking it retryable put `retryable: true` on
+  // the SSE failure a client reads, inviting a retry that cannot change.
+  if (status === 501) return { status, retryable: false };
+  if (status >= 500) return { status, retryable: true };
+  return { status, retryable: false };
+}
+
 export const DEVIN_API_SERVER = DEVIN_DEFAULT_API_SERVER;
 
-const EFFORT_SUFFIXES = new Set(["low", "medium", "high", "xhigh", "max", "none", "1m", "max-1m", "none-1m", "fast"]);
+/**
+ * Reasoning-effort values a CALLER may name. Deliberately not the same set as
+ * the catalog suffix tokens: `priority` is a service tier that appears in a UID
+ * but is not something a caller asks for as effort, and `max-1m` / `none-1m`
+ * are compound values a caller can send that never appear as a trailing token.
+ * The two sets share most members and mean different things; merging them would
+ * both admit a tier as an effort and silently drop the compound values.
+ */
+const CALLER_EFFORT_VALUES = new Set(["low", "medium", "high", "xhigh", "max", "none", "1m", "max-1m", "none-1m", "fast"]);
 
 /**
  * Cognition's catalog spells model ids with hyphens (`swe-1-7`), but the same
@@ -27,9 +89,52 @@ export function normalizeDevinModelId(modelId: string): string {
   return modelId.replace(/\./g, "-");
 }
 
+/**
+ * Does this id already carry a catalog effort/variant suffix?
+ *
+ * Delegates to the collapser so there is one answer to "what is a suffix".
+ * The previous local set had drifted: it was missing `priority`, so
+ * `gpt-5-6-sol-medium-priority` read as unsuffixed and got a second suffix
+ * appended, producing a UID Cognition answers with an opaque permission_denied.
+ * Delegating also handles compound suffixes, which testing only the final
+ * hyphen-separated token never could.
+ */
 function hasEffortSuffix(modelId: string): boolean {
-  const parts = modelId.split("-");
-  return parts.length > 1 && EFFORT_SUFFIXES.has(parts[parts.length - 1]!);
+  return collapseDevinModelUid(modelId) !== modelId;
+}
+
+/**
+ * SWE-2 ships exactly three native lanes. Cognition spells them as the model id,
+ * not as a separate effort field, so an explicit caller effort has to be resolved
+ * to the UID before the suffix shortcut below accepts whatever the picker sent.
+ *
+ * Kept as a named table rather than an inline branch because the caller-effort
+ * set does not carry `ultra`, `off`, or `minimal`, so the two would drift apart
+ * silently.
+ * Values below Medium select Medium: SWE-2 has no lane under it, and rounding down
+ * to nothing would quietly disable its reasoning.
+ */
+const SWE2_EFFORT: Record<string, "medium" | "high" | "max"> = {
+  none: "medium",
+  off: "medium",
+  minimal: "medium",
+  low: "medium",
+  medium: "medium",
+  high: "high",
+  xhigh: "max",
+  ultra: "max",
+  max: "max",
+};
+
+/**
+ * Resolve an explicit effort onto a SWE-2 lane, or undefined when this is not a
+ * SWE-2 id or the caller named no usable effort. Undefined leaves every existing
+ * path untouched, which is what keeps other model families on suffix precedence.
+ */
+function resolveSwe2Variant(modelId: string, reasoningEffort?: string): string | undefined {
+  if (!/^swe-2(?:-(?:medium|high|max))?$/.test(modelId)) return undefined;
+  const mapped = reasoningEffort ? SWE2_EFFORT[reasoningEffort.toLowerCase()] : undefined;
+  return mapped ? `swe-2-${mapped}` : undefined;
 }
 
 /**
@@ -51,11 +156,16 @@ async function resolveWireModelUid(
   reasoningEffort?: string,
 ): Promise<string> {
   const modelId = normalizeDevinModelId(rawModelId);
+  // Explicit effort wins over a suffix the picker already baked into the id, so
+  // `swe-2-high` asked for at `medium` becomes `swe-2-medium` instead of ignoring
+  // the caller. Runs before the shortcut below, which would otherwise return early.
+  const swe2 = resolveSwe2Variant(modelId, reasoningEffort);
+  if (swe2) return swe2;
   if (hasEffortSuffix(modelId)) return modelId;
   const catalog = await getCachedCatalog(apiKey, host);
   if (catalog) {
     if (catalog.byUid.has(modelId)) return modelId;
-    const effort = reasoningEffort && EFFORT_SUFFIXES.has(reasoningEffort) ? reasoningEffort : "medium";
+    const effort = reasoningEffort && CALLER_EFFORT_VALUES.has(reasoningEffort) ? reasoningEffort : "medium";
     const suffixed = `${modelId}-${effort}`;
     if (catalog.byUid.has(suffixed)) return suffixed;
     // Fall back to any enabled variant of this base model.
@@ -64,10 +174,17 @@ async function resolveWireModelUid(
     }
   }
   // Degraded mode: append the default effort suffix.
-  const effort = reasoningEffort && EFFORT_SUFFIXES.has(reasoningEffort) ? reasoningEffort : "medium";
+  const effort = reasoningEffort && CALLER_EFFORT_VALUES.has(reasoningEffort) ? reasoningEffort : "medium";
   return `${modelId}-${effort}`;
 }
 
+/**
+ * Test seam. The resolver stays module-private because it reaches the catalog;
+ * exporting it under its bare name would make an async network-touching helper
+ * part of the adapter public API. Mirrors sanitizeToolDescriptionForCognitionForTests.
+ */
+export const resolveWireModelUidForTests = resolveWireModelUid;
+
 export class DevinMissingCredentialError extends Error {
   constructor() {
     super("Devin live transport requires a Devin API key. Run ocx login devin to sign in with your Cognition/Devin account.");
@@ -108,18 +225,60 @@ function assistantToolCalls(message: OcxAssistantMessage): Array<{ id: string; n
 
 function assistantText(message: OcxAssistantMessage): string {
   return message.content
-    // Thinking stays out of the replayed content. Cognition has no reasoning
-    // replay field, and folding chain-of-thought into assistant text sends it
-    // back as visible prior output - which the model then treats as something
-    // it said to the user.
+    // Thinking stays out of the replayed TEXT: folding chain-of-thought into
+    // assistant text sends it back as visible prior output, which the model
+    // then treats as something it said to the user. It is replayed in its own
+    // field instead — see assistantThinking below.
     .map((part) => (part.type === "text" ? part.text : ""))
     .filter(Boolean)
     .join("\n");
 }
 
+/**
+ * The assistant turn's own reasoning, for replay in ChatMessagePrompt #11.
+ *
+ * This adapter previously asserted that Cognition has no reasoning-replay
+ * field and dropped the thinking outright, so a reasoning model restarted its
+ * chain on every turn of a tool loop. The field exists: two independent
+ * clients of the same service write #11 thinking with #12 signature and #18
+ * signature_type on the assistant prompt.
+ *
+ * The signature attests the thinking it was produced with, so a block without
+ * one contributes its text and nothing else rather than borrowing a neighbour's.
+ */
+function assistantThinking(
+  message: OcxAssistantMessage,
+): { thinking?: string; signature?: string } {
+  const blocks = message.content.filter(
+    (part): part is Extract<typeof part, { type: "thinking" }> => part.type === "thinking",
+  );
+  if (blocks.length === 0) return {};
+  const thinking = blocks.map(b => b.thinking).filter(Boolean).join("\n");
+  // Only one signature can ride the prompt, so take the last block that has
+  // one: that is the block the turn actually ended on.
+  const signature = blocks.filter(b => b.signature).at(-1)?.signature;
+  return {
+    ...(thinking ? { thinking } : {}),
+    ...(signature ? { signature } : {}),
+  };
+}
+
 export function mapOcxMessagesToDevin(parsed: OcxParsedRequest): ChatHistoryItem[] {
   const items: ChatHistoryItem[] = [];
-  const system = parsed.context.systemPrompt?.filter((line) => line.trim().length > 0).join("\n");
+  // Cognition is not an OpenAI host, and this adapter does advertise a real
+  // client tool catalog (proto #10 via `mapOcxToolsToDevin`), so the same
+  // contract paragraph the other non-OpenAI adapters inject belongs here. The
+  // wire name is the bare `tool.name` that encoder writes, not the namespaced
+  // form, so the nudge names exactly what the model is offered.
+  const toolCatalogNudge = buildNonOpenAIToolCatalogNudgeForTools(
+    parsed.context.tools,
+    parsed.options.toolChoice,
+    (tool) => tool.name,
+  );
+  const systemPrompt = parsed.context.systemPrompt?.filter((line) => line.trim().length > 0).join("\n");
+  const system = [systemPrompt, toolCatalogNudge]
+    .filter((part): part is string => typeof part === "string" && part.length > 0)
+    .join("\n\n");
   if (system) items.push({ role: "system", content: system });
 
   for (const message of parsed.context.messages) {
@@ -138,11 +297,15 @@ function mapOneMessage(message: OcxMessage): ChatHistoryItem | undefined {
   if (message.role === "assistant") {
     const toolCalls = assistantToolCalls(message);
     const text = assistantText(message);
-    if (!text && toolCalls.length === 0) return undefined;
+    const reasoning = assistantThinking(message);
+    // A turn that produced only reasoning is still worth replaying: dropping it
+    // is what makes the next turn re-derive the same chain.
+    if (!text && toolCalls.length === 0 && !reasoning.thinking) return undefined;
     return {
       role: "assistant",
       content: text || "",
       ...(toolCalls.length > 0 ? { tool_calls: toolCalls } : {}),
+      ...reasoning,
     };
   }
   if (message.role === "toolResult") {
@@ -164,13 +327,87 @@ export function mapOcxToolsToDevin(tools: OcxTool[] | undefined): ToolDef[] | un
   }));
 }
 
+/**
+ * Devin's request mapper advertises the local tool name, so a namespaced Codex tool such as
+ * `mcp__cua_repl__js` is sent upstream as `js`. Restore a returned bare name to its canonical request
+ * identity only when exactly one advertised tool owns it. A null owner is an ambiguous catalog and
+ * must fail before dispatch; an absent owner remains unchanged for the shared undeclared-tool guard
+ * to reject.
+ *
+ * Canonical names are registered as aliases of themselves because the adapter accepts them on return
+ * too. Tracking only local names let one tool's canonical identity collide with another tool's local
+ * name and resolve to the wrong owner: with `{ namespace: "a", name: "x" }` and
+ * `{ namespace: "b", name: "a__x" }`, a returned `a__x` is both the first tool's canonical identity
+ * and the second tool's advertised name, and it used to map to `b__a__x` — so the bridge dispatched
+ * the call to the wrong client tool. That case is genuinely ambiguous and now fails closed.
+ */
+function buildDevinReturnedToolNameMap(
+  tools: OcxTool[] | undefined,
+): ReadonlyMap<string, string | null> {
+  const names = new Map<string, string | null>();
+  const addOwner = (alias: string, canonical: string) => {
+    if (!names.has(alias)) {
+      names.set(alias, canonical);
+    } else if (names.get(alias) !== canonical) {
+      names.set(alias, null);
+    }
+  };
+  for (const tool of tools ?? []) {
+    const canonical = namespacedToolName(tool.namespace, tool.name);
+    addOwner(tool.name, canonical);
+    addOwner(canonical, canonical);
+  }
+  return names;
+}
+
+function restoreDevinReturnedToolName(
+  name: string,
+  names: ReadonlyMap<string, string | null>,
+): string | null {
+  return names.has(name) ? names.get(name)! : name;
+}
+
+type DevinMappedToolCallStart =
+  | Extract<AdapterEvent, { type: "tool_call_start" }>
+  | Extract<AdapterEvent, { type: "error" }>;
+
+function mapDevinToolCallStart(
+  id: string,
+  name: string,
+  names: ReadonlyMap<string, string | null>,
+): DevinMappedToolCallStart {
+  const restoredName = restoreDevinReturnedToolName(name, names);
+  if (restoredName === null) {
+    return {
+      type: "error",
+      message: "Devin emitted a bare client tool name that maps to multiple request-declared tools.",
+      status: 502,
+      retryable: false,
+    };
+  }
+  return { type: "tool_call_start", id, name: restoredName };
+}
+
+/** Test seam for the request-scoped tool-call event mapping used by runTurn. */
+export function mapDevinToolCallStartForTests(
+  id: string,
+  name: string,
+  tools: OcxTool[] | undefined,
+): DevinMappedToolCallStart {
+  return mapDevinToolCallStart(id, name, buildDevinReturnedToolNameMap(tools));
+}
+
 export function createDevinAdapter(
   provider: OcxProviderConfig,
   context: { providerId?: string } = {},
 ): ProviderAdapter {
-  // Which credential slot holds this row's tenant. Defaults to `devin` so every
-  // existing caller — including the tests that construct this adapter directly —
-  // behaves exactly as before.
+  // Which credential slot holds this row's tenant. The key is the configured
+  // provider id verbatim: `devin-cli` is a deprecated alias for the one merged
+  // `devin` provider, and the startup migration rekeys the config row and the
+  // credential slot together, so normalizing here would only misread a row that
+  // has not been migrated yet. Defaults to `devin` so every existing caller —
+  // including the tests that construct this adapter directly — behaves exactly
+  // as before.
   const credentialProviderId = context.providerId ?? "devin";
   const cascadeIds = new Map<string, string>();
   const CASCADE_ID_MAX = 256;
@@ -196,7 +433,7 @@ export function createDevinAdapter(
 
     async runTurn(parsed: OcxParsedRequest, incoming: IncomingMeta, emit: (event: AdapterEvent) => void) {
       if (incoming.abortSignal?.aborted) {
-        emit({ type: "error", message: "Devin turn was aborted before start." });
+        emit({ type: "error", message: DEVIN_CLIENT_CLOSED_MESSAGE, status: 499, retryable: false });
         return;
       }
       let apiKey: string;
@@ -225,6 +462,7 @@ export function createDevinAdapter(
       // every RPC to the US server it is not provisioned on.
       const host = resolveDevinApiServer(provider.baseUrl, credentialProviderId);
       const modelUid = await resolveWireModelUid(rawModelId, apiKey, host, parsed.options.reasoning);
+      const returnedToolNames = buildDevinReturnedToolNameMap(parsed.context.tools);
       let openToolId: string | undefined;
       let usage: OcxUsage | undefined;
       let stopReason: string | undefined;
@@ -258,7 +496,7 @@ export function createDevinAdapter(
             // Say what happened instead, the way the other runTurn-only adapter
             // does, and carry any usage already seen.
             closeOpenTool();
-            emit({ type: "error", message: "Devin turn was aborted.", ...(usage ? { usage } : {}) });
+            emit({ type: "error", message: DEVIN_CLIENT_CLOSED_MESSAGE, status: 499, retryable: false, ...(usage ? { usage } : {}) });
             return;
           }
           if (event.kind === "text") {
@@ -270,10 +508,21 @@ export function createDevinAdapter(
             if (event.text) emit({ type: "thinking_delta", thinking: event.text });
             continue;
           }
+          if (event.kind === "reasoning_signature") {
+            // Carried back out so the next turn can replay it in the prompt's
+            // signature field; an unsigned replay is what the service ignores.
+            emit({ type: "thinking_signature", signature: event.signature });
+            continue;
+          }
           if (event.kind === "tool_call_start") {
             closeOpenTool();
+            const mapped = mapDevinToolCallStart(event.id, event.name, returnedToolNames);
+            if (mapped.type === "error") {
+              emit({ ...mapped, ...(usage ? { usage } : {}) });
+              return;
+            }
             openToolId = event.id;
-            emit({ type: "tool_call_start", id: event.id, name: event.name });
+            emit(mapped);
             continue;
           }
           if (event.kind === "tool_call_args") {
@@ -291,7 +540,7 @@ export function createDevinAdapter(
           }
           if (event.kind === "usage") {
             const total = event.totalTokens ?? ((event.promptTokens ?? 0) + (event.completionTokens ?? 0));
-            usage = {
+            const next: OcxUsage = {
               inputTokens: event.promptTokens ?? 0,
               outputTokens: event.completionTokens ?? 0,
               ...(total > 0 ? { totalTokens: total } : {}),
@@ -299,19 +548,24 @@ export function createDevinAdapter(
               ...(event.cacheCreationInputTokens !== undefined ? { cacheCreationInputTokens: event.cacheCreationInputTokens } : {}),
               ...(event.reasoningTokens !== undefined ? { reasoningOutputTokens: event.reasoningTokens } : {}),
             };
+            // Merge rather than replace. A turn can carry more than one usage
+            // frame, and the counters are cumulative, so a later partial frame
+            // that omits a field used to zero a count the earlier frame had
+            // already reported.
+            usage = usage ? mergeDevinUsage(usage, next) : next;
             continue;
           }
         }
         closeOpenTool();
         if (incoming.abortSignal?.aborted) {
-          emit({ type: "error", message: "Devin turn was aborted.", ...(usage ? { usage } : {}) });
+          emit({ type: "error", message: DEVIN_CLIENT_CLOSED_MESSAGE, status: 499, retryable: false, ...(usage ? { usage } : {}) });
         } else {
           emit({ type: "done", ...(usage ? { usage } : {}), ...(stopReason ? { stopReason } : {}) });
         }
       } catch (error) {
         closeOpenTool();
         if (incoming.abortSignal?.aborted) {
-          emit({ type: "error", message: "Devin turn was aborted.", ...(usage ? { usage } : {}) });
+          emit({ type: "error", message: DEVIN_CLIENT_CLOSED_MESSAGE, status: 499, retryable: false, ...(usage ? { usage } : {}) });
           return;
         }
         const message = error instanceof CloudChatError
@@ -319,7 +573,13 @@ export function createDevinAdapter(
           : error instanceof Error ? error.message : String(error);
         // Usage that already arrived is still real; dropping it loses the
         // accounting for a turn that did most of its work before failing.
-        emit({ type: "error", message, ...(usage ? { usage } : {}) });
+        emit({
+          type: "error",
+          message,
+          ...devinErrorClassification(error),
+          ...(error instanceof CloudChatError && error.code ? { code: error.code } : {}),
+          ...(usage ? { usage } : {}),
+        });
       }
     },
   };

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

@@ -130,12 +130,20 @@ function compileGenerationConfig(value: unknown): JsonObject | undefined {
     ))].slice(0, 5);
     if (stopSequences.length > 0) out.stopSequences = stopSequences;
   }
-  if (isObject(value.thinkingConfig) && typeof value.thinkingConfig.thinkingLevel === "string") {
-    const raw = value.thinkingConfig.thinkingLevel.toLowerCase();
-    const thinkingLevel = GOOGLE_THINKING_LEVELS.has(raw)
-      ? raw
-      : (["xhigh", "max", "ultra"].includes(raw) ? "high" : undefined);
-    if (thinkingLevel) out.thinkingConfig = { thinkingLevel };
+  if (isObject(value.thinkingConfig)) {
+    const thinking: JsonObject = {};
+    if (typeof value.thinkingConfig.thinkingLevel === "string") {
+      const raw = value.thinkingConfig.thinkingLevel.toLowerCase();
+      const thinkingLevel = GOOGLE_THINKING_LEVELS.has(raw)
+        ? raw
+        : (["xhigh", "max", "ultra"].includes(raw) ? "high" : undefined);
+      if (thinkingLevel) thinking.thinkingLevel = thinkingLevel;
+    }
+    // The one key that makes Google return `thought: true` text. Cloud Code Assist serves
+    // thinking either way (thoughtsTokenCount stays non-zero) but withholds the text unless the
+    // request opts in, so dropping it here silently reinstates the missing-thinking behavior.
+    if (value.thinkingConfig.includeThoughts === true) thinking.includeThoughts = true;
+    if (Object.keys(thinking).length > 0) out.thinkingConfig = thinking;
   }
   if (Array.isArray(value.responseModalities)) {
     const valid = value.responseModalities.filter((m): m is string => typeof m === "string" && ["TEXT", "IMAGE", "AUDIO"].includes(m));

package/src/adapters/google.ts

@@ -568,13 +568,15 @@ 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, thoughtSummary = 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;
   return part.thought === true
-    ? { type: "reasoning_raw_delta", text: part.text }
+    ? thoughtSummary
+      ? { type: "thinking_delta", thinking: part.text }
+      : { type: "reasoning_raw_delta", text: part.text }
     : { type: "text_delta", text: part.text };
 }
 
@@ -721,6 +723,7 @@ export function createGoogleAdapter(provider: OcxProviderConfig): ProviderAdapte
   // Per-request closure: resolveAdapter builds a fresh adapter per request (server.ts), so buildRequest
   // can stash the CCA model/session for parseStream's reasoning-replay observation.
   let antigravityModel: string | undefined;
+  let returnsThoughtSummaries = false;
   let antigravitySession: string | undefined;
   // Vertex returns the same opaque Gemini thought signatures as CCA, but its replay namespace
   // must stay transport-scoped: a signature minted by one Google backend must never be sent to
@@ -795,6 +798,8 @@ export function createGoogleAdapter(provider: OcxProviderConfig): ProviderAdapte
         : provider.googleMode === "vertex"
           ? parsed.modelId
           : resolveDirectGeminiWireModelId(parsed.modelId, provider.directGeminiWireRenames !== false);
+      returnsThoughtSummaries = provider.googleMode === "cloud-code-assist"
+        && /^gemini-/.test(routedModelId) && !isImageCapableModel(parsed.modelId);
       // AI Studio's `-tiered` spelling is wire-only; CCA aliases may migrate to another generation.
       const identityModelId = provider.googleMode === "cloud-code-assist" ? routedModelId : parsed.modelId;
       const stripRejectedClaudeSdkParagraph = provider.googleMode === "cloud-code-assist"
@@ -866,11 +871,20 @@ export function createGoogleAdapter(provider: OcxProviderConfig): ProviderAdapte
         );
         antigravityModel = wireModelId;
         antigravitySession = sessionId;
+        // CCA Gemini exposes provider-authored thought summaries with includeThoughts.
+        // Other CCA model families do not share this request contract.
+        const includeThoughts = provider.showThinkingSummary === true
+          && parsed.options.hideThinkingSummary !== true
+          && /^gemini-/.test(wireModelId)
+          && !isImageCapableModel(parsed.modelId);
         // Effort → thinkingConfig for CCA (CLIProxyAPI proven: request.generationConfig.thinkingConfig).
         // Suffix/compat IDs return thinkingLevel=undefined — the suffix IS the effort, no contradiction.
-        if (thinkingLevel) {
+        if (thinkingLevel || includeThoughts) {
           const gc = (body.generationConfig ?? {}) as Record<string, unknown>;
-          gc.thinkingConfig = { thinkingLevel };
+          gc.thinkingConfig = {
+            ...(thinkingLevel ? { thinkingLevel } : {}),
+            ...(includeThoughts ? { includeThoughts: true } : {}),
+          };
           body.generationConfig = gc;
         }
         // Reasoning continuity: Gemini models re-inject cached thoughtSignatures; Claude-on-Antigravity
@@ -1139,7 +1153,7 @@ export function createGoogleAdapter(provider: OcxProviderConfig): ProviderAdapte
             if (part.thought === true && sig && isLikelyRealThoughtSignature(sig)) {
               pendingStreamThoughtSig = sig;
             }
-            const textEvent = googlePartTextEvent(part);
+            const textEvent = googlePartTextEvent(part, returnsThoughtSummaries);
             if (textEvent) {
               emittedContentEvent = true;
               yield textEvent;
@@ -1311,7 +1325,7 @@ export function createGoogleAdapter(provider: OcxProviderConfig): ProviderAdapte
         bytesReservation.commitRetained();
         budget.releaseRetained(total, { kind: "retained_collectors" });
         rawText = new TextDecoder().decode(bytes);
-        rawTextBytes = new TextEncoder().encode(rawText).byteLength;
+        rawTextBytes = Buffer.byteLength(rawText, "utf8");
         const textReservation = budget.reserveTransient(rawTextBytes, { kind: "retained_collectors" });
         textReservation.commitRetained();
         budget.releaseRetained(total, { kind: "retained_collectors" });
@@ -1333,7 +1347,7 @@ export function createGoogleAdapter(provider: OcxProviderConfig): ProviderAdapte
           return [{ type: "error", message: `google response was not a JSON object (${valueType})` }];
         }
         raw = parsedRaw;
-        rawBytes = new TextEncoder().encode(JSON.stringify(raw)).byteLength;
+        rawBytes = Buffer.byteLength(JSON.stringify(raw), "utf8");
         const rawReservation = budget.reserveTransient(rawBytes, { kind: "retained_collectors" });
         rawReservation.commitRetained();
         budget.releaseRetained(rawTextBytes, { kind: "retained_collectors" });
@@ -1415,7 +1429,7 @@ export function createGoogleAdapter(provider: OcxProviderConfig): ProviderAdapte
           if (part.thought === true && sig && isLikelyRealThoughtSignature(sig)) {
             pendingThoughtSig = sig;
           }
-          const textEvent = googlePartTextEvent(part);
+          const textEvent = googlePartTextEvent(part, returnsThoughtSummaries);
           if (textEvent) events.push(textEvent);
           const inline = (part as { inlineData?: { mimeType?: string; data?: string } }).inlineData;
           if (inline && typeof inline.data === "string") {