@vellumai/assistant 0.6.6 → 0.7.0

package/src/providers/model-intents.ts

@@ -5,10 +5,9 @@ import type { ModelIntent } from "./types.js";
  * Derived from PROVIDER_CATALOG — single source of truth for default models.
  * Each provider's `defaultModel` in the catalog populates this map.
  */
-export const PROVIDER_DEFAULT_MODELS: Record<string, string> =
-  Object.fromEntries(
-    PROVIDER_CATALOG.map((entry) => [entry.id, entry.defaultModel]),
-  );
+const PROVIDER_DEFAULT_MODELS: Record<string, string> = Object.fromEntries(
+  PROVIDER_CATALOG.map((entry) => [entry.id, entry.defaultModel]),
+);
 
 const PROVIDER_MODEL_INTENTS: Record<string, Record<ModelIntent, string>> = {
   anthropic: {
@@ -22,9 +21,9 @@ const PROVIDER_MODEL_INTENTS: Record<string, Record<ModelIntent, string>> = {
     "vision-optimized": "gpt-5.4",
   },
   gemini: {
-    "latency-optimized": "gemini-2.5-flash-lite",
-    "quality-optimized": "gemini-2.5-flash",
-    "vision-optimized": "gemini-2.5-flash",
+    "latency-optimized": "gemini-3.1-flash-lite-preview",
+    "quality-optimized": "gemini-3.1-pro-preview",
+    "vision-optimized": "gemini-3-flash-preview",
   },
   ollama: {
     "latency-optimized": "llama3.2",
@@ -43,7 +42,7 @@ const PROVIDER_MODEL_INTENTS: Record<string, Record<ModelIntent, string>> = {
   },
 };
 
-const FALLBACK_DEFAULT_MODEL = "claude-sonnet-4-6";
+const FALLBACK_DEFAULT_MODEL = "claude-opus-4-7";
 
 const MODEL_INTENTS = new Set<ModelIntent>([
   "latency-optimized",

package/src/providers/openai/chat-completions-provider.ts

@@ -62,22 +62,30 @@ export interface OpenAIChatCompletionsProviderOptions {
   streamTimeoutMs?: number;
   /** Extra params spread into every chat.completions.create call (e.g. reasoning). */
   extraCreateParams?: Record<string, unknown>;
+  /** Upper bound for `reasoning_effort` sent on the wire. Defaults to "xhigh"
+   *  (OpenAI's current ceiling). Compatibility providers whose APIs only
+   *  document `low|medium|high` (e.g. Fireworks) should set this to "high" so
+   *  Vellum's `xhigh`/`max` tiers don't 4xx upstream. */
+  maxReasoningEffort?: "high" | "xhigh";
 }
 
 /** Map our internal effort values to OpenAI's reasoning_effort parameter.
- *  OpenAI's reasoning_effort caps at "high", so "xhigh" and "max" both
- *  collapse to "high" on this transport. */
+ *  OpenAI caps at "xhigh", so our "max" tier collapses to "xhigh". `"none"` is
+ *  passed through explicitly because OpenAI defaults `reasoning_effort` to
+ *  "medium" when the field is omitted — the user's opt-out is only honored
+ *  when we send it on the wire. */
 const EFFORT_TO_REASONING_EFFORT: Record<
   string,
   NonNullable<
     OpenAI.Chat.Completions.ChatCompletionCreateParams["reasoning_effort"]
   >
 > = {
+  none: "none",
   low: "low",
   medium: "medium",
   high: "high",
-  xhigh: "high",
-  max: "high",
+  xhigh: "xhigh",
+  max: "xhigh",
 };
 
 const OPENAI_SUPPORTED_IMAGE_TYPES = new Set([
@@ -101,6 +109,7 @@ export class OpenAIChatCompletionsProvider implements Provider {
   private model: string;
   private streamTimeoutMs: number;
   private extraCreateParams: Record<string, unknown>;
+  private maxReasoningEffort: "high" | "xhigh";
 
   constructor(
     apiKey: string,
@@ -116,6 +125,7 @@ export class OpenAIChatCompletionsProvider implements Provider {
     this.model = model;
     this.streamTimeoutMs = options.streamTimeoutMs ?? 1_800_000;
     this.extraCreateParams = options.extraCreateParams ?? {};
+    this.maxReasoningEffort = options.maxReasoningEffort ?? "xhigh";
   }
 
   async sendMessage(
@@ -150,7 +160,10 @@ export class OpenAIChatCompletionsProvider implements Provider {
         ? EFFORT_TO_REASONING_EFFORT[effort]
         : undefined;
       if (reasoningEffort) {
-        params.reasoning_effort = reasoningEffort;
+        params.reasoning_effort =
+          reasoningEffort === "xhigh" && this.maxReasoningEffort === "high"
+            ? "high"
+            : reasoningEffort;
       }
 
       if (tools && tools.length > 0) {
@@ -178,6 +191,7 @@ export class OpenAIChatCompletionsProvider implements Provider {
       let promptTokens = 0;
       let completionTokens = 0;
       let reasoningTokens = 0;
+      let cachedPromptTokens = 0;
 
       try {
         const stream = await this.client.chat.completions.create(params, {
@@ -212,12 +226,18 @@ export class OpenAIChatCompletionsProvider implements Provider {
           if (chunk.usage) {
             promptTokens = chunk.usage.prompt_tokens;
             completionTokens = chunk.usage.completion_tokens;
-            const details = (
+            const completionDetails = (
               chunk.usage as {
                 completion_tokens_details?: { reasoning_tokens?: number };
               }
             ).completion_tokens_details;
-            reasoningTokens = details?.reasoning_tokens ?? 0;
+            reasoningTokens = completionDetails?.reasoning_tokens ?? 0;
+            const promptDetails = (
+              chunk.usage as {
+                prompt_tokens_details?: { cached_tokens?: number };
+              }
+            ).prompt_tokens_details;
+            cachedPromptTokens = promptDetails?.cached_tokens ?? 0;
           }
 
           responseModel = chunk.model;
@@ -276,6 +296,13 @@ export class OpenAIChatCompletionsProvider implements Provider {
                 },
               }
             : {}),
+          ...(cachedPromptTokens > 0
+            ? {
+                prompt_tokens_details: {
+                  cached_tokens: cachedPromptTokens,
+                },
+              }
+            : {}),
         },
       };
 
@@ -286,6 +313,9 @@ export class OpenAIChatCompletionsProvider implements Provider {
           inputTokens: promptTokens,
           outputTokens: completionTokens,
           ...(reasoningTokens > 0 ? { reasoningTokens } : {}),
+          ...(cachedPromptTokens > 0
+            ? { cacheReadInputTokens: cachedPromptTokens }
+            : {}),
         },
         stopReason: finishReason,
         rawRequest: params,

package/src/providers/openai/responses-provider.ts

@@ -26,15 +26,34 @@ export interface OpenAIResponsesProviderOptions {
 }
 
 /** Map our internal effort values to the Responses API reasoning.effort parameter.
- *  The Responses API caps at "high", so "xhigh" and "max" both collapse to "high". */
-const EFFORT_TO_REASONING_EFFORT: Record<string, "low" | "medium" | "high"> = {
+ *  OpenAI caps at "xhigh", so our "max" tier collapses to "xhigh". `"none"` is
+ *  passed through explicitly because OpenAI defaults `reasoning.effort` to
+ *  "medium" when the field is omitted — the user's opt-out is only honored
+ *  when we send it on the wire. */
+const EFFORT_TO_REASONING_EFFORT: Record<
+  string,
+  "none" | "low" | "medium" | "high" | "xhigh"
+> = {
+  none: "none",
   low: "low",
   medium: "medium",
   high: "high",
-  xhigh: "high",
-  max: "high",
+  xhigh: "xhigh",
+  max: "xhigh",
 };
 
+/** Values accepted by the Responses API `text.verbosity` parameter. */
+const VALID_VERBOSITIES = new Set<string>(["low", "medium", "high"]);
+
+/** `text.verbosity` is a GPT-5-series-only parameter. Older models on the
+ *  Responses API (o-series, etc.) reject unknown wire fields with HTTP 400, so
+ *  gate forwarding by model name here. The retry layer can't make this call
+ *  because verbosity defaults to "medium" in the LLM schema, so every
+ *  callSite-resolved request would otherwise carry it regardless of model. */
+function modelSupportsVerbosity(model: string): boolean {
+  return /^gpt-5(\b|[-.])/i.test(model);
+}
+
 /** Loosely-typed Responses stream event to avoid `any` while the SDK types settle. */
 interface ResponsesStreamEvent {
   type: string;
@@ -56,6 +75,7 @@ interface ResponsesStreamEvent {
       input_tokens?: number;
       output_tokens?: number;
       output_tokens_details?: { reasoning_tokens?: number };
+      input_tokens_details?: { cached_tokens?: number };
     };
   };
 }
@@ -109,6 +129,7 @@ export class OpenAIResponsesProvider implements Provider {
     const maxTokens = configObj?.max_tokens as number | undefined;
     const modelOverride = configObj?.model as string | undefined;
     const effort = configObj?.effort as string | undefined;
+    const verbosity = configObj?.verbosity as string | undefined;
 
     try {
       const input = this.toResponsesInput(messages);
@@ -137,6 +158,14 @@ export class OpenAIResponsesProvider implements Provider {
         params.reasoning = { effort: reasoningEffort };
       }
 
+      if (
+        verbosity &&
+        VALID_VERBOSITIES.has(verbosity) &&
+        modelSupportsVerbosity(modelOverride ?? this.model)
+      ) {
+        params.text = { verbosity };
+      }
+
       if (tools && tools.length > 0) {
         if (
           this.useNativeWebSearch &&
@@ -184,6 +213,7 @@ export class OpenAIResponsesProvider implements Provider {
       let inputTokens = 0;
       let outputTokens = 0;
       let reasoningTokens = 0;
+      let cachedInputTokens = 0;
       let rawFinalResponse: unknown = undefined;
 
       try {
@@ -281,6 +311,8 @@ export class OpenAIResponsesProvider implements Provider {
                   outputTokens = response.usage.output_tokens ?? 0;
                   reasoningTokens =
                     response.usage.output_tokens_details?.reasoning_tokens ?? 0;
+                  cachedInputTokens =
+                    response.usage.input_tokens_details?.cached_tokens ?? 0;
                 }
                 finishReason = response.status ?? "completed";
               }
@@ -350,6 +382,9 @@ export class OpenAIResponsesProvider implements Provider {
           inputTokens,
           outputTokens,
           ...(reasoningTokens > 0 ? { reasoningTokens } : {}),
+          ...(cachedInputTokens > 0
+            ? { cacheReadInputTokens: cachedInputTokens }
+            : {}),
         },
         stopReason,
         rawRequest: params,

package/src/providers/openrouter/client.ts

@@ -1,5 +1,6 @@
 import { AnthropicProvider } from "../anthropic/client.js";
 import { OpenAIChatCompletionsProvider } from "../openai/chat-completions-provider.js";
+import { isThinkingConfigEnabled } from "../thinking-config.js";
 import type {
   Message,
   ProviderResponse,
@@ -143,15 +144,13 @@ export class OpenRouterProvider extends OpenAIChatCompletionsProvider {
   }
 
   // OpenRouter's unified `reasoning` parameter controls extended thinking on
-  // its OpenAI-compatible endpoint. Mirror the assistant's `thinking.enabled`
-  // config — loop.ts only sets `config.thinking` when enabled — so non-
-  // Anthropic reasoning models (e.g. xAI Grok) can be toggled the same way.
-  // Anthropic models skip this path entirely and go through AnthropicProvider.
+  // its OpenAI-compatible endpoint. Anthropic models skip this path entirely and
+  // go through AnthropicProvider, which receives the native `thinking` object.
   protected override buildExtraCreateParams(
     options?: SendMessageOptions,
   ): Record<string, unknown> {
     const config = options?.config as Record<string, unknown> | undefined;
-    const thinkingEnabled = config?.thinking !== undefined;
+    const thinkingEnabled = isThinkingConfigEnabled(config?.thinking);
     const extras: Record<string, unknown> = {
       reasoning: { enabled: thinkingEnabled },
     };

package/src/providers/provider-env-vars.ts

@@ -6,13 +6,8 @@
  *   1. LLM providers — names come from `PROVIDER_CATALOG` in
  *      `model-catalog.ts`. `getLlmProviderEnvVar` consults the catalog
  *      directly.
- *   2. Search providers — names mirror `meta/provider-env-vars.json`
- *      (the single source of truth for the macOS client bundle). The
- *      mirror is an inline constant here; parity is enforced by
- *      `assistant/src/providers/__tests__/provider-env-vars.test.ts`
- *      to prevent drift. We inline rather than read the JSON at runtime
- *      because the daemon is compiled to a binary and `meta/` is not
- *      reliably present at a known path on disk.
+ *   2. Search providers — hardcoded in `SEARCH_PROVIDER_ENV_VAR_NAMES`
+ *      below. The env var name follows the pattern `${ID}_API_KEY`.
  *
  * Use `getLlmProviderEnvVar` when you're scoped to LLM providers,
  * `getSearchProviderEnvVar` when you're scoped to search providers, and
@@ -24,11 +19,8 @@
  */
 import { PROVIDER_CATALOG } from "./model-catalog.js";
 
-/**
- * Search-provider env var names. Mirrors `meta/provider-env-vars.json`.
- * Parity with the JSON file is enforced by `provider-env-vars.test.ts`.
- */
-export const SEARCH_PROVIDER_ENV_VAR_NAMES: Record<string, string> = {
+/** Search-provider env var names. */
+const SEARCH_PROVIDER_ENV_VAR_NAMES: Record<string, string> = {
   brave: "BRAVE_API_KEY",
   perplexity: "PERPLEXITY_API_KEY",
 };

package/src/providers/provider-send-message.ts

@@ -7,11 +7,7 @@
 import { resolveCallSiteConfig } from "../config/llm-resolver.js";
 import { getConfig } from "../config/loader.js";
 import type { LLMCallSite } from "../config/schemas/llm.js";
-import {
-  getProvider,
-  initializeProviders,
-  listProviders,
-} from "./registry.js";
+import { getProvider, initializeProviders, listProviders } from "./registry.js";
 import type {
   ContentBlock,
   Message,
@@ -43,15 +39,19 @@ let lazyInitPromise: Promise<void> | null = null;
  * performs a one-shot `initializeProviders(getConfig())`.
  *
  * The provider name is sourced from
- * `resolveCallSiteConfig(callSite, config.llm).provider` — i.e. the unified
- * `llm` block drives selection. The `callSite` argument is required so the
- * resolver can layer per-call-site overrides; pass the closest matching
- * call-site identifier from `LLMCallSiteEnum` when adding a new caller.
+ * `resolveCallSiteConfig(callSite, config.llm, opts).provider` — i.e. the
+ * unified `llm` block drives selection. The `callSite` argument is required
+ * so the resolver can layer per-call-site overrides; pass the closest
+ * matching call-site identifier from `LLMCallSiteEnum` when adding a new
+ * caller. Pass `opts.overrideProfile` to apply a per-call ad-hoc profile
+ * override (e.g. a per-conversation pinned profile) on top of any workspace
+ * `activeProfile`.
  *
  * Returns `null` when no providers are available at all.
  */
 export async function resolveConfiguredProvider(
   callSite: LLMCallSite,
+  opts: { overrideProfile?: string } = {},
 ): Promise<ConfiguredProviderResult | null> {
   const config = getConfig();
 
@@ -68,7 +68,11 @@ export async function resolveConfiguredProvider(
     }
   }
 
-  const inferenceProvider = resolveCallSiteConfig(callSite, config.llm).provider;
+  const inferenceProvider = resolveCallSiteConfig(
+    callSite,
+    config.llm,
+    opts,
+  ).provider;
 
   try {
     const provider = getProvider(inferenceProvider);
@@ -91,8 +95,9 @@ export async function resolveConfiguredProvider(
  */
 export async function getConfiguredProvider(
   callSite: LLMCallSite,
+  opts: { overrideProfile?: string } = {},
 ): Promise<Provider | null> {
-  const result = await resolveConfiguredProvider(callSite);
+  const result = await resolveConfiguredProvider(callSite, opts);
   return result?.provider ?? null;
 }
 

package/src/providers/registry.ts

@@ -18,7 +18,7 @@ import type { Provider } from "./types.js";
 const providers = new Map<string, Provider>();
 const routingSources = new Map<string, "user-key" | "managed-proxy">();
 
-export function registerProvider(name: string, provider: Provider): void {
+function registerProvider(name: string, provider: Provider): void {
   providers.set(name, provider);
 }
 

package/src/providers/retry.ts

@@ -9,6 +9,10 @@ import {
   isRetryableNetworkError,
   sleep,
 } from "../util/retry.js";
+import {
+  isThinkingConfigDisabled,
+  normalizeThinkingConfigForWire,
+} from "./thinking-config.js";
 import {
   isContextOverflowError,
   type Message,
@@ -30,11 +34,17 @@ const EFFORT_SUPPORTED_PROVIDERS = new Set([
 
 /**
  * Providers that consume the `thinking` config. Anthropic uses it directly on
- * the wire; OpenRouter translates it into its unified `reasoning` parameter so
- * users can control extended thinking on Anthropic models served via OpenRouter.
+ * the wire; OpenRouter either forwards it to its Anthropic-compatible path or
+ * translates it into the unified `reasoning` parameter on OpenAI-compat calls.
  */
 const THINKING_AWARE_PROVIDERS = new Set(["anthropic", "openrouter"]);
 
+/**
+ * Providers that consume the `verbosity` config. Currently OpenAI (mapped to
+ * `text.verbosity` on the Responses API — a GPT-5-series parameter).
+ */
+const VERBOSITY_SUPPORTED_PROVIDERS = new Set(["openai"]);
+
 /** Patterns that indicate a transient streaming corruption from the SDK. */
 const RETRYABLE_STREAM_PATTERNS = [
   "Unexpected event order",
@@ -88,22 +98,22 @@ function isRetryableError(error: unknown): boolean {
  * Normalize per-call options before handing them to the wrapped provider.
  *
  * When `config.callSite` is set, resolves model/maxTokens/effort/speed/
- * temperature/thinking via `resolveCallSiteConfig` and writes them into
- * `nextConfig` using the wire-format names that downstream provider clients
- * consume (`max_tokens` snake-case for the token cap; camelCase for the rest,
- * which matches the resolver's shape). Per-call explicit overrides on the
- * original `config` object win over the resolved values, so callers can pin
- * a model or other parameter for a single request. `contextWindow` and
+ * verbosity/temperature/thinking via `resolveCallSiteConfig` and writes them
+ * into `nextConfig` using the wire-format names that downstream provider
+ * clients consume (`max_tokens` snake-case for the token cap; camelCase for
+ * the rest, which matches the resolver's shape). Per-call explicit overrides
+ * on the original `config` object win over the resolved values, so callers can
+ * pin a model or other parameter for a single request. `contextWindow` and
  * `provider` are intentionally excluded from the written fields — they are
  * server-side routing/overflow concerns, not provider request parameters,
  * and forwarding them would leak unknown fields into provider request bodies
  * (strict-schema clients like Anthropic reject the request).
  *
  * Whether or not `callSite` is set, this function applies per-provider
- * stripping (`thinking`/`effort`/`speed`) based on the wrapped provider's
- * name — agent-loop callers that pre-resolve provider/model still need this
- * stripping so they don't accidentally send Anthropic-only knobs to OpenAI
- * etc.
+ * stripping (`thinking`/`effort`/`speed`/`verbosity`) based on the wrapped
+ * provider's name — agent-loop callers that pre-resolve provider/model still
+ * need this stripping so they don't accidentally send Anthropic-only knobs to
+ * OpenAI etc.
  */
 function normalizeSendMessageOptions(
   providerName: string,
@@ -114,16 +124,24 @@ function normalizeSendMessageOptions(
 
   const nextConfig: Record<string, unknown> = { ...config };
 
+  // `overrideProfile` is a routing/resolution-time concern (consumed by the
+  // resolver below and `CallSiteRoutingProvider`'s provider selection); it is
+  // not a wire-format field. Strip unconditionally so it never leaks into
+  // provider request bodies even when callers set it without a `callSite`.
+  delete nextConfig.overrideProfile;
+
   if (config.callSite !== undefined) {
-    const resolved = resolveCallSiteConfig(config.callSite, getConfig().llm);
+    const resolved = resolveCallSiteConfig(config.callSite, getConfig().llm, {
+      overrideProfile: config.overrideProfile,
+    });
 
     const explicitModel =
       typeof config.model === "string" && config.model.trim().length > 0
         ? config.model.trim()
         : undefined;
 
-    // Routing key is consumed by the RetryProvider layer and must not leak
-    // downstream.
+    // Routing key is consumed by the resolver above and must not leak
+    // downstream as a wire-format field.
     delete nextConfig.callSite;
 
     // Apply resolved values, letting per-call explicit fields win where set.
@@ -137,6 +155,9 @@ function normalizeSendMessageOptions(
     if (nextConfig.speed === undefined) {
       nextConfig.speed = resolved.speed;
     }
+    if (nextConfig.verbosity === undefined) {
+      nextConfig.verbosity = resolved.verbosity;
+    }
     // `temperature` defaults to `null` in the LLM schema (meaning "no opinion
     // — let the provider pick its own default"). Only forward when the
     // resolved value is an actual number; passing `temperature: null` to
@@ -151,16 +172,14 @@ function normalizeSendMessageOptions(
       nextConfig.temperature = resolved.temperature;
     }
     if (nextConfig.thinking === undefined) {
-      // Convert the schema-shape `{ enabled, streamThinking }` into the
-      // Anthropic wire-format `{ type: "adaptive" }` (or omit when disabled).
-      // Mirrors the non-callSite path in `agent/loop.ts` which sets
-      // `providerConfig.thinking = { type: "adaptive" }` only when enabled.
+      // Convert the schema-shape `{ enabled, streamThinking }` into Anthropic's
+      // discriminated wire-format (`{ type: "adaptive" | "disabled" }`).
       // Without this conversion, `thinking` arrives at `AnthropicProvider`
       // with a shape the SDK doesn't accept (`ThinkingConfigParam` requires
-      // a `type` discriminator), and OpenRouter's truthy check would treat
-      // a disabled config as enabled.
-      if (resolved.thinking?.enabled === true) {
-        nextConfig.thinking = { type: "adaptive" };
+      // a `type` discriminator).
+      const thinking = normalizeThinkingConfigForWire(resolved.thinking);
+      if (thinking !== undefined) {
+        nextConfig.thinking = thinking;
       }
     }
     // Forward OpenRouter-only routing preferences so `OpenRouterProvider` can
@@ -206,6 +225,7 @@ function normalizeSendMessageOptions(
   // and may support reasoning with forced tool_choice.
   const isThinkingForcedToolConflict = (() => {
     if (nextConfig.thinking == null) return false;
+    if (isThinkingConfigDisabled(nextConfig.thinking)) return false;
     const tc = nextConfig.tool_choice as Record<string, unknown> | undefined;
     if (tc == null || (tc.type !== "tool" && tc.type !== "any")) return false;
     if (providerName === "anthropic") return true;
@@ -233,6 +253,15 @@ function normalizeSendMessageOptions(
     delete nextConfig.speed;
   }
 
+  // verbosity maps to OpenAI's `text.verbosity` (Responses API); strip for
+  // providers that don't accept it to avoid leaking unknown fields on the wire.
+  if (
+    !VERBOSITY_SUPPORTED_PROVIDERS.has(providerName) &&
+    nextConfig.verbosity !== undefined
+  ) {
+    delete nextConfig.verbosity;
+  }
+
   // `openrouter.only` is OpenRouter-specific routing; strip for other
   // providers so strict-schema clients don't see an unknown field.
   if (providerName !== "openrouter" && nextConfig.openrouter !== undefined) {

package/src/providers/speech-to-text/openai-whisper-stream.ts

@@ -50,7 +50,7 @@ const log = getLogger("openai-whisper-stream");
  * OpenAI Whisper remains incremental-batch (not true token streaming), but
  * a tighter poll cadence reduces perceived latency for partial updates.
  */
-export const POLL_INTERVAL_MS = 400;
+const POLL_INTERVAL_MS = 400;
 
 /**
  * Timeout per incremental poll request (ms).

package/src/providers/speech-to-text/openai-whisper.ts

@@ -1,13 +1,13 @@
 import type { SttTranscribeResult } from "../../stt/types.js";
 
-export const WHISPER_API_URL = "https://api.openai.com/v1/audio/transcriptions";
+const WHISPER_API_URL = "https://api.openai.com/v1/audio/transcriptions";
 const DEFAULT_TIMEOUT_MS = 60_000;
 
 /**
  * Derive a filename extension from a MIME type so the Whisper API can detect
  * the audio format. Falls back to "audio" when the MIME type is unrecognised.
  */
-export function extensionFromMime(mimeType: string): string {
+function extensionFromMime(mimeType: string): string {
   const map: Record<string, string> = {
     "audio/wav": "wav",
     "audio/x-wav": "wav",
@@ -30,10 +30,7 @@ export function extensionFromMime(mimeType: string): string {
  * Shared between the batch provider and the streaming adapter to avoid
  * duplicating request construction logic.
  */
-export function buildWhisperFormData(
-  audio: Buffer,
-  mimeType: string,
-): FormData {
+function buildWhisperFormData(audio: Buffer, mimeType: string): FormData {
   const ext = extensionFromMime(mimeType);
 
   const formData = new FormData();