@vellumai/assistant 0.10.7 → 0.10.8-dev.202607102228.5945895

package/src/tts/synthesize-text.ts

@@ -3,11 +3,13 @@
  *
  * Resolves the globally configured provider via {@link resolveTtsConfig},
  * looks up the provider adapter in the registry, and delegates synthesis.
- * Callers supply the pre-sanitized text and a use-case discriminator;
- * provider selection is always global — per-use-case policy only gates
+ * Callers can pass raw text (including markdown, URLs, emoji); it is sanitized
+ * internally via {@link sanitizeForTts} before being sent to the provider.
+ * Provider selection is always global — per-use-case policy only gates
  * capabilities (e.g. format checks), never overrides the chosen provider.
  */
 
+import { sanitizeForTts } from "../calls/tts-text-sanitizer.js";
 import { getConfig } from "../config/loader.js";
 import { getLogger } from "../util/logger.js";
 import { getTtsProvider } from "./provider-catalog.js";
@@ -21,7 +23,7 @@ const log = getLogger("tts:synthesize");
 // ---------------------------------------------------------------------------
 
 export interface SynthesizeTextOptions {
-  /** Pre-sanitized text to speak. */
+  /** Text to speak. Sanitized internally — callers can pass raw model output. */
   text: string;
 
   /** Product surface requesting synthesis. */
@@ -72,6 +74,14 @@ export async function synthesizeText(
   const config = getConfig();
   const { provider: providerId } = resolveTtsConfig(config);
 
+  const sanitized = sanitizeForTts(options.text).trim();
+  if (!sanitized) {
+    throw new TtsSynthesisError(
+      "TTS_SYNTHESIS_FAILED",
+      "Text is empty after sanitization (markdown/URLs/emoji stripped).",
+    );
+  }
+
   let provider;
   try {
     provider = getTtsProvider(providerId);
@@ -93,14 +103,14 @@ export async function synthesizeText(
 
   try {
     return await provider.synthesize({
-      text: options.text,
+      text: sanitized,
       useCase: options.useCase,
       voiceId: options.voiceId,
       signal: options.signal,
     });
   } catch (err) {
     // Re-throw TtsSynthesisError as-is (e.g. from inner adapter errors).
-    if (err instanceof TtsSynthesisError) throw err;
+    if (err instanceof TtsSynthesisError) {throw err;}
 
     throw new TtsSynthesisError(
       "TTS_SYNTHESIS_FAILED",

package/src/tts/types.ts

@@ -104,6 +104,14 @@ export interface TtsSynthesisRequest {
    * actual format of the returned audio.
    */
   outputFormat?: "pcm";
+
+  /**
+   * Optional preferred output sample rate in Hz, meaningful with
+   * `outputFormat: "pcm"`. Providers pick the nearest rate they support;
+   * callers must not assume the hint was honoured exactly and should rely
+   * on provider-documented behavior (see each provider's format mapping).
+   */
+  sampleRateHz?: number;
 }
 
 /** Output of a completed TTS synthesis call. */
@@ -189,6 +197,19 @@ export interface TtsProvider {
   /** Static capability advertisement. */
   readonly capabilities: TtsProviderCapabilities;
 
+  /**
+   * Actual PCM output sample rate in Hz that synthesizing `request` will
+   * produce, when deterministically known before synthesis begins.
+   *
+   * This up-front probe is the single source of truth for the actual output
+   * rate — {@link TtsSynthesisResult} carries no rate. Streaming callers that
+   * label emitted chunks with a rate use this so the first chunk — delivered
+   * before the final result resolves — carries the provider's true output
+   * rate rather than the request's `sampleRateHz` hint. Returns `undefined`
+   * for non-PCM output or when the rate is not known up-front.
+   */
+  resolveOutputSampleRateHz?(request: TtsSynthesisRequest): number | undefined;
+
   /**
    * Synthesize text and return the complete audio buffer.
    *

package/src/usage/attribution.ts

@@ -1,4 +1,9 @@
-import { resolveCallSiteConfig } from "../config/llm-resolver.js";
+import { getEffectiveProfiles } from "../config/default-profile-catalog.js";
+import {
+  isOverrideOrDefaultResolutionEnabled,
+  resolveCallSiteConfig,
+  selectWinningProfile,
+} from "../config/llm-resolver.js";
 import { getConfig } from "../config/loader.js";
 import type { LLMCallSite } from "../config/schemas/llm.js";
 import { safeStringSlice } from "../util/unicode.js";
@@ -135,14 +140,19 @@ export function resolveUsageAttribution(
   const callSiteProfile = normalizeProfileId(
     llm.callSites?.[callSite]?.profile,
   );
-  const profile = resolveAppliedProfile({
-    callSite,
-    profiles: llm.profiles ?? {},
-    activeProfile,
-    overrideProfile,
-    forceOverrideProfile: input.forceOverrideProfile === true,
-    callSiteProfile,
-  });
+  // Under override-or-default semantics the resolver's own winner selection
+  // is the single source of truth for which profile applied — attribution
+  // must never re-derive precedence and drift from dispatch.
+  const profile = isOverrideOrDefaultResolutionEnabled()
+    ? appliedProfileFromWinnerSelection(callSite, llm, overrideProfile, input)
+    : resolveAppliedProfile({
+        callSite,
+        profiles: getEffectiveProfiles(llm.profiles),
+        activeProfile,
+        overrideProfile,
+        forceOverrideProfile: input.forceOverrideProfile === true,
+        callSiteProfile,
+      });
 
   return {
     callSite,
@@ -160,6 +170,30 @@ export function resolveUsageAttribution(
   };
 }
 
+function appliedProfileFromWinnerSelection(
+  callSite: LLMCallSite,
+  llm: Parameters<typeof selectWinningProfile>[1],
+  overrideProfile: string | null,
+  input: UsageAttributionInput,
+): Pick<UsageAttributionSnapshot, "appliedProfile" | "profileSource"> {
+  const selection = selectWinningProfile(callSite, llm, {
+    ...(overrideProfile != null ? { overrideProfile } : {}),
+    ...(input.selectionSeed != null
+      ? { selectionSeed: input.selectionSeed }
+      : {}),
+  });
+  const sourceBySelection = {
+    override: "conversation",
+    active: "active",
+    call_site: "call_site",
+    default: "default",
+  } as const;
+  return {
+    appliedProfile: selection.profileName,
+    profileSource: sourceBySelection[selection.source],
+  };
+}
+
 function resolveAppliedProfile(input: {
   callSite: LLMCallSite;
   profiles: Record<string, unknown>;

package/src/util/errors.ts

@@ -99,6 +99,28 @@ export class AssistantError extends VellumError {
   }
 }
 
+/**
+ * Semantic classification of a provider failure, stamped by the provider layer
+ * at the throw site (from status + body signals) so downstream consumers
+ * (`daemon/conversation-error.ts`, `providers/retry.ts`) can switch on intent
+ * instead of re-deriving it from status codes and message regex. Co-located
+ * with `ProviderError` — a leaf module — for the same reason as `abortReason`:
+ * no import cost. `unknown` (and an absent `reason`) defers to the existing
+ * status/regex fallback.
+ */
+export type ProviderErrorReason =
+  | "invalid_credentials"
+  | "model_restricted"
+  | "model_not_found"
+  | "insufficient_credits"
+  | "rate_limited"
+  | "overloaded"
+  | "context_overflow"
+  | "vision_unsupported"
+  | "bad_request"
+  | "server_error"
+  | "unknown";
+
 export class ProviderError extends AssistantError {
   /** Delay (in ms) suggested by the server's Retry-After header, if present. */
   public readonly retryAfterMs?: number;
@@ -120,6 +142,8 @@ export class ProviderError extends AssistantError {
    * `isAbortReason` is the canonical type guard for consumers.
    */
   public readonly abortReason?: unknown;
+  /** Semantic failure classification stamped at the throw site. */
+  public readonly reason?: ProviderErrorReason;
 
   constructor(
     message: string,
@@ -134,6 +158,7 @@ export class ProviderError extends AssistantError {
       apiErrorParam?: string;
       requestId?: string;
       rawBody?: string;
+      reason?: ProviderErrorReason;
     },
   ) {
     super(message, ErrorCode.PROVIDER_ERROR, options);
@@ -145,6 +170,7 @@ export class ProviderError extends AssistantError {
     this.requestId = options?.requestId;
     this.rawBody = options?.rawBody;
     this.abortReason = options?.abortReason;
+    this.reason = options?.reason;
   }
 }
 

package/src/util/image-conversion.ts

@@ -86,6 +86,12 @@ function evictIfNeeded(dir: string): void {
 export interface ConvertToJpegOptions {
   /** Downscale so neither side exceeds this; omit to keep full resolution. */
   maxDimensionPx?: number;
+  /**
+   * Resample to exactly these pixel dimensions (up- or downscaling). The
+   * caller is responsible for preserving aspect ratio. Mutually exclusive
+   * with `maxDimensionPx`; when both are set this wins.
+   */
+  resizeToPx?: { width: number; height: number };
   /** JPEG quality 1-100 (default 80). */
   quality?: number;
 }
@@ -99,10 +105,18 @@ function runSips(
   const outPath = join(tmpdir(), `vellum-img-opt-${stamp}-out.jpg`);
   try {
     writeFileSync(srcPath, inputBytes);
+    // `-z` resamples to an exact height/width (the only sips mode that can
+    // upscale); `--resampleHeightWidthMax` only caps the longest side.
     const args =
-      options.maxDimensionPx != null
-        ? ["--resampleHeightWidthMax", String(options.maxDimensionPx)]
-        : [];
+      options.resizeToPx != null
+        ? [
+            "-z",
+            String(options.resizeToPx.height),
+            String(options.resizeToPx.width),
+          ]
+        : options.maxDimensionPx != null
+          ? ["--resampleHeightWidthMax", String(options.maxDimensionPx)]
+          : [];
     args.push(
       "-s",
       "format",
@@ -142,8 +156,12 @@ export function convertImageToJpeg(
 ): Buffer | null {
   const hash = createHash("sha256").update(bytes).digest("hex").slice(0, 16);
   // Options qualify the key so full-resolution storage conversions and
-  // downscaled transport conversions of the same source never collide.
-  const cacheKey = `${hash}-${options.maxDimensionPx ?? "full"}-q${options.quality ?? DEFAULT_JPEG_QUALITY}`;
+  // resized transport conversions of the same source never collide.
+  const sizeKey =
+    options.resizeToPx != null
+      ? `${options.resizeToPx.width}x${options.resizeToPx.height}`
+      : (options.maxDimensionPx ?? "full");
+  const cacheKey = `${hash}-${sizeKey}-q${options.quality ?? DEFAULT_JPEG_QUALITY}`;
 
   const cached = readFromCache(cacheKey);
   if (cached) return cached;

package/src/util/logger.ts

@@ -5,12 +5,11 @@ import {
   readdirSync,
   unlinkSync,
 } from "node:fs";
+import { createRequire } from "node:module";
 import { join } from "node:path";
-import { Writable } from "node:stream";
 
-import pino from "pino";
+import type { Logger } from "pino";
 import type { PrettyOptions } from "pino-pretty";
-import pinoPretty from "pino-pretty";
 
 import {
   getDebugStdoutLogs,
@@ -18,7 +17,23 @@ import {
 } from "../config/env-registry.js";
 import { logSerializers } from "./log-redact.js";
 import { getLogsDir } from "./platform.js";
-import { createSentryLogStream } from "./sentry-log-stream.js";
+
+const loadModule = createRequire(import.meta.url);
+
+/**
+ * pino loads on first logger construction, not import, so CLI processes that
+ * never log skip its ~17 MiB graph. The `.default ?? mod` unwrap handles both
+ * the real dual-export and ESM-shaped test mocks.
+ */
+function loadPino(): typeof import("pino") {
+  const mod = loadModule("pino") as { default?: unknown };
+  return (mod.default ?? mod) as typeof import("pino");
+}
+
+function loadPinoPretty(): typeof import("pino-pretty") {
+  const mod = loadModule("pino-pretty") as { default?: unknown };
+  return (mod.default ?? mod) as typeof import("pino-pretty");
+}
 
 /** Common pino-pretty options that inline [module] into the message prefix. */
 function prettyOpts(extra?: PrettyOptions): PrettyOptions {
@@ -82,7 +97,7 @@ export function pruneOldLogFiles(dir: string, retentionDays: number): number {
   return removed;
 }
 
-let rootLogger: pino.Logger | null = null;
+let rootLogger: Logger | null = null;
 let activeLogDate: string | null = null;
 let activeLogFileConfig: LogFileConfig | null = null;
 
@@ -113,7 +128,9 @@ function resolveLogDir(config: LogFileConfig): string | undefined {
   return config.dir;
 }
 
-function buildRotatingLogger(config: LogFileConfig): pino.Logger {
+function buildRotatingLogger(config: LogFileConfig): Logger {
+  const pino = loadPino();
+  const pinoPretty = loadPinoPretty();
   const dir = resolveLogDir(config);
   if (!dir) {
     return pino(
@@ -143,11 +160,6 @@ function buildRotatingLogger(config: LogFileConfig): pino.Logger {
   activeLogDate = today;
   activeLogFileConfig = { ...config, dir };
 
-  const sentryStream = {
-    stream: createSentryLogStream(),
-    level: "error" as const,
-  };
-
   // When stdout is not a TTY (e.g. desktop app redirects to a hatch log file),
   // write to the rotating file only — the hatch log already captured early
   // startup output and echoing pino output there is unnecessary duplication.
@@ -156,10 +168,7 @@ function buildRotatingLogger(config: LogFileConfig): pino.Logger {
   if (!process.stdout.isTTY && !getDebugStdoutLogs()) {
     return pino(
       { name: "assistant", level: "info", serializers: logSerializers },
-      pino.multistream([
-        { stream: fileStream, level: "info" as const },
-        sentryStream,
-      ]),
+      pino.multistream([{ stream: fileStream, level: "info" as const }]),
     );
   }
 
@@ -171,7 +180,6 @@ function buildRotatingLogger(config: LogFileConfig): pino.Logger {
         stream: pinoPretty(prettyOpts({ destination: 1 })),
         level: "info" as const,
       },
-      sentryStream,
     ]),
   );
 }
@@ -200,17 +208,24 @@ export function initLogger(config: LogFileConfig): void {
   }
 }
 
-function getRootLogger(): pino.Logger {
+function getRootLogger(): Logger {
   if (activeLogFileConfig) {
     ensureCurrentDate();
   }
   if (!rootLogger) {
-    const forceStderr =
+    const pino = loadPino();
+    const pinoPretty = loadPinoPretty();
+    const isTest =
       process.env.BUN_TEST === "1" || process.env.NODE_ENV === "test";
-    if (forceStderr) {
+    if (isTest) {
+      // Silent by default so test output stays readable without per-file
+      // `mock.module("../util/logger.js", …)` boilerplate — the mocks this
+      // replaces did exactly this, module-wide. Set VELLUM_TEST_LOG_LEVEL
+      // (e.g. "info", "debug") to see log output on stderr when debugging
+      // a test run.
       rootLogger = pino(
         {
-          level: "info",
+          level: process.env.VELLUM_TEST_LOG_LEVEL ?? "silent",
           serializers: logSerializers,
         },
         pino.destination(2),
@@ -291,10 +306,10 @@ export function truncateForLog(value: string, maxLen = 500): string {
  * quickly (e.g. `assistant --help`). The child is rebuilt whenever the
  * underlying root logger changes (e.g. day rollover, late initLogger()).
  */
-export function getLogger(name: string): pino.Logger {
-  let cachedRoot: pino.Logger | null = null;
-  let child: pino.Logger | null = null;
-  const handler: ProxyHandler<pino.Logger> = {
+export function getLogger(name: string): Logger {
+  let cachedRoot: Logger | null = null;
+  let child: Logger | null = null;
+  const handler: ProxyHandler<Logger> = {
     get(_target, prop, receiver) {
       const root = getRootLogger();
       if (root !== cachedRoot) {
@@ -308,56 +323,40 @@ export function getLogger(name: string): pino.Logger {
       return val;
     },
   };
-  return new Proxy({} as pino.Logger, handler);
+  return new Proxy({} as Logger, handler);
 }
 
 /**
- * Pino destination that extracts the message text from JSON log entries
- * and writes it as plain text. Routes info/warn to stdout and error/fatal
- * to stderr, matching console.log/console.error behavior.
+ * Extract the message text from a pino-style log call: `(msg)` or
+ * `(mergeObject, msg)`. Structured fields are discarded — CLI output is the
+ * message text only, matching what the pino-backed implementation printed.
  */
-function cliDestination(fd: number, maxLevel?: number): Writable {
-  const output = fd === 2 ? process.stderr : process.stdout;
-  return new Writable({
-    write(chunk, _encoding, callback) {
-      try {
-        const obj = JSON.parse(chunk.toString());
-        if (maxLevel !== undefined && obj.level > maxLevel) {
-          callback();
-          return;
-        }
-        output.write((obj.msg ?? "") + "\n", callback);
-      } catch {
-        output.write(chunk, callback);
-      }
-    },
-  });
+function cliWrite(output: NodeJS.WriteStream): (...args: unknown[]) => void {
+  return (...args: unknown[]) => {
+    const msg =
+      typeof args[0] === "string" ? args[0] : (args[1] as string | undefined);
+    output.write((msg ?? "") + "\n");
+  };
 }
 
 /**
- * Logger for CLI commands. Outputs plain message text to stdout (info/warn)
- * and stderr (error/fatal) while providing structured log levels through pino.
- * Uses lazy initialization to avoid issues with fast-exit paths like --help.
+ * Logger for CLI commands. Outputs plain message text to stdout
+ * (trace/debug/info/warn) and stderr (error/fatal). Implemented without pino:
+ * the CLI only ever prints the message text, and pino's ~70-module graph
+ * costs ~17 MiB per process, which short-lived CLI invocations should not
+ * pay. Typed as pino's Logger so call sites keep pino call signatures; only
+ * the level methods are real, so anything beyond them fails at runtime —
+ * extend this object before using other pino APIs in CLI code.
  */
-export function getCliLogger(name: string): pino.Logger {
-  let logger: pino.Logger | null = null;
-  const handler: ProxyHandler<pino.Logger> = {
-    get(_target, prop, receiver) {
-      if (!logger) {
-        logger = pino(
-          { name, level: "trace", serializers: logSerializers },
-          pino.multistream([
-            { stream: cliDestination(1, 49), level: "trace" as const },
-            { stream: cliDestination(2), level: "error" as const },
-          ]),
-        );
-      }
-      const val = Reflect.get(logger, prop, receiver);
-      if (typeof val === "function") {
-        return val.bind(logger);
-      }
-      return val;
-    },
-  };
-  return new Proxy({} as pino.Logger, handler);
+export function getCliLogger(_name: string): Logger {
+  const toStdout = cliWrite(process.stdout);
+  const toStderr = cliWrite(process.stderr);
+  return {
+    trace: toStdout,
+    debug: toStdout,
+    info: toStdout,
+    warn: toStdout,
+    error: toStderr,
+    fatal: toStderr,
+  } as unknown as Logger;
 }

package/src/util/platform.ts

@@ -95,6 +95,25 @@ export function getConfigQuarantineNoticePath(): string {
   return join(getDataDir(), "config-quarantine-notice.json");
 }
 
+/**
+ * Returns the path to the config-validation-reset notice sentinel
+ * (`<workspace>/data/config-validation-reset-notice.json`).
+ *
+ * Written by the config loader when `config.json` parses as JSON but fails
+ * schema validation so hard that the loader falls back to *full* defaults
+ * (e.g. an unknown key that masks a `superRefine` violation until the offending
+ * key is stripped). Unlike a quarantine, the on-disk file is left untouched —
+ * the user's customized values are still present but inactive until the invalid
+ * entries are fixed. Read by the per-turn `config-validation-reset-notice`
+ * injector so the agent can explain a settings/connection change the user did
+ * not make. Lives beside the quarantine sentinel under the internal data dir
+ * for the same reasons (daemon-written bookkeeping; resolves without loading
+ * config, so it is safe during early-boot config load).
+ */
+export function getConfigValidationResetNoticePath(): string {
+  return join(getDataDir(), "config-validation-reset-notice.json");
+}
+
 /**
  * Returns the embedding models directory ($VELLUM_WORKSPACE_DIR/embedding-models).
  * Downloaded embedding runtime (onnxruntime-node, transformers bundle, model weights)
@@ -408,66 +427,6 @@ export function getProfilerRunDir(runId: string): string {
   return join(getProfilerRunsDir(), runId);
 }
 
-/**
- * Resolve the shipped source directory for a first-party skill (e.g.
- * `meet-join`) whose runtime is launched outside the compiled daemon
- * binary — notably the meet-host child process spawned via
- * `bun run <skill>/register.ts`.
- *
- * Layers on top of `getRepoSkillsDir()` from `skills/catalog-install.ts`:
- * that helper locates the first-party skills root (validated by
- * `catalog.json`); this helper appends the skill id and validates the
- * per-skill entry point (`register.ts`). Returns `undefined` when the
- * root is unavailable (e.g. dev-mode build without `VELLUM_DEV=1`) or
- * the skill directory has no `register.ts`.
- *
- * Implemented here instead of `skills/catalog-install.ts` to avoid
- * pulling that module's platform-API dependencies (fetch, memory graph)
- * into callers that only need a path resolution. Takes the first-party
- * skills root as a dependency to keep this module free of a reverse
- * import.
- */
-export function getSkillRuntimePath(
-  skillId: string,
-  firstPartySkillsRoot: string | undefined,
-): string | undefined {
-  if (!firstPartySkillsRoot) return undefined;
-  const candidate = join(firstPartySkillsRoot, skillId);
-  if (existsSync(join(candidate, "register.ts"))) {
-    return candidate;
-  }
-  return undefined;
-}
-
-/**
- * Resolve the on-disk path to a standalone `bun` binary that the meet-host
- * supervisor (PR 27) uses to spawn external skills. Prefers the
- * packaging-site-bundled copy before falling back to the shared
- * download/PATH resolver in `bun-runtime.ts`.
- *
- * Resolution order:
- *
- *   1. macOS `.app` bundle: `Contents/Resources/bun` — bundled at a version
- *      that matches `.tool-versions`.
- *   2. Next-to-binary: `<execDir>/bun` for Docker/generic compiled layouts
- *      that stage a bun binary alongside the daemon (PR 29 wires this up).
- *
- * Returns `undefined` when no bundled copy is present; callers should
- * fall back to `ensureBun()` from `./bun-runtime.ts`, which handles PATH
- * lookup and JIT download for bare-metal dev.
- */
-export function getBundledBunPath(): string | undefined {
-  const importDir = import.meta.dir;
-  if (!importDir.startsWith("/$bunfs/")) return undefined;
-
-  const execDir = dirname(process.execPath);
-  const resourcesPath = join(execDir, "..", "Resources", "bun");
-  if (existsSync(resourcesPath)) return resourcesPath;
-  const execDirPath = join(execDir, "bun");
-  if (existsSync(execDirPath)) return execDirPath;
-  return undefined;
-}
-
 export function ensureDataDir(): void {
   const root = vellumRoot();
   const workspace = getWorkspaceDir();

package/src/util/pricing.ts

@@ -1,4 +1,5 @@
 import type { ModelPricingOverride } from "../config/schema.js";
+import { isAnthropicDelegatingGateway } from "../providers/anthropic-gateway-shared.js";
 import type {
   CatalogModel,
   CatalogModelPricing,
@@ -141,17 +142,19 @@ function normalizeAnthropicModelId(model: string): string {
 /**
  * Whether Anthropic's pricing rules (cache-read/write multipliers, fast-mode
  * surcharge) apply for the given provider/model. True for direct Anthropic
- * calls and for Anthropic models routed through OpenRouter — OpenRouter
- * proxies to Anthropic's Messages API, so the usage response carries the
- * same cache and speed fields and is charged at Anthropic's rates.
+ * calls and for Anthropic models routed through OpenRouter or the Vercel AI
+ * Gateway — both gateways proxy `anthropic/*` to Anthropic's Messages API, so
+ * the usage response carries the same cache and speed fields and is charged
+ * at Anthropic's rates.
  */
 export function usesAnthropicPricingRules(
   provider: string,
   model: string,
 ): boolean {
-  if (provider === "anthropic") return true;
-  if (provider === "openrouter" && isAnthropicModelId(model)) return true;
-  return false;
+  if (provider === "anthropic") {
+    return true;
+  }
+  return isAnthropicDelegatingGateway(provider) && isAnthropicModelId(model);
 }
 
 /**
@@ -384,11 +387,11 @@ export function resolvePricingForUsage(
   model: string,
   usage: PricingUsage,
 ): PricingResult {
-  // Anthropic models routed through OpenRouter: look up against the Anthropic
-  // catalog using the normalized bare slug. OpenRouter bills these calls at
-  // Anthropic's rates and the underlying Messages API response includes
-  // Anthropic's cache- and speed-metadata fields.
-  if (provider === "openrouter" && isAnthropicModelId(model)) {
+  // Anthropic models routed through OpenRouter or the Vercel AI Gateway: look
+  // up against the Anthropic catalog using the normalized bare slug. Both
+  // gateways bill these calls at Anthropic's rates and the underlying Messages
+  // API response includes Anthropic's cache- and speed-metadata fields.
+  if (isAnthropicDelegatingGateway(provider) && isAnthropicModelId(model)) {
     const pricing = findPricing("anthropic", normalizeAnthropicModelId(model));
     if (pricing) {
       return {