@vellumai/assistant 0.8.1 → 0.8.3

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

@@ -60,6 +60,8 @@ export interface OpenAIChatCompletionsProviderOptions {
   providerName?: string;
   providerLabel?: string;
   streamTimeoutMs?: number;
+  /** Provider-level request headers merged into every API request. */
+  requestHeaders?: Record<string, string>;
   /** Extra params spread into every chat.completions.create call (e.g. reasoning). */
   extraCreateParams?: Record<string, unknown>;
   /** Upper bound for `reasoning_effort` sent on the wire. Defaults to "xhigh"
@@ -67,6 +69,10 @@ export interface OpenAIChatCompletionsProviderOptions {
    *  document `low|medium|high` (e.g. Fireworks) should set this to "high" so
    *  Vellum's `xhigh`/`max` tiers don't 4xx upstream. */
   maxReasoningEffort?: "high" | "xhigh";
+  /** Parse `<think>...</think>` tags from the content stream into thinking
+   *  blocks. MiniMax and similar providers embed reasoning inside XML-style
+   *  tags in the regular content field rather than using `reasoning_content`. */
+  parseThinkTags?: boolean;
 }
 
 /** Map our internal effort values to OpenAI's reasoning_effort parameter.
@@ -74,7 +80,7 @@ export interface OpenAIChatCompletionsProviderOptions {
  *  passed through explicitly because OpenAI defaults `reasoning_effort` to
  *  "medium" when the field is omitted — the user's opt-out is only honored
  *  when we send it on the wire. */
-const EFFORT_TO_REASONING_EFFORT: Record<
+export const EFFORT_TO_REASONING_EFFORT: Record<
   string,
   NonNullable<
     OpenAI.Chat.Completions.ChatCompletionCreateParams["reasoning_effort"]
@@ -95,6 +101,13 @@ const OPENAI_SUPPORTED_IMAGE_TYPES = new Set([
   "image/webp",
 ]);
 
+function partialTagSuffix(text: string, tag: string): number {
+  for (let len = Math.min(text.length, tag.length - 1); len > 0; len--) {
+    if (text.endsWith(tag.substring(0, len))) return len;
+  }
+  return 0;
+}
+
 /**
  * OpenAI-compatible chat-completions transport.
  *
@@ -110,6 +123,8 @@ export class OpenAIChatCompletionsProvider implements Provider {
   private streamTimeoutMs: number;
   private extraCreateParams: Record<string, unknown>;
   private maxReasoningEffort: "high" | "xhigh";
+  private requestHeaders: Record<string, string>;
+  private parseThinkTags: boolean;
 
   constructor(
     apiKey: string,
@@ -126,6 +141,8 @@ export class OpenAIChatCompletionsProvider implements Provider {
     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;
   }
 
   async sendMessage(
@@ -159,10 +176,17 @@ export class OpenAIChatCompletionsProvider implements Provider {
         params.max_completion_tokens = maxTokens;
       }
 
+      // Subclasses (OpenRouter) may already have nested effort under
+      // `reasoning.effort` via `buildExtraCreateParams`. Skip the flat
+      // `reasoning_effort` assignment in that case to avoid sending both forms,
+      // which OpenRouter rejects on reasoning models.
+      const nestedReasoningEffort = (
+        params as { reasoning?: { effort?: unknown } }
+      ).reasoning?.effort;
       const reasoningEffort = effort
         ? EFFORT_TO_REASONING_EFFORT[effort]
         : undefined;
-      if (reasoningEffort) {
+      if (reasoningEffort && typeof nestedReasoningEffort !== "string") {
         params.reasoning_effort =
           reasoningEffort === "xhigh" && this.maxReasoningEffort === "high"
             ? "high"
@@ -185,6 +209,68 @@ export class OpenAIChatCompletionsProvider implements Provider {
 
       // Accumulate the response from chunks
       let contentText = "";
+      let reasoningText = "";
+      let insideThinkBlock = false;
+      let pendingContent = "";
+
+      const flushPendingContent = (final: boolean): void => {
+        while (pendingContent.length > 0) {
+          if (insideThinkBlock) {
+            const closeIdx = pendingContent.indexOf("</think>");
+            if (closeIdx >= 0) {
+              const thinking = pendingContent.substring(0, closeIdx);
+              if (thinking) {
+                reasoningText += thinking;
+                onEvent?.({ type: "thinking_delta", thinking });
+              }
+              insideThinkBlock = false;
+              pendingContent = pendingContent.substring(
+                closeIdx + "</think>".length,
+              );
+            } else {
+              const partial = final
+                ? 0
+                : partialTagSuffix(pendingContent, "</think>");
+              const safeLen = pendingContent.length - partial;
+              if (safeLen > 0) {
+                const thinking = pendingContent.substring(0, safeLen);
+                reasoningText += thinking;
+                onEvent?.({ type: "thinking_delta", thinking });
+              }
+              pendingContent =
+                partial > 0 ? pendingContent.substring(safeLen) : "";
+              break;
+            }
+          } else {
+            const openIdx = pendingContent.indexOf("<think>");
+            if (openIdx >= 0) {
+              const text = pendingContent.substring(0, openIdx);
+              if (text) {
+                contentText += text;
+                onEvent?.({ type: "text_delta", text });
+              }
+              insideThinkBlock = true;
+              pendingContent = pendingContent.substring(
+                openIdx + "<think>".length,
+              );
+            } else {
+              const partial = final
+                ? 0
+                : partialTagSuffix(pendingContent, "<think>");
+              const safeLen = pendingContent.length - partial;
+              if (safeLen > 0) {
+                const t = pendingContent.substring(0, safeLen);
+                contentText += t;
+                onEvent?.({ type: "text_delta", text: t });
+              }
+              pendingContent =
+                partial > 0 ? pendingContent.substring(safeLen) : "";
+              break;
+            }
+          }
+        }
+      };
+
       const toolCallMap = new Map<
         number,
         { id: string; name: string; args: string }
@@ -197,10 +283,14 @@ export class OpenAIChatCompletionsProvider implements Provider {
       let cachedPromptTokens = 0;
 
       try {
+        const requestHeaders = {
+          ...this.requestHeaders,
+          ...(usageAttributionHeaders ?? {}),
+        };
         const stream = await this.client.chat.completions.create(params, {
           signal: timeoutSignal,
-          ...(usageAttributionHeaders
-            ? { headers: usageAttributionHeaders }
+          ...(Object.keys(requestHeaders).length > 0
+            ? { headers: requestHeaders }
             : {}),
         });
 
@@ -208,8 +298,62 @@ export class OpenAIChatCompletionsProvider implements Provider {
           const choice = chunk.choices[0];
           if (choice) {
             if (choice.delta.content) {
-              contentText += choice.delta.content;
-              onEvent?.({ type: "text_delta", text: choice.delta.content });
+              if (this.parseThinkTags) {
+                pendingContent += choice.delta.content;
+                flushPendingContent(false);
+              } else {
+                contentText += choice.delta.content;
+                onEvent?.({ type: "text_delta", text: choice.delta.content });
+              }
+            }
+
+            // Compatibility providers disagree on the field name: Fireworks /
+            // DeepSeek / Together / Groq stream `reasoning_content`; OpenRouter
+            // (per its ChatAssistantMessage spec) streams `reasoning`, and for
+            // reasoning summaries (e.g. Kimi K2.6) also populates
+            // `delta.reasoning_details[]` (entries are `reasoning.summary`,
+            // `reasoning.text`, or opaque `reasoning.encrypted`).
+            //
+            // Kimi K2.6 mirrors the same token into BOTH `delta.reasoning` and
+            // `delta.reasoning_details[].text` per chunk — prefer details when
+            // they carry visible text, otherwise fall through to the flat
+            // field. The encrypted-only case must fall through too, so the
+            // flat `reasoning` field isn't silently dropped.
+            const deltaWithReasoning = choice.delta as {
+              reasoning?: string | null;
+              reasoning_content?: string | null;
+              reasoning_details?: Array<{
+                type?: string;
+                summary?: string | null;
+                text?: string | null;
+              }> | null;
+            };
+
+            let sawVisibleDetail = false;
+            const reasoningDetails = deltaWithReasoning.reasoning_details;
+            if (Array.isArray(reasoningDetails)) {
+              for (const entry of reasoningDetails) {
+                if (entry.type === "reasoning.encrypted") continue;
+                const piece = entry.summary ?? entry.text;
+                if (piece) {
+                  sawVisibleDetail = true;
+                  reasoningText += piece;
+                  onEvent?.({ type: "thinking_delta", thinking: piece });
+                }
+              }
+            }
+
+            if (!sawVisibleDetail) {
+              const reasoningContent =
+                deltaWithReasoning.reasoning_content ??
+                deltaWithReasoning.reasoning;
+              if (reasoningContent) {
+                reasoningText += reasoningContent;
+                onEvent?.({
+                  type: "thinking_delta",
+                  thinking: reasoningContent,
+                });
+              }
             }
 
             if (choice.delta.tool_calls) {
@@ -252,10 +396,27 @@ export class OpenAIChatCompletionsProvider implements Provider {
         cleanupTimeout();
       }
 
+      if (this.parseThinkTags && pendingContent) {
+        flushPendingContent(true);
+      }
+
       // Build content blocks
+      const finalReasoning = this.parseThinkTags
+        ? reasoningText.trim()
+        : reasoningText;
+      const finalContent = this.parseThinkTags
+        ? contentText.trim()
+        : contentText;
       const content: ContentBlock[] = [];
-      if (contentText) {
-        content.push({ type: "text", text: contentText });
+      if (finalReasoning) {
+        content.push({
+          type: "thinking",
+          thinking: finalReasoning,
+          signature: "",
+        });
+      }
+      if (finalContent) {
+        content.push({ type: "text", text: finalContent });
       }
       for (const [, tc] of toolCallMap) {
         let input: Record<string, unknown>;

package/src/providers/openrouter/client.ts

@@ -1,6 +1,9 @@
 import { ProviderError } from "../../util/errors.js";
 import { AnthropicProvider } from "../anthropic/client.js";
-import { OpenAIChatCompletionsProvider } from "../openai/chat-completions-provider.js";
+import {
+  EFFORT_TO_REASONING_EFFORT,
+  OpenAIChatCompletionsProvider,
+} from "../openai/chat-completions-provider.js";
 import { isThinkingConfigEnabled } from "../thinking-config.js";
 import type {
   Message,
@@ -18,6 +21,11 @@ export interface OpenRouterProviderOptions {
 }
 
 const DEFAULT_OPENROUTER_BASE_URL = "https://openrouter.ai/api/v1";
+const OPENROUTER_APP_ATTRIBUTION_HEADERS = {
+  "HTTP-Referer": "https://www.vellum.ai",
+  "X-OpenRouter-Title": "Vellum Assistant",
+  "X-OpenRouter-Categories": "personal-agent,cli-agent",
+};
 
 // Models on OpenRouter prefixed `anthropic/` are routed through OpenRouter's
 // Anthropic-compatible Messages API at `<root>/v1/messages` (where `<root>` is
@@ -48,6 +56,25 @@ export function extractOnlyList(config: unknown): string[] {
   return only.filter((x): x is string => typeof x === "string" && x.length > 0);
 }
 
+// OpenRouter's `reasoning.summary` field controls whether reasoning models emit
+// a human-readable summary alongside (or instead of) encrypted reasoning blocks.
+// Models like Kimi K2.6 return only encrypted `reasoning_details` unless a
+// summary level is requested, so the stream carries no visible thinking content.
+// Default to "detailed" so users see thinking by default; allow per-call
+// override via `config.openrouter.reasoning.summary`. Per OpenRouter's
+// ChatRequestReasoning schema, valid values are "auto" | "concise" | "detailed".
+const VALID_REASONING_SUMMARIES = new Set(["auto", "concise", "detailed"]);
+
+function extractReasoningSummaryOverride(config: unknown): string | undefined {
+  const cfg = config as
+    | { openrouter?: { reasoning?: { summary?: unknown } } }
+    | undefined;
+  const summary = cfg?.openrouter?.reasoning?.summary;
+  return typeof summary === "string" && VALID_REASONING_SUMMARIES.has(summary)
+    ? summary
+    : undefined;
+}
+
 /**
  * Rewrite `options.config` for the Anthropic-compat path so OpenRouter's
  * `provider: { only: [...] }` body field travels through `AnthropicProvider`'s
@@ -93,6 +120,7 @@ export class OpenRouterProvider extends OpenAIChatCompletionsProvider {
       providerName: "openrouter",
       providerLabel: "OpenRouter",
       streamTimeoutMs: options.streamTimeoutMs,
+      requestHeaders: OPENROUTER_APP_ATTRIBUTION_HEADERS,
     });
     this.openRouterApiKey = apiKey;
     this.defaultModel = model;
@@ -154,14 +182,30 @@ export class OpenRouterProvider extends OpenAIChatCompletionsProvider {
   // OpenRouter's unified `reasoning` parameter controls extended thinking on
   // its OpenAI-compatible endpoint. Anthropic models skip this path entirely and
   // go through AnthropicProvider, which receives the native `thinking` object.
+  //
+  // `effort` nests under `reasoning` here (rather than flat `reasoning_effort`)
+  // because OpenRouter's documented `ChatRequestReasoning` shape is the union of
+  // { effort, summary }. `summary` is required for models like Kimi K2.6 that
+  // would otherwise return only encrypted reasoning blocks; we default to
+  // "detailed" and let callers override via `config.openrouter.reasoning.summary`.
   protected override buildExtraCreateParams(
     options?: SendMessageOptions,
   ): Record<string, unknown> {
     const config = options?.config as Record<string, unknown> | undefined;
     const thinkingEnabled = isThinkingConfigEnabled(config?.thinking);
-    const extras: Record<string, unknown> = {
-      reasoning: { enabled: thinkingEnabled },
-    };
+    const effort = config?.effort as string | undefined;
+    const mappedEffort = effort
+      ? EFFORT_TO_REASONING_EFFORT[effort]
+      : undefined;
+    const summaryOverride = extractReasoningSummaryOverride(config);
+    const reasoning: Record<string, unknown> = { enabled: thinkingEnabled };
+    if (mappedEffort) {
+      reasoning.effort = mappedEffort;
+    }
+    if (thinkingEnabled) {
+      reasoning.summary = summaryOverride ?? "detailed";
+    }
+    const extras: Record<string, unknown> = { reasoning };
     const only = extractOnlyList(config);
     if (only.length > 0) {
       const existingProvider = (config?.provider ?? {}) as Record<
@@ -192,6 +236,7 @@ export class OpenRouterProvider extends OpenAIChatCompletionsProvider {
           streamTimeoutMs: this.providerStreamTimeoutMs,
           authToken: this.openRouterApiKey,
           useNativeWebSearch: this.useNativeWebSearch,
+          requestHeaders: OPENROUTER_APP_ATTRIBUTION_HEADERS,
         },
       );
     }

package/src/providers/{managed-proxy → platform-proxy}/constants.ts

@@ -25,7 +25,7 @@ export interface ManagedProviderMeta {
  * managed credentials are present; that policy lives in the registry/context
  * fallback allowlists.
  */
-export const MANAGED_PROVIDER_META: Record<string, ManagedProviderMeta> = {
+export const PLATFORM_PROVIDER_META: Record<string, ManagedProviderMeta> = {
   openai: {
     name: "openai",
     managed: true,
@@ -43,11 +43,13 @@ export const MANAGED_PROVIDER_META: Record<string, ManagedProviderMeta> = {
   },
   fireworks: {
     name: "fireworks",
-    managed: false,
+    managed: true,
+    proxyPath: "/v1/runtime-proxy/fireworks",
   },
   openrouter: {
     name: "openrouter",
     managed: false,
   },
   ollama: { name: "ollama", managed: false },
+  "openai-compatible": { name: "openai-compatible", managed: false },
 };

package/src/providers/{managed-proxy → platform-proxy}/context.ts

@@ -12,7 +12,7 @@
 import { getPlatformBaseUrl } from "../../config/env.js";
 import { credentialKey } from "../../security/credential-key.js";
 import { getSecureKeyAsync } from "../../security/secure-keys.js";
-import { MANAGED_PROVIDER_META } from "./constants.js";
+import { PLATFORM_PROVIDER_META } from "./constants.js";
 
 /** Storage key for the assistant API key credential. */
 const ASSISTANT_API_KEY_STORAGE_KEY = credentialKey(
@@ -70,7 +70,7 @@ export async function hasManagedProxyPrereqs(): Promise<boolean> {
 export async function buildManagedBaseUrl(
   provider: string,
 ): Promise<string | undefined> {
-  const meta = MANAGED_PROVIDER_META[provider];
+  const meta = PLATFORM_PROVIDER_META[provider];
   if (!meta?.managed || !meta.proxyPath) return undefined;
 
   const ctx = await resolveManagedProxyContext();
@@ -88,7 +88,7 @@ export async function buildManagedBaseUrl(
 export async function managedFallbackEnabledFor(
   provider: string,
 ): Promise<boolean> {
-  const meta = MANAGED_PROVIDER_META[provider];
+  const meta = PLATFORM_PROVIDER_META[provider];
   if (!meta?.managed) return false;
   return await hasManagedProxyPrereqs();
 }

package/src/providers/provider-availability.ts

@@ -5,9 +5,11 @@
  * environment variable fallbacks, and managed proxy availability.
  */
 
-import { API_KEY_PROVIDERS } from "../config/loader.js";
+import { API_KEY_PROVIDERS, getConfig } from "../config/loader.js";
 import { getProviderKeyAsync } from "../security/secure-keys.js";
-import { managedFallbackEnabledFor } from "./managed-proxy/context.js";
+import { PROVIDER_CATALOG } from "./model-catalog.js";
+import { managedFallbackEnabledFor } from "./platform-proxy/context.js";
+import { getVisibleProviderCatalog } from "./provider-catalog-visibility.js";
 
 /**
  * Check whether a single provider is usable — via a user-provided key
@@ -25,11 +27,24 @@ export async function isProviderAvailable(provider: string): Promise<boolean> {
 /**
  * Build the list of providers that are usable — via a user-provided key
  * (secure storage or env var) or via the managed proxy fallback.
+ * Feature-flagged LLM providers that are currently disabled are excluded.
  * Ollama is always included because it does not require an API key.
  */
 export async function getConfiguredProviders(): Promise<string[]> {
+  // Build the set of LLM providers hidden by feature flags so we can
+  // exclude them while leaving non-LLM providers (search, STT, TTS)
+  // in API_KEY_PROVIDERS unchanged.
+  const allLlmIds = new Set(PROVIDER_CATALOG.map((p) => p.id));
+  const visibleLlmIds = new Set(
+    getVisibleProviderCatalog(getConfig()).map((p) => p.id),
+  );
+  const hiddenLlmIds = new Set(
+    [...allLlmIds].filter((id) => !visibleLlmIds.has(id)),
+  );
+
   const configured: string[] = [];
   for (const p of API_KEY_PROVIDERS) {
+    if (hiddenLlmIds.has(p)) continue;
     if (await isProviderAvailable(p)) {
       configured.push(p);
     }

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

@@ -0,0 +1,38 @@
+/**
+ * Feature-flag-aware provider catalog filtering.
+ *
+ * User-facing catalog consumers (model info, slash commands, provider
+ * availability) use `getVisibleProviderCatalog()` to hide providers and
+ * models gated behind disabled feature flags. Internal consumers
+ * (adapter-factory, pricing, auth) continue using the unfiltered
+ * `PROVIDER_CATALOG` directly.
+ */
+
+import { isAssistantFeatureFlagEnabled } from "../config/assistant-feature-flags.js";
+import type { AssistantConfig } from "../config/schema.js";
+import {
+  PROVIDER_CATALOG,
+  type ProviderCatalogEntry,
+} from "./model-catalog.js";
+
+export function getVisibleProviderCatalog(
+  config: AssistantConfig,
+): ProviderCatalogEntry[] {
+  return PROVIDER_CATALOG.filter(
+    (entry) =>
+      !entry.featureFlag ||
+      isAssistantFeatureFlagEnabled(entry.featureFlag, config),
+  )
+    .map((entry) => {
+      const visibleModels = entry.models.filter(
+        (m) =>
+          !m.featureFlag ||
+          isAssistantFeatureFlagEnabled(m.featureFlag, config),
+      );
+      if (visibleModels.length === entry.models.length) return entry;
+      return { ...entry, models: visibleModels };
+    })
+    .filter(
+      (entry) => entry.models.length > 0 || entry.defaultModel === "",
+    );
+}

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

@@ -7,8 +7,10 @@
 import { resolveCallSiteConfig } from "../config/llm-resolver.js";
 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 { tryResolveProviderForConnectionName } from "./connection-resolution.js";
+import { listConnections } from "./inference/connections.js";
 import { initializeProviders, listProviders } from "./registry.js";
 import type {
   ContentBlock,
@@ -110,22 +112,35 @@ export async function resolveConfiguredProvider(
 
   const resolved = resolveCallSiteConfig(callSite, config.llm, opts);
   const inferenceProvider = resolved.provider;
-  const connectionName = resolved.provider_connection;
+  let connectionName = resolved.provider_connection;
 
   // Connection-aware path: every dispatch goes through `provider_connection`.
   // The boot-time backfill ensures every profile has one in production.
-  // When unset (test envs that skip backfill, freshly-installed configs
-  // not yet backfilled, or users who manually cleared the field), we
-  // return null so callsites with deterministic fallbacks (invite
-  // instructions, telegram username resolution, etc.) keep working.
-  // Hard config errors — connection lookup failure, provider mismatch —
-  // still throw via `tryResolveProviderForConnectionName` below.
+  // 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.
   if (!connectionName) {
-    log.debug(
-      { callSite, inferenceProvider },
-      "resolveCallSiteConfig yielded no provider_connection — returning null so callsite can fall back",
-    );
-    return null;
+    if (inferenceProvider) {
+      try {
+        const candidates = listConnections(getDb(), {
+          provider: inferenceProvider,
+        });
+        const active = candidates.find((c) => c.status === "active");
+        if (active) {
+          connectionName = active.name;
+        }
+      } catch {
+        // DB not available — fall through to the existing null-return path.
+      }
+    }
+    if (!connectionName) {
+      log.debug(
+        { callSite, inferenceProvider },
+        "resolveCallSiteConfig yielded no provider_connection — returning null so callsite can fall back",
+      );
+      return null;
+    }
   }
 
   const connectionProvider = await tryResolveProviderForConnectionName(

package/src/providers/registry.ts

@@ -1,4 +1,6 @@
+import { isAssistantFeatureFlagEnabled } from "../config/assistant-feature-flags.js";
 import { resolveCallSiteConfig } from "../config/llm-resolver.js";
+import type { AssistantConfig } from "../config/schema.js";
 import { type LLMConfig } from "../config/schemas/llm.js";
 import { getProviderKeyAsync } from "../security/secure-keys.js";
 import { ProviderNotConfiguredError } from "../util/errors.js";
@@ -12,12 +14,12 @@ import {
 // ---------------------------------------------------------------------------
 import type { ProviderConnection } from "./inference/auth.js";
 import { resolveAuth } from "./inference/resolve-auth.js";
+import { isModelInCatalog, PROVIDER_CATALOG } from "./model-catalog.js";
+import { getProviderDefaultModel } from "./model-intents.js";
 import {
   buildManagedBaseUrl,
   resolveManagedProxyContext,
-} from "./managed-proxy/context.js";
-import { isModelInCatalog, PROVIDER_CATALOG } from "./model-catalog.js";
-import { getProviderDefaultModel } from "./model-intents.js";
+} from "./platform-proxy/context.js";
 import { RetryProvider } from "./retry.js";
 import type { Provider } from "./types.js";
 import { UsageTrackingProvider } from "./usage-tracking.js";
@@ -26,6 +28,7 @@ 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";
 
 /** Per-connection provider cache, keyed by connection name. */
 const connectionProviders = new Map<string, Provider>();
@@ -69,6 +72,16 @@ export interface ProvidersConfig {
   timeouts?: { providerStreamTimeoutSec?: number };
 }
 
+function isProviderFeatureFlagEnabled(
+  key: string,
+  config: ProvidersConfig,
+): boolean {
+  return isAssistantFeatureFlagEnabled(
+    key,
+    config as unknown as AssistantConfig,
+  );
+}
+
 function resolveModel(config: ProvidersConfig, providerName: string): string {
   const resolved = resolveCallSiteConfig("mainAgent", config.llm);
   const inferenceProvider = resolved.provider;
@@ -92,9 +105,7 @@ function resolveModel(config: ProvidersConfig, providerName: string): string {
  * The routing decision is now derived from credential availability rather than
  * the removed `services.inference.mode` config field.
  */
-async function resolveProviderCredentials(
-  providerName: string,
-): Promise<{
+async function resolveProviderCredentials(providerName: string): Promise<{
   apiKey: string;
   baseURL?: string;
   source: "user-key" | "managed-proxy";
@@ -106,7 +117,11 @@ async function resolveProviderCredentials(
   const managedBaseUrl = await buildManagedBaseUrl(providerName);
   if (managedBaseUrl) {
     const ctx = await resolveManagedProxyContext();
-    return { apiKey: ctx.assistantApiKey, baseURL: managedBaseUrl, source: "managed-proxy" };
+    return {
+      apiKey: ctx.assistantApiKey,
+      baseURL: managedBaseUrl,
+      source: "managed-proxy",
+    };
   }
   return null;
 }
@@ -122,10 +137,19 @@ export async function initializeProviders(
     (config.timeouts?.providerStreamTimeoutSec ?? 1800) * 1000;
   const useNativeWebSearch =
     config.services["web-search"].provider === "inference-provider-native";
-  const mainAgentProvider = resolveCallSiteConfig("mainAgent", config.llm)
-    .provider;
+  const mainAgentProvider = resolveCallSiteConfig(
+    "mainAgent",
+    config.llm,
+  ).provider;
 
   for (const entry of PROVIDER_CATALOG) {
+    if (
+      entry.featureFlag &&
+      !isProviderFeatureFlagEnabled(entry.featureFlag, config)
+    ) {
+      continue;
+    }
+
     const isKeyless = entry.setupMode === "keyless";
 
     // Credential resolution: user key first, managed proxy second. Keyless
@@ -198,10 +222,19 @@ export async function resolveProviderFromConnection(
   connection: ProviderConnection,
   config: ProvidersConfig,
 ): Promise<Provider | null> {
+  if (
+    connection.provider === "openai-compatible" &&
+    !isProviderFeatureFlagEnabled(OPENAI_COMPATIBLE_ENDPOINTS_FLAG, config)
+  ) {
+    return null;
+  }
+
   const cached = connectionProviders.get(connection.name);
   if (cached) return cached;
 
-  const authResult = await resolveAuth(connection.auth, connection.provider);
+  const authResult = await resolveAuth(connection.auth, connection.provider, {
+    baseUrl: connection.baseUrl,
+  });
   if (!authResult.ok) {
     const err = authResult.error;
     if (err.code === "not_implemented") {
@@ -230,11 +263,15 @@ export async function resolveProviderFromConnection(
     config.services["web-search"].provider === "inference-provider-native";
   const model = resolveModel(config, connection.provider);
 
-  const provider = createAdapterFromConnection(connection, authResult.resolved, {
-    model,
-    streamTimeoutMs,
-    useNativeWebSearch,
-  });
+  const provider = createAdapterFromConnection(
+    connection,
+    authResult.resolved,
+    {
+      model,
+      streamTimeoutMs,
+      useNativeWebSearch,
+    },
+  );
 
   if (provider) {
     connectionProviders.set(connection.name, provider);