@vellumai/assistant 0.8.4 → 0.8.6

package/src/providers/gemini/client.ts

@@ -1,10 +1,10 @@
 import type * as genai from "@google/genai";
-import { ApiError, GoogleGenAI } from "@google/genai";
+import { ApiError, GoogleGenAI, ThinkingLevel } from "@google/genai";
 
-import { SYSTEM_PROMPT_CACHE_BOUNDARY } from "../../prompts/cache-boundary.js";
 import { isAbortReason } from "../../util/abort-reasons.js";
 import { ProviderError } from "../../util/errors.js";
 import { getLogger } from "../../util/logger.js";
+import { PROVIDER_CATALOG } from "../model-catalog.js";
 import { createStreamTimeout } from "../stream-timeout.js";
 import type {
   ContentBlock,
@@ -34,6 +34,65 @@ function isGemini3Model(model: string): boolean {
   return model.startsWith("gemini-3") || model.startsWith("models/gemini-3");
 }
 
+const THINKING_LEVEL_BY_NAME: Record<string, ThinkingLevel> = {
+  minimal: ThinkingLevel.MINIMAL,
+  low: ThinkingLevel.LOW,
+  medium: ThinkingLevel.MEDIUM,
+  high: ThinkingLevel.HIGH,
+};
+
+/**
+ * Translate the resolved wire-shape `thinking` config into Gemini's
+ * `thinkingConfig`. Returns `undefined` when no thinking config was supplied,
+ * which lets Google's per-model default apply (e.g. `gemini-3.5-flash`
+ * defaults to dynamic medium-level thinking).
+ *
+ * `enabled: false` maps to `thinkingLevel: MINIMAL` because Gemini 3.x cannot
+ * fully disable thinking — `"minimal"` is the floor. `includeThoughts` is
+ * gated on `streamThinking` so callers that opted out of streaming thoughts
+ * don't pay for thought tokens in the response.
+ */
+function buildThinkingConfig(
+  thinking: Record<string, unknown> | undefined,
+): genai.ThinkingConfig | undefined {
+  if (!thinking) return undefined;
+  if (thinking.type === "disabled") {
+    return {
+      thinkingLevel: ThinkingLevel.MINIMAL,
+      includeThoughts: false,
+    };
+  }
+  if (thinking.type !== "adaptive") return undefined;
+
+  const result: genai.ThinkingConfig = {};
+  if (typeof thinking.level === "string") {
+    const mapped = THINKING_LEVEL_BY_NAME[thinking.level];
+    if (mapped) result.thinkingLevel = mapped;
+  }
+  if (typeof thinking.streamThinking === "boolean") {
+    result.includeThoughts = thinking.streamThinking;
+  }
+  return Object.keys(result).length > 0 ? result : undefined;
+}
+
+/**
+ * Whether the active Gemini model accepts a `thinkingConfig`. Non-thinking
+ * models (e.g. `gemini-2.5-flash-lite`) reject thinking params, and gemini is
+ * in `THINKING_AWARE_PROVIDERS` so `providers/retry.ts` no longer strips them —
+ * so we gate on the catalog's `supportsThinking` capability here. Unknown or
+ * uncatalogued models default to allowing thinking config (preserving prior
+ * behavior); only an explicit `supportsThinking: false` suppresses it.
+ */
+function geminiModelSupportsThinking(model: string): boolean {
+  const normalized = model.startsWith("models/")
+    ? model.slice("models/".length)
+    : model;
+  const catalogModel = PROVIDER_CATALOG.find(
+    (provider) => provider.id === "gemini",
+  )?.models.find((m) => m.id === normalized);
+  return catalogModel?.supportsThinking !== false;
+}
+
 function stripGeminiHttpOptions(
   config: genai.GenerateContentConfig,
 ): genai.GenerateContentConfig {
@@ -176,6 +235,11 @@ export class GeminiProvider implements Provider {
       | Record<string, string>
       | undefined;
     const activeModel = modelOverride ?? this.model;
+    const thinkingConfig = geminiModelSupportsThinking(activeModel)
+      ? buildThinkingConfig(
+          configObj?.thinking as Record<string, unknown> | undefined,
+        )
+      : undefined;
 
     try {
       const geminiContents = this.toGeminiContents(messages, activeModel);
@@ -183,14 +247,14 @@ export class GeminiProvider implements Provider {
       const geminiConfig: genai.GenerateContentConfig = {};
 
       if (systemPrompt) {
-        geminiConfig.systemInstruction = systemPrompt.replaceAll(
-          SYSTEM_PROMPT_CACHE_BOUNDARY,
-          "\n",
-        );
+        geminiConfig.systemInstruction = systemPrompt;
       }
       if (maxTokens) {
         geminiConfig.maxOutputTokens = maxTokens;
       }
+      if (thinkingConfig) {
+        geminiConfig.thinkingConfig = thinkingConfig;
+      }
       if (tools && tools.length > 0) {
         geminiConfig.tools = [
           {

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

@@ -24,7 +24,6 @@ describe("openai-compatible adapter factory", () => {
       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" }],
@@ -52,7 +51,6 @@ describe("openai-compatible adapter factory", () => {
       name: "my-vllm",
       provider: "openai-compatible",
       auth: { type: "none" },
-      status: "active",
       label: null,
       baseUrl: "http://localhost:8080/v1",
       models: [{ id: "my-model" }],

package/src/providers/inference/__tests__/base-url-security.test.ts

@@ -7,6 +7,7 @@ import { migrateCreateProviderConnections } from "../../../memory/migrations/243
 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 { migrateStripBaseUrlNonOpenaiCompatible } from "../../../memory/migrations/257-strip-base-url-non-openai-compatible.js";
+import { migrateDropProviderConnectionStatus } from "../../../memory/migrations/265-drop-provider-connection-status.js";
 import * as schema from "../../../memory/schema.js";
 import { providerConnections } from "../../../memory/schema/inference.js";
 import { getConnection } from "../connections.js";
@@ -22,6 +23,7 @@ function bootDb() {
   const db = createTestDb();
   migrateCreateProviderConnections(db);
   migrateProviderConnectionStatusLabel(db);
+  migrateDropProviderConnectionStatus(db);
   migrateProviderConnectionBaseUrlAndModels(db);
   return db;
 }
@@ -42,7 +44,6 @@ describe("migration 257: strip base_url from non-openai-compatible connections",
         name: "bad-anthropic",
         provider: "anthropic",
         auth: JSON.stringify({ type: "api_key", credential: "cred-abc" }),
-        status: "active",
         baseUrl: "https://evil.example.com/v1",
         createdAt: now,
         updatedAt: now,
@@ -65,7 +66,6 @@ describe("migration 257: strip base_url from non-openai-compatible connections",
         name: "good-vllm",
         provider: "openai-compatible",
         auth: JSON.stringify({ type: "api_key", credential: "cred-vllm" }),
-        status: "active",
         baseUrl: "https://my-vllm.example.com/v1",
         models: JSON.stringify([{ id: "my-model" }]),
         createdAt: now,
@@ -89,7 +89,6 @@ describe("migration 257: strip base_url from non-openai-compatible connections",
         name: "bad-openai",
         provider: "openai",
         auth: JSON.stringify({ type: "api_key", credential: "cred-abc" }),
-        status: "active",
         baseUrl: "https://evil.example.com/v1",
         createdAt: now,
         updatedAt: now,

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

@@ -6,10 +6,10 @@ 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 { migrateDropProviderConnectionStatus } from "../../../memory/migrations/265-drop-provider-connection-status.js";
 import * as schema from "../../../memory/schema.js";
 import {
   createConnection,
-  disableManagedConnectionsForByokHatch,
   getConnection,
   listConnections,
   seedCanonicalConnections,
@@ -25,13 +25,17 @@ function createTestDb() {
 function bootDb() {
   const db = createTestDb();
   migrateCreateProviderConnections(db);
+  // 244 adds status + label columns. 265 drops status. This mirrors the
+  // production migration sequence so the Drizzle schema (which no longer
+  // declares status) stays consistent with the DB shape.
   migrateProviderConnectionStatusLabel(db);
+  migrateDropProviderConnectionStatus(db);
   migrateProviderConnectionBaseUrlAndModels(db);
   return db;
 }
 
-describe("connection CRUD status + label defaults", () => {
-  test("new connection without status/label gets status=active and label=null", () => {
+describe("connection CRUD label defaults", () => {
+  test("new connection without label gets label=null", () => {
     const db = bootDb();
     const result = createConnection(db, {
       name: "my-conn",
@@ -40,61 +44,38 @@ describe("connection CRUD status + label defaults", () => {
     });
     expect(result.ok).toBe(true);
     if (result.ok) {
-      expect(result.connection.status).toBe("active");
       expect(result.connection.label).toBeNull();
     }
   });
 
-  test("createConnection passes explicit status and label", () => {
+  test("createConnection passes explicit label", () => {
     const db = bootDb();
     const result = createConnection(db, {
-      name: "disabled-conn",
+      name: "labeled-conn",
       provider: "openai",
       auth: { type: "platform" },
-      status: "disabled",
       label: "My OpenAI",
     });
     expect(result.ok).toBe(true);
     if (result.ok) {
-      expect(result.connection.status).toBe("disabled");
       expect(result.connection.label).toBe("My OpenAI");
     }
   });
 
-  test("getConnection returns status and label from DB", () => {
+  test("getConnection returns label from DB", () => {
     const db = bootDb();
     createConnection(db, {
       name: "get-me",
       provider: "gemini",
       auth: { type: "platform" },
-      status: "disabled",
       label: "Gemini Pro",
     });
 
     const conn = getConnection(db, "get-me");
     expect(conn).not.toBeNull();
-    expect(conn!.status).toBe("disabled");
     expect(conn!.label).toBe("Gemini Pro");
   });
 
-  test("updateConnection updates status", () => {
-    const db = bootDb();
-    createConnection(db, {
-      name: "toggle-me",
-      provider: "anthropic",
-      auth: { type: "platform" },
-    });
-
-    const result = updateConnection(db, "toggle-me", {
-      auth: { type: "platform" },
-      status: "disabled",
-    });
-    expect(result.ok).toBe(true);
-    if (result.ok) {
-      expect(result.connection.status).toBe("disabled");
-    }
-  });
-
   test("updateConnection clears label when set to null", () => {
     const db = bootDb();
     createConnection(db, {
@@ -116,7 +97,7 @@ describe("connection CRUD status + label defaults", () => {
 });
 
 describe("seedCanonicalConnections labels", () => {
-  test("first boot seeds default labels on all three managed connections", () => {
+  test("first boot seeds default labels on all managed connections", () => {
     const db = bootDb();
     seedCanonicalConnections(db);
 
@@ -162,7 +143,7 @@ describe("seedCanonicalConnections labels", () => {
     expect(after?.label).toBe("Anthropic");
   });
 
-  test("backfill leaves explicit empty-overwrite null untouched on subsequent boot", () => {
+  test("backfill fills null label on subsequent boot", () => {
     const db = bootDb();
     seedCanonicalConnections(db);
 
@@ -183,83 +164,3 @@ describe("seedCanonicalConnections labels", () => {
     expect(conn?.label).toBe("OpenAI");
   });
 });
-
-describe("disableManagedConnectionsForByokHatch", () => {
-  test("flips all three canonical managed connections to status='disabled'", () => {
-    const db = bootDb();
-    seedCanonicalConnections(db);
-
-    // Sanity: seeded rows default to active.
-    expect(getConnection(db, "anthropic-managed")?.status).toBe("active");
-    expect(getConnection(db, "openai-managed")?.status).toBe("active");
-    expect(getConnection(db, "gemini-managed")?.status).toBe("active");
-
-    disableManagedConnectionsForByokHatch(db);
-
-    expect(getConnection(db, "anthropic-managed")?.status).toBe("disabled");
-    expect(getConnection(db, "openai-managed")?.status).toBe("disabled");
-    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
-    // subsequent daemon boot runs seedCanonicalConnections — and that
-    // boot must NOT revert the user's choice. The hatch-disable helper
-    // is only ever called from the seedInferenceProfiles hatch branch,
-    // so it does not run on a non-hatch boot; this test confirms the
-    // ambient seed pass leaves status alone.
-    const db = bootDb();
-    seedCanonicalConnections(db);
-    disableManagedConnectionsForByokHatch(db);
-
-    // User re-enables anthropic post-hatch.
-    updateConnection(db, "anthropic-managed", {
-      auth: { type: "platform" },
-      status: "active",
-    });
-    expect(getConnection(db, "anthropic-managed")?.status).toBe("active");
-
-    // Simulate a normal restart: seedCanonicalConnections runs every boot,
-    // disableManagedConnectionsForByokHatch does NOT.
-    seedCanonicalConnections(db);
-
-    expect(getConnection(db, "anthropic-managed")?.status).toBe("active");
-    // The two the user didn't touch stay disabled.
-    expect(getConnection(db, "openai-managed")?.status).toBe("disabled");
-    expect(getConnection(db, "gemini-managed")?.status).toBe("disabled");
-  });
-
-  test("idempotent re-hatch leaves all three at disabled", () => {
-    // Workspace reset / re-hatch scenario: helper runs again and any
-    // user re-enable from before the reset is intentionally undone —
-    // re-hatch means re-onboard.
-    const db = bootDb();
-    seedCanonicalConnections(db);
-    disableManagedConnectionsForByokHatch(db);
-
-    updateConnection(db, "anthropic-managed", {
-      auth: { type: "platform" },
-      status: "active",
-    });
-
-    disableManagedConnectionsForByokHatch(db);
-
-    expect(getConnection(db, "anthropic-managed")?.status).toBe("disabled");
-    expect(getConnection(db, "openai-managed")?.status).toBe("disabled");
-    expect(getConnection(db, "gemini-managed")?.status).toBe("disabled");
-  });
-});

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

@@ -21,6 +21,7 @@
 import { AnthropicProvider } from "../anthropic/client.js";
 import { FireworksProvider } from "../fireworks/client.js";
 import { GeminiProvider } from "../gemini/client.js";
+import { MinimaxProvider } from "../minimax/client.js";
 import { PROVIDER_CATALOG } from "../model-catalog.js";
 import { OllamaProvider } from "../ollama/client.js";
 import { OpenAIChatCompletionsProvider } from "../openai/chat-completions-provider.js";
@@ -111,6 +112,8 @@ const ADAPTER_FACTORIES: Record<string, AdapterFactory> = {
       streamTimeoutMs,
       ...(baseURL ? { baseURL } : {}),
     }),
+  minimax: ({ apiKey, model, streamTimeoutMs }) =>
+    new MinimaxProvider(apiKey, model, { streamTimeoutMs }),
 };
 
 /**

package/src/providers/inference/auth.ts

@@ -79,13 +79,6 @@ export const ConnectionProviderSchema = z.enum(
   VALID_CONNECTION_PROVIDERS as readonly [string, ...string[]],
 );
 
-// ---------------------------------------------------------------------------
-// Connection status
-// ---------------------------------------------------------------------------
-
-export const ConnectionStatusSchema = z.enum(["active", "disabled"]);
-export type ConnectionStatus = z.infer<typeof ConnectionStatusSchema>;
-
 // ---------------------------------------------------------------------------
 // Per-connection model entries (openai-compatible)
 // ---------------------------------------------------------------------------
@@ -104,7 +97,6 @@ export const ProviderConnectionSchema = z.object({
   name: z.string().min(1),
   provider: ConnectionProviderSchema,
   auth: AuthSchema,
-  status: ConnectionStatusSchema,
   label: z.string().min(1).nullable(),
   baseUrl: z.string().url().nullable(),
   models: z.array(ConnectionModelSchema).nullable(),

package/src/providers/inference/connections.ts

@@ -11,8 +11,6 @@ import {
   ConnectionModelSchema,
   type ConnectionProvider,
   ConnectionProviderSchema,
-  type ConnectionStatus,
-  ConnectionStatusSchema,
   type ProviderConnection,
   VALID_CONNECTION_PROVIDERS,
 } from "./auth.js";
@@ -55,16 +53,11 @@ export function listConnections(
     if (!auth.success) return [];
     const provider = ConnectionProviderSchema.safeParse(row.provider);
     if (!provider.success) return [];
-    const statusResult = ConnectionStatusSchema.safeParse(row.status);
-    const status: ConnectionStatus = statusResult.success
-      ? statusResult.data
-      : "active";
     return [
       {
         ...row,
         auth: auth.data,
         provider: provider.data,
-        status,
         label: row.label ?? null,
         baseUrl: row.baseUrl ?? null,
         models: parseModelsColumn(row.models),
@@ -89,15 +82,10 @@ export function getConnection(
   if (!auth.success) return null;
   const provider = ConnectionProviderSchema.safeParse(row.provider);
   if (!provider.success) return null;
-  const statusResult = ConnectionStatusSchema.safeParse(row.status);
-  const status: ConnectionStatus = statusResult.success
-    ? statusResult.data
-    : "active";
   return {
     ...row,
     auth: auth.data,
     provider: provider.data,
-    status,
     label: row.label ?? null,
     baseUrl: row.baseUrl ?? null,
     models: parseModelsColumn(row.models),
@@ -113,7 +101,6 @@ export type CreateConnectionInput = {
   name: string;
   provider: string;
   auth: Auth;
-  status?: ConnectionStatus;
   label?: string | null;
   baseUrl?: string | null;
   models?: ConnectionModel[] | null;
@@ -121,7 +108,6 @@ export type CreateConnectionInput = {
 
 export type UpdateConnectionInput = {
   auth: Auth;
-  status?: ConnectionStatus;
   label?: string | null;
   baseUrl?: string | null;
   models?: ConnectionModel[] | null;
@@ -173,7 +159,6 @@ export function createConnection(
     return { ok: false, error: { code: "already_exists" } };
   }
 
-  const status = input.status ?? "active";
   const label = input.label ?? null;
   const baseUrl = input.baseUrl ?? null;
   const models = input.models ?? null;
@@ -191,7 +176,6 @@ export function createConnection(
       name: input.name,
       provider,
       auth: JSON.stringify(authResult.data),
-      status,
       label,
       baseUrl,
       models: models === null ? null : JSON.stringify(models),
@@ -210,7 +194,6 @@ export function createConnection(
       name: input.name,
       provider,
       auth: authResult.data,
-      status,
       label,
       baseUrl,
       models,
@@ -255,12 +238,10 @@ export function updateConnection(
   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)
@@ -280,7 +261,6 @@ export function updateConnection(
     connection: {
       ...existing,
       auth: authResult.data,
-      status: input.status !== undefined ? input.status : existing.status,
       label: input.label !== undefined ? input.label : existing.label,
       baseUrl: nextBaseUrl,
       models: nextModels,
@@ -376,10 +356,9 @@ const CANONICAL_CONNECTIONS: Array<{
  *     blocking prevents a confusing delete → re-appear loop).
  *   - PATCH that changes `auth` is blocked (auth is locked to `{type:"platform"}`
  *     so any other value would be reverted on the next boot upsert).
- *   - PATCH that changes `label` and/or `status` is allowed — users may legitimately
- *     disable or relabel the managed connection. `status` is never touched by the
- *     boot upsert. `label` is seeded on initial INSERT and backfilled when null
- *     on subsequent boots so pre-seed installs pick up the default; a non-null
+ *   - PATCH that changes `label` is allowed — users may legitimately relabel the
+ *     managed connection. `label` is seeded on initial INSERT and backfilled when
+ *     null on subsequent boots so pre-seed installs pick up the default; a non-null
  *     user-customized label is preserved (see `seedCanonicalConnections`).
  *
  * Mirrors `MANAGED_PROFILE_NAMES` (config/seed-inference-profiles.ts).
@@ -399,14 +378,6 @@ export const MANAGED_CONNECTION_NAMES: ReadonlySet<string> = new Set(
  * customization is preserved; the separate backfill step below assigns the
  * default only when the existing row has `label IS NULL`, covering installs
  * that pre-date the label seed.
- *
- * 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 canonical managed rows to
- * `status: "disabled"` ONCE at hatch time via
- * `disableManagedConnectionsForByokHatch` (called from `seedInferenceProfiles`
- * when `isHatch && !isPlatform`); subsequent boots leave whatever the user
- * has chosen alone, so a post-hatch re-enable persists.
  */
 export function seedCanonicalConnections(db: DrizzleDb): void {
   const now = Date.now();
@@ -445,37 +416,3 @@ export function seedCanonicalConnections(db: DrizzleDb): void {
   }
 }
 
-/**
- * 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
- * BYOK user doesn't have yet, so surfacing them as enabled in the picker
- * would let users pick an unusable option on day one. But this is a
- * first-time-only default — the moment the user explicitly flips one
- * back to active (e.g. after logging into Vellum), we never want a daemon
- * restart to revert that. `seedCanonicalConnections` leaves `status` alone
- * on the UPDATE path, and this helper is invoked ONLY from
- * `seedInferenceProfiles`'s `isHatch && !isPlatform` branch. Subsequent
- * non-hatch boots never call it.
- *
- * 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,
-  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))
-      .run();
-  }
-}

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

@@ -89,9 +89,8 @@ export async function resolveAuth(
       // we need the prefix "credential/openai-codex" for the refresh logic.
       const credentialPrefix = auth.credential.replace(/\/access_token$/, "");
 
-      const { getValidCodexAccessToken } = await import(
-        "./codex-token-refresh.js"
-      );
+      const { getValidCodexAccessToken } =
+        await import("./codex-token-refresh.js");
       const token = await getValidCodexAccessToken(credentialPrefix);
 
       if (!token) {