@vellumai/assistant 0.8.4 → 0.8.6

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

@@ -1,6 +1,5 @@
 import OpenAI from "openai";
 
-import { SYSTEM_PROMPT_CACHE_BOUNDARY } from "../../prompts/cache-boundary.js";
 import { isAbortReason } from "../../util/abort-reasons.js";
 import { ProviderError } from "../../util/errors.js";
 import { extractRetryAfterMs } from "../../util/retry.js";
@@ -55,6 +54,81 @@ export function detectOpenAICompatibleContextOverflow(
   return extractOverflowTokensFromMessage(message);
 }
 
+/**
+ * Build the human-readable error string surfaced from an
+ * `OpenAI.APIError`. The SDK's `error.message` is typically a one-line
+ * summary like `"400 Provider returned error"` — useless when the
+ * upstream is OpenRouter (which wraps the real downstream error on
+ * `error.error.metadata.raw`) or any provider that returns nested
+ * structured details.
+ *
+ * Returns `{ detail, requestId }` where `detail` includes the JSON body
+ * (truncated) and `requestId` is the upstream correlation header when
+ * present. Callers fold these into the thrown `ProviderError` so log
+ * lines actually identify the failure without re-running the request.
+ *
+ * Exported for tests.
+ */
+export function extractApiErrorDetail(
+  error: InstanceType<typeof OpenAI.APIError>,
+): { detail: string; requestId: string | undefined } {
+  const body = (error as { error?: unknown }).error;
+  let detail = "";
+  if (body !== undefined && body !== null) {
+    try {
+      const serialized = typeof body === "string" ? body : JSON.stringify(body);
+      if (serialized && serialized !== "{}") {
+        detail =
+          serialized.length > MAX_API_ERROR_DETAIL_CHARS
+            ? `${serialized.slice(0, MAX_API_ERROR_DETAIL_CHARS)}…`
+            : serialized;
+      }
+    } catch {
+      // Body had a cycle or threw on toJSON — fall through with empty detail.
+    }
+  }
+  const requestId = readHeader(error.headers, [
+    "x-request-id",
+    "x-openrouter-request-id",
+    "openai-request-id",
+    "x-amzn-requestid",
+  ]);
+  return { detail, requestId };
+}
+
+/** Cap on the inline-rendered body to keep log lines readable while still
+ *  surfacing the meaningful upstream payload. Tuned to comfortably hold
+ *  OpenRouter's `error.metadata.raw` strings, which are typically <1KB. */
+const MAX_API_ERROR_DETAIL_CHARS = 2000;
+
+/**
+ * Read the first matching header from an SDK error's headers object,
+ * tolerating both Map-like (`Headers.get()`) and plain-object shapes.
+ * Mirrors the shape-tolerance already in `extractRetryAfterMs`.
+ */
+function readHeader(
+  headers: unknown,
+  names: readonly string[],
+): string | undefined {
+  if (!headers) return undefined;
+  const getter =
+    typeof (headers as { get?: unknown }).get === "function"
+      ? (headers as { get(name: string): string | null }).get.bind(headers)
+      : undefined;
+  for (const name of names) {
+    let value: string | null | undefined;
+    if (getter) {
+      value = getter(name);
+    } else if (typeof headers === "object") {
+      const record = headers as Record<string, unknown>;
+      const raw = record[name] ?? record[name.toLowerCase()];
+      value = typeof raw === "string" ? raw : undefined;
+    }
+    if (typeof value === "string" && value.length > 0) return value;
+  }
+  return undefined;
+}
+
 export interface OpenAIChatCompletionsProviderOptions {
   baseURL?: string;
   providerName?: string;
@@ -76,6 +150,10 @@ export interface OpenAIChatCompletionsProviderOptions {
    *  blocks. MiniMax and similar providers embed reasoning inside XML-style
    *  tags in the regular content field rather than using `reasoning_content`. */
   parseThinkTags?: boolean;
+  /** Wire field used to replay prior assistant thinking on multi-turn requests.
+   *  DeepSeek/Fireworks use `"reasoning_content"`; OpenRouter uses `"reasoning"`.
+   *  When unset, thinking blocks are dropped from outbound assistant messages. */
+  assistantReasoningField?: "reasoning" | "reasoning_content";
 }
 
 /** Wire-level reasoning_effort values. The OpenAI SDK type doesn't include
@@ -147,6 +225,10 @@ export class OpenAIChatCompletionsProvider implements Provider {
   private maxReasoningEffort: "high" | "xhigh" | "max";
   private requestHeaders: Record<string, string>;
   private parseThinkTags: boolean;
+  private assistantReasoningField:
+    | "reasoning"
+    | "reasoning_content"
+    | undefined;
 
   constructor(
     apiKey: string,
@@ -155,16 +237,21 @@ export class OpenAIChatCompletionsProvider implements Provider {
   ) {
     this.name = options.providerName ?? "openai";
     this.providerLabel = options.providerLabel ?? "OpenAI";
+    this.streamTimeoutMs = options.streamTimeoutMs ?? 1_800_000;
+    // Keep the SDK deadline behind our provider stream timeout so
+    // createStreamTimeout owns the user-facing timeout error.
+    const sdkTimeoutMs = this.streamTimeoutMs + 60_000;
     this.client = new OpenAI({
       apiKey,
       baseURL: options.baseURL,
+      timeout: sdkTimeoutMs,
     });
     this.model = model;
-    this.streamTimeoutMs = options.streamTimeoutMs ?? 1_800_000;
     this.extraCreateParams = options.extraCreateParams ?? {};
     this.maxReasoningEffort = options.maxReasoningEffort ?? "xhigh";
     this.requestHeaders = options.requestHeaders ?? {};
     this.parseThinkTags = options.parseThinkTags ?? false;
+    this.assistantReasoningField = options.assistantReasoningField;
   }
 
   async sendMessage(
@@ -521,18 +608,18 @@ export class OpenAIChatCompletionsProvider implements Provider {
           ? signal.reason
           : undefined;
       if (error instanceof OpenAI.APIError) {
+        const { detail, requestId } = extractApiErrorDetail(error);
+        const detailSuffix = detail ? ` ${detail}` : "";
+        const requestIdSuffix = requestId ? ` [request_id=${requestId}]` : "";
+        const formattedMessage = `${this.providerLabel} API error (${error.status}): ${error.message}${detailSuffix}${requestIdSuffix}`;
         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,
-            },
-          );
+          throw new ContextOverflowError(formattedMessage, this.name, {
+            actualTokens: overflow.actualTokens,
+            maxTokens: overflow.maxTokens,
+            statusCode: error.status,
+            cause: error,
+          });
         }
         const retryAfterMs = extractRetryAfterMs(error.headers);
         const errorOptions: {
@@ -543,7 +630,7 @@ export class OpenAIChatCompletionsProvider implements Provider {
           errorOptions.retryAfterMs = retryAfterMs;
         if (abortReason) errorOptions.abortReason = abortReason;
         throw new ProviderError(
-          `${this.providerLabel} API error (${error.status}): ${error.message}`,
+          formattedMessage,
           this.name,
           error.status,
           Object.keys(errorOptions).length > 0 ? errorOptions : undefined,
@@ -593,7 +680,7 @@ export class OpenAIChatCompletionsProvider implements Provider {
     if (systemPrompt) {
       result.push({
         role: "system",
-        content: systemPrompt.replaceAll(SYSTEM_PROMPT_CACHE_BOUNDARY, "\n"),
+        content: systemPrompt,
       });
     }
 
@@ -658,6 +745,7 @@ export class OpenAIChatCompletionsProvider implements Provider {
     msg: Message,
   ): OpenAI.Chat.Completions.ChatCompletionAssistantMessageParam {
     const textParts: string[] = [];
+    const reasoningParts: string[] = [];
     const toolCalls: OpenAI.Chat.Completions.ChatCompletionMessageToolCall[] =
       [];
 
@@ -666,6 +754,10 @@ export class OpenAIChatCompletionsProvider implements Provider {
         case "text":
           textParts.push(block.text);
           break;
+        case "thinking":
+          // Anthropic thinking blocks carry signatures — skip those.
+          if (!block.signature) reasoningParts.push(block.thinking);
+          break;
         case "tool_use":
           toolCalls.push({
             id: block.id,
@@ -682,7 +774,7 @@ export class OpenAIChatCompletionsProvider implements Provider {
         case "web_search_tool_result":
           textParts.push("[Web search results]");
           break;
-        // thinking, redacted_thinking, image — not applicable for OpenAI assistant messages
+        // redacted_thinking, image — not applicable for OpenAI assistant messages
       }
     }
 
@@ -692,6 +784,15 @@ export class OpenAIChatCompletionsProvider implements Provider {
         content: textParts.length > 0 ? textParts.join("") : null,
       };
 
+    if (reasoningParts.length > 0 && this.assistantReasoningField) {
+      (
+        result as OpenAI.Chat.Completions.ChatCompletionAssistantMessageParam & {
+          reasoning?: string;
+          reasoning_content?: string;
+        }
+      )[this.assistantReasoningField] = reasoningParts.join("");
+    }
+
     if (toolCalls.length > 0) {
       result.tool_calls = toolCalls;
     }

package/src/providers/openai/codex-models.ts

@@ -0,0 +1,20 @@
+/**
+ * Model IDs accepted by the ChatGPT Codex subscription endpoint
+ * (`https://chatgpt.com/backend-api/codex`).
+ *
+ * `oauth_subscription` OpenAI connections hard-route every request to that
+ * endpoint, which rejects any model outside this set with HTTP 400. The set
+ * gates whether such a connection may serve a given model during auto-
+ * resolution of an "Any active OpenAI connection" profile.
+ */
+export const CODEX_SUBSCRIPTION_MODEL_IDS: ReadonlySet<string> = new Set([
+  "gpt-5.5",
+  "gpt-5.4",
+  "gpt-5.4-mini",
+  "gpt-5.3-codex",
+]);
+
+/** True when `model` is accepted by the Codex subscription endpoint. */
+export function isCodexSubscriptionModel(model: string): boolean {
+  return CODEX_SUBSCRIPTION_MODEL_IDS.has(model);
+}

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

@@ -1,8 +1,8 @@
 import OpenAI from "openai";
 
-import { SYSTEM_PROMPT_CACHE_BOUNDARY } from "../../prompts/cache-boundary.js";
 import { isAbortReason } from "../../util/abort-reasons.js";
 import { ProviderError } from "../../util/errors.js";
+import { getLogger } from "../../util/logger.js";
 import { extractRetryAfterMs } from "../../util/retry.js";
 import { escapeXmlAttr } from "../../util/xml.js";
 import { createStreamTimeout } from "../stream-timeout.js";
@@ -17,6 +17,8 @@ import type {
 import { ContextOverflowError } from "../types.js";
 import { detectOpenAICompatibleContextOverflow } from "./chat-completions-provider.js";
 
+const log = getLogger("openai-responses");
+
 export interface OpenAIResponsesProviderOptions {
   baseURL?: string;
   providerName?: string;
@@ -24,7 +26,7 @@ export interface OpenAIResponsesProviderOptions {
   streamTimeoutMs?: number;
   useNativeWebSearch?: boolean;
   /** When true, target the Codex subscription endpoint and strip fields it
-   *  rejects (`max_output_tokens`, `metadata`). */
+   *  rejects (`max_output_tokens`). */
   codexSubscription?: boolean;
 }
 
@@ -72,6 +74,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. */
@@ -107,6 +112,7 @@ export class OpenAIResponsesProvider implements Provider {
   private streamTimeoutMs: number;
   private useNativeWebSearch: boolean;
   private codexSubscription: boolean;
+  private lastCodexErrorBody: string | undefined;
 
   constructor(
     apiKey: string,
@@ -116,14 +122,39 @@ export class OpenAIResponsesProvider implements Provider {
     this.name = options.providerName ?? "openai";
     this.providerLabel = options.providerLabel ?? "OpenAI";
     this.codexSubscription = options.codexSubscription ?? false;
+    this.streamTimeoutMs = options.streamTimeoutMs ?? 1_800_000;
+    // Keep the SDK deadline behind our provider stream timeout so
+    // createStreamTimeout owns the user-facing timeout error.
+    const sdkTimeoutMs = this.streamTimeoutMs + 60_000;
     this.client = new OpenAI({
       apiKey,
       baseURL: this.codexSubscription
         ? "https://chatgpt.com/backend-api/codex"
         : options.baseURL,
+      timeout: sdkTimeoutMs,
+      ...(this.codexSubscription
+        ? {
+            fetch: async (url: RequestInfo | URL, init?: RequestInit) => {
+              const res = await globalThis.fetch(url, init);
+              if (!res.ok) {
+                const body = await res.text();
+                this.lastCodexErrorBody = body;
+                log.warn(
+                  { status: res.status, body, url: String(url) },
+                  "Codex endpoint raw error response",
+                );
+                return new Response(body, {
+                  status: res.status,
+                  statusText: res.statusText,
+                  headers: res.headers,
+                });
+              }
+              return res;
+            },
+          }
+        : {}),
     });
     this.model = model;
-    this.streamTimeoutMs = options.streamTimeoutMs ?? 1_800_000;
     this.useNativeWebSearch = options.useNativeWebSearch ?? false;
   }
 
@@ -149,13 +180,11 @@ export class OpenAIResponsesProvider implements Provider {
       const params: Record<string, unknown> = {
         model: modelOverride ?? this.model,
         input,
+        ...(this.codexSubscription ? { store: false } : {}),
       };
 
       if (systemPrompt) {
-        params.instructions = systemPrompt.replaceAll(
-          SYSTEM_PROMPT_CACHE_BOUNDARY,
-          "\n",
-        );
+        params.instructions = systemPrompt;
       }
 
       if (maxTokens && !this.codexSubscription) {
@@ -190,9 +219,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) => ({
@@ -228,20 +257,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) {
@@ -313,7 +348,8 @@ export class OpenAIResponsesProvider implements Provider {
               break;
             }
 
-            case "response.completed": {
+            case "response.completed":
+            case "response.incomplete": {
               const response = event.response;
               if (response) {
                 rawFinalResponse = response;
@@ -328,15 +364,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;
             }
@@ -431,8 +474,22 @@ export class OpenAIResponsesProvider implements Provider {
         if (retryAfterMs !== undefined)
           errorOptions.retryAfterMs = retryAfterMs;
         if (abortReason) errorOptions.abortReason = abortReason;
+        let errorDetail = error.message;
+        if (this.lastCodexErrorBody) {
+          try {
+            const parsed = JSON.parse(this.lastCodexErrorBody);
+            if (parsed.detail) errorDetail = parsed.detail;
+          } catch {
+            errorDetail = this.lastCodexErrorBody.slice(0, 200);
+          }
+          this.lastCodexErrorBody = undefined;
+        }
+        const extras = [error.code, error.type, error.param]
+          .filter(Boolean)
+          .join(", ");
+        const extraSuffix = extras ? ` [${extras}]` : "";
         throw new ProviderError(
-          `${this.providerLabel} API error (${error.status}): ${error.message}`,
+          `${this.providerLabel} API error (${error.status}): ${errorDetail}${extraSuffix}`,
           this.name,
           error.status,
           Object.keys(errorOptions).length > 0 ? errorOptions : undefined,

package/src/providers/openrouter/client.ts

@@ -122,6 +122,7 @@ export class OpenRouterProvider extends OpenAIChatCompletionsProvider {
       providerLabel: "OpenRouter",
       streamTimeoutMs: options.streamTimeoutMs,
       requestHeaders: OPENROUTER_APP_ATTRIBUTION_HEADERS,
+      assistantReasoningField: "reasoning",
     });
     this.openRouterApiKey = apiKey;
     this.defaultModel = model;
@@ -199,17 +200,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/provider-send-message.ts

@@ -9,6 +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 {
+  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";
@@ -116,19 +120,29 @@ 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");
+        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.
@@ -147,6 +161,7 @@ export async function resolveConfiguredProvider(
     connectionName,
     config,
     inferenceProvider,
+    resolved.model,
   );
   if (!connectionProvider) {
     // Soft credential failure — the connection resolved to no usable

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;