@vellumai/assistant 0.11.0 → 0.11.1-staging.2

package/src/providers/__tests__/request-diagnostics.test.ts

@@ -0,0 +1,131 @@
+/**
+ * Tests for per-request provider diagnostics: what URL went out, what came
+ * back, and whether a missing upstream error body means "the upstream sent
+ * nothing" or "we failed to read it".
+ */
+
+import { afterAll, describe, expect, test } from "bun:test";
+
+import {
+  recordProviderRequestDiagnostics,
+  redactUrl,
+  runWithProviderRequestDiagnostics,
+} from "../request-diagnostics.js";
+
+const server = Bun.serve({
+  port: 0,
+  fetch(req) {
+    const { pathname } = new URL(req.url);
+    if (pathname === "/empty-404") {
+      return new Response(null, { status: 404 });
+    }
+    if (pathname === "/verbose-404") {
+      return new Response(
+        JSON.stringify({ error: { code: 404, message: "model not found" } }),
+        { status: 404, headers: { "content-type": "application/json" } },
+      );
+    }
+    return new Response("ok");
+  },
+});
+const origin = `http://localhost:${server.port}`;
+
+afterAll(() => {
+  server.stop(true);
+});
+
+describe("redactUrl", () => {
+  test("masks credential-bearing query parameters and userinfo", () => {
+    // GIVEN a Gemini-style URL that carries the API key in the query string
+    const url = `https://generativelanguage.googleapis.com/v1beta/models/gemini-3-pro:streamGenerateContent?key=super-secret&alt=sse`;
+
+    // WHEN it is redacted for diagnostics
+    const redacted = redactUrl(url);
+
+    // THEN the path and non-credential params survive verbatim
+    expect(redacted).toContain(
+      "/v1beta/models/gemini-3-pro:streamGenerateContent",
+    );
+    expect(redacted).toContain("alt=sse");
+
+    // AND the key is masked
+    expect(redacted).toContain("key=REDACTED");
+    expect(redacted).not.toContain("super-secret");
+  });
+});
+
+describe("runWithProviderRequestDiagnostics", () => {
+  test("reports the outbound URL, status and verbatim upstream error body", async () => {
+    // GIVEN an upstream that answers a request with a non-empty 404 body
+    const path = "/verbose-404?key=super-secret";
+
+    // WHEN the request runs inside a diagnostics scope
+    const outcome = await runWithProviderRequestDiagnostics(async () => {
+      recordProviderRequestDiagnostics({
+        model_id: "gemini-3-pro",
+        connection_name: "gemini-personal",
+      });
+      const response = await fetch(`${origin}${path}`);
+      // The SDK's own read must still work after diagnostics captured the body.
+      return response.text();
+    });
+
+    // THEN the call's own body read is unaffected
+    expect(outcome.ok).toBe(true);
+
+    // AND the evidence identifies the exact request and the verbatim response
+    expect(outcome.diagnostics).toEqual({
+      resolved_url: `${origin}/verbose-404?key=REDACTED`,
+      model_id: "gemini-3-pro",
+      connection_name: "gemini-personal",
+      http_status: 404,
+      upstream_error_body: JSON.stringify({
+        error: { code: 404, message: "model not found" },
+      }),
+      upstream_error_body_state: "captured",
+      upstream_error_body_bytes: 50,
+    });
+  });
+
+  test("distinguishes an upstream that sent no body from a body we never captured", async () => {
+    // GIVEN an upstream that answers 404 with an empty body
+    // WHEN the request runs inside a diagnostics scope
+    const outcome = await runWithProviderRequestDiagnostics(() =>
+      fetch(`${origin}/empty-404`),
+    );
+
+    // THEN the emptiness is recorded as an observation, not as missing evidence
+    expect(outcome.diagnostics.http_status).toBe(404);
+    expect(outcome.diagnostics.upstream_error_body_state).toBe("empty");
+    expect(outcome.diagnostics.upstream_error_body_bytes).toBe(0);
+    expect(outcome.diagnostics.upstream_error_body).toBeUndefined();
+  });
+
+  test("keeps the diagnostics collected before a thrown failure", async () => {
+    // GIVEN a request that fails after reaching the upstream
+    const boom = new Error("stream aborted");
+
+    // WHEN it throws inside the diagnostics scope
+    const outcome = await runWithProviderRequestDiagnostics(async () => {
+      await fetch(`${origin}/verbose-404`);
+      throw boom;
+    });
+
+    // THEN the failure is returned with the evidence gathered up to that point
+    expect(outcome).toMatchObject({ ok: false, error: boom });
+    expect(outcome.diagnostics.resolved_url).toBe(`${origin}/verbose-404`);
+    expect(outcome.diagnostics.http_status).toBe(404);
+  });
+
+  test("leaves requests made outside a scope unrecorded", async () => {
+    // GIVEN an outer scope whose work finished
+    const outer = await runWithProviderRequestDiagnostics(async () => "done");
+
+    // WHEN a request is made outside any diagnostics scope
+    const response = await fetch(`${origin}/verbose-404`);
+
+    // THEN it still completes normally and records nothing
+    expect(response.status).toBe(404);
+    expect(outer.diagnostics).toEqual({});
+  });
+});

package/src/providers/__tests__/retry-callsite.test.ts

@@ -270,6 +270,36 @@ describe("RetryProvider — callSite resolution", () => {
     expect(config.max_tokens).toBe(expected.maxTokens as number);
   });
 
+  test("live-voice front-door call sites reach OpenAI with reasoning off", async () => {
+    // The `latency-optimized` pin's whole value is time-to-first-token, and on
+    // an OpenAI upstream that depends entirely on disabled thinking being
+    // encoded as `effort: "none"`. OpenAI-compatible APIs reason by default
+    // when the field is absent, which pushes first-token past the verdict
+    // deadline the profile exists to beat.
+    //
+    // The profile declares `provider: "vellum"` (the provider-agnostic managed
+    // sentinel) and the real upstream comes from the model id, so the stub is
+    // named for that resolved upstream rather than the sentinel, matching what
+    // `createAdapterFromConnection` builds for a managed route.
+    setLlmConfig({});
+
+    const expected = CODE_DEFAULT_PROFILE_ENTRIES["latency-optimized"];
+    for (const callSite of ["voiceFrontDoor", "voiceFrontDecision"] as const) {
+      let seen: SendMessageOptions | undefined;
+      const wrapped = new RetryProvider(
+        makeProvider("openai", (options) => {
+          seen = options;
+        }),
+      );
+
+      await wrapped.sendMessage(DUMMY_MESSAGES, { config: { callSite } });
+
+      const config = seen?.config as Record<string, unknown>;
+      expect(config.model).toBe(expected.model as string);
+      expect(config.effort).toBe("none");
+    }
+  });
+
   test("propagates resolved effort/speed/temperature; omits server-side fields", async () => {
     setLlmConfig({
       callSites: {

package/src/providers/__tests__/search-provider-catalog.test.ts

@@ -20,7 +20,10 @@ describe("search-provider-catalog", () => {
 
   test("every BYOK provider has the full set of required fields", () => {
     for (const provider of BYOK_SEARCH_PROVIDERS) {
-      expect(provider.apiKeyPrefix, `${provider.id}.apiKeyPrefix`).toBeDefined();
+      expect(
+        provider.apiKeyPrefix,
+        `${provider.id}.apiKeyPrefix`,
+      ).toBeDefined();
       expect(provider.envVar, `${provider.id}.envVar`).toBeDefined();
       expect(provider.secretKey, `${provider.id}.secretKey`).toBeDefined();
       expect(

package/src/providers/__tests__/vellum-mismatch-routing.test.ts

@@ -26,12 +26,14 @@ mock.module("../inference/connections.js", () => ({
     fakeConnections.get(name) ?? null,
   listConnections: (_db: unknown, _filter?: { provider?: string }) =>
     listResult,
+  canonicalVellumConnection: () => ({ ...vellumConn }),
 }));
 
 const resolveCalls: Array<{
   connection: Connection;
   opts: { model?: string; providerOverride?: string };
 }> = [];
+let resolveResult: unknown = undefined;
 mock.module("../registry.js", () => ({
   resolveProviderFromConnection: async (
     connection: Connection,
@@ -39,7 +41,11 @@ mock.module("../registry.js", () => ({
     opts: { model?: string; providerOverride?: string },
   ) => {
     resolveCalls.push({ connection, opts });
-    return { __provider: connection.name };
+    // `undefined` means "use the default stub"; an explicit null models a
+    // credential the vault cannot serve.
+    return resolveResult === undefined
+      ? { __provider: connection.name }
+      : resolveResult;
   },
 }));
 
@@ -65,6 +71,7 @@ function reset(): void {
   resolveCalls.length = 0;
   fakeConnections.clear();
   listResult = [];
+  resolveResult = undefined;
 }
 
 describe("vellum connection mismatch handling", () => {
@@ -127,3 +134,103 @@ describe("vellum connection mismatch handling", () => {
     expect(resolveCalls[0].opts.providerOverride).toBeUndefined();
   });
 });
+
+/**
+ * Boot seeding leaves a user-owned row claiming the `vellum` name in place, so
+ * an install can have no canonical row at all. A managed profile only resolves
+ * on a platform install, so its route is platform auth, never the credentials
+ * that row happens to carry, and never an error over the name collision.
+ */
+describe("user-owned connection claiming the vellum name", () => {
+  beforeEach(reset);
+
+  const userOwnedOpenai: Connection = {
+    name: "vellum",
+    provider: "openai",
+    auth: { type: "api_key", credential: "credential/openai/api_key" },
+  };
+
+  test("routes through platform auth, not the claiming row", async () => {
+    // The row's provider equals the model's upstream, so plain provider
+    // equality would have accepted it and billed the user's own key.
+    fakeConnections.set("vellum", userOwnedOpenai);
+    const provider = await tryResolveProviderForConnectionName(
+      "vellum",
+      config,
+      "vellum",
+      "gpt-5.6-luna",
+    );
+    expect(provider).not.toBeNull();
+    expect(resolveCalls).toHaveLength(1);
+    expect(resolveCalls[0].connection.auth.type).toBe("platform");
+    expect(resolveCalls[0].opts.providerOverride).toBe("openai");
+  });
+
+  test("does not reroute onto another BYOK row for the upstream", async () => {
+    fakeConnections.set("vellum", {
+      name: "vellum",
+      provider: "anthropic",
+      auth: { type: "api_key", credential: "credential/anthropic/api_key" },
+    });
+    listResult = [
+      {
+        name: "openai-personal",
+        provider: "openai",
+        auth: { type: "api_key", credential: "credential/openai/api_key" },
+      },
+    ];
+    await tryResolveProviderForConnectionName(
+      "vellum",
+      config,
+      "vellum",
+      "gpt-5.6-luna",
+    );
+    expect(resolveCalls).toHaveLength(1);
+    expect(resolveCalls[0].connection.auth.type).toBe("platform");
+  });
+
+  test("an unavailable platform is a soft miss, not a fall-through", async () => {
+    fakeConnections.set("vellum", userOwnedOpenai);
+    resolveResult = null; // not signed in to the platform
+    const provider = await tryResolveProviderForConnectionName(
+      "vellum",
+      config,
+      "vellum",
+      "gpt-5.6-luna",
+    );
+    expect(provider).toBeNull();
+    expect(resolveCalls).toHaveLength(1);
+    expect(resolveCalls[0].connection.auth.type).toBe("platform");
+  });
+
+  test("a concrete provider over the canonical name is still platform-billed", async () => {
+    // The shape `resolveCallSiteConfig` produces when a call-site tweak pins a
+    // concrete upstream over a managed profile: provider is the upstream, the
+    // managed connection survives. The legacy config of the same shape (a BYOK
+    // profile pointing at a row named `vellum`) resolves the same way.
+    fakeConnections.set("vellum", userOwnedOpenai);
+    const provider = await tryResolveProviderForConnectionName(
+      "vellum",
+      config,
+      "openai",
+      "gpt-5.6-luna",
+    );
+    expect(provider).not.toBeNull();
+    expect(resolveCalls).toHaveLength(1);
+    expect(resolveCalls[0].connection.auth.type).toBe("platform");
+    expect(resolveCalls[0].opts.providerOverride).toBe("openai");
+  });
+
+  test("the canonical row still routes", async () => {
+    fakeConnections.set("vellum", vellumConn);
+    const provider = await tryResolveProviderForConnectionName(
+      "vellum",
+      config,
+      "vellum",
+      "gpt-5.6-luna",
+    );
+    expect(provider).not.toBeNull();
+    expect(resolveCalls).toHaveLength(1);
+    expect(resolveCalls[0].opts.providerOverride).toBe("openai");
+  });
+});

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" ||