@vellumai/assistant 0.11.7-staging.1 → 0.11.7

package/src/__tests__/provider-platform-proxy-integration.test.ts

@@ -665,13 +665,14 @@ describe("config mode flip → provider reinit", () => {
 });
 
 describe("managed proxy integration — constants integrity", () => {
-  test("anthropic, openai, gemini, fireworks, and together have metadata with managed=true and a proxyPath", () => {
+  test("anthropic, openai, gemini, fireworks, together, and vellum have metadata with managed=true and a proxyPath", () => {
     for (const provider of [
       "anthropic",
       "openai",
       "gemini",
       "fireworks",
       "together",
+      "vellum",
     ]) {
       const meta = PLATFORM_PROVIDER_META[provider];
       expect(meta).toBeDefined();
@@ -711,6 +712,12 @@ describe("managed proxy integration — constants integrity", () => {
     );
   });
 
+  test("vellum routes through the vellum runtime-proxy path", () => {
+    expect(PLATFORM_PROVIDER_META.vellum.proxyPath).toBe(
+      "/v1/runtime-proxy/vellum",
+    );
+  });
+
   test("openrouter is not managed proxy capable", () => {
     expect(PLATFORM_PROVIDER_META.openrouter.managed).toBe(false);
     expect(PLATFORM_PROVIDER_META.openrouter.proxyPath).toBeUndefined();

package/src/calls/__tests__/voice-session-bridge.test.ts

@@ -390,6 +390,7 @@ describe("startVoiceTurn escalation-continuation persistence", () => {
     );
     expect(fake.lastPersistOpts()?.metadata).toEqual({
       voiceSessionTurn: true,
+      scripted: true,
       hidden: true,
       messageKind: VOICE_ESCALATION_CONTINUATION_MESSAGE_KIND,
     });
@@ -404,8 +405,11 @@ describe("startVoiceTurn escalation-continuation persistence", () => {
 
     await startVoiceTurn(makeTurnOptions()); // content: CALL_OPENING_MARKER
 
+    // Visible AND scripted: the opener is shown, but the assistant wrote it,
+    // so it is not the user taking a turn.
     expect(fake.lastPersistOpts()?.metadata).toEqual({
       voiceSessionTurn: true,
+      scripted: true,
     });
   });
 
@@ -425,6 +429,7 @@ describe("startVoiceTurn escalation-continuation persistence", () => {
     // analytics already read.
     expect(fake.lastPersistOpts()?.metadata).toEqual({
       voiceSessionTurn: true,
+      scripted: true,
       client: {
         voice: true,
         voice_session_id: "session-123",
@@ -444,10 +449,41 @@ describe("startVoiceTurn escalation-continuation persistence", () => {
 
     expect(fake.lastPersistOpts()?.metadata).toEqual({
       voiceSessionTurn: true,
+      scripted: true,
       client: { voice: true, voice_session_id: "session-123" },
     });
   });
 
+  test("a turn the user really spoke is left unmarked, not marked false", async () => {
+    // Absent means UNKNOWN and falls through to the legacy classifier, which
+    // is the safe answer here. Stamping `false` would assert this turn was
+    // typed by the user, and a wrong `false` is trusted downstream.
+    const fake = makeFakeConversation({ processing: false });
+    fakeConversation = fake.conversation;
+
+    await startVoiceTurn({
+      ...makeTurnOptions(),
+      content: "what is on my calendar",
+    });
+
+    expect(fake.lastPersistOpts()?.metadata).not.toHaveProperty("scripted");
+  });
+
+  test("scripted is not derived from hidden", async () => {
+    // The two answer different questions, and the opener is the case that
+    // separates them: shown to the user, written by the assistant. Deriving
+    // one from the other lets every visible-but-scripted turn count as
+    // activation, which is the largest single source of funnel inflation.
+    const fake = makeFakeConversation({ processing: false });
+    fakeConversation = fake.conversation;
+
+    await startVoiceTurn(makeTurnOptions()); // content: CALL_OPENING_MARKER
+
+    const metadata = fake.lastPersistOpts()?.metadata;
+    expect(metadata?.scripted).toBe(true);
+    expect(metadata).not.toHaveProperty("hidden");
+  });
+
   test("a phone turn carries no client bag", async () => {
     const fake = makeFakeConversation({ processing: false });
     fakeConversation = fake.conversation;
@@ -501,6 +537,7 @@ describe("startVoiceTurn hiddenSyntheticPrompt", () => {
     expect(fake.lastPersistOpts()?.content).toBe(SYNTHETIC_CONTENT);
     expect(fake.lastPersistOpts()?.metadata).toEqual({
       voiceSessionTurn: true,
+      scripted: true,
       hidden: true,
     });
     expect(echoes).toHaveLength(0);

package/src/calls/voice-session-bridge.ts

@@ -1031,6 +1031,19 @@ export async function startVoiceTurn(
         // Durable "this turn came from an open voice session" marker; see
         // `isVoiceSessionUserMessage` for why the channel fields cannot carry it.
         voiceSessionTurn: true,
+        // Auto-sent on the user's behalf rather than spoken or typed by them,
+        // so activation metrics exclude it (see the `scripted` contract on the
+        // send route). Keyed off the synthetic set, NOT off
+        // `isHiddenSyntheticPrompt`: the two answer different questions, and
+        // deriving one from the other is what lets a visible-but-scripted turn
+        // through. `hidden` decides whether a human sees the row; `scripted`
+        // decides whether it counts as the user taking a turn.
+        //
+        // Only ever `true` here. A genuine voice turn is left absent rather
+        // than stamped `false`, because absent means UNKNOWN and falls through
+        // to the legacy classifier, while a wrong `false` is trusted
+        // downstream.
+        ...(isSyntheticVoicePrompt ? { scripted: true } : {}),
         ...(isHiddenSyntheticPrompt ? { hidden: true } : {}),
         ...(isEscalationContinuation
           ? { messageKind: VOICE_ESCALATION_CONTINUATION_MESSAGE_KIND }

package/src/config/feature-flag-registry.json

@@ -404,6 +404,22 @@
       "label": "Channel Conversation Sidecar",
       "description": "Renders a conversation bound to an external channel (Slack, Telegram, Discord, phone, email, and any other channel adapter) as two lanes in web chat: Vellum stays the primary full-width lane, and the canonical external-channel transcript moves into the existing read-only right drawer, opened from a channel-thread control in the chat header. Rows the client can attribute to the external channel are drawn once, in the drawer, instead of being blended into the Vellum lane. The drawer offers an Open in <channel> secondary action and a per-message Reference in Vellum action that stages one quoted reference above the Vellum composer. The Vellum composer stays the only input; nothing about delivery, routing, or permissions changes. Off leaves the header deep-link pill and the blended transcript unchanged.",
       "defaultEnabled": false
+    },
+    {
+      "id": "monday-oauth",
+      "scope": "assistant",
+      "key": "monday-oauth",
+      "label": "monday.com Integration",
+      "description": "Gates the seeded monday.com OAuth provider. When off, the provider is hidden from GET /v1/oauth/providers, its get-by-id route, and the connect/update routes, so it cannot be listed or connected from the CLI, gateway, or web integrations list. The row is still seeded into oauth_providers on startup; only its visibility changes.",
+      "defaultEnabled": false
+    },
+    {
+      "id": "chatgpt-device-code-login",
+      "scope": "client",
+      "key": "chatgpt-device-code-login",
+      "label": "ChatGPT Device Code Login",
+      "description": "Gates the device-code sign-in as the primary ChatGPT subscription connect flow in the web client. Off: the redirect-and-paste flow is the only flow the connect section shows, with no device code UI and no other-sign-in-options disclosure. On: device code leads, and the redirect-and-paste flow stays reachable behind that disclosure and takes the section over when the assistant has no device-auth route.",
+      "defaultEnabled": false
     }
   ]
 }

package/src/config/schemas/llm.ts

@@ -58,10 +58,10 @@ export const KNOWN_LLM_PROVIDERS = [
   "opencode",
   "baseten",
   "poolside",
-  // Routing identities rather than adapters: "vellum" = the platform-managed
-  // route (upstream derived from the model at dispatch), "chatgpt" = the
-  // subscription route to OpenAI. Neither has a PROVIDER_CATALOG entry;
-  // dispatch substitutes the real upstream before any adapter lookup.
+  // Routing identities: "vellum" = the platform-managed route (upstream
+  // derived from the model at dispatch) and the catalog owner of
+  // Vellum-hosted GPU models; "chatgpt" = the subscription route to OpenAI.
+  // Dispatch substitutes a concrete upstream before adapter lookup.
   "vellum",
   "chatgpt",
 ] as const;

package/src/live-voice/__tests__/live-voice-session-telemetry.test.ts

@@ -157,6 +157,70 @@ describe("live-voice session telemetry", () => {
     });
   });
 
+  /**
+   * Run one typed turn against a session with a real turn starter, then close.
+   *
+   * `readySession` wires none, so `handleTextTurn` returns before dispatching
+   * and every silence assertion against it passes for the wrong reason.
+   */
+  async function endAfterTypedTurn(frame: {
+    text: string;
+    hidden?: boolean;
+  }): Promise<void> {
+    let started = false;
+    const session = new LiveVoiceSession(createContext(), {
+      resolveTranscriber: mock(async () => new MockStreamingTranscriber()),
+      resolveCredentialReadiness: mock(
+        async (): Promise<LiveVoiceCredentialReadiness> => ({
+          status: "ready",
+        }),
+      ),
+      startVoiceTurn: mock(async () => {
+        started = true;
+        return { turnId: "bridge-turn-1", abort: mock() };
+      }),
+      emitMetrics: false,
+    });
+    await session.start();
+    await session.handleClientFrame({ type: "text", ...frame });
+    for (let attempt = 0; attempt < 40 && !started; attempt += 1) {
+      await new Promise((resolve) => setTimeout(resolve, 5));
+    }
+    if (!started) {
+      throw new Error("the typed turn never reached the bridge");
+    }
+    await session.close("client_end");
+  }
+
+  test("the greeting that opens a session does not spend its silence reason", async () => {
+    // The classification answers "did anything come from the person?". A
+    // session that greets and hears nothing back is silent, and counting the
+    // greeting would retire the taxonomy for every greeted session.
+    await endAfterTypedTurn({
+      text: "this message is sent automatically",
+      hidden: true,
+    });
+
+    expect(recordLiveVoiceSessionEnded).toHaveBeenCalledWith({
+      sessionId: "session-123",
+      screen: "ended_client_end:silent_no_audio",
+      outcome: "completed",
+    });
+  });
+
+  test("a turn the user really took clears the silence reason", async () => {
+    // The other half, and what keeps the test above honest: the same path with
+    // an ordinary typed turn is the person taking a turn, so the session is
+    // not silent and carries no classification at all.
+    await endAfterTypedTurn({ text: "typed by hand" });
+
+    expect(recordLiveVoiceSessionEnded).toHaveBeenCalledWith({
+      sessionId: "session-123",
+      screen: "ended_client_end",
+      outcome: "completed",
+    });
+  });
+
   test("a dropped socket ends as completed, not failed", async () => {
     const session = readySession();
     await session.start();

package/src/live-voice/live-voice-session.ts

@@ -4953,7 +4953,17 @@ export class LiveVoiceSession implements LiveVoiceSessionContract {
       // silent" onto a session that has turns, a contradictory row. Setting it
       // before can at worst leave a silent session unexplained, which is a gap
       // rather than a false statement.
-      this.dispatchedTurn = true;
+      //
+      // A synthetic prompt does not count. The silence classification answers
+      // "did anything come from the person?", and the session opening by
+      // greeting them is the session talking to itself. Counting it would
+      // retire the whole taxonomy for every greeted session: `no_speech`,
+      // `text_only` and `no_turn` become unreachable, and `no_audio` survives
+      // only where capture failed early enough to withhold the greeting. That
+      // is the one rate the funnel has for "voice didn't work for me".
+      if (!activeTurn.hiddenPrompt) {
+        this.dispatchedTurn = true;
+      }
       const handle = await this.startVoiceTurn({
         conversationId: this.conversationId,
         voiceSessionId: this.context.sessionId,

package/src/messaging/read-provider-metadata.ts

@@ -1,3 +1,4 @@
+import type { ChannelId } from "../channels/types.js";
 import { safeParseRecord } from "../util/json.js";
 import {
   type ProviderMessageMetadata,
@@ -49,3 +50,34 @@ export function readProviderMetadata(
   const slackMeta = readSlackMetadataFromMessageMetadata(metadata, opts);
   return slackMeta ? slackMetadataAsProviderMetadata(slackMeta) : null;
 }
+
+/**
+ * Merge an edit or delete stamp into a row's serialized metadata, producing
+ * the neutral envelope to store back under `providerMeta`.
+ *
+ * The base is whatever the row already says about itself through
+ * {@link readProviderMetadata}, flat-legacy Slack rows included, so fields
+ * the old envelope carried (thread, actor, display name) survive the stamp
+ * rather than being shadowed by a minimal synthesis. A row that says
+ * nothing gets the envelope synthesized from the caller's lookup-derived
+ * facts, so the result always validates on read.
+ */
+export function mergeProviderMessageMetadata(
+  rowMetadata: string | null,
+  seed: {
+    source: ChannelId;
+    conversationExternalId: string;
+    messageId: string;
+    threadId?: string;
+  },
+  patch: { editedAt?: number; deletedAt?: number },
+): string {
+  const base = readProviderMetadata(rowMetadata, { allowFlatLegacy: true }) ?? {
+    source: seed.source,
+    conversationExternalId: seed.conversationExternalId,
+    messageId: seed.messageId,
+    ...(seed.threadId ? { threadId: seed.threadId } : {}),
+    eventKind: "message" as const,
+  };
+  return JSON.stringify({ ...base, ...patch });
+}

package/src/oauth/connect-orchestrator.ts

@@ -19,6 +19,7 @@
  * - Running identity verifiers
  */
 
+import { loadConfig } from "../config/loader.js";
 import { emitPostConnectNudge } from "../home/post-connect-feed.js";
 import { invalidateAssistantSuggestedPromptsCache } from "../home/suggested-prompts-cache.js";
 import type { TokenEndpointAuthMethod } from "../security/oauth2.js";
@@ -27,6 +28,7 @@ import { getLogger } from "../util/logger.js";
 import type { OAuthConnectResult } from "./connect-types.js";
 import { verifyIdentity } from "./identity-verifier.js";
 import { getProvider } from "./oauth-store.js";
+import { isProviderVisible } from "./provider-visibility.js";
 import { storeOAuth2Tokens } from "./token-persistence.js";
 
 const log = getLogger("oauth-connect-orchestrator");
@@ -130,6 +132,20 @@ export async function orchestrateOAuthConnect(
     };
   }
 
+  // A provider gated behind a disabled feature flag is not connectable. This
+  // is the choke point every connect path funnels through (runtime routes,
+  // gateway, CLI, credential vault tool), so enforcing here covers all of
+  // them rather than relying on each entry point to check. The error matches
+  // the not-found case above so a gated provider is indistinguishable from an
+  // absent one, mirroring the provider routes.
+  if (!isProviderVisible(providerRow, loadConfig())) {
+    return {
+      success: false,
+      error: `No OAuth provider registered for "${options.service}". Ensure the provider is seeded in the database.`,
+      safeError: true,
+    };
+  }
+
   // Deserialize JSON fields from the DB row
   const dbAuthorizeParams = safeJsonParse<Record<string, string> | undefined>(
     providerRow.authorizeParams,

package/src/oauth/seed-providers.ts

@@ -807,6 +807,7 @@ export const PROVIDER_SEED_DATA: Record<
     identityHeaders: { "Content-Type": "application/json" },
     identityBody: { query: "{ me { id name email } }" },
     identityResponsePaths: ["data.me.name", "data.me.email"],
+    featureFlag: "monday-oauth",
   },
 
   eventbrite: {

package/src/persistence/conversation-crud.ts

@@ -3999,7 +3999,9 @@ export function updateMessageMetadata(
     .from(messages)
     .where(eq(messages.id, messageId))
     .get();
-  const existing = row?.metadata ? JSON.parse(row.metadata) : {};
+  // Sanitized like the transactional sibling above: a malformed stored
+  // envelope must not fail the update that is trying to stamp the row.
+  const existing = row?.metadata ? safeParseRecord(row.metadata) : {};
   db.update(messages)
     .set({ metadata: JSON.stringify({ ...existing, ...updates }) })
     .where(eq(messages.id, messageId))

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

@@ -38,6 +38,7 @@ describe("API_KEY_PROVIDERS", () => {
     expect(API_KEY_PROVIDERS).toContain("anthropic");
     expect(API_KEY_PROVIDERS).toContain("openai");
     expect(API_KEY_PROVIDERS).toContain("gemini");
+    expect(API_KEY_PROVIDERS).not.toContain("vellum");
   });
 
   test("includes search providers", () => {

package/src/providers/__tests__/vellum-connection-routing.test.ts

@@ -52,9 +52,10 @@ describe("vellum connection routing", () => {
     expect(isVellumManagedConnection({ provider: "vellum" })).toBe(true);
   });
 
-  test("the vellum sentinel is not a real provider without an override", () => {
-    // No `provider` override → effective provider is the `vellum` sentinel,
-    // which has no catalog entry / adapter → null.
+  test("the vellum sentinel does not dispatch without an override", () => {
+    // No `provider` override → the connection column is the routing
+    // sentinel and must not build an adapter, even though Vellum-hosted
+    // GPU models share this catalog id.
     const adapter = createAdapterFromConnection(
       vellumConnection,
       resolvedAuth,
@@ -76,6 +77,23 @@ describe("vellum connection routing", () => {
     );
     expect(adapter).not.toBeNull();
   });
+
+  test("provider override vellum routes GPU models through VellumProvider", () => {
+    const adapter = createAdapterFromConnection(
+      vellumConnection,
+      {
+        kind: "header",
+        headers: { Authorization: "Bearer test-key" },
+        baseUrl: "https://platform.example/v1/runtime-proxy/vellum",
+      },
+      {
+        model: "qwen/qwen3-8b",
+        provider: "vellum",
+      },
+    );
+    expect(adapter).not.toBeNull();
+    expect(adapter?.name).toBe("vellum");
+  });
 });
 
 describe("effectiveConnectionAuth", () => {

package/src/providers/inference/adapter-factory.ts

@@ -48,6 +48,7 @@ import { RetryProvider } from "../retry.js";
 import { TogetherProvider } from "../together/client.js";
 import type { Provider, SendMessageOptions } from "../types.js";
 import { UsageTrackingProvider } from "../usage-tracking.js";
+import { VellumProvider } from "../vellum/client.js";
 import {
   getManagedUpstream,
   isVellumManagedConnection,
@@ -204,6 +205,11 @@ const ADAPTER_FACTORIES: Record<string, AdapterFactory> = {
       streamTimeoutMs,
       ...(baseURL ? { baseURL } : {}),
     }),
+  vellum: ({ apiKey, model, streamTimeoutMs, baseURL }) =>
+    new VellumProvider(apiKey, model, {
+      streamTimeoutMs,
+      ...(baseURL ? { baseURL } : {}),
+    }),
 };
 
 /**
@@ -551,6 +557,15 @@ function buildConnectionAdapter(
   },
 ): Provider | null {
   const provider = opts.provider ?? connection.provider;
+  // The connection's own `vellum` column is a routing sentinel. Dispatch
+  // only when the caller names an upstream, including Vellum-hosted GPU
+  // models whose catalog id is also `vellum`.
+  if (
+    connection.provider === VELLUM_MANAGED_PROVIDER &&
+    opts.provider === undefined
+  ) {
+    return null;
+  }
   const entry = PROVIDER_CATALOG.find((e) => e.id === provider);
   if (!entry) {
     return null;

package/src/providers/inference/auth.ts

@@ -118,20 +118,20 @@ export type ResolvedAuth =
 // providers at runtime.
 
 export const VALID_CONNECTION_PROVIDERS: readonly string[] = [
-  ...PROVIDER_CATALOG.map((p) => p.id),
-  // The provider-agnostic Vellum-managed connection stores this sentinel in its
-  // `provider` column. It is intentionally not a PROVIDER_CATALOG entry (it
-  // names no single upstream), so it must be allowlisted explicitly or the DB
-  // loaders (getConnection/listConnections) and the create route would reject
-  // persisted `vellum` rows — the routing threaded in via `providerOverride`
-  // never runs on a row that fails to load.
-  VELLUM_MANAGED_PROVIDER,
-  // The ChatGPT-subscription row stores the "chatgpt" routing identity in its
-  // `provider` column for the same reason: the row IS the subscription route
-  // (auth modality = provider identity), and dispatch derives the openai
-  // upstream per-request. Allowlisted explicitly or the DB loaders would drop
-  // the persisted row.
-  "chatgpt",
+  ...new Set([
+    ...PROVIDER_CATALOG.map((p) => p.id),
+    // The provider-agnostic Vellum-managed connection stores this sentinel in
+    // its `provider` column. The same id owns Vellum-hosted GPU models in the
+    // catalog. Keep it allowlisted explicitly so a future catalog rename
+    // cannot drop persisted `vellum` rows from the DB loaders.
+    VELLUM_MANAGED_PROVIDER,
+    // The ChatGPT-subscription row stores the "chatgpt" routing identity in
+    // its `provider` column: the row IS the subscription route (auth
+    // modality = provider identity), and dispatch derives the openai
+    // upstream per-request. Allowlisted explicitly or the DB loaders would
+    // drop the persisted row.
+    "chatgpt",
+  ]),
 ];
 
 export type ConnectionProvider = string;

package/src/providers/model-catalog.ts

@@ -2271,6 +2271,31 @@ const RAW_PROVIDER_CATALOG: ProviderCatalogEntry[] = [
     apiKeyUrl: "https://poolside.ai",
     apiKeyPlaceholder: "Your Poolside API key",
   },
+  {
+    id: "vellum",
+    displayName: "Vellum",
+    subtitle:
+      "Models served on Vellum GPU nodes through the managed connection.",
+    setupMode: "api-key",
+    setupHint:
+      "Uses the assistant API key through the Vellum managed connection. These models cannot use a bring-your-own key.",
+    featureFlag: "settings-developer-nav",
+    models: [
+      {
+        id: "qwen/qwen3-8b",
+        displayName: "Qwen3 8B",
+        contextWindowTokens: 32768,
+        maxOutputTokens: 32768,
+        supportsThinking: false,
+        supportsCaching: false,
+        supportsVision: false,
+        supportsToolUse: true,
+        pricing: { inputPer1mTokens: 0.3, outputPer1mTokens: 0.3 },
+        featureFlag: "settings-developer-nav",
+      },
+    ],
+    defaultModel: "qwen/qwen3-8b",
+  },
 ];
 
 export const PROVIDER_CATALOG: ProviderCatalogEntry[] =

package/src/providers/platform-proxy/constants.ts

@@ -51,6 +51,11 @@ export const PLATFORM_PROVIDER_META: Record<string, ManagedProviderMeta> = {
     managed: true,
     proxyPath: "/v1/runtime-proxy/together",
   },
+  vellum: {
+    name: "vellum",
+    managed: true,
+    proxyPath: "/v1/runtime-proxy/vellum",
+  },
   poolside: {
     name: "poolside",
     managed: false,

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

@@ -39,14 +39,15 @@ import { listCredentialProviderNames as listSttCredentialProviderNames } from ".
  * `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 ...`.
+ * `assistant keys ...`. `vellum` is excluded: those models authenticate
+ * with the assistant API key on the managed connection, not a user key.
  *
  * Search providers (`brave`, `perplexity`, `tavily`) have no catalog module
  * yet and remain statically declared below.
  */
 const LLM_API_KEY_PROVIDERS: readonly string[] = PROVIDER_CATALOG.map(
   (p) => p.id,
-);
+).filter((id) => id !== "vellum");
 
 /**
  * Search API providers, derived from `SEARCH_PROVIDER_CATALOG`. Managed

package/src/providers/vellum/client.ts

@@ -0,0 +1,29 @@
+import { OpenAIChatCompletionsProvider } from "../openai/chat-completions-provider.js";
+
+export interface VellumProviderOptions {
+  apiKey?: string;
+  baseURL?: string;
+  streamTimeoutMs?: number;
+}
+
+/**
+ * OpenAI-compatible client for Vellum-hosted GPU inference (vLLM).
+ * Managed requests set `baseURL` to the platform `/v1/runtime-proxy/vellum`
+ * path and authenticate with the assistant API key. These models have no
+ * bring-your-own-key path.
+ */
+export class VellumProvider extends OpenAIChatCompletionsProvider {
+  constructor(
+    apiKey: string,
+    model: string,
+    options: VellumProviderOptions = {},
+  ) {
+    super(apiKey || "not-needed", model, {
+      providerName: "vellum",
+      providerLabel: "Vellum",
+      streamTimeoutMs: options.streamTimeoutMs,
+      omitToolChoiceWhenReasoning: true,
+      ...(options.baseURL ? { baseURL: options.baseURL } : {}),
+    });
+  }
+}

package/src/providers/vellum-model-routing.test.ts

@@ -41,6 +41,7 @@ describe("vellum-model-routing", () => {
 
   test("getManagedUpstream resolves a bare catalog id to its owner", () => {
     expect(getManagedUpstream("claude-fable-5")).toBe("anthropic");
+    expect(getManagedUpstream("qwen/qwen3-8b")).toBe("vellum");
   });
 
   test("getManagedUpstream resolves a routing string by its prefix", () => {
@@ -72,6 +73,7 @@ describe("vellum-model-routing", () => {
       "gemini",
       "openai",
       "together",
+      "vellum",
     ]);
   });
 });

package/src/providers/vellum-model-routing.ts

@@ -36,9 +36,9 @@ export const MANAGED_ROUTABLE_PROVIDERS: ReadonlySet<string> = new Set(
  * Sentinel provider id for the single, provider-agnostic Vellum-managed
  * connection. Unlike the per-provider `*-managed` connections, this one does
  * not name an upstream provider on its DB row — the upstream is determined
- * per-request from the resolving profile. This id is never a real catalog
- * entry, so routing code must substitute the effective provider before any
- * catalog/adapter lookup.
+ * per-request from the resolving profile. The same id is the catalog owner
+ * of Vellum-hosted GPU models. Dispatch still substitutes a concrete
+ * upstream (including `vellum` for those GPU models) before adapter lookup.
  */
 export const VELLUM_MANAGED_PROVIDER = "vellum";