@vellumai/assistant 0.12.1 → 0.12.2-staging.1

package/src/__tests__/unicode.test.ts

@@ -171,6 +171,19 @@ describe("stripOrphanedSurrogatesDeep", () => {
     expect(result.value.b[1]).toBe("also clean");
   });
 
+  test("skipKey leaves a property unscanned and uncopied", () => {
+    const payload = { type: "base64", data: `raw${HIGH}` };
+    const input = { text: `bad${HIGH}`, payload };
+    const result = stripOrphanedSurrogatesDeep(input, {
+      skipKey: (key, parent) => key === "data" && parent.type === "base64",
+    });
+    expect(result.changed).toBe(true);
+    expect(result.fixedStringCount).toBe(1);
+    expect(result.value.text).toBe(`bad${REPLACEMENT}`);
+    // The skipped subtree is carried over by reference, orphan and all.
+    expect(result.value.payload).toBe(payload);
+  });
+
   test("leaves non-plain objects untouched", () => {
     class Custom {
       value = `bad${HIGH}`;

package/src/__tests__/vellum-self-knowledge-inline-command.test.ts

@@ -136,6 +136,10 @@ describe("vellum-self-knowledge skill", () => {
     const result = await executeSkillLoad({ skill: "vellum-self-knowledge" });
     expect(result.content).toContain("## Critical Rule");
     expect(result.content).toContain("Never answer from memory");
+    expect(result.content).toContain("distinct, legacy Vellum product");
+    expect(result.content).toContain(
+      "Never use it to answer questions about this Vellum",
+    );
   });
 
   // ── Resolution order ─────────────────────────────────────────────────

package/src/__tests__/watch-retro-tool-availability.test.ts

@@ -1,13 +1,10 @@
 /**
  * The gate that decides whether a watch retrospective can report at all.
  *
- * A retrospective runs as a `clientless` wake, which pins the turn
- * non-interactive. `conversation-tool-setup` gates the whole `ui_surface`
- * family on a client being present, so in that turn `ui_show` is not denied,
- * it is absent: a retrospective told to call it can only tell the user it
- * cannot. Nothing about the card's schema, its renderer, or the prompt's
- * wording reveals that, which is why it is asserted here against the real
- * registry rather than assumed anywhere else.
+ * A retrospective runs as a `clientless` wake, but its report continues to
+ * use the post-turn renderer so the report lands after its tool call has been
+ * persisted. The core UI tools remain available on that turn for other
+ * background work, so this file pins both contracts against the real registry.
  */
 
 import { afterAll, describe, expect, test } from "bun:test";
@@ -54,20 +51,14 @@ describe("watch retrospective tool availability", () => {
     ).toBe(true);
   });
 
-  test("ui_show is absent from a clientless turn", async () => {
+  test("core UI tools stay available on a clientless turn", async () => {
     await initializeTools();
     const ctx = clientlessContext();
 
-    // The reason the report does not go through `ui_show`. If this ever flips
-    // to true, the extra tool above can be reconsidered; while it is false,
-    // routing the retrospective's card through `ui_show` produces a turn that
-    // cannot report at all.
-    expect(isToolActiveForContext("ui_show", ctx)).toBe(false);
-    expect(isToolActiveForContext("ui_update", ctx)).toBe(false);
-    expect(isToolActiveForContext("ui_dismiss", ctx)).toBe(false);
+    for (const name of ["ui_show", "ui_update", "ui_dismiss"]) {
+      expect(isToolActiveForContext(name, ctx)).toBe(true);
+    }
 
-    // And the gate really is about the client, not about the tools being
-    // unregistered: with one attached, the same names are active.
     const withClient = clientfulContext();
     expect(isToolActiveForContext("ui_show", withClient)).toBe(true);
   });

package/src/__tests__/workspace-git-service.test.ts

@@ -4,6 +4,7 @@ import {
   existsSync,
   mkdirSync,
   readFileSync,
+  renameSync,
   rmSync,
   statSync,
   symlinkSync,
@@ -523,6 +524,31 @@ describe("WorkspaceGitService", () => {
       expect(trackedFiles()).not.toContain("gone-b.txt");
       expect(trackedFiles()).not.toContain("gone-c.txt");
     });
+
+    test("batched rename stages origin and destination even when they split", async () => {
+      const service = new WorkspaceGitService(testDir);
+      await service.ensureInitialized();
+
+      writeFileSync(join(testDir, "old-name.txt"), "moved");
+      await service.commitChanges("Seed rename source");
+
+      renameSync(join(testDir, "old-name.txt"), join(testDir, "new-name.txt"));
+      for (const name of ["x0.txt", "x1.txt", "x2.txt", "x3.txt"]) {
+        writeFileSync(join(testDir, name), name);
+      }
+
+      await withStageBatchSize(2, async () => {
+        await service.commitChanges("Rename across batches");
+      });
+
+      expect(trackedFiles()).toContain("new-name.txt");
+      expect(trackedFiles()).not.toContain("old-name.txt");
+      const status = execFileSync("git", ["status", "--porcelain"], {
+        cwd: testDir,
+        encoding: "utf-8",
+      }).trim();
+      expect(status).toBe("");
+    });
   });
 
   describe("getStatus", () => {

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

@@ -0,0 +1,336 @@
+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();
+  });
+});