@vellumai/assistant 0.11.7-staging.1 → 0.11.7

package/node_modules/@vellumai/service-contracts/src/rpc.ts

@@ -16,6 +16,13 @@
  * - `delete_credential` — Delete a credential by account name
  * - `list_credentials` — List all credential account names
  * - `bulk_set_credentials` — Store multiple credentials at once
+ *
+ * **Credential records** (non-secret identity + policy)
+ * - `get_credential_record` — Retrieve a credential record by account name
+ * - `set_credential_record` — Store or update a credential record
+ * - `delete_credential_record` — Delete a credential record by account name
+ * - `list_credential_records` — List all credential records
+ * - `bulk_set_credential_records` — Store multiple credential records at once
  */
 
 import { z } from "zod";
@@ -38,6 +45,16 @@ export const CesRpcMethod = {
   ListCredentials: "list_credentials",
   /** Bulk-import credentials (set multiple at once). */
   BulkSetCredentials: "bulk_set_credentials",
+  /** Retrieve a single credential record (identity + policy) by account name. */
+  GetCredentialRecord: "get_credential_record",
+  /** Store or update a credential record by account name. */
+  SetCredentialRecord: "set_credential_record",
+  /** Delete a credential record by account name. */
+  DeleteCredentialRecord: "delete_credential_record",
+  /** List all credential records. */
+  ListCredentialRecords: "list_credential_records",
+  /** Bulk-import credential records. */
+  BulkSetCredentialRecords: "bulk_set_credential_records",
 } as const;
 
 export type CesRpcMethod = (typeof CesRpcMethod)[keyof typeof CesRpcMethod];
@@ -168,6 +185,123 @@ export type BulkSetCredentialsResponse = z.infer<
   typeof BulkSetCredentialsResponseSchema
 >;
 
+// ---------------------------------------------------------------------------
+// Credential records (identity + policy, never secret values)
+// ---------------------------------------------------------------------------
+
+export const CredentialInjectionTemplateSchema = z.object({
+  hostPattern: z.string(),
+  injectionType: z.enum(["header", "query"]),
+  headerName: z.string().optional(),
+  valuePrefix: z.string().optional(),
+  queryParamName: z.string().optional(),
+  composeWith: z
+    .object({
+      service: z.string(),
+      field: z.string(),
+      separator: z.string(),
+    })
+    .optional(),
+  valueTransform: z.enum(["base64"]).optional(),
+});
+export type CredentialInjectionTemplate = z.infer<
+  typeof CredentialInjectionTemplateSchema
+>;
+
+export const CredentialRecordSchema = z.object({
+  credentialId: z.string(),
+  service: z.string(),
+  field: z.string(),
+  allowedTools: z.array(z.string()),
+  allowedDomains: z.array(z.string()),
+  usageDescription: z.string().optional(),
+  alias: z.string().optional(),
+  injectionTemplates: z.array(CredentialInjectionTemplateSchema).optional(),
+  createdAt: z.number(),
+  updatedAt: z.number(),
+});
+export type CredentialRecord = z.infer<typeof CredentialRecordSchema>;
+
+export const GetCredentialRecordSchema = z.object({
+  /** The account name to look up (`credential/{service}/{field}`). */
+  account: z.string(),
+});
+export type GetCredentialRecord = z.infer<typeof GetCredentialRecordSchema>;
+
+export const GetCredentialRecordResponseSchema = z.object({
+  found: z.boolean(),
+  record: CredentialRecordSchema.optional(),
+});
+export type GetCredentialRecordResponse = z.infer<
+  typeof GetCredentialRecordResponseSchema
+>;
+
+export const SetCredentialRecordSchema = z.object({
+  account: z.string(),
+  record: CredentialRecordSchema,
+});
+export type SetCredentialRecord = z.infer<typeof SetCredentialRecordSchema>;
+
+export const SetCredentialRecordResponseSchema = z.object({
+  ok: z.boolean(),
+});
+export type SetCredentialRecordResponse = z.infer<
+  typeof SetCredentialRecordResponseSchema
+>;
+
+export const DeleteCredentialRecordSchema = z.object({
+  account: z.string(),
+});
+export type DeleteCredentialRecord = z.infer<
+  typeof DeleteCredentialRecordSchema
+>;
+
+export const DeleteCredentialRecordResponseSchema = z.object({
+  result: z.enum(["deleted", "not-found", "error"]),
+});
+export type DeleteCredentialRecordResponse = z.infer<
+  typeof DeleteCredentialRecordResponseSchema
+>;
+
+export const ListCredentialRecordsSchema = z.object({});
+export type ListCredentialRecords = z.infer<typeof ListCredentialRecordsSchema>;
+
+export const ListCredentialRecordsResponseSchema = z.object({
+  records: z.array(
+    z.object({
+      account: z.string(),
+      record: CredentialRecordSchema,
+    }),
+  ),
+});
+export type ListCredentialRecordsResponse = z.infer<
+  typeof ListCredentialRecordsResponseSchema
+>;
+
+export const BulkSetCredentialRecordsSchema = z.object({
+  records: z.array(
+    z.object({
+      account: z.string(),
+      record: CredentialRecordSchema,
+    }),
+  ),
+});
+export type BulkSetCredentialRecords = z.infer<
+  typeof BulkSetCredentialRecordsSchema
+>;
+
+export const BulkSetCredentialRecordsResponseSchema = z.object({
+  results: z.array(
+    z.object({
+      account: z.string(),
+      ok: z.boolean(),
+    }),
+  ),
+});
+export type BulkSetCredentialRecordsResponse = z.infer<
+  typeof BulkSetCredentialRecordsResponseSchema
+>;
+
 // ---------------------------------------------------------------------------
 // Full RPC contract type map
 // ---------------------------------------------------------------------------
@@ -201,6 +335,26 @@ export interface CesRpcContract {
     request: BulkSetCredentials;
     response: BulkSetCredentialsResponse;
   };
+  [CesRpcMethod.GetCredentialRecord]: {
+    request: GetCredentialRecord;
+    response: GetCredentialRecordResponse;
+  };
+  [CesRpcMethod.SetCredentialRecord]: {
+    request: SetCredentialRecord;
+    response: SetCredentialRecordResponse;
+  };
+  [CesRpcMethod.DeleteCredentialRecord]: {
+    request: DeleteCredentialRecord;
+    response: DeleteCredentialRecordResponse;
+  };
+  [CesRpcMethod.ListCredentialRecords]: {
+    request: ListCredentialRecords;
+    response: ListCredentialRecordsResponse;
+  };
+  [CesRpcMethod.BulkSetCredentialRecords]: {
+    request: BulkSetCredentialRecords;
+    response: BulkSetCredentialRecordsResponse;
+  };
 }
 
 /**
@@ -231,4 +385,24 @@ export const CesRpcSchemas = {
     request: BulkSetCredentialsSchema,
     response: BulkSetCredentialsResponseSchema,
   },
+  [CesRpcMethod.GetCredentialRecord]: {
+    request: GetCredentialRecordSchema,
+    response: GetCredentialRecordResponseSchema,
+  },
+  [CesRpcMethod.SetCredentialRecord]: {
+    request: SetCredentialRecordSchema,
+    response: SetCredentialRecordResponseSchema,
+  },
+  [CesRpcMethod.DeleteCredentialRecord]: {
+    request: DeleteCredentialRecordSchema,
+    response: DeleteCredentialRecordResponseSchema,
+  },
+  [CesRpcMethod.ListCredentialRecords]: {
+    request: ListCredentialRecordsSchema,
+    response: ListCredentialRecordsResponseSchema,
+  },
+  [CesRpcMethod.BulkSetCredentialRecords]: {
+    request: BulkSetCredentialRecordsSchema,
+    response: BulkSetCredentialRecordsResponseSchema,
+  },
 } as const;

package/openapi.yaml

@@ -15046,7 +15046,7 @@ paths:
             type: string
           description:
             "Filter by provider id. One of: anthropic, openai, gemini, ollama, fireworks, together, openrouter,
-            vercel-ai-gateway, litellm, opencode, openai-compatible, minimax, atlascloud, baseten, poolside"
+            vercel-ai-gateway, litellm, opencode, openai-compatible, minimax, atlascloud, baseten, poolside, vellum"
       responses:
         "200":
           description: Successful response

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@vellumai/assistant",
-  "version": "0.11.7-staging.1",
+  "version": "0.11.7",
   "license": "MIT",
   "type": "module",
   "exports": {

package/scripts/sync-llm-catalog.ts

@@ -86,6 +86,9 @@ function projectModel(model: CatalogModel): Record<string, unknown> {
   if (model.pricing !== undefined) {
     projected.pricing = model.pricing;
   }
+  if (model.featureFlag !== undefined) {
+    projected.featureFlag = model.featureFlag;
+  }
   return projected;
 }
 
@@ -115,6 +118,9 @@ function projectProvider(entry: ProviderCatalogEntry): Record<string, unknown> {
   if (entry.supportsPlatformAuth !== undefined) {
     projected.supportsPlatformAuth = entry.supportsPlatformAuth;
   }
+  if (entry.featureFlag !== undefined) {
+    projected.featureFlag = entry.featureFlag;
+  }
   projected.defaultModel = entry.defaultModel;
   projected.models = entry.models.map(projectModel);
   // NOTE: `apiKeyUrl` intentionally omitted — clients use

package/src/__tests__/credential-record-write-through.test.ts

@@ -0,0 +1,78 @@
+import { afterEach, describe, expect, test } from "bun:test";
+
+import { credentialKey } from "@vellumai/credential-storage";
+import type { CredentialRecord } from "@vellumai/service-contracts/credential-rpc";
+
+import type { CredentialRecordBackend } from "../security/ces-rpc-record-backend.js";
+import {
+  _setMetadataPath,
+  persistCredentialMetadata,
+  setCredentialRecordBackend,
+  upsertCredentialMetadata,
+} from "../tools/credentials/metadata-store.js";
+
+function makeBackend(): CredentialRecordBackend & {
+  store: Map<string, CredentialRecord>;
+} {
+  const store = new Map<string, CredentialRecord>();
+  return {
+    store,
+    isAvailable: () => true,
+    get: async (account) => store.get(account),
+    set: async (account, record) => {
+      store.set(account, record);
+      return true;
+    },
+    delete: async (account) => {
+      if (!store.has(account)) {
+        return "not-found";
+      }
+      store.delete(account);
+      return "deleted";
+    },
+    list: async () =>
+      [...store.entries()].map(([account, record]) => ({ account, record })),
+    bulkSet: async (records) => {
+      for (const { account, record } of records) {
+        store.set(account, record);
+      }
+      return records.map((entry) => ({ account: entry.account, ok: true }));
+    },
+  };
+}
+
+describe("CES credential record write-through", () => {
+  afterEach(() => {
+    setCredentialRecordBackend(undefined);
+    _setMetadataPath(null);
+  });
+
+  test("upsert write-through updates the CES backend", async () => {
+    const backend = makeBackend();
+    setCredentialRecordBackend(backend);
+
+    const created = upsertCredentialMetadata("slack_channel", "bot_token", {
+      allowedTools: ["bash"],
+    });
+    await persistCredentialMetadata(created);
+
+    const stored = backend.store.get(
+      credentialKey("slack_channel", "bot_token"),
+    );
+    expect(stored?.allowedTools).toEqual(["bash"]);
+    expect(stored?.credentialId).toBe(created.credentialId);
+  });
+
+  test("test metadata path override skips CES write-through", async () => {
+    const backend = makeBackend();
+    setCredentialRecordBackend(backend);
+    _setMetadataPath("/tmp/does-not-write-through-metadata.json");
+
+    const created = upsertCredentialMetadata("github", "token", {
+      allowedTools: ["bash"],
+    });
+    await persistCredentialMetadata(created);
+
+    expect(backend.store.size).toBe(0);
+  });
+});

package/src/__tests__/delete-propagation.test.ts

@@ -9,6 +9,8 @@
  */
 import { beforeEach, describe, expect, mock, test } from "bun:test";
 
+import { readProviderMetadata } from "../messaging/read-provider-metadata.js";
+
 mock.module("../config/env.js", () => ({
   isHttpAuthDisabled: () => true,
   getGatewayInternalBaseUrl: () => "http://127.0.0.1:7830",
@@ -249,7 +251,10 @@ describe("Slack delete propagation", () => {
     expect(slackMeta!.deletedAt).toBeUndefined();
   });
 
-  test("delete for row without slackMeta is a no-op (legacy row)", async () => {
+  test("delete for row without slackMeta stamps the neutral metadata", async () => {
+    // A legacy pre-enrichment row still gets its delete marked: the neutral
+    // envelope is synthesized so readProviderMetadata serves the stamp to
+    // every channel-agnostic reader, and content stays for audit.
     const seeded = seedSlackMessage({
       externalChatId: "C0123CHANNEL",
       originalTs: "2222.2222",
@@ -257,6 +262,7 @@ describe("Slack delete propagation", () => {
       withSlackMeta: false,
     });
 
+    const before = Date.now();
     const req = buildSlackDeleteRequest({
       externalChatId: seeded.externalChatId,
       deletedTs: seeded.originalTs,
@@ -265,7 +271,7 @@ describe("Slack delete propagation", () => {
     const json = (await resp.json()) as Record<string, unknown>;
 
     expect(json.accepted).toBe(true);
-    expect(json.deleted).toBe(false);
+    expect(json.deleted).toBe(true);
 
     const db = getDb();
     const row = db
@@ -277,6 +283,90 @@ describe("Slack delete propagation", () => {
     expect(row!.content).toBe("Legacy pre-upgrade text");
     const parsed = JSON.parse(row!.metadata!) as Record<string, unknown>;
     expect(parsed.slackMeta).toBeUndefined();
+    const neutral = readProviderMetadata(row!.metadata);
+    expect(neutral).not.toBeNull();
+    expect(neutral!.source).toBe("slack");
+    expect(neutral!.messageId).toBe(seeded.originalTs);
+    expect(neutral!.deletedAt).toBeDefined();
+    expect(neutral!.deletedAt!).toBeGreaterThanOrEqual(before);
+  });
+
+  test("a flat-legacy row's fields survive the delete stamp", async () => {
+    // Rows written before slackMeta nesting carry the Slack envelope flat in
+    // messages.metadata. The stamp bases on the mapped envelope, so thread
+    // and display identity remain readable beside deletedAt instead of
+    // being shadowed by a minimal synthesis.
+    const seeded = seedSlackMessage({
+      externalChatId: "C0123CHANNEL",
+      originalTs: "3333.3333",
+      content: "Flat legacy text",
+      withSlackMeta: false,
+    });
+    const db = getDb();
+    db.update(messages)
+      .set({
+        metadata: JSON.stringify({
+          source: "slack",
+          channelId: seeded.externalChatId,
+          channelTs: seeded.originalTs,
+          threadTs: "3000.0001",
+          eventKind: "message",
+          displayName: "Flat User",
+        }),
+      })
+      .where(eq(messages.id, seeded.messageId))
+      .run();
+
+    const req = buildSlackDeleteRequest({
+      externalChatId: seeded.externalChatId,
+      deletedTs: seeded.originalTs,
+    });
+    const resp = await handleChannelInbound(req, undefined, TEST_BEARER_TOKEN);
+    const json = (await resp.json()) as Record<string, unknown>;
+    expect(json.deleted).toBe(true);
+
+    const row = db
+      .select()
+      .from(messages)
+      .where(eq(messages.id, seeded.messageId))
+      .get();
+    const neutral = readProviderMetadata(row!.metadata);
+    expect(neutral).not.toBeNull();
+    expect(neutral!.deletedAt).toBeDefined();
+    expect(neutral!.threadId).toBe("3000.0001");
+    expect(neutral!.displayName).toBe("Flat User");
+  });
+
+  test("a row with malformed metadata still records its delete", async () => {
+    const seeded = seedSlackMessage({
+      externalChatId: "C0123CHANNEL",
+      originalTs: "4444.4444",
+      content: "Row with broken envelope",
+      withSlackMeta: false,
+    });
+    const db = getDb();
+    db.update(messages)
+      .set({ metadata: "{not json" })
+      .where(eq(messages.id, seeded.messageId))
+      .run();
+
+    const req = buildSlackDeleteRequest({
+      externalChatId: seeded.externalChatId,
+      deletedTs: seeded.originalTs,
+    });
+    const resp = await handleChannelInbound(req, undefined, TEST_BEARER_TOKEN);
+    const json = (await resp.json()) as Record<string, unknown>;
+    expect(json.accepted).toBe(true);
+    expect(json.deleted).toBe(true);
+
+    const row = db
+      .select()
+      .from(messages)
+      .where(eq(messages.id, seeded.messageId))
+      .get();
+    const neutral = readProviderMetadata(row!.metadata);
+    expect(neutral).not.toBeNull();
+    expect(neutral!.deletedAt).toBeDefined();
   });
 
   test("delete missing sourceMetadata.messageId is a no-op", async () => {

package/src/__tests__/edit-propagation.test.ts

@@ -12,6 +12,7 @@ import { beforeEach, describe, expect, test } from "bun:test";
 import { eq } from "drizzle-orm";
 
 import { readSlackMetadata } from "../messaging/providers/slack/message-metadata.js";
+import { readProviderMetadata } from "../messaging/read-provider-metadata.js";
 import { addMessage } from "../persistence/conversation-crud.js";
 import { getConversationByKey } from "../persistence/conversation-key-store.js";
 import { getDb, getMemoryDb } from "../persistence/db-connection.js";
@@ -72,11 +73,13 @@ async function seedSlackMessage(opts: {
   conversationExternalId: string;
   channelTs: string;
   initialContent: string;
+  sourceChannel?: "slack" | "telegram";
 }): Promise<SeededFixture> {
   const { conversationExternalId, channelTs, initialContent } = opts;
+  const sourceChannel = opts.sourceChannel ?? "slack";
 
   const inboundResult = recordInbound(
-    "slack",
+    sourceChannel,
     conversationExternalId,
     channelTs,
     {
@@ -88,7 +91,7 @@ async function seedSlackMessage(opts: {
     inboundResult.conversationId,
     "user",
     initialContent,
-    { metadata: { userMessageChannel: "slack" }, skipIndexing: true },
+    { metadata: { userMessageChannel: sourceChannel }, skipIndexing: true },
   );
 
   linkMessage(inboundResult.eventId, inserted.id);
@@ -171,6 +174,43 @@ describe("Slack edit propagation", () => {
     expect(slackMeta!.editedAt!).toBeGreaterThanOrEqual(t0);
   });
 
+  test("a Telegram edit stamps the neutral editedAt every reader serves", async () => {
+    // The neutral stamp is what makes an edit visible on channels without a
+    // provider envelope of their own: content rewrites in place and
+    // readProviderMetadata reports when.
+    const seeded = await seedSlackMessage({
+      conversationExternalId: "555010042",
+      channelTs: "60",
+      initialContent: "original text",
+      sourceChannel: "telegram",
+    });
+
+    const t0 = Date.now();
+    const resp = await handleEditIntercept({
+      sourceChannel: "telegram",
+      conversationExternalId: seeded.conversationExternalId,
+      externalMessageId: nextEditEventId(),
+      sourceMessageId: seeded.channelTs,
+      assistantId: "self",
+      content: "corrected text",
+    });
+
+    const respJson = resp as Record<string, unknown>;
+    expect(respJson.accepted).toBe(true);
+    expect(respJson.duplicate).toBe(false);
+
+    const after = readMessageRow(seeded.messageId);
+    expect(after.content).toBe("corrected text");
+
+    const neutral = readProviderMetadata(after.metadata);
+    expect(neutral).not.toBeNull();
+    expect(neutral!.source).toBe("telegram");
+    expect(neutral!.conversationExternalId).toBe(seeded.conversationExternalId);
+    expect(neutral!.messageId).toBe(seeded.channelTs);
+    expect(typeof neutral!.editedAt).toBe("number");
+    expect(neutral!.editedAt!).toBeGreaterThanOrEqual(t0);
+  });
+
   // Times out on the default budget: an unresolvable target pays the full
   // `EDIT_LOOKUP_RETRIES` window before it is dropped.
   test("an edit of a message the assistant never stored creates no conversation", async () => {

package/src/__tests__/llm-catalog-parity.test.ts

@@ -67,6 +67,7 @@ interface ClientCatalogModel {
       cacheWritePer1mTokens?: number;
     }>;
   };
+  featureFlag?: string;
 }
 
 interface ClientCatalogEntry {
@@ -79,6 +80,7 @@ interface ClientCatalogEntry {
   apiKeyPlaceholder?: string;
   credentialsGuide?: ClientCatalogCredentialsGuide;
   supportsPlatformAuth?: boolean;
+  featureFlag?: string;
   defaultModel: string;
   models: ClientCatalogModel[];
 }
@@ -133,6 +135,7 @@ describe("LLM catalog parity: daemon vs client", () => {
       expect(clientEntry.supportsPlatformAuth).toBe(
         daemonEntry.supportsPlatformAuth,
       );
+      expect(clientEntry.featureFlag).toBe(daemonEntry.featureFlag);
       expect(clientEntry.credentialsGuide).toEqual(
         daemonEntry.credentialsGuide,
       );
@@ -199,6 +202,7 @@ describe("LLM catalog parity: daemon vs client", () => {
         expect(clientModel.supportsVision).toBe(daemonModel.supportsVision);
         expect(clientModel.supportsToolUse).toBe(daemonModel.supportsToolUse);
         expect(clientModel.pricing).toEqual(daemonModel.pricing);
+        expect(clientModel.featureFlag).toBe(daemonModel.featureFlag);
       }
     }
   });

package/src/__tests__/oauth-connect-orchestrator.test.ts

@@ -133,6 +133,7 @@ mock.module("../inbound/public-ingress-urls.js", () => ({
 // ---------------------------------------------------------------------------
 
 import { orchestrateOAuthConnect } from "../oauth/connect-orchestrator.js";
+import { setOverridesForTesting } from "./feature-flag-test-helpers.js";
 import { setConfig } from "./helpers/set-config.js";
 
 /** Seed `ingress.publicBaseUrl` in the real workspace config. */
@@ -219,6 +220,7 @@ beforeEach(() => {
   setPublicBaseUrl("");
   mockIdentityResult = "user@example.com";
   mockProviderStore = {};
+  setOverridesForTesting({});
 
   mockPrepareResult = {
     authorizeUrl: "https://provider.example.com/authorize?prepared",
@@ -805,3 +807,96 @@ describe("orchestrateOAuthConnect — transport selection", () => {
     });
   });
 });
+
+// ---------------------------------------------------------------------------
+// Feature-flag gating
+// ---------------------------------------------------------------------------
+
+/**
+ * A provider whose seed entry declares a `featureFlag` is only connectable
+ * while that flag is enabled. The orchestrator is the shared choke point for
+ * every connect path (runtime routes, gateway, CLI, credential vault tool),
+ * so the gate lives here rather than in each entry point.
+ */
+describe("orchestrateOAuthConnect — feature-flag gating", () => {
+  const GATED_PROVIDER = makeProviderRow({
+    provider: "gated",
+    displayLabel: "Gated",
+    loopbackPort: 17399,
+    featureFlag: "gated-provider-flag",
+  });
+
+  test("refuses to connect a gated provider when its flag is disabled", async () => {
+    mockProviderStore["gated"] = GATED_PROVIDER;
+    setOverridesForTesting({ "gated-provider-flag": false });
+
+    const result = await orchestrateOAuthConnect({
+      service: "gated",
+      clientId: "client-id",
+      isInteractive: false,
+      callbackTransport: "loopback",
+    });
+
+    expect(result.success).toBe(false);
+    // No authorization flow may be started for a gated provider.
+    expect(lastPrepareArgs).toBeNull();
+    expect(lastStartArgs).toBeNull();
+  });
+
+  test("gated provider is indistinguishable from an unregistered one", async () => {
+    mockProviderStore["gated"] = GATED_PROVIDER;
+    setOverridesForTesting({ "gated-provider-flag": false });
+
+    const gated = await orchestrateOAuthConnect({
+      service: "gated",
+      clientId: "client-id",
+      isInteractive: false,
+      callbackTransport: "loopback",
+    });
+    const absent = await orchestrateOAuthConnect({
+      service: "not-a-provider",
+      clientId: "client-id",
+      isInteractive: false,
+      callbackTransport: "loopback",
+    });
+
+    expect(gated.success).toBe(false);
+    expect(absent.success).toBe(false);
+    if (gated.success || absent.success) {
+      return;
+    }
+    // Identical wording so the gate does not leak that the provider exists.
+    expect(gated.error).toBe(absent.error.replace("not-a-provider", "gated"));
+  });
+
+  test("connects a gated provider once its flag is enabled", async () => {
+    mockProviderStore["gated"] = GATED_PROVIDER;
+    setOverridesForTesting({ "gated-provider-flag": true });
+
+    const result = await orchestrateOAuthConnect({
+      service: "gated",
+      clientId: "client-id",
+      isInteractive: false,
+      callbackTransport: "loopback",
+    });
+
+    expect(result.success).toBe(true);
+    expect(lastPrepareArgs).not.toBeNull();
+  });
+
+  test("leaves ungated providers connectable", async () => {
+    mockProviderStore["google"] = GOOGLE_PROVIDER;
+    setOverridesForTesting({});
+
+    const result = await orchestrateOAuthConnect({
+      service: "google",
+      clientId: "client-id",
+      isInteractive: false,
+      callbackTransport: "loopback",
+    });
+
+    expect(GOOGLE_PROVIDER.featureFlag).toBeNull();
+    expect(result.success).toBe(true);
+    expect(lastPrepareArgs).not.toBeNull();
+  });
+});

package/src/__tests__/provider-catalog-visibility.test.ts

@@ -19,6 +19,23 @@ function makeConfig(): AssistantConfig {
 }
 
 describe("getVisibleProviderCatalog", () => {
+  test("hides Vellum-hosted GPU models unless developer mode is on", () => {
+    setOverridesForTesting({});
+    const hidden = getVisibleProviderCatalog(makeConfig());
+    expect(hidden.find((p) => p.id === "vellum")).toBeUndefined();
+    expect(
+      hidden
+        .flatMap((p) => p.models)
+        .some((m) => m.id === "qwen/qwen3-8b"),
+    ).toBe(false);
+
+    setOverridesForTesting({ "settings-developer-nav": true });
+    const visible = getVisibleProviderCatalog(makeConfig());
+    const vellum = visible.find((p) => p.id === "vellum");
+    expect(vellum).toBeDefined();
+    expect(vellum!.models.map((m) => m.id)).toEqual(["qwen/qwen3-8b"]);
+  });
+
   test("shows openai-compatible endpoints unconditionally (GA'ed)", () => {
     setOverridesForTesting({});