@vellumai/assistant 0.12.1-dev.202609141913.5e16607 → 0.12.1-staging.2

package/src/__tests__/workspace-migration-154-repair-retired-codex-gpt-5-4-model-ids.test.ts

@@ -1,336 +0,0 @@
-import {
-  existsSync,
-  mkdirSync,
-  readFileSync,
-  rmSync,
-  writeFileSync,
-} from "node:fs";
-import { tmpdir } from "node:os";
-import { join } from "node:path";
-import { Database } from "bun:sqlite";
-import { afterEach, beforeEach, describe, expect, test } from "bun:test";
-
-import { repairRetiredCodexGpt54ModelIdsMigration } from "../workspace/migrations/154-repair-retired-codex-gpt-5-4-model-ids.js";
-import { WORKSPACE_MIGRATIONS } from "../workspace/migrations/registry.js";
-import { assertNotLiveDb } from "./assert-not-live-db.js";
-
-const STALE = "gpt-5.4";
-const STALE_MINI = "gpt-5.4-mini";
-const REPLACEMENT = "gpt-5.5";
-const REPLACEMENT_MINI = "gpt-5.6-luna";
-
-const API_KEY_AUTH = '{"type":"api_key","credential":"credential/openai"}';
-const SUBSCRIPTION_AUTH =
-  '{"type":"oauth_subscription","credential":"credential/chatgpt"}';
-
-let workspaceDir: string;
-
-function freshWorkspace(): void {
-  workspaceDir = join(
-    tmpdir(),
-    `vellum-migration-154-test-${Date.now()}-${Math.random().toString(36).slice(2)}`,
-  );
-  mkdirSync(workspaceDir, { recursive: true });
-}
-
-function writeConfig(data: Record<string, unknown>): void {
-  writeFileSync(
-    join(workspaceDir, "config.json"),
-    JSON.stringify(data, null, 2) + "\n",
-  );
-}
-
-function readConfig(): Record<string, unknown> {
-  return JSON.parse(readFileSync(join(workspaceDir, "config.json"), "utf-8"));
-}
-
-function readLlm(): Record<string, any> {
-  return readConfig().llm as Record<string, any>;
-}
-
-function seedRows(
-  rows: Array<{ name: string; provider: string; auth: string }>,
-): void {
-  mkdirSync(join(workspaceDir, "data", "db"), { recursive: true });
-  const db = new Database(join(workspaceDir, "data", "db", "assistant.db"));
-  db.run(`CREATE TABLE IF NOT EXISTS provider_connections (
-    name TEXT PRIMARY KEY,
-    provider TEXT NOT NULL,
-    auth TEXT NOT NULL,
-    created_at INTEGER NOT NULL,
-    updated_at INTEGER NOT NULL
-  )`);
-  for (const row of rows) {
-    db.query(
-      `INSERT INTO provider_connections (name, provider, auth, created_at, updated_at) VALUES (?, ?, ?, 1, 1)`,
-    ).run(row.name, row.provider, row.auth);
-  }
-  db.close();
-}
-
-const SUBSCRIPTION_ROW = {
-  name: "chatgpt-subscription",
-  provider: "chatgpt",
-  auth: SUBSCRIPTION_AUTH,
-};
-const API_KEY_ROW = {
-  name: "openai-key",
-  provider: "openai",
-  auth: API_KEY_AUTH,
-};
-
-beforeEach(() => {
-  freshWorkspace();
-});
-
-afterEach(() => {
-  if (existsSync(workspaceDir)) {
-    assertNotLiveDb(workspaceDir);
-    rmSync(workspaceDir, { recursive: true, force: true });
-  }
-});
-
-describe("154-repair-retired-codex-gpt-5-4-model-ids migration", () => {
-  test("has correct migration id and is registered", () => {
-    expect(repairRetiredCodexGpt54ModelIdsMigration.id).toBe(
-      "154-repair-retired-codex-gpt-5-4-model-ids",
-    );
-    expect(WORKSPACE_MIGRATIONS.map((m) => m.id)).toContain(
-      "154-repair-retired-codex-gpt-5-4-model-ids",
-    );
-  });
-
-  test("repairs chatgpt fragments in default, call sites, and profiles", () => {
-    writeConfig({
-      llm: {
-        default: { provider: "chatgpt", model: STALE },
-        callSites: {
-          recall: { provider: "chatgpt", model: STALE_MINI, maxTokens: 4096 },
-          heartbeat: { provider: "chatgpt", model: `${STALE}-tuned` },
-          malformed: STALE,
-        },
-        profiles: {
-          codex: { provider: "chatgpt", model: STALE, source: "user" },
-          budget: { provider: "chatgpt", model: STALE_MINI },
-          current: { provider: "chatgpt", model: "gpt-5.6-terra" },
-          // The identity fails schema validation regardless of a stray
-          // binding, so it is repaired without consulting the rows.
-          strayBinding: {
-            provider: "chatgpt",
-            provider_connection: "openai-key",
-            model: STALE,
-          },
-        },
-      },
-    });
-
-    repairRetiredCodexGpt54ModelIdsMigration.run(workspaceDir);
-
-    const llm = readLlm();
-    expect(llm.default.model).toBe(REPLACEMENT);
-    expect(llm.callSites.recall.model).toBe(REPLACEMENT_MINI);
-    expect(llm.callSites.recall.maxTokens).toBe(4096);
-    // Non-exact matches and malformed leaves are untouched.
-    expect(llm.callSites.heartbeat.model).toBe(`${STALE}-tuned`);
-    expect(llm.callSites.malformed).toBe(STALE);
-    expect(llm.profiles.codex.model).toBe(REPLACEMENT);
-    expect(llm.profiles.codex.source).toBe("user");
-    expect(llm.profiles.budget.model).toBe(REPLACEMENT_MINI);
-    expect(llm.profiles.current.model).toBe("gpt-5.6-terra");
-    expect(llm.profiles.strayBinding.model).toBe(REPLACEMENT);
-  });
-
-  test("repairs entry-bound fragments whose row is the subscription", () => {
-    seedRows([
-      // Post-DB-migration-366 row shape.
-      SUBSCRIPTION_ROW,
-      // Pre-366 row shape: provider still openai, auth proves the route.
-      { name: "legacy-sub", provider: "openai", auth: SUBSCRIPTION_AUTH },
-    ]);
-    writeConfig({
-      llm: {
-        default: {
-          provider: "openai",
-          provider_connection: "chatgpt-subscription",
-          model: STALE,
-        },
-        callSites: {
-          recall: { provider: "chatgpt-subscription", model: STALE_MINI },
-        },
-        profiles: {
-          bound: { provider: "chatgpt-subscription", model: STALE },
-          legacy: { provider: "legacy-sub", model: STALE_MINI },
-          // Legacy binding: dispatch honors it ahead of the declared
-          // provider and accepts the ChatGPT row for openai.
-          pinned: {
-            provider: "openai",
-            provider_connection: "chatgpt-subscription",
-            model: STALE,
-          },
-        },
-      },
-    });
-
-    repairRetiredCodexGpt54ModelIdsMigration.run(workspaceDir);
-
-    const llm = readLlm();
-    expect(llm.default.model).toBe(REPLACEMENT);
-    expect(llm.callSites.recall.model).toBe(REPLACEMENT_MINI);
-    expect(llm.profiles.bound.model).toBe(REPLACEMENT);
-    expect(llm.profiles.legacy.model).toBe(REPLACEMENT_MINI);
-    expect(llm.profiles.pinned.model).toBe(REPLACEMENT);
-  });
-
-  test("judges a binding as a row even when named like a vendor", () => {
-    seedRows([
-      { name: "openai", provider: "openai", auth: SUBSCRIPTION_AUTH },
-      { name: "chatgpt", provider: "openai", auth: API_KEY_AUTH },
-    ]);
-    writeConfig({
-      llm: {
-        profiles: {
-          subRow: {
-            provider: "openai",
-            provider_connection: "openai",
-            model: STALE,
-          },
-          keyRow: {
-            provider: "chatgpt-subscription",
-            provider_connection: "chatgpt",
-            model: STALE_MINI,
-          },
-        },
-      },
-    });
-
-    repairRetiredCodexGpt54ModelIdsMigration.run(workspaceDir);
-
-    const llm = readLlm();
-    expect(llm.profiles.subRow.model).toBe(REPLACEMENT);
-    expect(llm.profiles.keyRow.model).toBe(STALE_MINI);
-  });
-
-  test("leaves API-key, other-vendor, providerless, and dangling fragments untouched", () => {
-    seedRows([API_KEY_ROW, SUBSCRIPTION_ROW]);
-    const config = {
-      llm: {
-        // Explicit vendors keep the model: API-key OpenAI still serves it
-        // and an openai-compatible endpoint may too.
-        default: { provider: "openai", model: STALE },
-        defaultProvider: { provider: "chatgpt" },
-        callSites: {
-          vision: { provider: "openai-compatible", model: STALE_MINI },
-          recall: { provider: "openai", model: STALE },
-          // A providerless pin is out of scope: it serves the model on an
-          // API-key or managed winner, and on a subscription winner the
-          // request already fails upstream with no config loss.
-          heartbeatAgent: { model: STALE },
-          // A raw call-site binding is stripped by the schema.
-          filingAgent: {
-            provider: "openai-key",
-            provider_connection: "chatgpt-subscription",
-            model: STALE,
-          },
-        },
-        profiles: {
-          byok: { provider: "openai", model: STALE_MINI },
-          keyBound: { provider: "openai-key", model: STALE },
-          // Entry name with no row: nothing proves it is the subscription.
-          dangling: { provider: "ghost", model: STALE },
-          // Dispatch honors the explicit binding ahead of the provider.
-          keyOverride: {
-            provider: "chatgpt-subscription",
-            provider_connection: "openai-key",
-            model: STALE,
-          },
-        },
-      },
-    };
-    writeConfig(config);
-    const before = readFileSync(join(workspaceDir, "config.json"), "utf-8");
-
-    repairRetiredCodexGpt54ModelIdsMigration.run(workspaceDir);
-
-    expect(readFileSync(join(workspaceDir, "config.json"), "utf-8")).toBe(
-      before,
-    );
-  });
-
-  test("needs no DB for identity or vendor fragments", () => {
-    writeConfig({
-      llm: {
-        default: { provider: "chatgpt", model: STALE },
-        profiles: {
-          byok: { provider: "openai", model: STALE },
-          bound: { provider: "chatgpt-subscription", model: STALE },
-        },
-      },
-    });
-
-    repairRetiredCodexGpt54ModelIdsMigration.run(workspaceDir);
-
-    const llm = readLlm();
-    expect(llm.default.model).toBe(REPLACEMENT);
-    expect(llm.profiles.byok.model).toBe(STALE);
-    // An entry name with no DB file is dangling.
-    expect(llm.profiles.bound.model).toBe(STALE);
-  });
-
-  test("throws when an entry name needs rows and the DB is unreadable", () => {
-    // A DB file without the provider_connections table is unqueryable, so
-    // the run must fail (and retry later) instead of skipping the profile.
-    mkdirSync(join(workspaceDir, "data", "db"), { recursive: true });
-    writeFileSync(join(workspaceDir, "data", "db", "assistant.db"), "");
-    writeConfig({
-      llm: {
-        profiles: { bound: { provider: "chatgpt-subscription", model: STALE } },
-      },
-    });
-
-    expect(() =>
-      repairRetiredCodexGpt54ModelIdsMigration.run(workspaceDir),
-    ).toThrow();
-    expect(readLlm().profiles.bound.model).toBe(STALE);
-
-    // The identity form never needs the rows, so the same broken DB does
-    // not block its repair.
-    writeConfig({
-      llm: { default: { provider: "chatgpt", model: STALE } },
-    });
-    repairRetiredCodexGpt54ModelIdsMigration.run(workspaceDir);
-    expect(readLlm().default.model).toBe(REPLACEMENT);
-  });
-
-  test("is idempotent and a no-op without the stale IDs", () => {
-    writeConfig({
-      llm: {
-        default: { provider: "chatgpt", model: STALE },
-        profiles: { fine: { provider: "chatgpt", model: REPLACEMENT } },
-      },
-    });
-
-    repairRetiredCodexGpt54ModelIdsMigration.run(workspaceDir);
-    const first = readConfig();
-    repairRetiredCodexGpt54ModelIdsMigration.run(workspaceDir);
-    expect(readConfig()).toEqual(first);
-
-    const llm = first.llm as Record<string, any>;
-    expect(llm.default.model).toBe(REPLACEMENT);
-    expect(llm.profiles.fine.model).toBe(REPLACEMENT);
-  });
-
-  test("handles missing config, missing llm block, and invalid JSON", () => {
-    expect(() =>
-      repairRetiredCodexGpt54ModelIdsMigration.run(workspaceDir),
-    ).not.toThrow();
-
-    writeConfig({ theme: "dark" });
-    repairRetiredCodexGpt54ModelIdsMigration.run(workspaceDir);
-    expect(readConfig()).toEqual({ theme: "dark" });
-
-    writeFileSync(join(workspaceDir, "config.json"), "{not json");
-    expect(() =>
-      repairRetiredCodexGpt54ModelIdsMigration.run(workspaceDir),
-    ).not.toThrow();
-  });
-});

package/src/acp/__tests__/helpers/acp-model-option.ts

@@ -1,51 +0,0 @@
-/**
- * Shared test fixture: the `SessionConfigOption` an adapter advertises for
- * model selection, shaped the way claude-agent-acp reports one (a `select`
- * with id and category `model`).
- */
-
-import type { SessionConfigOption } from "@agentclientprotocol/sdk";
-
-/** A model selector currently sitting on `currentValue`. */
-export function modelOption(currentValue: string): SessionConfigOption {
-  return {
-    type: "select",
-    id: "model",
-    name: "Model",
-    category: "model",
-    currentValue,
-    options: [
-      { value: "sonnet", name: "Sonnet" },
-      { value: "opus", name: "Opus", description: "Most capable" },
-    ],
-  };
-}
-
-/**
- * A model selector sitting on nothing. `deriveModelInfo` reads an empty
- * `currentValue` as "no model reported", which is the only shape that leaves a
- * resumed session with a selector to pin through.
- */
-export function modelOptionWithoutCurrent(): SessionConfigOption {
-  return modelOption("");
-}
-
-/**
- * A selector that is not the model one, so a set carrying only this reads as
- * an adapter that advertises no model selection.
- */
-export function nonModelOption(): SessionConfigOption {
-  return {
-    type: "select",
-    id: "mode",
-    name: "Mode",
-    currentValue: "default",
-    options: [{ value: "default", name: "Default" }],
-  };
-}
-
-/** `modelOption`'s options as `deriveModelInfo` flattens them. */
-export const MODEL_OPTION_MODELS = [
-  { value: "sonnet", label: "Sonnet" },
-  { value: "opus", label: "Opus", description: "Most capable" },
-];

package/src/acp/model-config.test.ts

@@ -1,166 +0,0 @@
-/**
- * Tests for the pure ACP model-config helpers: flattening an adapter's model
- * `SessionConfigOption` into publishable model info, and the spawn-time
- * precedence ladder.
- */
-
-import { describe, expect, test } from "bun:test";
-
-import type { SessionConfigOption } from "@agentclientprotocol/sdk";
-
-import {
-  MODEL_OPTION_MODELS,
-  modelOption,
-} from "./__tests__/helpers/acp-model-option.js";
-import { deriveModelInfo, resolveAcpModel } from "./model-config.js";
-
-const flatModelOption = modelOption("sonnet");
-
-describe("deriveModelInfo", () => {
-  test("flattens flat options and reports the current value", () => {
-    expect(deriveModelInfo([flatModelOption])).toEqual({
-      model: "sonnet",
-      modelConfigId: "model",
-      availableModels: MODEL_OPTION_MODELS,
-    });
-  });
-
-  test("flattens grouped options and carries the group name", () => {
-    const grouped: SessionConfigOption = {
-      type: "select",
-      id: "model",
-      name: "Model",
-      category: "model",
-      currentValue: "opus",
-      options: [
-        {
-          group: "anthropic",
-          name: "Anthropic",
-          options: [
-            { value: "opus", name: "Opus" },
-            { value: "haiku", name: "Haiku", description: "Fast" },
-          ],
-        },
-        {
-          group: "aliases",
-          name: "Aliases",
-          options: [{ value: "best", name: "Best available" }],
-        },
-      ],
-    };
-
-    expect(deriveModelInfo([grouped])).toEqual({
-      model: "opus",
-      modelConfigId: "model",
-      availableModels: [
-        { value: "opus", label: "Opus", group: "Anthropic" },
-        {
-          value: "haiku",
-          label: "Haiku",
-          description: "Fast",
-          group: "Anthropic",
-        },
-        { value: "best", label: "Best available", group: "Aliases" },
-      ],
-    });
-  });
-
-  test("matches on id alone when no category is reported", () => {
-    const uncategorized: SessionConfigOption = {
-      type: "select",
-      id: "model",
-      name: "Model",
-      currentValue: "haiku",
-      options: [{ value: "haiku", name: "Haiku" }],
-    };
-
-    const info = deriveModelInfo([uncategorized]);
-
-    expect(info.modelConfigId).toBe("model");
-    expect(info.model).toBe("haiku");
-  });
-
-  test("matches on category alone when the id differs", () => {
-    const byCategory: SessionConfigOption = {
-      type: "select",
-      id: "llm",
-      name: "LLM",
-      category: "model",
-      currentValue: "gpt-5",
-      options: [{ value: "gpt-5", name: "GPT-5" }],
-    };
-
-    expect(deriveModelInfo([byCategory]).modelConfigId).toBe("llm");
-  });
-
-  test("ignores a boolean option even when its category is model", () => {
-    const booleanOption: SessionConfigOption = {
-      type: "boolean",
-      id: "model",
-      name: "Model",
-      category: "model",
-      currentValue: true,
-    };
-
-    expect(deriveModelInfo([booleanOption])).toEqual({ availableModels: [] });
-  });
-
-  test("skips non-model select options and picks the first match", () => {
-    const mode: SessionConfigOption = {
-      type: "select",
-      id: "mode",
-      name: "Mode",
-      category: "mode",
-      currentValue: "ask",
-      options: [{ value: "ask", name: "Ask" }],
-    };
-
-    expect(deriveModelInfo([mode, flatModelOption]).modelConfigId).toBe(
-      "model",
-    );
-  });
-
-  test("returns no model info for an empty array", () => {
-    expect(deriveModelInfo([])).toEqual({ availableModels: [] });
-  });
-
-  test("returns no model info for null", () => {
-    expect(deriveModelInfo(null)).toEqual({ availableModels: [] });
-  });
-
-  test("returns no model info for undefined", () => {
-    expect(deriveModelInfo(undefined)).toEqual({ availableModels: [] });
-  });
-});
-
-describe("resolveAcpModel", () => {
-  test("prefers the requested model over the per-agent one", () => {
-    expect(
-      resolveAcpModel({ requestedModel: "opus", agentModel: "haiku" }),
-    ).toBe("opus");
-  });
-
-  test("falls back to the per-agent model", () => {
-    expect(resolveAcpModel({ agentModel: "haiku" })).toBe("haiku");
-  });
-
-  test("returns undefined when every rung is unset", () => {
-    expect(resolveAcpModel({})).toBeUndefined();
-  });
-
-  test("treats blank and whitespace-only values as unset", () => {
-    expect(
-      resolveAcpModel({ requestedModel: "\t\n", agentModel: "haiku" }),
-    ).toBe("haiku");
-  });
-
-  test("returns undefined when every rung is whitespace", () => {
-    expect(
-      resolveAcpModel({ requestedModel: " ", agentModel: "  " }),
-    ).toBeUndefined();
-  });
-
-  test("trims the value it returns", () => {
-    expect(resolveAcpModel({ requestedModel: "  opus  " })).toBe("opus");
-  });
-});

package/src/acp/model-config.ts

@@ -1,138 +0,0 @@
-/**
- * Pure helpers for ACP session model selection.
- *
- * ACP 0.25.0 has no `session/set_model`: a model is one `SessionConfigOption`
- * among the set an adapter reports from `session/new`, `session/load`,
- * `session/resume`, and `session/set_config_option`. `deriveModelInfo` turns
- * that raw set into the trio the daemon publishes and persists (current model,
- * selectable options, and the config id to write back through
- * `setSessionConfigOption`), flattening the grouped `options` variant so
- * callers never branch on it.
- *
- * The model option is identified by `type === "select"` and `id === "model"`
- * or `category === "model"` only. Option `name` is a human label an adapter
- * may localize or restyle at will, so it is never matched against.
- *
- * `resolveAcpModel` is the precedence ladder a spawn or a resume walks before
- * it talks to the adapter: an explicit request beats the per-agent default from
- * `acp.agents.<id>.model`, and nothing named there leaves the adapter on its
- * own. Values are adapter-reported aliases (`opus`, `sonnet`), never Assistant
- * catalog ids, and are passed through unvalidated: only the adapter knows what
- * it accepts.
- *
- * Both helpers are synchronous and side-effect free.
- */
-
-import type {
-  SessionConfigOption,
-  SessionConfigSelectGroup,
-  SessionConfigSelectOption,
-} from "@agentclientprotocol/sdk";
-import type { z } from "zod";
-
-import type { AcpSessionModelUpdateEventSchema } from "../api/events/acp-session-model-update.js";
-
-/**
- * A selectable model as reported by the adapter, flattened out of its group.
- * Derived from the event schema so the published wire shape and the shape the
- * daemon carries in memory cannot drift apart.
- */
-export type AcpModelOption = z.infer<
-  typeof AcpSessionModelUpdateEventSchema
->["availableModels"][number];
-
-/** What an adapter's config-option set says about the session's model. */
-export type AcpModelInfo = {
-  model?: string;
-  availableModels: AcpModelOption[];
-  modelConfigId?: string;
-};
-
-type ResolveAcpModelInput = {
-  requestedModel?: string;
-  agentModel?: string;
-};
-
-type ModelSelectOption = Extract<SessionConfigOption, { type: "select" }>;
-
-function isGroup(
-  entry: SessionConfigSelectOption | SessionConfigSelectGroup,
-): entry is SessionConfigSelectGroup {
-  return "group" in entry;
-}
-
-function toModelOption(
-  option: SessionConfigSelectOption,
-  group?: string,
-): AcpModelOption {
-  return {
-    value: option.value,
-    label: option.name,
-    ...(option.description ? { description: option.description } : {}),
-    ...(group ? { group } : {}),
-  };
-}
-
-/**
- * The adapter's model selector, if it advertises one. `category` is UX-only
- * per the ACP spec, so a `model` id counts too; non-select options never do.
- */
-function findModelConfigOption(
-  configOptions: SessionConfigOption[] | null | undefined,
-): ModelSelectOption | undefined {
-  return configOptions?.find(
-    (option): option is ModelSelectOption =>
-      option.type === "select" &&
-      (option.id === "model" || option.category === "model"),
-  );
-}
-
-/**
- * Extract current model, selectable models, and the config id to write back.
- * Returns `{ availableModels: [] }` when the adapter advertises no model
- * selector, which is how the whole feature degrades to invisible.
- */
-export function deriveModelInfo(
-  configOptions: SessionConfigOption[] | null | undefined,
-): AcpModelInfo {
-  const modelOption = findModelConfigOption(configOptions);
-
-  if (!modelOption) {
-    return { availableModels: [] };
-  }
-
-  const availableModels: AcpModelOption[] = [];
-  for (const entry of modelOption.options) {
-    if (isGroup(entry)) {
-      for (const option of entry.options) {
-        availableModels.push(toModelOption(option, entry.name));
-      }
-      continue;
-    }
-    availableModels.push(toModelOption(entry));
-  }
-
-  return {
-    ...(modelOption.currentValue ? { model: modelOption.currentValue } : {}),
-    availableModels,
-    modelConfigId: modelOption.id,
-  };
-}
-
-/**
- * Pick the model a session should start on. Blank and whitespace-only values
- * count as unset so an empty config field never pins anything.
- */
-export function resolveAcpModel(
-  input: ResolveAcpModelInput,
-): string | undefined {
-  const ladder = [input.requestedModel, input.agentModel];
-
-  for (const candidate of ladder) {
-    const trimmed = candidate?.trim();
-    if (trimmed) {
-      return trimmed;
-    }
-  }
-  return undefined;
-}