@vellumai/assistant 0.8.0 → 0.8.1

package/src/providers/model-catalog.ts

@@ -1,8 +1,37 @@
+import { MANAGED_PROVIDER_META } from "./managed-proxy/constants.js";
+
 export type LongContextMode =
   | "native-model"
   | "provider-request-option"
   | "unsupported";
 
+export interface CatalogModelPricingTier {
+  /**
+   * Threshold in total prompt input tokens above which this tier's rates
+   * apply. The largest matched threshold wins when usage exceeds multiple
+   * tiers (single-step staircase, not progressive bracketing).
+   */
+  inputTokenThreshold: number;
+  inputPer1mTokens: number;
+  outputPer1mTokens: number;
+  cacheReadPer1mTokens?: number;
+  cacheWritePer1mTokens?: number;
+}
+
+export interface CatalogModelPricing {
+  inputPer1mTokens: number;
+  outputPer1mTokens: number;
+  cacheWritePer1mTokens?: number;
+  cacheReadPer1mTokens?: number;
+  /**
+   * Optional long-context pricing tiers. Selected by total prompt input
+   * tokens. When set, the base fields above apply at the low-context tier
+   * (below every tier threshold) and tier entries override at higher
+   * thresholds.
+   */
+  tiers?: CatalogModelPricingTier[];
+}
+
 export interface CatalogModel {
   id: string;
   displayName: string;
@@ -15,12 +44,7 @@ export interface CatalogModel {
   supportsCaching?: boolean;
   supportsVision?: boolean;
   supportsToolUse?: boolean;
-  pricing?: {
-    inputPer1mTokens: number;
-    outputPer1mTokens: number;
-    cacheWritePer1mTokens?: number;
-    cacheReadPer1mTokens?: number;
-  };
+  pricing?: CatalogModelPricing;
 }
 
 const DEFAULT_CONTEXT_WINDOW_TOKENS = 200000;
@@ -64,6 +88,15 @@ export interface ProviderCatalogEntry {
     url: string;
     linkLabel: string;
   };
+  /**
+   * Whether this provider supports the `platform` auth type (Vellum-managed
+   * keys routed through the platform proxy). Derived from
+   * `MANAGED_PROVIDER_META` at catalog build time so the two stay in lock
+   * step. Clients use this field to hide the "Platform (managed by Vellum)"
+   * option from the auth-type dropdown for providers like Fireworks or
+   * OpenRouter where managed keys are not available.
+   */
+  supportsManagedAuth?: boolean;
 }
 
 /**
@@ -201,6 +234,15 @@ const RAW_PROVIDER_CATALOG: ProviderCatalogEntry[] = [
           inputPer1mTokens: 5.0,
           outputPer1mTokens: 30.0,
           cacheReadPer1mTokens: 0.5,
+          tiers: [
+            {
+              inputTokenThreshold:
+                OPENAI_LONG_CONTEXT_PRICING_THRESHOLD_TOKENS,
+              inputPer1mTokens: 10,
+              outputPer1mTokens: 45,
+              cacheReadPer1mTokens: 1,
+            },
+          ],
         },
       },
       {
@@ -217,6 +259,14 @@ const RAW_PROVIDER_CATALOG: ProviderCatalogEntry[] = [
         pricing: {
           inputPer1mTokens: 30.0,
           outputPer1mTokens: 180.0,
+          tiers: [
+            {
+              inputTokenThreshold:
+                OPENAI_LONG_CONTEXT_PRICING_THRESHOLD_TOKENS,
+              inputPer1mTokens: 60,
+              outputPer1mTokens: 270,
+            },
+          ],
         },
       },
       {
@@ -234,6 +284,15 @@ const RAW_PROVIDER_CATALOG: ProviderCatalogEntry[] = [
           inputPer1mTokens: 2.5,
           outputPer1mTokens: 15.0,
           cacheReadPer1mTokens: 0.25,
+          tiers: [
+            {
+              inputTokenThreshold:
+                OPENAI_LONG_CONTEXT_PRICING_THRESHOLD_TOKENS,
+              inputPer1mTokens: 5,
+              outputPer1mTokens: 22.5,
+              cacheReadPer1mTokens: 0.5,
+            },
+          ],
         },
       },
       {
@@ -315,6 +374,14 @@ const RAW_PROVIDER_CATALOG: ProviderCatalogEntry[] = [
           inputPer1mTokens: 2.0,
           outputPer1mTokens: 12.0,
           cacheReadPer1mTokens: 0.2,
+          tiers: [
+            {
+              inputTokenThreshold: 200_000,
+              inputPer1mTokens: 4,
+              outputPer1mTokens: 18,
+              cacheReadPer1mTokens: 0.4,
+            },
+          ],
         },
       },
       {
@@ -331,6 +398,14 @@ const RAW_PROVIDER_CATALOG: ProviderCatalogEntry[] = [
           inputPer1mTokens: 2.0,
           outputPer1mTokens: 12.0,
           cacheReadPer1mTokens: 0.2,
+          tiers: [
+            {
+              inputTokenThreshold: 200_000,
+              inputPer1mTokens: 4,
+              outputPer1mTokens: 18,
+              cacheReadPer1mTokens: 0.4,
+            },
+          ],
         },
       },
       {
@@ -407,6 +482,14 @@ const RAW_PROVIDER_CATALOG: ProviderCatalogEntry[] = [
           inputPer1mTokens: 1.25,
           outputPer1mTokens: 10.0,
           cacheReadPer1mTokens: 0.3125,
+          tiers: [
+            {
+              inputTokenThreshold: 200_000,
+              inputPer1mTokens: 2.5,
+              outputPer1mTokens: 15,
+              cacheReadPer1mTokens: 0.625,
+            },
+          ],
         },
       },
     ],
@@ -761,6 +844,11 @@ export const PROVIDER_CATALOG: ProviderCatalogEntry[] =
   RAW_PROVIDER_CATALOG.map((entry) => ({
     ...entry,
     models: entry.models.map(catalogModel),
+    // Derive supportsManagedAuth from MANAGED_PROVIDER_META so the catalog
+    // and the proxy routing table can never drift. Adding a provider to
+    // MANAGED_PROVIDER_META with `managed: true` automatically opts it into
+    // the Platform auth-type dropdown in the clients.
+    supportsManagedAuth: MANAGED_PROVIDER_META[entry.id]?.managed === true,
   }));
 
 /** Check if a model ID is in the catalog for a given provider. */
@@ -768,3 +856,13 @@ export function isModelInCatalog(provider: string, modelId: string): boolean {
   const entry = PROVIDER_CATALOG.find((p) => p.id === provider);
   return entry?.models.some((m) => m.id === modelId) ?? false;
 }
+
+/** Return the unique catalog provider that owns a model ID, if known. */
+export function getCatalogProviderForModel(
+  modelId: string,
+): string | undefined {
+  const matches = PROVIDER_CATALOG.filter((p) =>
+    p.models.some((m) => m.id === modelId),
+  );
+  return matches.length === 1 ? matches[0]?.id : undefined;
+}

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

@@ -49,9 +49,11 @@ const VALID_VERBOSITIES = new Set<string>(["low", "medium", "high"]);
  *  Responses API (o-series, etc.) reject unknown wire fields with HTTP 400, so
  *  gate forwarding by model name here. The retry layer can't make this call
  *  because verbosity defaults to "medium" in the LLM schema, so every
- *  callSite-resolved request would otherwise carry it regardless of model. */
+ *  callSite-resolved request would otherwise carry it regardless of model.
+ *  Also matches OpenAI fine-tune IDs of the form `ft:gpt-5.x:org::id` so users
+ *  on GPT-5 fine-tunes keep explicit verbosity control. */
 function modelSupportsVerbosity(model: string): boolean {
-  return /^gpt-5(\b|[-.])/i.test(model);
+  return /^(ft:)?gpt-5(\b|[-.])/i.test(model);
 }
 
 /** Loosely-typed Responses stream event to avoid `any` while the SDK types settle. */

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

@@ -6,8 +6,9 @@
  *   1. LLM providers — names come from `PROVIDER_CATALOG` in
  *      `model-catalog.ts`. `getLlmProviderEnvVar` consults the catalog
  *      directly.
- *   2. Search providers — hardcoded in `SEARCH_PROVIDER_ENV_VAR_NAMES`
- *      below. The env var name follows the pattern `${ID}_API_KEY`.
+ *   2. Search providers — names come from `SEARCH_PROVIDER_CATALOG` in
+ *      `search-provider-catalog.ts`. `getSearchProviderEnvVar` consults
+ *      the catalog directly.
  *
  * Use `getLlmProviderEnvVar` when you're scoped to LLM providers,
  * `getSearchProviderEnvVar` when you're scoped to search providers, and
@@ -18,12 +19,21 @@
  * unknown IDs, and providers outside the helper's scope.
  */
 import { PROVIDER_CATALOG } from "./model-catalog.js";
+import { SEARCH_PROVIDER_CATALOG } from "./search-provider-catalog.js";
 
-/** Search-provider env var names. */
-const SEARCH_PROVIDER_ENV_VAR_NAMES: Record<string, string> = {
-  brave: "BRAVE_API_KEY",
-  perplexity: "PERPLEXITY_API_KEY",
-};
+/**
+ * Search-provider env var names, derived from `SEARCH_PROVIDER_CATALOG`.
+ * Adding a BYOK provider to the catalog automatically extends this map —
+ * managed providers (no `envVar`) are filtered out.
+ */
+const SEARCH_PROVIDER_ENV_VAR_NAMES: Record<string, string> = Object.freeze(
+  Object.fromEntries(
+    SEARCH_PROVIDER_CATALOG.filter((p) => p.envVar !== undefined).map((p) => [
+      p.id,
+      p.envVar!,
+    ]),
+  ),
+);
 
 export function getLlmProviderEnvVar(providerId: string): string | undefined {
   return PROVIDER_CATALOG.find((p) => p.id === providerId)?.envVar;

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

@@ -2,13 +2,17 @@
  * Canonical source for API-key-addressable providers.
  *
  * This module composes the full set of providers that store API keys in
- * secure storage (the `api_key` secret type) from three sources:
+ * secure storage (the `api_key` secret type) from four sources:
  *
- * 1. **LLM / search providers** -- statically declared here because they
- *    have no separate catalog module yet.
- * 2. **STT providers** -- dynamically derived from the canonical STT
+ * 1. **LLM providers** -- derived from `PROVIDER_CATALOG`
+ *    (`model-catalog.ts`). Adding a provider to the catalog automatically
+ *    extends the API-key-addressable set.
+ * 2. **Search providers** -- derived from `SEARCH_PROVIDER_CATALOG`
+ *    (`search-provider-catalog.ts`). Adding a BYOK search provider to
+ *    the catalog automatically extends the API-key-addressable set.
+ * 3. **STT providers** -- dynamically derived from the canonical STT
  *    provider catalog by reading credential-provider names.
- * 3. **TTS catalog providers** -- dynamically derived from the canonical
+ * 4. **TTS catalog providers** -- dynamically derived from the canonical
  *    TTS provider catalog by selecting entries whose secret requirements
  *    use the bare-name (non-credential) storage convention.
  *
@@ -18,30 +22,45 @@
  */
 
 import { listCatalogProviders } from "../tts/provider-catalog.js";
+import { PROVIDER_CATALOG } from "./model-catalog.js";
+import { BYOK_SEARCH_PROVIDERS } from "./search-provider-catalog.js";
 import { listCredentialProviderNames as listSttCredentialProviderNames } from "./speech-to-text/provider-catalog.js";
 
 // ---------------------------------------------------------------------------
-// Static LLM / search providers
+// LLM and search providers
 // ---------------------------------------------------------------------------
 
 /**
- * LLM and search providers that store API keys under their bare provider
- * name in the secure credential store (e.g. `anthropic`, `openai`).
+ * LLM providers that store API keys under their bare provider name in the
+ * secure credential store (e.g. `anthropic`, `openai`).
  *
- * These are declared statically because no provider-catalog module exists
- * for them yet. When one is introduced, this array should be replaced with
- * a catalog-derived computation analogous to the TTS logic below.
+ * Derived from `PROVIDER_CATALOG` so that adding a new LLM provider to the
+ * catalog automatically extends the API-key-addressable provider set.
+ * `ollama` is intentionally included here even though it is `setupMode:
+ * "keyless"` — the keyless mode is enforced elsewhere; this list is purely
+ * about the set of bare-name credential-store keys accepted by
+ * `assistant keys ...`.
+ *
+ * Search providers (`brave`, `perplexity`, `tavily`) have no catalog module
+ * yet and remain statically declared below.
  */
-const LLM_AND_SEARCH_API_KEY_PROVIDERS = [
-  "anthropic",
-  "openai",
-  "gemini",
-  "ollama",
-  "fireworks",
-  "openrouter",
-  "brave",
-  "perplexity",
-] as const;
+const LLM_API_KEY_PROVIDERS: readonly string[] = PROVIDER_CATALOG.map(
+  (p) => p.id,
+);
+
+/**
+ * Search API providers, derived from `SEARCH_PROVIDER_CATALOG`. Managed
+ * search providers (e.g. `inference-provider-native`) are filtered out;
+ * only BYOK entries with a `secretKey` end up here.
+ */
+const SEARCH_API_KEY_PROVIDERS: readonly string[] = BYOK_SEARCH_PROVIDERS.map(
+  (p) => p.secretKey!,
+);
+
+const LLM_AND_SEARCH_API_KEY_PROVIDERS: readonly string[] = [
+  ...LLM_API_KEY_PROVIDERS,
+  ...SEARCH_API_KEY_PROVIDERS,
+];
 
 // ---------------------------------------------------------------------------
 // STT catalog-derived providers
@@ -110,15 +129,15 @@ function catalogApiKeyNames(): string[] {
  * - CLI `keys` command (help text, list iteration)
  * - Provider availability checks
  *
- * Adding a new TTS provider to the catalog with a bare-name secret
- * requirement automatically includes it here. Adding a new STT
- * provider to the STT catalog automatically includes it here (shared
- * credential names like `openai` are deduplicated against the LLM
- * list). Shared credential names across STT and TTS (e.g. `deepgram`)
- * are deduplicated so the list contains no duplicates. Adding a new
- * LLM or search provider requires appending to
- * {@link LLM_AND_SEARCH_API_KEY_PROVIDERS} until those domains get
- * their own catalog modules.
+ * Adding a new LLM provider to `PROVIDER_CATALOG` (`model-catalog.ts`)
+ * automatically includes it here. Adding a new BYOK search provider to
+ * `SEARCH_PROVIDER_CATALOG` (`search-provider-catalog.ts`) automatically
+ * includes it here. Adding a new TTS provider to the TTS catalog with a
+ * bare-name secret requirement automatically includes it here. Adding a
+ * new STT provider to the STT catalog automatically includes it here.
+ * Shared credential names across domains (e.g. `openai` for both LLM
+ * and STT; `deepgram` for both STT and TTS) are deduplicated so the
+ * list contains no duplicates.
  */
 export const API_KEY_PROVIDERS: readonly string[] = (() => {
   const seen = new Set<string>();

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

@@ -7,7 +7,9 @@
 import { resolveCallSiteConfig } from "../config/llm-resolver.js";
 import { getConfig } from "../config/loader.js";
 import type { LLMCallSite } from "../config/schemas/llm.js";
-import { getProvider, initializeProviders, listProviders } from "./registry.js";
+import { getLogger } from "../util/logger.js";
+import { tryResolveProviderForConnectionName } from "./connection-resolution.js";
+import { initializeProviders, listProviders } from "./registry.js";
 import type {
   ContentBlock,
   Message,
@@ -18,8 +20,7 @@ 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.
+const log = getLogger("provider-send-message");
 
 export interface ConfiguredProviderResult {
   provider: Provider;
@@ -107,25 +108,45 @@ export async function resolveConfiguredProvider(
     }
   }
 
-  const inferenceProvider = resolveCallSiteConfig(
-    callSite,
-    config.llm,
-    opts,
-  ).provider;
-
-  try {
-    const provider = getProvider(inferenceProvider);
-    return {
-      provider: new CallSiteConfiguredProvider(
-        provider,
-        callSite,
-        opts.overrideProfile,
-      ),
-      configuredProviderName: inferenceProvider,
-    };
-  } catch {
+  const resolved = resolveCallSiteConfig(callSite, config.llm, opts);
+  const inferenceProvider = resolved.provider;
+  const 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.
+  if (!connectionName) {
+    log.debug(
+      { callSite, inferenceProvider },
+      "resolveCallSiteConfig yielded no provider_connection — returning null so callsite can fall back",
+    );
     return null;
   }
+
+  const connectionProvider = await tryResolveProviderForConnectionName(
+    connectionName,
+    config,
+    inferenceProvider,
+  );
+  if (!connectionProvider) {
+    // Soft credential failure — the connection resolved to no usable
+    // adapter (credential missing, transient auth failure, etc.).
+    // Callers handle null as "no provider available" rather than crash.
+    return null;
+  }
+  return {
+    provider: new CallSiteConfiguredProvider(
+      connectionProvider,
+      callSite,
+      opts.overrideProfile,
+    ),
+    configuredProviderName: inferenceProvider,
+  };
 }
 
 /**