@vellumai/assistant 0.6.3 → 0.6.5

package/src/providers/openrouter/client.ts

@@ -1,25 +1,189 @@
-import { OpenAIProvider } from "../openai/client.js";
+import { AnthropicProvider } from "../anthropic/client.js";
+import { OpenAIChatCompletionsProvider } from "../openai/chat-completions-provider.js";
+import type {
+  Message,
+  ProviderResponse,
+  SendMessageOptions,
+  ToolDefinition,
+} from "../types.js";
+import { ContextOverflowError, isContextOverflowError } from "../types.js";
 
 export interface OpenRouterProviderOptions {
   apiKey?: string;
   baseURL?: string;
   streamTimeoutMs?: number;
+  useNativeWebSearch?: boolean;
 }
 
 const DEFAULT_OPENROUTER_BASE_URL = "https://openrouter.ai/api/v1";
 
-export class OpenRouterProvider extends OpenAIProvider {
+// Models on OpenRouter prefixed `anthropic/` are routed through OpenRouter's
+// Anthropic-compatible Messages API at `<root>/v1/messages` (where `<root>` is
+// the OpenRouter API root, e.g. `https://openrouter.ai/api`) so that
+// Anthropic-native features — extended thinking, prompt caching, cache TTL,
+// output_config — work without lossy translation through the OpenAI chat
+// completions compatibility layer. The Anthropic SDK appends `/v1/messages` to
+// its configured baseURL, so we strip the trailing `/v1` segment from the
+// OpenAI-compat base before handing it to the SDK.
+function isAnthropicModel(model: string): boolean {
+  return model.startsWith("anthropic/");
+}
+
+function toAnthropicMessagesBaseURL(openRouterBaseURL: string): string {
+  return openRouterBaseURL.replace(/\/v1\/?$/, "");
+}
+
+/**
+ * Extract the normalized `openrouter.only` list from a per-call config. Returns
+ * an empty array when the field is absent, empty, or contains no usable string
+ * entries, so callers can branch on `length > 0` to decide whether to emit the
+ * wire-format `provider: { only: [...] }` field. Exported for tests.
+ */
+export function extractOnlyList(config: unknown): string[] {
+  const cfg = config as { openrouter?: { only?: unknown } } | undefined;
+  const only = cfg?.openrouter?.only;
+  if (!Array.isArray(only)) return [];
+  return only.filter((x): x is string => typeof x === "string" && x.length > 0);
+}
+
+/**
+ * Rewrite `options.config` for the Anthropic-compat path so OpenRouter's
+ * `provider: { only: [...] }` body field travels through `AnthropicProvider`'s
+ * `...restConfig` spread into `Anthropic.MessageStreamParams`. The `openrouter`
+ * key itself is removed because Anthropic's JSON parser doesn't know about it
+ * — only the translated `provider` field should reach the wire. Safe to inject
+ * here because `getAnthropicInner()` hardcodes OpenRouter's baseURL; the inner
+ * `AnthropicProvider` never talks to Anthropic directly. Exported for tests.
+ */
+export function withOpenRouterBodyExtras(
+  options?: SendMessageOptions,
+): SendMessageOptions | undefined {
+  if (!options?.config) return options;
+  const only = extractOnlyList(options.config);
+  if (only.length === 0) return options;
+  const { openrouter: _openrouter, ...rest } = options.config as Record<
+    string,
+    unknown
+  >;
+  const existingProvider = (rest.provider ?? {}) as Record<string, unknown>;
+  return {
+    ...options,
+    config: { ...rest, provider: { ...existingProvider, only } },
+  };
+}
+
+export class OpenRouterProvider extends OpenAIChatCompletionsProvider {
+  private readonly openRouterApiKey: string;
+  private readonly defaultModel: string;
+  private readonly resolvedBaseURL: string;
+  private readonly providerStreamTimeoutMs: number | undefined;
+  private readonly useNativeWebSearch: boolean;
+  private anthropicInner: AnthropicProvider | undefined;
+
   constructor(
     apiKey: string,
     model: string,
     options: OpenRouterProviderOptions = {},
   ) {
+    const baseURL = options.baseURL?.trim() || DEFAULT_OPENROUTER_BASE_URL;
     super(apiKey, model, {
-      baseURL: options.baseURL?.trim() || DEFAULT_OPENROUTER_BASE_URL,
+      baseURL,
       providerName: "openrouter",
       providerLabel: "OpenRouter",
       streamTimeoutMs: options.streamTimeoutMs,
-      extraCreateParams: { reasoning: { enabled: true } },
     });
+    this.openRouterApiKey = apiKey;
+    this.defaultModel = model;
+    this.resolvedBaseURL = baseURL;
+    this.providerStreamTimeoutMs = options.streamTimeoutMs;
+    this.useNativeWebSearch = options.useNativeWebSearch ?? false;
+  }
+
+  // When routing to an `anthropic/*` model, actual API calls hit the Anthropic
+  // Messages endpoint, which charges for images using dimension-based pricing
+  // (~width*height/750 tokens) rather than the generic `base64/4` heuristic.
+  // Expose this so the local token estimator picks the matching rules and
+  // `shouldCompact()` doesn't over-count image tokens by ~100×.
+  get tokenEstimationProvider(): string {
+    return isAnthropicModel(this.defaultModel) ? "anthropic" : this.name;
+  }
+
+  override async sendMessage(
+    messages: Message[],
+    tools?: ToolDefinition[],
+    systemPrompt?: string,
+    options?: SendMessageOptions,
+  ): Promise<ProviderResponse> {
+    const effectiveModel = this.resolveEffectiveModel(options);
+    try {
+      if (isAnthropicModel(effectiveModel)) {
+        return await this.getAnthropicInner().sendMessage(
+          messages,
+          tools,
+          systemPrompt,
+          withOpenRouterBodyExtras(options),
+        );
+      }
+      return await super.sendMessage(messages, tools, systemPrompt, options);
+    } catch (error) {
+      // Re-tag delegate-thrown ContextOverflowError so the outer provider name
+      // matches the configured provider ("openrouter"). This keeps downstream
+      // error reporting and metrics attribution accurate, while preserving the
+      // actualTokens/maxTokens extracted by the delegate.
+      if (isContextOverflowError(error) && error.provider !== this.name) {
+        throw new ContextOverflowError(error.message, this.name, {
+          actualTokens: error.actualTokens,
+          maxTokens: error.maxTokens,
+          statusCode: error.statusCode,
+          cause: error,
+        });
+      }
+      throw error;
+    }
+  }
+
+  // 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.
+  protected override buildExtraCreateParams(
+    options?: SendMessageOptions,
+  ): Record<string, unknown> {
+    const config = options?.config as Record<string, unknown> | undefined;
+    const thinkingEnabled = config?.thinking !== undefined;
+    const extras: Record<string, unknown> = {
+      reasoning: { enabled: thinkingEnabled },
+    };
+    const only = extractOnlyList(config);
+    if (only.length > 0) {
+      extras.provider = { only };
+    }
+    return extras;
+  }
+
+  private resolveEffectiveModel(options?: SendMessageOptions): string {
+    const config = options?.config as Record<string, unknown> | undefined;
+    const override =
+      typeof config?.model === "string" && config.model.trim().length > 0
+        ? config.model.trim()
+        : undefined;
+    return override ?? this.defaultModel;
+  }
+
+  private getAnthropicInner(): AnthropicProvider {
+    if (!this.anthropicInner) {
+      this.anthropicInner = new AnthropicProvider(
+        this.openRouterApiKey,
+        this.defaultModel,
+        {
+          baseURL: toAnthropicMessagesBaseURL(this.resolvedBaseURL),
+          streamTimeoutMs: this.providerStreamTimeoutMs,
+          authToken: this.openRouterApiKey,
+          useNativeWebSearch: this.useNativeWebSearch,
+        },
+      );
+    }
+    return this.anthropicInner;
   }
 }

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

@@ -0,0 +1,56 @@
+/**
+ * Provider env-var lookup helpers.
+ *
+ * Two sources of truth feed these helpers:
+ *
+ *   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.
+ *
+ * Use `getLlmProviderEnvVar` when you're scoped to LLM providers,
+ * `getSearchProviderEnvVar` when you're scoped to search providers, and
+ * `getAnyProviderEnvVar` (LLM-first, then search) when you accept either
+ * kind — e.g. the generic `getProviderKeyAsync` env-var fallback.
+ *
+ * Each helper returns `undefined` for keyless providers (e.g. Ollama),
+ * unknown IDs, and providers outside the helper's scope.
+ */
+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> = {
+  brave: "BRAVE_API_KEY",
+  perplexity: "PERPLEXITY_API_KEY",
+};
+
+export function getLlmProviderEnvVar(providerId: string): string | undefined {
+  return PROVIDER_CATALOG.find((p) => p.id === providerId)?.envVar;
+}
+
+export function getSearchProviderEnvVar(
+  providerId: string,
+): string | undefined {
+  return SEARCH_PROVIDER_ENV_VAR_NAMES[providerId];
+}
+
+/**
+ * Resolve a provider env-var name from either source — LLM catalog first,
+ * then the search-provider mirror. Returns `undefined` when no provider
+ * scope declares an env var for the given ID (keyless LLM providers like
+ * Ollama, unknown IDs, etc.).
+ */
+export function getAnyProviderEnvVar(providerId: string): string | undefined {
+  return (
+    getLlmProviderEnvVar(providerId) ?? getSearchProviderEnvVar(providerId)
+  );
+}

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

@@ -0,0 +1,139 @@
+/**
+ * Canonical source for API-key-addressable providers.
+ *
+ * This module composes the full set of providers that store API keys in
+ * secure storage (the `api_key` secret type) from three sources:
+ *
+ * 1. **LLM / search providers** -- statically declared here because they
+ *    have no separate catalog module yet.
+ * 2. **STT providers** -- dynamically derived from the canonical STT
+ *    provider catalog by reading credential-provider names.
+ * 3. **TTS catalog providers** -- dynamically derived from the canonical
+ *    TTS provider catalog by selecting entries whose secret requirements
+ *    use the bare-name (non-credential) storage convention.
+ *
+ * Consumers that need the set of valid API-key provider names should
+ * import {@link API_KEY_PROVIDERS} from this module rather than
+ * maintaining their own inline arrays.
+ */
+
+import { listCatalogProviders } from "../tts/provider-catalog.js";
+import { listCredentialProviderNames as listSttCredentialProviderNames } from "./speech-to-text/provider-catalog.js";
+
+// ---------------------------------------------------------------------------
+// Static LLM / search providers
+// ---------------------------------------------------------------------------
+
+/**
+ * LLM and search providers that store API keys under their bare provider
+ * name in the secure credential store (e.g. `anthropic`, `openai`).
+ *
+ * These are declared statically because no provider-catalog module exists
+ * for them yet. When one is introduced, this array should be replaced with
+ * a catalog-derived computation analogous to the TTS logic below.
+ */
+const LLM_AND_SEARCH_API_KEY_PROVIDERS = [
+  "anthropic",
+  "openai",
+  "gemini",
+  "ollama",
+  "fireworks",
+  "openrouter",
+  "brave",
+  "perplexity",
+] as const;
+
+// ---------------------------------------------------------------------------
+// STT catalog-derived providers
+// ---------------------------------------------------------------------------
+
+/**
+ * Derive the deduplicated set of STT credential-provider names from the
+ * canonical STT provider catalog, filtering out names that already appear
+ * in the LLM/search list to avoid duplicates (e.g. `openai-whisper` maps
+ * to `"openai"` which is already present in
+ * {@link LLM_AND_SEARCH_API_KEY_PROVIDERS}).
+ */
+function sttApiKeyProviderNames(): string[] {
+  const llmSet = new Set<string>(LLM_AND_SEARCH_API_KEY_PROVIDERS);
+  return listSttCredentialProviderNames().filter((name) => !llmSet.has(name));
+}
+
+// ---------------------------------------------------------------------------
+// TTS catalog-derived providers
+// ---------------------------------------------------------------------------
+
+/**
+ * The credential-store key prefix used by the namespaced credential type.
+ * Secrets stored under this prefix use the `credential` secret type
+ * (`assistant credentials set ...`) rather than the `api_key` type
+ * (`assistant keys set ...`), so they are excluded from the API-key
+ * provider list.
+ */
+const CREDENTIAL_KEY_PREFIX = "credential/";
+
+/**
+ * Derive the set of TTS bare-name credential store keys that use the
+ * `api_key` secret type by inspecting the catalog's secret requirements.
+ *
+ * A TTS provider entry is API-key-addressable when it declares at least
+ * one secret whose `credentialStoreKey` is a bare name (i.e. does NOT
+ * start with the `credential/` prefix). The bare key name is returned
+ * rather than the provider ID because the key name is what appears in
+ * the credential store (e.g. `deepgram` not `deepgram-tts`).
+ */
+function catalogApiKeyNames(): string[] {
+  return listCatalogProviders()
+    .filter((entry) =>
+      entry.secretRequirements.some(
+        (s) => !s.credentialStoreKey.startsWith(CREDENTIAL_KEY_PREFIX),
+      ),
+    )
+    .flatMap((entry) =>
+      entry.secretRequirements
+        .filter((s) => !s.credentialStoreKey.startsWith(CREDENTIAL_KEY_PREFIX))
+        .map((s) => s.credentialStoreKey),
+    );
+}
+
+// ---------------------------------------------------------------------------
+// Unified export
+// ---------------------------------------------------------------------------
+
+/**
+ * All providers that store API keys in secure storage via the `api_key`
+ * secret type (`assistant keys set <provider> <key>`).
+ *
+ * This is the **single authoritative list** consumed by:
+ * - Config loader (validation of provider names in `config.json`)
+ * - Secret routes (HTTP API key add / read / delete validation)
+ * - CLI `keys` command (help text, list iteration)
+ * - Provider availability checks
+ *
+ * Adding a new TTS provider to the catalog with a bare-name secret
+ * requirement automatically includes it here. Adding a new STT
+ * provider to the STT catalog automatically includes it here (shared
+ * credential names like `openai` are deduplicated against the LLM
+ * list). Shared credential names across STT and TTS (e.g. `deepgram`)
+ * are deduplicated so the list contains no duplicates. Adding a new
+ * LLM or search provider requires appending to
+ * {@link LLM_AND_SEARCH_API_KEY_PROVIDERS} until those domains get
+ * their own catalog modules.
+ */
+export const API_KEY_PROVIDERS: readonly string[] = (() => {
+  const seen = new Set<string>();
+  const result: string[] = [];
+
+  for (const name of [
+    ...LLM_AND_SEARCH_API_KEY_PROVIDERS,
+    ...sttApiKeyProviderNames(),
+    ...catalogApiKeyNames(),
+  ]) {
+    if (!seen.has(name)) {
+      seen.add(name);
+      result.push(name);
+    }
+  }
+
+  return result;
+})();

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

@@ -4,7 +4,9 @@
  * and response extraction helpers.
  */
 
+import { resolveCallSiteConfig } from "../config/llm-resolver.js";
 import { getConfig } from "../config/loader.js";
+import type { LLMCallSite } from "../config/schemas/llm.js";
 import {
   getProvider,
   initializeProviders,
@@ -18,6 +20,10 @@ import type {
   ToolUseContent,
 } from "./types.js";
 
+// Re-export the typed context-overflow error so callsites that dispatch on
+// this category do not need to reach into `./types.js` directly.
+export { ContextOverflowError, isContextOverflowError } from "./types.js";
+
 export interface ConfiguredProviderResult {
   provider: Provider;
   configuredProviderName: string;
@@ -36,9 +42,17 @@ let lazyInitPromise: Promise<void> | null = null;
  * If providers haven't been initialized yet (e.g. non-daemon code paths),
  * 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.
+ *
  * Returns `null` when no providers are available at all.
  */
-export async function resolveConfiguredProvider(): Promise<ConfiguredProviderResult | null> {
+export async function resolveConfiguredProvider(
+  callSite: LLMCallSite,
+): Promise<ConfiguredProviderResult | null> {
   const config = getConfig();
 
   if (listProviders().length === 0) {
@@ -54,7 +68,7 @@ export async function resolveConfiguredProvider(): Promise<ConfiguredProviderRes
     }
   }
 
-  const inferenceProvider = config.services.inference.provider;
+  const inferenceProvider = resolveCallSiteConfig(callSite, config.llm).provider;
 
   try {
     const provider = getProvider(inferenceProvider);
@@ -72,10 +86,13 @@ export async function resolveConfiguredProvider(): Promise<ConfiguredProviderRes
  * Thin wrapper around `resolveConfiguredProvider()` for callsites
  * that only need the Provider instance.
  *
- * Returns `null` when no providers are available.
+ * `callSite` is required — see `resolveConfiguredProvider`. Returns `null`
+ * when no providers are available.
  */
-export async function getConfiguredProvider(): Promise<Provider | null> {
-  const result = await resolveConfiguredProvider();
+export async function getConfiguredProvider(
+  callSite: LLMCallSite,
+): Promise<Provider | null> {
+  const result = await resolveConfiguredProvider(callSite);
   return result?.provider ?? null;
 }
 

package/src/providers/ratelimit.ts

@@ -14,6 +14,10 @@ const log = getLogger("rate-limit");
 export class RateLimitProvider implements Provider {
   public readonly name: string;
 
+  get tokenEstimationProvider(): string | undefined {
+    return this.inner.tokenEstimationProvider;
+  }
+
   private requestTimestamps: number[];
 
   constructor(

package/src/providers/registry.ts

@@ -7,9 +7,10 @@ import {
   buildManagedBaseUrl,
   resolveManagedProxyContext,
 } from "./managed-proxy/context.js";
+import { isModelInCatalog } from "./model-catalog.js";
 import { getProviderDefaultModel } from "./model-intents.js";
 import { OllamaProvider } from "./ollama/client.js";
-import { OpenAIProvider } from "./openai/client.js";
+import { OpenAIResponsesProvider } from "./openai/client.js";
 import { OpenRouterProvider } from "./openrouter/client.js";
 import { RetryProvider } from "./retry.js";
 import type { Provider } from "./types.js";
@@ -51,8 +52,6 @@ export interface ProvidersConfig {
   services: {
     inference: {
       mode: "managed" | "your-own";
-      provider: string;
-      model: string;
     };
     "image-generation": {
       mode: "managed" | "your-own";
@@ -64,18 +63,28 @@ export interface ProvidersConfig {
       provider: string;
     };
   };
+  llm: {
+    default: {
+      provider: string;
+      model: string;
+    };
+  };
   timeouts?: { providerStreamTimeoutSec?: number };
 }
 
 function resolveModel(config: ProvidersConfig, providerName: string): string {
-  const inferenceProvider = config.services.inference.provider;
-  const inferenceModel = config.services.inference.model;
+  const inferenceProvider = config.llm.default.provider;
+  const inferenceModel = config.llm.default.model;
   if (inferenceProvider === providerName) {
-    // If a non-Anthropic provider is selected with the untouched global default
-    // model, use a provider-appropriate fallback instead.
+    // If a non-Anthropic provider is selected but the configured model is
+    // still an Anthropic catalog model (current or previous default), use a
+    // provider-appropriate fallback instead. Checking the full Anthropic
+    // catalog rather than only the current default prevents stale persisted
+    // defaults (e.g. claude-opus-4-6) from being sent to non-Anthropic APIs
+    // after the catalog default changes.
     if (
       providerName !== "anthropic" &&
-      inferenceModel === getProviderDefaultModel("anthropic")
+      isModelInCatalog("anthropic", inferenceModel)
     ) {
       return getProviderDefaultModel(providerName);
     }
@@ -174,7 +183,8 @@ export async function initializeProviders(
     registerProvider(
       "openai",
       new RetryProvider(
-        new OpenAIProvider(openaiCreds.apiKey, model, {
+        new OpenAIResponsesProvider(openaiCreds.apiKey, model, {
+          useNativeWebSearch,
           streamTimeoutMs,
           ...(openaiCreds.baseURL ? { baseURL: openaiCreds.baseURL } : {}),
         }),
@@ -203,7 +213,7 @@ export async function initializeProviders(
 
   // Ollama (keyless provider — always init when configured or key present)
   const ollamaKey = await getProviderKeyAsync("ollama");
-  if (config.services.inference.provider === "ollama" || ollamaKey) {
+  if (config.llm.default.provider === "ollama" || ollamaKey) {
     const model = resolveModel(config, "ollama");
     registerProvider(
       "ollama",
@@ -240,6 +250,7 @@ export async function initializeProviders(
       "openrouter",
       new RetryProvider(
         new OpenRouterProvider(openrouterKey, model, {
+          useNativeWebSearch,
           streamTimeoutMs,
         }),
       ),