@vellumai/assistant 0.8.5 → 0.8.7-dev.202606052118.34cd356

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

@@ -12,7 +12,6 @@ import type {
   Provider,
   ProviderResponse,
   SendMessageOptions,
-  ToolDefinition,
 } from "../types.js";
 import { ContextOverflowError } from "../types.js";
 import { detectOpenAICompatibleContextOverflow } from "./chat-completions-provider.js";
@@ -26,7 +25,7 @@ export interface OpenAIResponsesProviderOptions {
   streamTimeoutMs?: number;
   useNativeWebSearch?: boolean;
   /** When true, target the Codex subscription endpoint and strip fields it
-   *  rejects (`max_output_tokens`, `reasoning`, `text`, `tools`). */
+   *  rejects (`max_output_tokens`). */
   codexSubscription?: boolean;
 }
 
@@ -74,6 +73,9 @@ interface ResponsesStreamEvent {
   response?: {
     model?: string;
     status?: string;
+    incomplete_details?: {
+      reason?: "max_output_tokens" | "content_filter";
+    } | null;
     /** Full output items array — preserved as part of rawResponse for the
      *  LLM context normalizer, which uses its presence to detect Responses
      *  API payloads in stored diagnostics. */
@@ -157,11 +159,9 @@ export class OpenAIResponsesProvider implements Provider {
 
   async sendMessage(
     messages: Message[],
-    tools?: ToolDefinition[],
-    systemPrompt?: string,
     options?: SendMessageOptions,
   ): Promise<ProviderResponse> {
-    const { config, onEvent, signal } = options ?? {};
+    const { tools, systemPrompt, config, onEvent, signal } = options ?? {};
     const configObj = config as Record<string, unknown> | undefined;
     const maxTokens = configObj?.max_tokens as number | undefined;
     const modelOverride = configObj?.model as string | undefined;
@@ -188,24 +188,22 @@ export class OpenAIResponsesProvider implements Provider {
         params.max_output_tokens = maxTokens;
       }
 
-      if (!this.codexSubscription) {
-        const reasoningEffort = effort
-          ? EFFORT_TO_REASONING_EFFORT[effort]
-          : undefined;
-        if (reasoningEffort) {
-          params.reasoning = { effort: reasoningEffort };
-        }
+      const reasoningEffort = effort
+        ? EFFORT_TO_REASONING_EFFORT[effort]
+        : undefined;
+      if (reasoningEffort) {
+        params.reasoning = { effort: reasoningEffort };
+      }
 
-        if (
-          verbosity &&
-          VALID_VERBOSITIES.has(verbosity) &&
-          modelSupportsVerbosity(modelOverride ?? this.model)
-        ) {
-          params.text = { verbosity };
-        }
+      if (
+        verbosity &&
+        VALID_VERBOSITIES.has(verbosity) &&
+        modelSupportsVerbosity(modelOverride ?? this.model)
+      ) {
+        params.text = { verbosity };
       }
 
-      if (tools && tools.length > 0 && !this.codexSubscription) {
+      if (tools && tools.length > 0) {
         if (
           this.useNativeWebSearch &&
           tools.some((t) => t.name === "web_search")
@@ -218,9 +216,9 @@ export class OpenAIResponsesProvider implements Provider {
             parameters: t.input_schema,
             strict: null,
           }));
-          const webSearchTool = {
-            type: "web_search_preview" as const,
-          };
+          const webSearchTool = this.codexSubscription
+            ? { type: "web_search" as const, external_web_access: false }
+            : { type: "web_search_preview" as const };
           params.tools = [...mappedOther, webSearchTool];
         } else {
           params.tools = tools.map((t) => ({
@@ -256,20 +254,26 @@ export class OpenAIResponsesProvider implements Provider {
       let rawFinalResponse: unknown = undefined;
 
       try {
-        // The SDK exposes `client.responses.stream()` — cast through
-        // `unknown` to avoid `any` while the SDK's exported types stabilise.
+        // Use `create()` with `stream: true` instead of the higher-level
+        // `stream()` helper. The `stream()` helper wraps the response in a
+        // `ResponseStream` that runs `maybeParseResponse()` after iteration,
+        // which crashes when the Codex subscription endpoint omits `output`
+        // from the `response.completed` event payload.
         const responsesApi = this.client.responses as unknown as {
-          stream(
+          create(
             p: Record<string, unknown>,
-            o: { signal: AbortSignal; headers?: Record<string, string> },
-          ): AsyncIterable<ResponsesStreamEvent>;
+            o?: { signal?: AbortSignal; headers?: Record<string, string> },
+          ): Promise<AsyncIterable<ResponsesStreamEvent>>;
         };
-        const stream = responsesApi.stream(params, {
-          signal: timeoutSignal,
-          ...(usageAttributionHeaders
-            ? { headers: usageAttributionHeaders }
-            : {}),
-        });
+        const stream = await responsesApi.create(
+          { ...params, stream: true },
+          {
+            signal: timeoutSignal,
+            ...(usageAttributionHeaders
+              ? { headers: usageAttributionHeaders }
+              : {}),
+          },
+        );
 
         for await (const event of stream) {
           switch (event.type) {
@@ -341,7 +345,8 @@ export class OpenAIResponsesProvider implements Provider {
               break;
             }
 
-            case "response.completed": {
+            case "response.completed":
+            case "response.incomplete": {
               const response = event.response;
               if (response) {
                 rawFinalResponse = response;
@@ -356,15 +361,22 @@ export class OpenAIResponsesProvider implements Provider {
                   cachedInputTokens =
                     response.usage.input_tokens_details?.cached_tokens ?? 0;
                 }
-                finishReason = response.status ?? "completed";
+                finishReason =
+                  response.incomplete_details?.reason ??
+                  response.status ??
+                  (event.type === "response.incomplete"
+                    ? "incomplete"
+                    : "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,
-                });
+              if (event.type === "response.completed") {
+                for (const toolUseId of webSearchCallIds) {
+                  onEvent?.({
+                    type: "server_tool_complete",
+                    toolUseId,
+                    isError: false,
+                  });
+                }
               }
               break;
             }
@@ -438,21 +450,6 @@ export class OpenAIResponsesProvider implements Provider {
           ? signal.reason
           : undefined;
       if (error instanceof OpenAI.APIError) {
-        // Temporary diagnostic: log the raw error shape for Codex 400 debugging
-        if (this.codexSubscription) {
-          log.warn(
-            {
-              status: error.status,
-              message: error.message,
-              code: error.code,
-              type: error.type,
-              param: error.param,
-              errorBody: error.error,
-              headers: Object.fromEntries(error.headers?.entries?.() ?? []),
-            },
-            "Codex subscription API error — raw details",
-          );
-        }
         const overflow = detectOpenAICompatibleContextOverflow(error);
         if (overflow) {
           throw new ContextOverflowError(

package/src/providers/openrouter/client.ts

@@ -10,7 +10,6 @@ import type {
   Message,
   ProviderResponse,
   SendMessageOptions,
-  ToolDefinition,
 } from "../types.js";
 import { ContextOverflowError, isContextOverflowError } from "../types.js";
 
@@ -122,6 +121,8 @@ export class OpenRouterProvider extends OpenAIChatCompletionsProvider {
       providerLabel: "OpenRouter",
       streamTimeoutMs: options.streamTimeoutMs,
       requestHeaders: OPENROUTER_APP_ATTRIBUTION_HEADERS,
+      assistantReasoningField: "reasoning",
+      backfillEmptyAssistantContent: true,
     });
     this.openRouterApiKey = apiKey;
     this.defaultModel = model;
@@ -141,8 +142,6 @@ export class OpenRouterProvider extends OpenAIChatCompletionsProvider {
 
   override async sendMessage(
     messages: Message[],
-    tools?: ToolDefinition[],
-    systemPrompt?: string,
     options?: SendMessageOptions,
   ): Promise<ProviderResponse> {
     const effectiveModel = this.resolveEffectiveModel(options);
@@ -150,12 +149,10 @@ export class OpenRouterProvider extends OpenAIChatCompletionsProvider {
       if (isAnthropicModel(effectiveModel)) {
         return await this.getAnthropicInner().sendMessage(
           messages,
-          tools,
-          systemPrompt,
           withOpenRouterBodyExtras(options),
         );
       }
-      return await super.sendMessage(messages, tools, systemPrompt, options);
+      return await super.sendMessage(messages, options);
     } catch (error) {
       // Re-tag delegate-thrown ContextOverflowError so the outer provider name
       // matches the configured provider ("openrouter"). This keeps downstream
@@ -199,17 +196,21 @@ export class OpenRouterProvider extends OpenAIChatCompletionsProvider {
       ? EFFORT_TO_REASONING_EFFORT[effort]
       : undefined;
     const summaryOverride = extractReasoningSummaryOverride(config);
-    const reasoning: Record<string, unknown> = { enabled: thinkingEnabled };
-    if (mappedEffort) {
-      reasoning.effort = clampReasoningEffort(
-        mappedEffort,
-        this.resolveMaxReasoningEffort(this.resolveEffectiveModel(options)),
-      );
-    }
+    // Only send `reasoning` when explicitly enabling thinking. Omitting the
+    // field lets OpenRouter use the model's natural default, which avoids 400s
+    // from reasoning-only models (e.g. DeepSeek R1) that reject `enabled: false`.
+    const extras: Record<string, unknown> = {};
     if (thinkingEnabled) {
+      const reasoning: Record<string, unknown> = { enabled: true };
+      if (mappedEffort) {
+        reasoning.effort = clampReasoningEffort(
+          mappedEffort,
+          this.resolveMaxReasoningEffort(this.resolveEffectiveModel(options)),
+        );
+      }
       reasoning.summary = summaryOverride ?? "detailed";
+      extras.reasoning = reasoning;
     }
-    const extras: Record<string, unknown> = { reasoning };
     const only = extractOnlyList(config);
     if (only.length > 0) {
       const existingProvider = (config?.provider ?? {}) as Record<

package/src/providers/placeholder-sentinels.ts

@@ -0,0 +1,35 @@
+// Internal placeholder sentinels injected as assistant-message content when a
+// turn would otherwise serialize with neither text nor tool calls. Provider
+// request bodies must keep a non-empty content slot (Anthropic to preserve
+// role alternation; strict OpenAI-compatible backends to satisfy the
+// "content or tool_calls must be set" constraint), but these markers must
+// never be persisted or rendered to users.
+//
+// The null-byte prefix makes the prefixed form impossible to produce via
+// normal model output or user input, preventing false positives. Some
+// OpenAI-compatible backends reject control characters in message content, so
+// the OpenAI path emits the bare (prefix-stripped) form, which
+// `isPlaceholderSentinelText` still recognizes.
+export const PLACEHOLDER_EMPTY_TURN =
+  "\x00__PLACEHOLDER__[empty assistant turn]";
+export const PLACEHOLDER_BLOCKS_OMITTED =
+  "\x00__PLACEHOLDER__[internal blocks omitted]";
+
+// Compared against the payload with any leading `\x00` stripped, so the check
+// matches both the prefixed sentinel we emit and any bare variant that lost
+// the null byte in transit (e.g. the model echoing the text back without
+// reproducing the control character).
+const PLACEHOLDER_SENTINEL_BARE: ReadonlySet<string> = new Set([
+  PLACEHOLDER_EMPTY_TURN.slice(1),
+  PLACEHOLDER_BLOCKS_OMITTED.slice(1),
+]);
+
+/**
+ * True when the text is one of the internal alternation-preserving sentinels,
+ * with or without the null-byte prefix. These must never be persisted or
+ * rendered to users — they exist only in outbound provider request bodies.
+ */
+export function isPlaceholderSentinelText(text: string): boolean {
+  const normalized = text.startsWith("\x00") ? text.slice(1) : text;
+  return PLACEHOLDER_SENTINEL_BARE.has(normalized);
+}

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

@@ -9,7 +9,10 @@ import { getConfig } from "../config/loader.js";
 import type { LLMCallSite } from "../config/schemas/llm.js";
 import { getDb } from "../memory/db-connection.js";
 import { getLogger } from "../util/logger.js";
-import { isConnectionCompatibleWithModel } from "./connection-model-compat.js";
+import {
+  describeSubscriptionModelIncompatibility,
+  isConnectionCompatibleWithModel,
+} from "./connection-model-compat.js";
 import { tryResolveProviderForConnectionName } from "./connection-resolution.js";
 import { listConnections } from "./inference/connections.js";
 import { initializeProviders, listProviders } from "./registry.js";
@@ -19,7 +22,6 @@ import type {
   Provider,
   ProviderResponse,
   SendMessageOptions,
-  ToolDefinition,
   ToolUseContent,
 } from "./types.js";
 
@@ -53,16 +55,14 @@ export class CallSiteConfiguredProvider implements Provider {
 
   sendMessage(
     messages: Message[],
-    tools?: ToolDefinition[],
-    systemPrompt?: string,
     options?: SendMessageOptions,
   ): Promise<ProviderResponse> {
     const config = options?.config;
     if (config?.callSite) {
-      return this.inner.sendMessage(messages, tools, systemPrompt, options);
+      return this.inner.sendMessage(messages, options);
     }
 
-    return this.inner.sendMessage(messages, tools, systemPrompt, {
+    return this.inner.sendMessage(messages, {
       ...options,
       config: {
         ...config,
@@ -117,23 +117,32 @@ export async function resolveConfiguredProvider(
 
   // Connection-aware path: every dispatch goes through `provider_connection`.
   // The boot-time backfill ensures every profile has one in production.
-  // When unset (profile set provider with "Any active" connection, test envs
-  // that skip backfill, freshly-installed configs not yet backfilled, or
-  // users who manually cleared the field), try to auto-resolve from the
-  // provider before falling back to null.
+  // When unset (profile set provider without a connection, test envs that
+  // skip backfill, freshly-installed configs not yet backfilled, or users
+  // who manually cleared the field), try to auto-resolve from the provider
+  // before falling back to null.
   if (!connectionName) {
     if (inferenceProvider) {
       try {
         const candidates = listConnections(getDb(), {
           provider: inferenceProvider,
         });
-        const active = candidates.find(
-          (c) =>
-            c.status === "active" &&
-            isConnectionCompatibleWithModel(c, resolved.model),
+        const active = candidates.find((c) =>
+          isConnectionCompatibleWithModel(c, resolved.model),
         );
         if (active) {
           connectionName = active.name;
+        } else {
+          const incompatMsg = describeSubscriptionModelIncompatibility(
+            candidates,
+            resolved.model,
+          );
+          if (incompatMsg) {
+            log.warn(
+              { callSite, inferenceProvider, model: resolved.model },
+              incompatMsg,
+            );
+          }
         }
       } catch {
         // DB not available — fall through to the existing null-return path.

package/src/providers/ratelimit.ts

@@ -6,7 +6,6 @@ import type {
   Provider,
   ProviderResponse,
   SendMessageOptions,
-  ToolDefinition,
 } from "./types.js";
 
 const log = getLogger("rate-limit");
@@ -36,8 +35,6 @@ export class RateLimitProvider implements Provider {
 
   async sendMessage(
     messages: Message[],
-    tools?: ToolDefinition[],
-    systemPrompt?: string,
     options?: SendMessageOptions,
   ): Promise<ProviderResponse> {
     this.enforceRequestRate();
@@ -46,12 +43,7 @@ export class RateLimitProvider implements Provider {
     // calls from bypassing the rate limit during the async gap.
     this.recordRequest();
 
-    const response = await this.inner.sendMessage(
-      messages,
-      tools,
-      systemPrompt,
-      options,
-    );
+    const response = await this.inner.sendMessage(messages, options);
 
     return response;
   }

package/src/providers/registry.ts

@@ -29,10 +29,18 @@ const log = getLogger("provider-registry");
 const providers = new Map<string, Provider>();
 const routingSources = new Map<string, "user-key" | "managed-proxy">();
 const OPENAI_COMPATIBLE_ENDPOINTS_FLAG = "openai-compatible-endpoints";
+const NATIVE_WEB_SEARCH_PROVIDER_IDS = new Set(["anthropic", "openai"]);
 
-/** Per-connection provider cache, keyed by connection name. */
+/** Per-connection provider cache, keyed by connection name and model. */
 const connectionProviders = new Map<string, Provider>();
 
+function getConnectionProviderCacheKey(
+  connection: ProviderConnection,
+  model: string,
+): string {
+  return `${connection.name}\u0000${model}`;
+}
+
 function registerProvider(name: string, provider: Provider): void {
   providers.set(name, new UsageTrackingProvider(provider));
 }
@@ -98,6 +106,30 @@ function resolveModel(config: ProvidersConfig, providerName: string): string {
   return getProviderDefaultModel(providerName);
 }
 
+export function isNativeWebSearchCapableProvider(
+  providerName: string,
+  model: string,
+): boolean {
+  if (NATIVE_WEB_SEARCH_PROVIDER_IDS.has(providerName)) {
+    return true;
+  }
+  if (providerName === "openrouter" && model.startsWith("anthropic/")) {
+    return true;
+  }
+  return false;
+}
+
+function shouldUseNativeWebSearch(
+  config: ProvidersConfig,
+  providerName: string,
+  model: string,
+): boolean {
+  return (
+    config.services["web-search"].provider === "inference-provider-native" &&
+    isNativeWebSearchCapableProvider(providerName, model)
+  );
+}
+
 /**
  * Resolve provider credentials. User key takes precedence; managed proxy is
  * used as a fallback when platform prerequisites are available.
@@ -135,8 +167,6 @@ export async function initializeProviders(
 
   const streamTimeoutMs =
     (config.timeouts?.providerStreamTimeoutSec ?? 1800) * 1000;
-  const useNativeWebSearch =
-    config.services["web-search"].provider === "inference-provider-native";
   const mainAgentProvider = resolveCallSiteConfig(
     "mainAgent",
     config.llm,
@@ -174,6 +204,11 @@ export async function initializeProviders(
     }
 
     const model = resolveModel(config, entry.id);
+    const useNativeWebSearch = shouldUseNativeWebSearch(
+      config,
+      entry.id,
+      model,
+    );
     const adapter = buildProviderAdapter(entry.id, {
       apiKey,
       model,
@@ -221,6 +256,7 @@ export async function initializeProviders(
 export async function resolveProviderFromConnection(
   connection: ProviderConnection,
   config: ProvidersConfig,
+  opts: { model?: string } = {},
 ): Promise<Provider | null> {
   if (
     connection.provider === "openai-compatible" &&
@@ -229,7 +265,9 @@ export async function resolveProviderFromConnection(
     return null;
   }
 
-  const cached = connectionProviders.get(connection.name);
+  const model = opts.model ?? resolveModel(config, connection.provider);
+  const cacheKey = getConnectionProviderCacheKey(connection, model);
+  const cached = connectionProviders.get(cacheKey);
   if (cached) return cached;
 
   const authResult = await resolveAuth(connection.auth, connection.provider, {
@@ -259,9 +297,11 @@ export async function resolveProviderFromConnection(
 
   const streamTimeoutMs =
     (config.timeouts?.providerStreamTimeoutSec ?? 1800) * 1000;
-  const useNativeWebSearch =
-    config.services["web-search"].provider === "inference-provider-native";
-  const model = resolveModel(config, connection.provider);
+  const useNativeWebSearch = shouldUseNativeWebSearch(
+    config,
+    connection.provider,
+    model,
+  );
 
   const provider = createAdapterFromConnection(
     connection,
@@ -274,7 +314,7 @@ export async function resolveProviderFromConnection(
   );
 
   if (provider) {
-    connectionProviders.set(connection.name, provider);
+    connectionProviders.set(cacheKey, provider);
   }
 
   return provider;

package/src/providers/retry.ts

@@ -23,7 +23,6 @@ import {
   type Provider,
   type ProviderResponse,
   type SendMessageOptions,
-  type ToolDefinition,
 } from "./types.js";
 
 const log = getLogger("retry");
@@ -34,6 +33,7 @@ const USAGE_ATTRIBUTION_HEADER_NAMES = {
   inferenceProfileSource: "X-Vellum-Inference-Profile-Source",
   resolvedProvider: "X-Vellum-Resolved-Provider",
   resolvedModel: "X-Vellum-Resolved-Model",
+  resolvedMixArm: "X-Vellum-Resolved-Mix-Arm",
 } as const;
 
 /** Providers that support the `effort` config (extended thinking / reasoning). */
@@ -195,19 +195,23 @@ function normalizeSendMessageOptions(
   delete nextConfig.usageAttributionHeaders;
   delete nextConfig.usageTracking;
 
-  // `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`.
+  // `overrideProfile` and `selectionSeed` are routing/resolution-time concerns
+  // (consumed by the resolver below and `CallSiteRoutingProvider`'s provider
+  // selection); neither is a wire-format field. Strip unconditionally so they
+  // never leak into provider request bodies even when callers set them without
+  // a `callSite`.
   delete nextConfig.overrideProfile;
+  delete nextConfig.selectionSeed;
 
   if (config.callSite !== undefined) {
     const resolved = resolveCallSiteConfig(config.callSite, getConfig().llm, {
       overrideProfile: config.overrideProfile,
+      selectionSeed: config.selectionSeed,
     });
     const attribution = resolveUsageAttribution({
       callSite: config.callSite,
       overrideProfile: config.overrideProfile,
+      selectionSeed: config.selectionSeed,
     });
 
     const explicitModel =
@@ -225,6 +229,7 @@ function normalizeSendMessageOptions(
         profileSource: attribution.profileSource,
         resolvedProvider: attribution.resolvedProvider,
         resolvedModel: attribution.resolvedModel,
+        resolvedMixArm: attribution.resolvedMixArm,
       });
       if (Object.keys(usageAttributionHeaders).length > 0) {
         nextConfig.usageAttributionHeaders = usageAttributionHeaders;
@@ -446,6 +451,7 @@ function buildUsageAttributionHeaders(input: {
   profileSource: string;
   resolvedProvider: string;
   resolvedModel: string;
+  resolvedMixArm: string | null;
 }): Record<string, string> {
   const headers: Record<string, string> = {};
   addSanitizedHeader(
@@ -475,6 +481,11 @@ function buildUsageAttributionHeaders(input: {
     USAGE_ATTRIBUTION_HEADER_NAMES.resolvedModel,
     input.resolvedModel,
   );
+  addSanitizedHeader(
+    headers,
+    USAGE_ATTRIBUTION_HEADER_NAMES.resolvedMixArm,
+    input.resolvedMixArm,
+  );
   return headers;
 }
 
@@ -513,8 +524,6 @@ export class RetryProvider implements Provider {
 
   async sendMessage(
     messages: Message[],
-    tools?: ToolDefinition[],
-    systemPrompt?: string,
     options?: SendMessageOptions,
   ): Promise<ProviderResponse> {
     let lastError: unknown;
@@ -529,8 +538,6 @@ export class RetryProvider implements Provider {
       try {
         const result = await this.inner.sendMessage(
           messages,
-          tools,
-          systemPrompt,
           normalizedOptions,
         );
         return result;

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

@@ -42,8 +42,17 @@ export interface SearchProviderCatalogEntry {
    * privacy notices). Defaults to {@link displayName} when omitted.
    */
   readonly displayNameLong?: string;
-  /** Authentication style. `managed` providers are routed through the
-   *  inference provider; `byok` providers require a user-supplied key. */
+  /**
+   * Authentication style for the search provider choice.
+   *
+   * `managed` means the choice does not require a user-supplied search API key.
+   * For `inference-provider-native`, the daemon uses the inference API's native
+   * hosted web-search tool only when the selected inference provider/model
+   * supports it. Managed non-native inference providers keep the app-executed
+   * `web_search` tool, which can route through the platform search proxy.
+   *
+   * `byok` providers require a user-supplied key in Your Own mode.
+   */
   readonly kind: SearchProviderKind;
   /** Placeholder shown in the API-key input. BYOK providers only. */
   readonly apiKeyPrefix?: string;
@@ -99,19 +108,18 @@ export const SEARCH_PROVIDER_CATALOG: readonly SearchProviderCatalogEntry[] = [
 ];
 
 /** Provider ids accepted by the web-search config schema. */
-export const SEARCH_PROVIDER_IDS: readonly string[] = SEARCH_PROVIDER_CATALOG.map(
-  (p) => p.id,
-);
+export const SEARCH_PROVIDER_IDS: readonly string[] =
+  SEARCH_PROVIDER_CATALOG.map((p) => p.id);
 
 /** Catalog entries that store an API key under their bare provider name. */
 export const BYOK_SEARCH_PROVIDERS: readonly SearchProviderCatalogEntry[] =
   SEARCH_PROVIDER_CATALOG.filter((p) => p.kind === "byok");
 
 /** BYOK provider ids, ordered by `fallbackOrder` (ascending). */
-export const SEARCH_PROVIDER_FALLBACK_ORDER: readonly string[] = BYOK_SEARCH_PROVIDERS
-  .slice()
-  .sort((a, b) => (a.fallbackOrder ?? 0) - (b.fallbackOrder ?? 0))
-  .map((p) => p.id);
+export const SEARCH_PROVIDER_FALLBACK_ORDER: readonly string[] =
+  BYOK_SEARCH_PROVIDERS.slice()
+    .sort((a, b) => (a.fallbackOrder ?? 0) - (b.fallbackOrder ?? 0))
+    .map((p) => p.id);
 
 /** Look up a single catalog entry by id. Returns `undefined` if unknown. */
 export function getSearchProvider(