@vellumai/assistant 0.11.0 → 0.11.1-staging.1

package/src/providers/anthropic/client.ts

@@ -17,6 +17,7 @@ import {
   PLACEHOLDER_BLOCKS_OMITTED,
   PLACEHOLDER_EMPTY_TURN,
 } from "../placeholder-sentinels.js";
+import { recordProviderRequestDiagnostics } from "../request-diagnostics.js";
 import { createStreamTimeout } from "../stream-timeout.js";
 import type {
   ContentBlock,
@@ -55,7 +56,9 @@ export function detectAnthropicContextOverflow(
   error: InstanceType<typeof Anthropic.APIError>,
 ): { actualTokens?: number; maxTokens?: number } | null {
   // 413 is theoretically adjacent but Anthropic does not emit it today.
-  if (error.status !== 400) return null;
+  if (error.status !== 400) {
+    return null;
+  }
   const body = error.error as
     | {
         type?: string;
@@ -69,7 +72,9 @@ export function detectAnthropicContextOverflow(
       : undefined) ?? "";
   const topLevelMessage = error.message ?? "";
   const combined = `${innerMessage} ${topLevelMessage}`;
-  if (!/prompt.?is.?too.?long|prompt_too_long/i.test(combined)) return null;
+  if (!/prompt.?is.?too.?long|prompt_too_long/i.test(combined)) {
+    return null;
+  }
   // Prefer the clean inner message over the JSON-stringified top-level string.
   return extractOverflowTokensFromMessage(innerMessage || topLevelMessage);
 }
@@ -153,9 +158,15 @@ export function deriveAnthropicReason(
   if (apiType === "not_found_error" || status === 404) {
     return mentionsModel ? "model_not_found" : "bad_request";
   }
-  if (apiType === "rate_limit_error" || status === 429) return "rate_limited";
-  if (apiType === "overloaded_error" || status === 529) return "overloaded";
-  if (status !== undefined && status >= 500) return "server_error";
+  if (apiType === "rate_limit_error" || status === 429) {
+    return "rate_limited";
+  }
+  if (apiType === "overloaded_error" || status === 529) {
+    return "overloaded";
+  }
+  if (status !== undefined && status >= 500) {
+    return "server_error";
+  }
   if (
     apiType === "invalid_request_error" ||
     (status !== undefined && status >= 400)
@@ -174,15 +185,23 @@ function logOrphanedSurrogateWarning(
   messages: Anthropic.MessageParam[],
 ): void {
   const now = Date.now();
-  if (now - lastOrphanWarningMs < ORPHAN_WARNING_THROTTLE_MS) return;
+  if (now - lastOrphanWarningMs < ORPHAN_WARNING_THROTTLE_MS) {
+    return;
+  }
   lastOrphanWarningMs = now;
   const blockTypes = new Set<string>();
   for (const msg of messages) {
-    if (!Array.isArray(msg.content)) continue;
+    if (!Array.isArray(msg.content)) {
+      continue;
+    }
     for (const block of msg.content) {
-      if (typeof block !== "object" || block == null) continue;
+      if (typeof block !== "object" || block == null) {
+        continue;
+      }
       const type = (block as { type?: string }).type;
-      if (type) blockTypes.add(type);
+      if (type) {
+        blockTypes.add(type);
+      }
     }
   }
   log.warn(
@@ -257,7 +276,9 @@ function isTextBasedMimeType(mediaType: string): boolean {
 
 /** Anthropic requires tool_use IDs to match ^[a-zA-Z0-9_-]+$ */
 function sanitizeToolId(id: string): string {
-  if (!id) return "empty";
+  if (!id) {
+    return "empty";
+  }
   // Escape `x` itself (to `x78`) so it can safely serve as the hex-escape
   // prefix without collisions.  E.g. "a:" → "ax3a", "ax3a" → "ax783a".
   return id.replace(TOOL_ID_RE, (ch) => {
@@ -306,13 +327,18 @@ function summarizeMessages(messages: Anthropic.MessageParam[]): string[] {
     const content = Array.isArray(m.content) ? m.content : [{ type: "text" }];
     const blockDescs = content.map((b) => {
       const bt = (b as { type: string }).type;
-      if (bt === "tool_use") return `tool_use(${(b as { id: string }).id})`;
-      if (bt === "server_tool_use")
+      if (bt === "tool_use") {
+        return `tool_use(${(b as { id: string }).id})`;
+      }
+      if (bt === "server_tool_use") {
         return `server_tool_use(${(b as { id: string }).id})`;
-      if (bt === "tool_result")
+      }
+      if (bt === "tool_result") {
         return `tool_result(${(b as { tool_use_id: string }).tool_use_id})`;
-      if (bt === "web_search_tool_result")
+      }
+      if (bt === "web_search_tool_result") {
         return `web_search_tool_result(${(b as { tool_use_id: string }).tool_use_id})`;
+      }
       return bt;
     });
     return `[${idx}] ${m.role}: ${blockDescs.join(", ") || "(empty)"}`;
@@ -355,12 +381,18 @@ function hasOrderedToolResultPrefix(
   content: Anthropic.ContentBlockParam[],
   orderedToolUseIds: string[],
 ): boolean {
-  if (content.length < orderedToolUseIds.length) return false;
+  if (content.length < orderedToolUseIds.length) {
+    return false;
+  }
   for (let idx = 0; idx < orderedToolUseIds.length; idx++) {
     const block = content[idx];
     const expectedId = orderedToolUseIds[idx];
-    if (!isToolResultBlock(block)) return false;
-    if (block.tool_use_id !== expectedId) return false;
+    if (!isToolResultBlock(block)) {
+      return false;
+    }
+    if (block.tool_use_id !== expectedId) {
+      return false;
+    }
   }
   return true;
 }
@@ -498,7 +530,9 @@ function repairOrphanedServerToolBlocks(
   messages: Anthropic.MessageParam[],
 ): Anthropic.MessageParam[] {
   return messages.map((msg) => {
-    if (msg.role !== "assistant") return msg;
+    if (msg.role !== "assistant") {
+      return msg;
+    }
     const content = Array.isArray(msg.content) ? msg.content : [];
 
     const serverToolUseIds = new Set<string>();
@@ -514,11 +548,15 @@ function repairOrphanedServerToolBlocks(
 
     const orphanServerToolUseIds = new Set<string>();
     for (const id of serverToolUseIds) {
-      if (!webSearchResultIds.has(id)) orphanServerToolUseIds.add(id);
+      if (!webSearchResultIds.has(id)) {
+        orphanServerToolUseIds.add(id);
+      }
     }
     const orphanWebSearchResultIds = new Set<string>();
     for (const id of webSearchResultIds) {
-      if (!serverToolUseIds.has(id)) orphanWebSearchResultIds.add(id);
+      if (!serverToolUseIds.has(id)) {
+        orphanWebSearchResultIds.add(id);
+      }
     }
 
     if (
@@ -644,7 +682,9 @@ function findActiveToolUseContinuationStart(
       const hasToolResult = content.some(
         (b) => typeof b !== "string" && isToolResultBlock(b),
       );
-      if (!hasToolResult) break;
+      if (!hasToolResult) {
+        break;
+      }
       // This user message has tool_result — the preceding assistant message
       // should have the matching tool_use and its thinking blocks preserved.
       i--;
@@ -653,7 +693,9 @@ function findActiveToolUseContinuationStart(
       const hasToolUse = content.some(
         (b) => typeof b !== "string" && isToolUseBlock(b),
       );
-      if (!hasToolUse) break;
+      if (!hasToolUse) {
+        break;
+      }
       // This assistant message has tool_use — it's part of the active span.
       // Check if the preceding user message continues the chain.
       i--;
@@ -808,10 +850,14 @@ function ensureToolPairing(
   // within assistant messages and are not validated here.
   for (let j = 0; j < result.length; j++) {
     const m = result[j];
-    if (m.role !== "assistant") continue;
+    if (m.role !== "assistant") {
+      continue;
+    }
     const c = Array.isArray(m.content) ? m.content : [];
     const validationIds = getOrderedToolUseIds(c);
-    if (validationIds.length === 0) continue;
+    if (validationIds.length === 0) {
+      continue;
+    }
 
     const nxt = result[j + 1];
     const nxtContent =
@@ -1049,7 +1095,9 @@ export class AnthropicProvider implements Provider {
             text,
             ...(disableCache ? {} : { cache_control: cacheControl }),
           }));
-        if (params.system.length === 0) delete params.system;
+        if (params.system.length === 0) {
+          delete params.system;
+        }
       }
 
       // Tools precede the system blocks in the cached prefix, so the first
@@ -1106,20 +1154,26 @@ export class AnthropicProvider implements Provider {
       const findUserTextMsgIdx = (startIdx: number): number => {
         for (let i = startIdx; i >= 0; i--) {
           const msg = msgs[i];
-          if (msg.role !== "user" || !Array.isArray(msg.content)) continue;
+          if (msg.role !== "user" || !Array.isArray(msg.content)) {
+            continue;
+          }
           const hasText = msg.content.some(
             (b) =>
               typeof b !== "string" &&
               b.type === "text" &&
               b.text !== SYNTHETIC_CONTINUATION_TEXT,
           );
-          if (hasText) return i;
+          if (hasText) {
+            return i;
+          }
         }
         return -1;
       };
       const applyCacheControlToLastBlock = (msgIdx: number): void => {
         const content = msgs[msgIdx].content;
-        if (!Array.isArray(content) || content.length === 0) return;
+        if (!Array.isArray(content) || content.length === 0) {
+          return;
+        }
         const lastBlock = content[content.length - 1];
         if (typeof lastBlock !== "string") {
           (lastBlock as unknown as Record<string, unknown>).cache_control =
@@ -1162,8 +1216,9 @@ export class AnthropicProvider implements Provider {
         turnStartIdx > 0
       ) {
         const prevTurnAnchorIdx = findUserTextMsgIdx(turnStartIdx - 1);
-        if (prevTurnAnchorIdx >= 0)
+        if (prevTurnAnchorIdx >= 0) {
           applyCacheControlToLastBlock(prevTurnAnchorIdx);
+        }
       }
 
       // Advancing tail: place a short-lived 5m cache breakpoint on the last
@@ -1241,13 +1296,19 @@ export class AnthropicProvider implements Provider {
       //   The client's own breakpoints already omit it for Haiku.
       if (disableCache || isHaiku) {
         for (const msg of sentMessages) {
-          if (!Array.isArray(msg.content)) continue;
+          if (!Array.isArray(msg.content)) {
+            continue;
+          }
           for (const block of msg.content) {
-            if (typeof block === "string") continue;
+            if (typeof block === "string") {
+              continue;
+            }
             const blockRecord = block as {
               cache_control?: { ttl?: unknown };
             };
-            if (!blockRecord.cache_control) continue;
+            if (!blockRecord.cache_control) {
+              continue;
+            }
             if (disableCache) {
               delete blockRecord.cache_control;
             } else if ("ttl" in blockRecord.cache_control) {
@@ -1286,6 +1347,7 @@ export class AnthropicProvider implements Provider {
 
       let response: Anthropic.Message;
       try {
+        recordProviderRequestDiagnostics({ model_id: params.model });
         const requestHeaders = {
           ...this.requestHeaders,
           ...(usageAttributionHeaders ?? {}),
@@ -1338,7 +1400,9 @@ export class AnthropicProvider implements Provider {
 
         stream.on("text", (text) => {
           textBuffer += text;
-          if (couldBePlaceholderSentinelPrefix(textBuffer)) return;
+          if (couldBePlaceholderSentinelPrefix(textBuffer)) {
+            return;
+          }
           onEvent?.({ type: "text_delta", text: textBuffer });
           textBuffer = "";
         });
@@ -1491,7 +1555,9 @@ export class AnthropicProvider implements Provider {
             accumulatedServerToolInputJson += partialJson;
             return;
           }
-          if (!currentStreamingToolName) return;
+          if (!currentStreamingToolName) {
+            return;
+          }
           accumulatedInputJson += partialJson;
           const now = Date.now();
           if (now - lastInputJsonEmitMs >= 150) {
@@ -1660,24 +1726,33 @@ export class AnthropicProvider implements Provider {
           apiErrorType?: string;
           apiErrorCode?: string;
         } = {};
-        if (retryAfterMs !== undefined)
+        if (retryAfterMs !== undefined) {
           errorOptions.retryAfterMs = retryAfterMs;
-        if (abortReason) errorOptions.abortReason = abortReason;
+        }
+        if (abortReason) {
+          errorOptions.abortReason = abortReason;
+        }
         // Stamp the semantic reason + structured type/code so downstream
         // classification/retry can switch on intent. Skip on caller-abort:
         // abortReason already short-circuits and carries the intent.
         if (!abortReason) {
           errorOptions.reason = deriveAnthropicReason(error);
           const apiErrorType = readAnthropicErrorType(error);
-          if (apiErrorType) errorOptions.apiErrorType = apiErrorType;
+          if (apiErrorType) {
+            errorOptions.apiErrorType = apiErrorType;
+          }
           const apiErrorCode = readAnthropicErrorCode(error);
-          if (apiErrorCode) errorOptions.apiErrorCode = apiErrorCode;
+          if (apiErrorCode) {
+            errorOptions.apiErrorCode = apiErrorCode;
+          }
         }
         // Only preserve the original error as `cause` for transport aborts
         // without a daemon-tagged reason — it's the diagnostic signal the
         // retry layer and log reader rely on. Don't leak it through the
         // caller-aborted path, which already carries `abortReason`.
-        if (!abortReason && isAbortMessage) errorOptions.cause = error;
+        if (!abortReason && isAbortMessage) {
+          errorOptions.cause = error;
+        }
         // Rewrite the message only for inner-timeout, so the retry layer
         // won't retry a request that already hit its 30-min deadline.
         const rewrittenMessage =
@@ -1859,8 +1934,9 @@ export class AnthropicProvider implements Provider {
             c.length !== 1 ||
             typeof c[0] === "string" ||
             c[0].type !== "text"
-          )
+          ) {
             return false;
+          }
           const text = (c[0] as { text?: string }).text;
           return typeof text === "string" && isPlaceholderSentinelText(text);
         };
@@ -1921,7 +1997,9 @@ export class AnthropicProvider implements Provider {
     const activeToolUseStart = findActiveToolUseContinuationStart(formatted);
     for (let i = 0; i < activeToolUseStart; i++) {
       const msg = formatted[i];
-      if (msg.role !== "assistant" || !Array.isArray(msg.content)) continue;
+      if (msg.role !== "assistant" || !Array.isArray(msg.content)) {
+        continue;
+      }
       const stripped = (msg.content as Anthropic.ContentBlockParam[]).filter(
         (b) =>
           typeof b === "string" ||

package/src/providers/call-site-routing.ts

@@ -37,6 +37,7 @@ import {
 import { listConnections } from "./inference/connections.js";
 import type { ProvidersConfig } from "./registry.js";
 import { shouldUseNativeWebSearch } from "./registry.js";
+import { recordProviderRequestDiagnostics } from "./request-diagnostics.js";
 import type {
   Message,
   Provider,
@@ -266,6 +267,12 @@ export class CallSiteRoutingProvider implements Provider {
         resolved.model,
       );
       if (connectionProvider) {
+        // The connection whose credential the call authenticates with is only
+        // known here, and diagnostics for a failed request are unactionable
+        // without it ("which key was this?"). Recorded once the adapter exists,
+        // so a connection that fell back to the default transport is not
+        // reported as the one that signed the request.
+        recordProviderRequestDiagnostics({ connection_name: connectionName });
         return connectionProvider;
       }
       // Soft credential failure: the routed connection yielded no usable

package/src/providers/connection-model-compat.ts

@@ -32,8 +32,12 @@ export function isConnectionCompatibleWithModel(
   connection: Pick<ProviderConnection, "auth">,
   model: string | undefined,
 ): boolean {
-  if (connection.auth.type !== "oauth_subscription") return true;
-  if (!model) return true;
+  if (connection.auth.type !== "oauth_subscription") {
+    return true;
+  }
+  if (!model) {
+    return true;
+  }
   return isCodexSubscriptionModel(model);
 }
 
@@ -49,13 +53,17 @@ export function describeSubscriptionModelIncompatibility(
   candidates: Pick<ProviderConnection, "auth">[],
   model: string | undefined,
 ): string | null {
-  if (!model || candidates.length === 0) return null;
+  if (!model || candidates.length === 0) {
+    return null;
+  }
   if (candidates.some((c) => isConnectionCompatibleWithModel(c, model))) {
     return null;
   }
   const allSubscription = candidates.every(
     (c) => c.auth.type === "oauth_subscription",
   );
-  if (!allSubscription) return null;
+  if (!allSubscription) {
+    return null;
+  }
   return `Model "${model}" isn't available through your ChatGPT subscription. Select a supported model or add an OpenAI API key connection.`;
 }

package/src/providers/fetch-provider-catalog.ts

@@ -68,8 +68,9 @@ export const FETCH_PROVIDER_CATALOG: readonly FetchProviderCatalogEntry[] = [
 ];
 
 /** Provider ids accepted by the web-fetch config schema. */
-export const FETCH_PROVIDER_IDS: readonly string[] =
-  FETCH_PROVIDER_CATALOG.map((p) => p.id);
+export const FETCH_PROVIDER_IDS: readonly string[] = FETCH_PROVIDER_CATALOG.map(
+  (p) => p.id,
+);
 
 /** Catalog entries that require a user-supplied API key. */
 export const BYOK_FETCH_PROVIDERS: readonly FetchProviderCatalogEntry[] =

package/src/providers/gemini/client.ts

@@ -12,6 +12,7 @@ import { getLogger } from "../../util/logger.js";
 import { DAILY_LIMIT_PATTERNS } from "../../util/provider-error-patterns.js";
 import { base64Source, resolveMediaReferences } from "../media-resolve.js";
 import { PROVIDER_CATALOG } from "../model-catalog.js";
+import { recordProviderRequestDiagnostics } from "../request-diagnostics.js";
 import { createStreamTimeout } from "../stream-timeout.js";
 import type {
   ContentBlock,
@@ -116,7 +117,9 @@ function buildThinkingConfig(
   thinking: Record<string, unknown> | undefined,
   model: string,
 ): genai.ThinkingConfig | undefined {
-  if (!thinking) return undefined;
+  if (!thinking) {
+    return undefined;
+  }
   const floor = geminiThinkingFloor(model);
 
   if (thinking.type === "disabled") {
@@ -125,7 +128,9 @@ function buildThinkingConfig(
       includeThoughts: false,
     };
   }
-  if (thinking.type !== "adaptive") return undefined;
+  if (thinking.type !== "adaptive") {
+    return undefined;
+  }
 
   const result: genai.ThinkingConfig = {};
   if (
@@ -196,13 +201,17 @@ export function detectGeminiContextOverflow(
   const status = error.status;
   // 400 = INVALID_ARGUMENT (prompt too long), 413 occasional,
   // 429 with RESOURCE_EXHAUSTED is the Vertex path.
-  if (status !== 400 && status !== 413 && status !== 429) return null;
+  if (status !== 400 && status !== 413 && status !== 429) {
+    return null;
+  }
   const message = error.message ?? "";
 
   // 429 has two meanings (quota vs context-overflow) — require a
   // token/context-specific phrase to classify as overflow.
   if (status === 429) {
-    if (!GEMINI_CONTEXT_OVERFLOW_TOKEN_PATTERNS.test(message)) return null;
+    if (!GEMINI_CONTEXT_OVERFLOW_TOKEN_PATTERNS.test(message)) {
+      return null;
+    }
     return extractOverflowTokensFromMessage(message);
   }
 
@@ -211,7 +220,9 @@ export function detectGeminiContextOverflow(
   const matches =
     /resource.?exhausted/i.test(message) ||
     GEMINI_CONTEXT_OVERFLOW_TOKEN_PATTERNS.test(message);
-  if (!matches) return null;
+  if (!matches) {
+    return null;
+  }
   return extractOverflowTokensFromMessage(message);
 }
 
@@ -229,12 +240,47 @@ const GEMINI_MODEL_RESTRICTED_PATTERNS =
 /** 5xx/UNAVAILABLE bodies that indicate transient overload rather than a generic server error. */
 const GEMINI_OVERLOAD_PATTERNS = /overload/i;
 
+/**
+ * Detect whether an `ApiError` has an empty (or whitespace-only) message.
+ * Google's API always returns a JSON body with a real message on genuine
+ * errors. An empty message means the response had no body — the SDK's
+ * fallback `ApiError` construction — which indicates a proxy or egress
+ * filter intercepted the request before it reached Google.
+ */
+function hasEmptyMessage(error: ApiError): boolean {
+  return (error.message ?? "").trim().length === 0;
+}
+
+/**
+ * Format a human-readable error message from a Gemini `ApiError`. When the
+ * error has an empty message (no JSON body returned), surface a distinct,
+ * actionable message pointing at network/proxy interception instead of the
+ * generic "Gemini API error (404): " which reads as "model not found."
+ */
+export function formatGeminiErrorMessage(error: ApiError): string {
+  if (hasEmptyMessage(error)) {
+    return (
+      `Gemini API returned ${error.status} with no response body — ` +
+      "this typically indicates a network proxy or egress filter " +
+      "intercepting the request, not a genuine Google API error. " +
+      "Check your network configuration and ensure requests to " +
+      "generativelanguage.googleapis.com are allowed."
+    );
+  }
+  return `Gemini API error (${error.status}): ${error.message}`;
+}
+
 /**
  * Map a Gemini `ApiError`'s HTTP status / status-name to a semantic
  * {@link ProviderErrorReason}. The SDK's `ApiError` exposes only `status` and
  * `message`, and the canonical status-name (e.g. `PERMISSION_DENIED`) rides the
  * message body, so we match on both. Context-overflow is handled separately by
  * {@link detectGeminiContextOverflow}; a plain 429 here is a rate limit.
+ *
+ * When the error message is empty (no JSON body), the response did not come
+ * from Google's API — a proxy or egress filter intercepted the request. In
+ * that case we return `"network_error"` for 404/403 status codes rather than
+ * `"model_not_found"` / `"invalid_credentials"`, which would mislead users.
  */
 export function deriveGeminiReason(error: ApiError): ProviderErrorReason {
   const status = error.status;
@@ -242,6 +288,13 @@ export function deriveGeminiReason(error: ApiError): ProviderErrorReason {
   const upper = message.toUpperCase();
   const hasName = (name: string) => upper.includes(name);
 
+  // Empty message → proxy/network interception, not a genuine Google error.
+  // Check this before the status-code branches so 404-with-empty-body doesn't
+  // get misclassified as "model_not_found."
+  if (hasEmptyMessage(error) && (status === 404 || status === 403)) {
+    return "network_error";
+  }
+
   // The managed proxy's daily-limit 402 body carries a specific code; match it
   // before the status branches so it isn't classified as a generic 4xx.
   if (DAILY_LIMIT_PATTERNS.some((re) => re.test(message))) {
@@ -299,9 +352,19 @@ export async function validateGeminiApiKey(
         return { valid: false, reason: "API key is invalid or expired." };
       }
       if (error.status === 403) {
+        // An empty-body 403 likely came from a proxy, not Google's API.
+        // Treat it as inconclusive (allow key storage) rather than rejecting
+        // with a non-actionable "Gemini API error (403): " message.
+        if (hasEmptyMessage(error)) {
+          log.warn(
+            { status: 403 },
+            "Gemini API returned 403 with empty body during key validation — likely proxy interception, allowing key storage",
+          );
+          return { valid: true };
+        }
         return {
           valid: false,
-          reason: `Gemini API error (${error.status}): ${error.message}`,
+          reason: formatGeminiErrorMessage(error),
         };
       }
       // Transient errors (429, 5xx, etc.) — validation is inconclusive,
@@ -370,6 +433,7 @@ export class GeminiProvider implements Provider {
       : undefined;
 
     try {
+      recordProviderRequestDiagnostics({ model_id: activeModel });
       const geminiContents = this.toGeminiContents(messages, activeModel);
 
       const geminiConfig: genai.GenerateContentConfig = {};
@@ -454,7 +518,9 @@ export class GeminiProvider implements Provider {
           if (functionCallParts.length > 0) {
             for (const part of functionCallParts) {
               const fc = part.functionCall;
-              if (!fc) continue;
+              if (!fc) {
+                continue;
+              }
               appendFunctionCall(fc, part.thoughtSignature);
             }
           } else {
@@ -561,7 +627,7 @@ export class GeminiProvider implements Provider {
           );
         }
         throw new ProviderError(
-          `Gemini API error (${error.status}): ${error.message}`,
+          formatGeminiErrorMessage(error),
           "gemini",
           error.status,
           // Skip reason on caller-abort: abortReason already carries the intent
@@ -812,18 +878,26 @@ export class GeminiProvider implements Provider {
     parts: genai.Part[],
     model: string,
   ): void {
-    if (!isGemini3Model(model)) return;
+    if (!isGemini3Model(model)) {
+      return;
+    }
 
     const functionCallParts = parts.filter((part) => part.functionCall);
-    if (functionCallParts.length === 0) return;
+    if (functionCallParts.length === 0) {
+      return;
+    }
 
     const hasRealThoughtSignature = functionCallParts.some((part) =>
       Boolean(part.thoughtSignature),
     );
-    if (hasRealThoughtSignature) return;
+    if (hasRealThoughtSignature) {
+      return;
+    }
 
     const firstFunctionCallPart = functionCallParts[0];
-    if (!firstFunctionCallPart) return;
+    if (!firstFunctionCallPart) {
+      return;
+    }
     firstFunctionCallPart.thoughtSignature =
       GEMINI_3_UNSIGNED_TOOL_CALL_THOUGHT_SIGNATURE;
   }

package/src/providers/inference/codex-token-refresh.ts

@@ -41,12 +41,16 @@ export async function getValidCodexAccessToken(
   const accessToken = await getSecureKeyAsync(
     `${credentialPrefix}/access_token`,
   );
-  if (!accessToken) return null;
+  if (!accessToken) {
+    return null;
+  }
 
   const expiresAtStr = await getSecureKeyAsync(
     `${credentialPrefix}/expires_at`,
   );
-  if (!expiresAtStr) return accessToken; // no expiry info — use token as-is
+  if (!expiresAtStr) {
+    return accessToken;
+  } // no expiry info — use token as-is
 
   const expiresAt = Number(expiresAtStr);
   const now = Date.now() / 1000;