@vellumai/assistant 0.8.2 → 0.8.3

package/src/providers/inference/__tests__/adapter-factory-openai-compatible.test.ts

@@ -0,0 +1,74 @@
+import { describe, expect, test } from "bun:test";
+
+import { OpenAIChatCompletionsProvider } from "../../openai/chat-completions-provider.js";
+import {
+  buildProviderAdapter,
+  createAdapterFromConnection,
+} from "../adapter-factory.js";
+import type { ProviderConnection, ResolvedAuth } from "../auth.js";
+
+describe("openai-compatible adapter factory", () => {
+  test("buildProviderAdapter returns an OpenAIChatCompletionsProvider", () => {
+    const adapter = buildProviderAdapter("openai-compatible", {
+      apiKey: "test-key",
+      model: "my-local-model",
+      streamTimeoutMs: 60_000,
+      baseURL: "http://localhost:8080/v1",
+      useNativeWebSearch: false,
+    });
+    expect(adapter).toBeInstanceOf(OpenAIChatCompletionsProvider);
+  });
+
+  test("createAdapterFromConnection wires baseURL from ResolvedAuth", () => {
+    const connection: ProviderConnection = {
+      name: "my-vllm",
+      provider: "openai-compatible",
+      auth: { type: "api_key", credential: "cred-vllm" },
+      status: "active",
+      label: "vLLM",
+      baseUrl: "http://localhost:8080/v1",
+      models: [{ id: "my-model" }],
+      createdAt: Date.now(),
+      updatedAt: Date.now(),
+      isManaged: false,
+    };
+
+    const resolvedAuth: ResolvedAuth = {
+      kind: "header",
+      headers: { Authorization: "Bearer sk-test" },
+      baseUrl: "http://localhost:8080/v1",
+    };
+
+    const adapter = createAdapterFromConnection(connection, resolvedAuth, {
+      model: "my-model",
+      streamTimeoutMs: 60_000,
+    });
+
+    expect(adapter).not.toBeNull();
+  });
+
+  test("createAdapterFromConnection rejects 'none' auth for openai-compatible", () => {
+    const connection: ProviderConnection = {
+      name: "my-vllm",
+      provider: "openai-compatible",
+      auth: { type: "none" },
+      status: "active",
+      label: null,
+      baseUrl: "http://localhost:8080/v1",
+      models: [{ id: "my-model" }],
+      createdAt: Date.now(),
+      updatedAt: Date.now(),
+      isManaged: false,
+    };
+
+    const resolvedAuth: ResolvedAuth = { kind: "none" };
+
+    const adapter = createAdapterFromConnection(connection, resolvedAuth, {
+      model: "my-model",
+    });
+
+    // openai-compatible is setupMode: "api-key", not keyless, so none auth
+    // should be rejected.
+    expect(adapter).toBeNull();
+  });
+});

package/src/providers/inference/__tests__/connections-openai-compatible.test.ts

@@ -0,0 +1,175 @@
+import { Database } from "bun:sqlite";
+import { describe, expect, test } from "bun:test";
+
+import { drizzle } from "drizzle-orm/bun-sqlite";
+
+import { migrateCreateProviderConnections } from "../../../memory/migrations/243-provider-connections.js";
+import { migrateProviderConnectionStatusLabel } from "../../../memory/migrations/244-provider-connection-status-label.js";
+import { migrateProviderConnectionBaseUrlAndModels } from "../../../memory/migrations/250-provider-connection-base-url-and-models.js";
+import * as schema from "../../../memory/schema.js";
+import {
+  createConnection,
+  getConnection,
+  listConnections,
+  updateConnection,
+} from "../connections.js";
+
+function createTestDb() {
+  const sqlite = new Database(":memory:");
+  sqlite.exec("PRAGMA journal_mode=WAL");
+  return drizzle(sqlite, { schema });
+}
+
+function bootDb() {
+  const db = createTestDb();
+  migrateCreateProviderConnections(db);
+  migrateProviderConnectionStatusLabel(db);
+  migrateProviderConnectionBaseUrlAndModels(db);
+  return db;
+}
+
+describe("openai-compatible connection CRUD", () => {
+  test("create requires base_url", () => {
+    const db = bootDb();
+    const result = createConnection(db, {
+      name: "my-vllm",
+      provider: "openai-compatible",
+      auth: { type: "api_key", credential: "cred-vllm" },
+      models: [{ id: "my-model" }],
+    });
+    expect(result.ok).toBe(false);
+    if (!result.ok) {
+      expect(result.error.code).toBe("base_url_required");
+    }
+  });
+
+  test("create requires at least one model", () => {
+    const db = bootDb();
+    const result = createConnection(db, {
+      name: "my-vllm",
+      provider: "openai-compatible",
+      auth: { type: "api_key", credential: "cred-vllm" },
+      baseUrl: "http://localhost:8080/v1",
+    });
+    expect(result.ok).toBe(false);
+    if (!result.ok) {
+      expect(result.error.code).toBe("models_required");
+    }
+  });
+
+  test("create rejects empty models array", () => {
+    const db = bootDb();
+    const result = createConnection(db, {
+      name: "my-vllm",
+      provider: "openai-compatible",
+      auth: { type: "api_key", credential: "cred-vllm" },
+      baseUrl: "http://localhost:8080/v1",
+      models: [],
+    });
+    expect(result.ok).toBe(false);
+    if (!result.ok) {
+      expect(result.error.code).toBe("models_required");
+    }
+  });
+
+  test("create persists baseUrl and models; round-trips via getConnection", () => {
+    const db = bootDb();
+    const models = [
+      { id: "llama-3-70b" },
+      { id: "mistral-7b", displayName: "Mistral 7B" },
+    ];
+    const result = createConnection(db, {
+      name: "my-vllm",
+      provider: "openai-compatible",
+      auth: { type: "api_key", credential: "cred-vllm" },
+      baseUrl: "http://localhost:8080/v1",
+      models,
+    });
+    expect(result.ok).toBe(true);
+    if (result.ok) {
+      expect(result.connection.baseUrl).toBe("http://localhost:8080/v1");
+      expect(result.connection.models).toEqual(models);
+    }
+
+    const fetched = getConnection(db, "my-vllm");
+    expect(fetched).not.toBeNull();
+    expect(fetched!.baseUrl).toBe("http://localhost:8080/v1");
+    expect(fetched!.models).toEqual(models);
+  });
+
+  test("non-openai-compatible providers leave baseUrl/models null", () => {
+    const db = bootDb();
+    const result = createConnection(db, {
+      name: "my-anthropic",
+      provider: "anthropic",
+      auth: { type: "api_key", credential: "cred-anthropic" },
+    });
+    expect(result.ok).toBe(true);
+    if (result.ok) {
+      expect(result.connection.baseUrl).toBeNull();
+      expect(result.connection.models).toBeNull();
+    }
+  });
+
+  test("updateConnection can change models without re-supplying baseUrl", () => {
+    const db = bootDb();
+    createConnection(db, {
+      name: "my-vllm",
+      provider: "openai-compatible",
+      auth: { type: "api_key", credential: "cred-vllm" },
+      baseUrl: "http://localhost:8080/v1",
+      models: [{ id: "llama-3-70b" }],
+    });
+
+    const result = updateConnection(db, "my-vllm", {
+      auth: { type: "api_key", credential: "cred-vllm" },
+      models: [{ id: "llama-3-70b" }, { id: "mistral-7b" }],
+    });
+    expect(result.ok).toBe(true);
+    if (result.ok) {
+      expect(result.connection.baseUrl).toBe("http://localhost:8080/v1");
+      expect(result.connection.models).toEqual([
+        { id: "llama-3-70b" },
+        { id: "mistral-7b" },
+      ]);
+    }
+  });
+
+  test("updateConnection rejects clearing models on openai-compatible", () => {
+    const db = bootDb();
+    createConnection(db, {
+      name: "my-vllm",
+      provider: "openai-compatible",
+      auth: { type: "api_key", credential: "cred-vllm" },
+      baseUrl: "http://localhost:8080/v1",
+      models: [{ id: "llama-3-70b" }],
+    });
+
+    const result = updateConnection(db, "my-vllm", {
+      auth: { type: "api_key", credential: "cred-vllm" },
+      models: [],
+    });
+    expect(result.ok).toBe(false);
+    if (!result.ok) {
+      expect(result.error.code).toBe("models_required");
+    }
+  });
+
+  test("listConnections includes baseUrl and models", () => {
+    const db = bootDb();
+    createConnection(db, {
+      name: "my-vllm",
+      provider: "openai-compatible",
+      auth: { type: "api_key", credential: "cred-vllm" },
+      baseUrl: "http://localhost:8080/v1",
+      models: [{ id: "llama-3-70b" }],
+    });
+
+    const connections = listConnections(db, {
+      provider: "openai-compatible",
+    });
+    expect(connections.length).toBe(1);
+    expect(connections[0]!.baseUrl).toBe("http://localhost:8080/v1");
+    expect(connections[0]!.models).toEqual([{ id: "llama-3-70b" }]);
+  });
+});

package/src/providers/inference/__tests__/connections-status-label.test.ts

@@ -5,6 +5,7 @@ import { drizzle } from "drizzle-orm/bun-sqlite";
 
 import { migrateCreateProviderConnections } from "../../../memory/migrations/243-provider-connections.js";
 import { migrateProviderConnectionStatusLabel } from "../../../memory/migrations/244-provider-connection-status-label.js";
+import { migrateProviderConnectionBaseUrlAndModels } from "../../../memory/migrations/250-provider-connection-base-url-and-models.js";
 import * as schema from "../../../memory/schema.js";
 import {
   createConnection,
@@ -25,6 +26,7 @@ function bootDb() {
   const db = createTestDb();
   migrateCreateProviderConnections(db);
   migrateProviderConnectionStatusLabel(db);
+  migrateProviderConnectionBaseUrlAndModels(db);
   return db;
 }
 
@@ -199,6 +201,19 @@ describe("disableManagedConnectionsForByokHatch", () => {
     expect(getConnection(db, "gemini-managed")?.status).toBe("disabled");
   });
 
+  test("leaves an excluded managed connection active", () => {
+    const db = bootDb();
+    seedCanonicalConnections(db);
+
+    disableManagedConnectionsForByokHatch(db, {
+      excludeConnection: "anthropic-managed",
+    });
+
+    expect(getConnection(db, "anthropic-managed")?.status).toBe("active");
+    expect(getConnection(db, "openai-managed")?.status).toBe("disabled");
+    expect(getConnection(db, "gemini-managed")?.status).toBe("disabled");
+  });
+
   test("subsequent seedCanonicalConnections call does NOT re-flip a user-re-enabled connection", () => {
     // Models the post-hatch lifecycle: at hatch we disable; the user
     // later flips one back to active (e.g. after Vellum login). Every

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

@@ -84,33 +84,22 @@ const ADAPTER_FACTORIES: Record<string, AdapterFactory> = {
       apiKey: apiKey || undefined,
       streamTimeoutMs,
     }),
-  fireworks: ({ apiKey, model, streamTimeoutMs }) =>
-    new FireworksProvider(apiKey, model, { streamTimeoutMs }),
+  fireworks: ({ apiKey, model, streamTimeoutMs, baseURL }) =>
+    new FireworksProvider(apiKey, model, {
+      streamTimeoutMs,
+      ...(baseURL ? { baseURL } : {}),
+    }),
   openrouter: ({ apiKey, model, streamTimeoutMs, useNativeWebSearch }) =>
     new OpenRouterProvider(apiKey, model, {
       useNativeWebSearch,
       streamTimeoutMs,
     }),
-  zai: ({ apiKey, model, streamTimeoutMs }) =>
-    new OpenAIChatCompletionsProvider(apiKey, model, {
-      providerName: "zai",
-      providerLabel: "z.ai",
-      baseURL: "https://api.z.ai/api/paas/v4/",
-      streamTimeoutMs,
-    }),
-  deepseek: ({ apiKey, model, streamTimeoutMs }) =>
+  "openai-compatible": ({ apiKey, model, streamTimeoutMs, baseURL }) =>
     new OpenAIChatCompletionsProvider(apiKey, model, {
-      providerName: "deepseek",
-      providerLabel: "DeepSeek",
-      baseURL: "https://api.deepseek.com",
-      streamTimeoutMs,
-    }),
-  minimax: ({ apiKey, model, streamTimeoutMs }) =>
-    new OpenAIChatCompletionsProvider(apiKey, model, {
-      providerName: "minimax",
-      providerLabel: "MiniMax",
-      baseURL: "https://api.minimax.io/v1",
+      providerName: "openai-compatible",
+      providerLabel: "OpenAI-compatible",
       streamTimeoutMs,
+      ...(baseURL ? { baseURL } : {}),
     }),
 };
 

package/src/providers/inference/auth.ts

@@ -86,6 +86,16 @@ export const ConnectionProviderSchema = z.enum(
 export const ConnectionStatusSchema = z.enum(["active", "disabled"]);
 export type ConnectionStatus = z.infer<typeof ConnectionStatusSchema>;
 
+// ---------------------------------------------------------------------------
+// Per-connection model entries (openai-compatible)
+// ---------------------------------------------------------------------------
+
+export const ConnectionModelSchema = z.object({
+  id: z.string().min(1),
+  displayName: z.string().min(1).optional(),
+});
+export type ConnectionModel = z.infer<typeof ConnectionModelSchema>;
+
 // ---------------------------------------------------------------------------
 // Full connection shape used by CRUD layer
 // ---------------------------------------------------------------------------
@@ -96,6 +106,8 @@ export const ProviderConnectionSchema = z.object({
   auth: AuthSchema,
   status: ConnectionStatusSchema,
   label: z.string().min(1).nullable(),
+  baseUrl: z.string().url().nullable(),
+  models: z.array(ConnectionModelSchema).nullable(),
   createdAt: z.number().int(),
   updatedAt: z.number().int(),
   /**

package/src/providers/inference/backfill.ts

@@ -21,7 +21,12 @@ import { loadRawConfig, saveRawConfig } from "../../config/loader.js";
 import type { DrizzleDb } from "../../memory/db-connection.js";
 import { credentialKey } from "../../security/credential-key.js";
 import { getLogger } from "../../util/logger.js";
-import { createConnection, getConnection, seedCanonicalConnections } from "./connections.js";
+import {
+  createConnection,
+  getConnection,
+  PROVIDERS_REQUIRING_BASE_URL_AND_MODELS,
+  seedCanonicalConnections,
+} from "./connections.js";
 
 const log = getLogger("provider-connections-backfill");
 
@@ -149,6 +154,14 @@ function ensureProviderConnection(
   const provider = entry.provider as string | undefined;
   if (!provider) return false;
 
+  if (PROVIDERS_REQUIRING_BASE_URL_AND_MODELS.has(provider)) {
+    log.warn(
+      { entry: entryLabel, provider },
+      "Skipping backfill for provider that requires per-connection base_url/models",
+    );
+    return false;
+  }
+
   let connectionName: string;
 
   if (globalMode === "managed" && MANAGED_PROVIDERS.has(provider)) {

package/src/providers/inference/connections.ts

@@ -1,4 +1,5 @@
 import { and, eq, isNull } from "drizzle-orm";
+import { z } from "zod";
 
 import type { DrizzleDb } from "../../memory/db-connection.js";
 import { providerConnections } from "../../memory/schema/inference.js";
@@ -6,6 +7,8 @@ import { clearConnectionProviderCache } from "../registry.js";
 import {
   type Auth,
   AuthSchema,
+  type ConnectionModel,
+  ConnectionModelSchema,
   type ConnectionProvider,
   ConnectionProviderSchema,
   type ConnectionStatus,
@@ -14,6 +17,23 @@ import {
   VALID_CONNECTION_PROVIDERS,
 } from "./auth.js";
 
+// ---------------------------------------------------------------------------
+// Helpers
+// ---------------------------------------------------------------------------
+
+function parseModelsColumn(raw: string | null): ConnectionModel[] | null {
+  if (raw === null || raw === "") return null;
+  try {
+    const parsed = z.array(ConnectionModelSchema).safeParse(JSON.parse(raw));
+    return parsed.success ? parsed.data : null;
+  } catch {
+    return null;
+  }
+}
+
+export const PROVIDERS_REQUIRING_BASE_URL_AND_MODELS: ReadonlySet<string> =
+  new Set(["openai-compatible"]);
+
 // ---------------------------------------------------------------------------
 // Read
 // ---------------------------------------------------------------------------
@@ -46,6 +66,8 @@ export function listConnections(
         provider: provider.data,
         status,
         label: row.label ?? null,
+        baseUrl: row.baseUrl ?? null,
+        models: parseModelsColumn(row.models),
         isManaged: MANAGED_CONNECTION_NAMES.has(row.name),
       },
     ];
@@ -77,6 +99,8 @@ export function getConnection(
     provider: provider.data,
     status,
     label: row.label ?? null,
+    baseUrl: row.baseUrl ?? null,
+    models: parseModelsColumn(row.models),
     isManaged: MANAGED_CONNECTION_NAMES.has(row.name),
   };
 }
@@ -91,22 +115,30 @@ export type CreateConnectionInput = {
   auth: Auth;
   status?: ConnectionStatus;
   label?: string | null;
+  baseUrl?: string | null;
+  models?: ConnectionModel[] | null;
 };
 
 export type UpdateConnectionInput = {
   auth: Auth;
   status?: ConnectionStatus;
   label?: string | null;
+  baseUrl?: string | null;
+  models?: ConnectionModel[] | null;
 };
 
 export type ConnectionCreateError =
   | { code: "already_exists" }
   | { code: "invalid_provider"; provider: string }
-  | { code: "invalid_auth" };
+  | { code: "invalid_auth" }
+  | { code: "base_url_required" }
+  | { code: "models_required" };
 
 export type ConnectionUpdateError =
   | { code: "not_found" }
-  | { code: "invalid_auth" };
+  | { code: "invalid_auth" }
+  | { code: "base_url_required" }
+  | { code: "models_required" };
 
 export type ConnectionDeleteError =
   | { code: "not_found" }
@@ -143,6 +175,15 @@ export function createConnection(
 
   const status = input.status ?? "active";
   const label = input.label ?? null;
+  const baseUrl = input.baseUrl ?? null;
+  const models = input.models ?? null;
+
+  if (PROVIDERS_REQUIRING_BASE_URL_AND_MODELS.has(provider)) {
+    if (!baseUrl) return { ok: false, error: { code: "base_url_required" } };
+    if (!models || models.length === 0) {
+      return { ok: false, error: { code: "models_required" } };
+    }
+  }
 
   const now = Date.now();
   db.insert(providerConnections)
@@ -152,6 +193,8 @@ export function createConnection(
       auth: JSON.stringify(authResult.data),
       status,
       label,
+      baseUrl,
+      models: models === null ? null : JSON.stringify(models),
       createdAt: now,
       updatedAt: now,
     })
@@ -169,6 +212,8 @@ export function createConnection(
       auth: authResult.data,
       status,
       label,
+      baseUrl,
+      models,
       createdAt: now,
       updatedAt: now,
       isManaged: MANAGED_CONNECTION_NAMES.has(input.name),
@@ -193,15 +238,34 @@ export function updateConnection(
     return { ok: false, error: { code: "invalid_auth" } };
   }
 
+  const nextBaseUrl =
+    input.baseUrl !== undefined ? input.baseUrl : existing.baseUrl;
+  const nextModels =
+    input.models !== undefined ? input.models : existing.models;
+
+  if (PROVIDERS_REQUIRING_BASE_URL_AND_MODELS.has(existing.provider)) {
+    if (!nextBaseUrl)
+      return { ok: false, error: { code: "base_url_required" } };
+    if (!nextModels || nextModels.length === 0) {
+      return { ok: false, error: { code: "models_required" } };
+    }
+  }
+
   const now = Date.now();
   const setClause: {
     auth: string;
     updatedAt: number;
     status?: string;
     label?: string | null;
+    baseUrl?: string | null;
+    models?: string | null;
   } = { auth: JSON.stringify(authResult.data), updatedAt: now };
   if (input.status !== undefined) setClause.status = input.status;
   if (input.label !== undefined) setClause.label = input.label;
+  if (input.baseUrl !== undefined) setClause.baseUrl = input.baseUrl;
+  if (input.models !== undefined)
+    setClause.models =
+      input.models === null ? null : JSON.stringify(input.models);
 
   db.update(providerConnections)
     .set(setClause)
@@ -218,6 +282,8 @@ export function updateConnection(
       auth: authResult.data,
       status: input.status !== undefined ? input.status : existing.status,
       label: input.label !== undefined ? input.label : existing.label,
+      baseUrl: nextBaseUrl,
+      models: nextModels,
       updatedAt: now,
     },
   };
@@ -294,6 +360,12 @@ const CANONICAL_CONNECTIONS: Array<{
     auth: { type: "platform" },
     label: "Google Gemini",
   },
+  {
+    name: "fireworks-managed",
+    provider: "fireworks",
+    auth: { type: "platform" },
+    label: "Fireworks",
+  },
 ];
 
 /**
@@ -330,7 +402,7 @@ export const MANAGED_CONNECTION_NAMES: ReadonlySet<string> = new Set(
  *
  * Status handling: the upsert never touches `status` so user customization
  * is preserved across reboots. New rows default to `status: "active"` via the
- * column default. Off-platform installs flip the three canonical rows to
+ * column default. Off-platform installs flip canonical managed rows to
  * `status: "disabled"` ONCE at hatch time via
  * `disableManagedConnectionsForByokHatch` (called from `seedInferenceProfiles`
  * when `isHatch && !isPlatform`); subsequent boots leave whatever the user
@@ -374,7 +446,7 @@ export function seedCanonicalConnections(db: DrizzleDb): void {
 }
 
 /**
- * Flip the three canonical managed connections to `status: "disabled"` at
+ * Flip canonical managed connections to `status: "disabled"` at
  * hatch time on BYOK (off-platform) installs.
  *
  * Why hatch-time only: managed connections need platform auth that a fresh
@@ -389,10 +461,18 @@ export function seedCanonicalConnections(db: DrizzleDb): void {
  *
  * Idempotent: a second hatch (workspace reset) re-disables the rows, which
  * is the right call — re-hatch means re-onboard.
+ *
+ * When onboarding explicitly selected a managed profile, callers may exclude
+ * that selected connection so the managed route remains usable for the first
+ * post-onboarding message.
  */
-export function disableManagedConnectionsForByokHatch(db: DrizzleDb): void {
+export function disableManagedConnectionsForByokHatch(
+  db: DrizzleDb,
+  options: { excludeConnection?: string } = {},
+): void {
   const now = Date.now();
   for (const name of MANAGED_CONNECTION_NAMES) {
+    if (name === options.excludeConnection) continue;
     db.update(providerConnections)
       .set({ status: "disabled", updatedAt: now })
       .where(eq(providerConnections.name, name))

package/src/providers/inference/resolve-auth.ts

@@ -23,6 +23,7 @@ export type ResolveAuthError =
 export async function resolveAuth(
   auth: Auth,
   provider: string,
+  opts: { baseUrl?: string | null } = {},
 ): Promise<
   { ok: true; resolved: ResolvedAuth } | { ok: false; error: ResolveAuthError }
 > {
@@ -40,6 +41,7 @@ export async function resolveAuth(
         resolved: {
           kind: "header",
           headers: { Authorization: `Bearer ${value}` },
+          ...(opts.baseUrl ? { baseUrl: opts.baseUrl } : {}),
         },
       };
     }