@vellumai/assistant 0.6.4 → 0.6.5

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

@@ -14,6 +14,46 @@ import type {
   SendMessageOptions,
   ToolDefinition,
 } from "../types.js";
+import {
+  ContextOverflowError,
+  extractOverflowTokensFromMessage,
+} from "../types.js";
+
+/**
+ * Detect OpenAI-compatible context-overflow signals on an `OpenAI.APIError`.
+ *
+ * OpenAI proper returns HTTP 400 with body
+ *   `{ error: { code: "context_length_exceeded", message, ... } }`
+ * Other OpenAI-compatible providers (OpenRouter, Fireworks, Ollama, etc.)
+ * forward similar shapes; not all populate `code` so we also probe the
+ * message/param fields. Returns an object with any extractable token counts
+ * when the error matches, or `null` when it does not.
+ *
+ * Most OpenAI-compatible providers do not report `actualTokens`/`maxTokens`
+ * in the error body, but the typed wrapper is still valuable as a stable
+ * signal for the agent loop.
+ */
+export function detectOpenAICompatibleContextOverflow(
+  error: InstanceType<typeof OpenAI.APIError>,
+): { actualTokens?: number; maxTokens?: number } | null {
+  // OpenAI-compatible providers use 400 (most) or 413 (rarer payload-too-large).
+  const status = error.status;
+  if (status !== 400 && status !== 413) return null;
+  const code = error.code;
+  const codeMatches =
+    typeof code === "string" &&
+    /context_length_exceeded|context_window_exceeded|input_too_long|prompt_too_long/i.test(
+      code,
+    );
+  const message = error.message ?? "";
+  const messageMatches =
+    /context.?length.?exceeded|context.?window.?exceeded|prompt.?is.?too.?long|prompt_too_long|input.?too.?long|too.?many.?(?:input.?)?tokens|maximum.?context/i.test(
+      message,
+    );
+  if (!codeMatches && !messageMatches) return null;
+  // OpenAI-compatible providers rarely report usable token counts; best-effort extract.
+  return extractOverflowTokensFromMessage(message);
+}
 
 export interface OpenAIChatCompletionsProviderOptions {
   baseURL?: string;
@@ -24,7 +64,9 @@ export interface OpenAIChatCompletionsProviderOptions {
   extraCreateParams?: Record<string, unknown>;
 }
 
-/** Map our internal effort values to OpenAI's reasoning_effort parameter. */
+/** 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. */
 const EFFORT_TO_REASONING_EFFORT: Record<
   string,
   NonNullable<
@@ -34,6 +76,7 @@ const EFFORT_TO_REASONING_EFFORT: Record<
   low: "low",
   medium: "medium",
   high: "high",
+  xhigh: "high",
   max: "high",
 };
 
@@ -256,6 +299,19 @@ export class OpenAIChatCompletionsProvider implements Provider {
           ? signal.reason
           : undefined;
       if (error instanceof OpenAI.APIError) {
+        const overflow = detectOpenAICompatibleContextOverflow(error);
+        if (overflow) {
+          throw new ContextOverflowError(
+            `${this.providerLabel} API error (${error.status}): ${error.message}`,
+            this.name,
+            {
+              actualTokens: overflow.actualTokens,
+              maxTokens: overflow.maxTokens,
+              statusCode: error.status,
+              cause: error,
+            },
+          );
+        }
         const retryAfterMs = extractRetryAfterMs(error.headers);
         const errorOptions: {
           retryAfterMs?: number;

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

@@ -14,19 +14,24 @@ import type {
   SendMessageOptions,
   ToolDefinition,
 } from "../types.js";
+import { ContextOverflowError } from "../types.js";
+import { detectOpenAICompatibleContextOverflow } from "./chat-completions-provider.js";
 
 export interface OpenAIResponsesProviderOptions {
   baseURL?: string;
   providerName?: string;
   providerLabel?: string;
   streamTimeoutMs?: number;
+  useNativeWebSearch?: boolean;
 }
 
-/** Map our internal effort values to the Responses API reasoning.effort parameter. */
+/** 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"> = {
   low: "low",
   medium: "medium",
   high: "high",
+  xhigh: "high",
   max: "high",
 };
 
@@ -75,6 +80,7 @@ export class OpenAIResponsesProvider implements Provider {
   private client: OpenAI;
   private model: string;
   private streamTimeoutMs: number;
+  private useNativeWebSearch: boolean;
 
   constructor(
     apiKey: string,
@@ -89,6 +95,7 @@ export class OpenAIResponsesProvider implements Provider {
     });
     this.model = model;
     this.streamTimeoutMs = options.streamTimeoutMs ?? 1_800_000;
+    this.useNativeWebSearch = options.useNativeWebSearch ?? false;
   }
 
   async sendMessage(
@@ -131,13 +138,31 @@ export class OpenAIResponsesProvider implements Provider {
       }
 
       if (tools && tools.length > 0) {
-        params.tools = tools.map((t) => ({
-          type: "function" as const,
-          name: t.name,
-          description: t.description,
-          parameters: t.input_schema,
-          strict: null,
-        }));
+        if (
+          this.useNativeWebSearch &&
+          tools.some((t) => t.name === "web_search")
+        ) {
+          const otherTools = tools.filter((t) => t.name !== "web_search");
+          const mappedOther = otherTools.map((t) => ({
+            type: "function" as const,
+            name: t.name,
+            description: t.description,
+            parameters: t.input_schema,
+            strict: null,
+          }));
+          const webSearchTool = {
+            type: "web_search_preview" as const,
+          };
+          params.tools = [...mappedOther, webSearchTool];
+        } else {
+          params.tools = tools.map((t) => ({
+            type: "function" as const,
+            name: t.name,
+            description: t.description,
+            parameters: t.input_schema,
+            strict: null,
+          }));
+        }
       }
 
       const { signal: timeoutSignal, cleanup: cleanupTimeout } =
@@ -152,6 +177,8 @@ export class OpenAIResponsesProvider implements Provider {
       >();
       // Maps item_id → callId so we can look up tool calls from delta events.
       const itemIdToCallId = new Map<string, string>();
+      // Track web search call item IDs so we can emit server_tool_complete.
+      const webSearchCallIds: string[] = [];
       let finishReason = "unknown";
       let responseModel = modelOverride ?? this.model;
       let inputTokens = 0;
@@ -195,6 +222,15 @@ export class OpenAIResponsesProvider implements Provider {
                   args: "",
                 });
                 itemIdToCallId.set(itemId, callId);
+              } else if (item?.type === "web_search_call") {
+                const toolUseId = item.id ?? "";
+                webSearchCallIds.push(toolUseId);
+                onEvent?.({
+                  type: "server_tool_start",
+                  name: "web_search",
+                  toolUseId,
+                  input: {},
+                });
               }
               break;
             }
@@ -248,6 +284,14 @@ export class OpenAIResponsesProvider implements Provider {
                 }
                 finishReason = response.status ?? "completed";
               }
+              // Emit server_tool_complete for any web search calls that were started.
+              for (const toolUseId of webSearchCallIds) {
+                onEvent?.({
+                  type: "server_tool_complete",
+                  toolUseId,
+                  isError: false,
+                });
+              }
               break;
             }
           }
@@ -256,8 +300,28 @@ export class OpenAIResponsesProvider implements Provider {
         cleanupTimeout();
       }
 
-      // Build content blocks
+      // Build content blocks.
+      // Inject server_tool_use + web_search_tool_result pairs before text so
+      // conversation history matches the shape Anthropic produces for native
+      // web search. The paired result block prevents repairHistory() from
+      // treating completed searches as interrupted (which would inject a
+      // synthetic web_search_tool_result_error and corrupt history). OpenAI
+      // weaves search results into the text output, so the result content is
+      // an empty array — the actual results are in the text block that follows.
       const content: ContentBlock[] = [];
+      for (const toolUseId of webSearchCallIds) {
+        content.push({
+          type: "server_tool_use",
+          id: toolUseId,
+          name: "web_search",
+          input: {},
+        });
+        content.push({
+          type: "web_search_tool_result",
+          tool_use_id: toolUseId,
+          content: [],
+        });
+      }
       if (contentText) {
         content.push({ type: "text", text: contentText });
       }
@@ -297,6 +361,19 @@ export class OpenAIResponsesProvider implements Provider {
           ? signal.reason
           : undefined;
       if (error instanceof OpenAI.APIError) {
+        const overflow = detectOpenAICompatibleContextOverflow(error);
+        if (overflow) {
+          throw new ContextOverflowError(
+            `${this.providerLabel} API error (${error.status}): ${error.message}`,
+            this.name,
+            {
+              actualTokens: overflow.actualTokens,
+              maxTokens: overflow.maxTokens,
+              statusCode: error.status,
+              cause: error,
+            },
+          );
+        }
         const retryAfterMs = extractRetryAfterMs(error.headers);
         const errorOptions: {
           retryAfterMs?: number;

package/src/providers/openrouter/client.ts

@@ -6,11 +6,13 @@ import type {
   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";
@@ -31,11 +33,51 @@ 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(
@@ -54,6 +96,7 @@ export class OpenRouterProvider extends OpenAIChatCompletionsProvider {
     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
@@ -72,15 +115,31 @@ export class OpenRouterProvider extends OpenAIChatCompletionsProvider {
     options?: SendMessageOptions,
   ): Promise<ProviderResponse> {
     const effectiveModel = this.resolveEffectiveModel(options);
-    if (isAnthropicModel(effectiveModel)) {
-      return this.getAnthropicInner().sendMessage(
-        messages,
-        tools,
-        systemPrompt,
-        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;
     }
-    return super.sendMessage(messages, tools, systemPrompt, options);
   }
 
   // OpenRouter's unified `reasoning` parameter controls extended thinking on
@@ -93,7 +152,14 @@ export class OpenRouterProvider extends OpenAIChatCompletionsProvider {
   ): Record<string, unknown> {
     const config = options?.config as Record<string, unknown> | undefined;
     const thinkingEnabled = config?.thinking !== undefined;
-    return { reasoning: { enabled: thinkingEnabled } };
+    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 {
@@ -114,6 +180,7 @@ export class OpenRouterProvider extends OpenAIChatCompletionsProvider {
           baseURL: toAnthropicMessagesBaseURL(this.resolvedBaseURL),
           streamTimeoutMs: this.providerStreamTimeoutMs,
           authToken: this.openRouterApiKey,
+          useNativeWebSearch: this.useNativeWebSearch,
         },
       );
     }

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-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,6 +7,7 @@ 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 { OpenAIResponsesProvider } from "./openai/client.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);
     }
@@ -175,6 +184,7 @@ export async function initializeProviders(
       "openai",
       new RetryProvider(
         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,
         }),
       ),