@vellumai/assistant 0.11.0 → 0.11.1-staging.2

package/src/__tests__/workspace-migration-082-backfill-managed-profile-labels.test.ts

@@ -196,10 +196,7 @@ describe("082-backfill-managed-profile-labels migration", () => {
     });
 
     backfillManagedProfileLabelsMigration.run(workspaceDir);
-    const afterFirst = readFileSync(
-      join(workspaceDir, "config.json"),
-      "utf-8",
-    );
+    const afterFirst = readFileSync(join(workspaceDir, "config.json"), "utf-8");
 
     backfillManagedProfileLabelsMigration.run(workspaceDir);
     const afterSecond = readFileSync(

package/src/__tests__/workspace-migration-130-speech-mode-to-provider.test.ts

@@ -118,7 +118,9 @@ describe("130-speech-mode-to-provider", () => {
   });
 
   test("is idempotent", () => {
-    writeConfig({ services: { stt: { mode: "managed", provider: "deepgram" } } });
+    writeConfig({
+      services: { stt: { mode: "managed", provider: "deepgram" } },
+    });
 
     speechModeToProviderMigration.run(workspaceDir);
     const once = readConfig();

package/src/__tests__/workspace-migration-136-repair-stale-fireworks-kimi-model-id.test.ts

@@ -0,0 +1,139 @@
+import {
+  existsSync,
+  mkdirSync,
+  readFileSync,
+  rmSync,
+  writeFileSync,
+} from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { afterEach, beforeEach, describe, expect, test } from "bun:test";
+
+import { repairStaleFireworksKimiModelIdMigration } from "../workspace/migrations/136-repair-stale-fireworks-kimi-model-id.js";
+import { WORKSPACE_MIGRATIONS } from "../workspace/migrations/registry.js";
+
+const STALE = "accounts/fireworks/models/kimi-k2p5";
+const REPLACEMENT = "accounts/fireworks/models/deepseek-v4-flash";
+
+let workspaceDir: string;
+
+function freshWorkspace(): void {
+  workspaceDir = join(
+    tmpdir(),
+    `vellum-migration-136-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"));
+}
+
+beforeEach(() => {
+  freshWorkspace();
+});
+
+afterEach(() => {
+  if (existsSync(workspaceDir)) {
+    rmSync(workspaceDir, { recursive: true, force: true });
+  }
+});
+
+describe("136-repair-stale-fireworks-kimi-model-id migration", () => {
+  test("has correct migration id and is registered", () => {
+    expect(repairStaleFireworksKimiModelIdMigration.id).toBe(
+      "136-repair-stale-fireworks-kimi-model-id",
+    );
+    expect(WORKSPACE_MIGRATIONS.map((m) => m.id)).toContain(
+      "136-repair-stale-fireworks-kimi-model-id",
+    );
+  });
+
+  test("repairs the stale ID in default, call sites, and profiles", () => {
+    writeConfig({
+      llm: {
+        default: { provider: "fireworks", model: STALE },
+        callSites: {
+          recall: { model: STALE, maxTokens: 4096 },
+          heartbeat: { model: `${STALE}-tuned` },
+          malformed: STALE,
+        },
+        profiles: {
+          "cost-optimized": { provider: "vellum", model: STALE },
+          legacy: { model: STALE },
+        },
+      },
+    });
+
+    repairStaleFireworksKimiModelIdMigration.run(workspaceDir);
+
+    const llm = readConfig().llm as Record<string, any>;
+    expect(llm.default.model).toBe(REPLACEMENT);
+    expect(llm.callSites.recall.model).toBe(REPLACEMENT);
+    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);
+    // Managed profiles stamped provider "vellum" carry Fireworks model IDs.
+    expect(llm.profiles["cost-optimized"].model).toBe(REPLACEMENT);
+    expect(llm.profiles.legacy.model).toBe(REPLACEMENT);
+  });
+
+  test("leaves fragments with an explicit other provider untouched", () => {
+    writeConfig({
+      llm: {
+        default: { provider: "openai-compatible", model: STALE },
+        profiles: {
+          byo: { provider: "openai-compatible", model: STALE },
+        },
+      },
+    });
+
+    repairStaleFireworksKimiModelIdMigration.run(workspaceDir);
+
+    const llm = readConfig().llm as Record<string, any>;
+    expect(llm.default.model).toBe(STALE);
+    expect(llm.profiles.byo.model).toBe(STALE);
+  });
+
+  test("is idempotent and a no-op without the stale ID", () => {
+    writeConfig({
+      llm: {
+        default: { provider: "fireworks", model: STALE },
+        profiles: { fine: { provider: "fireworks", model: REPLACEMENT } },
+      },
+    });
+
+    repairStaleFireworksKimiModelIdMigration.run(workspaceDir);
+    const first = readConfig();
+    repairStaleFireworksKimiModelIdMigration.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", () => {
+    // No config.json at all.
+    expect(() =>
+      repairStaleFireworksKimiModelIdMigration.run(workspaceDir),
+    ).not.toThrow();
+
+    writeConfig({ theme: "dark" });
+    repairStaleFireworksKimiModelIdMigration.run(workspaceDir);
+    expect(readConfig()).toEqual({ theme: "dark" });
+
+    writeFileSync(join(workspaceDir, "config.json"), "{not json");
+    expect(() =>
+      repairStaleFireworksKimiModelIdMigration.run(workspaceDir),
+    ).not.toThrow();
+  });
+});

package/src/__tests__/workspace-migration-down-functions.test.ts

@@ -776,8 +776,11 @@ describe("016-extract-feature-flags-to-protected down()", () => {
   });
 
   afterEach(() => {
-    if (savedWorkspaceDir === undefined) delete process.env.VELLUM_WORKSPACE_DIR;
-    else process.env.VELLUM_WORKSPACE_DIR = savedWorkspaceDir;
+    if (savedWorkspaceDir === undefined) {
+      delete process.env.VELLUM_WORKSPACE_DIR;
+    } else {
+      process.env.VELLUM_WORKSPACE_DIR = savedWorkspaceDir;
+    }
   });
 
   test("moves feature flags from protected dir back to config.json", () => {

package/src/__tests__/workspace-migration-meets.test.ts

@@ -47,7 +47,9 @@ function snapshotTree(
 ): Record<string, { mtimeMs: number; content: string }> {
   const out: Record<string, { mtimeMs: number; content: string }> = {};
   function walk(dir: string): void {
-    if (!existsSync(dir)) return;
+    if (!existsSync(dir)) {
+      return;
+    }
     for (const entry of readdirSync(dir, { withFileTypes: true })) {
       const abs = join(dir, entry.name);
       if (entry.isDirectory()) {
@@ -179,11 +181,7 @@ describe("037-create-meets-dir migration", () => {
     const meetingDir = join(meetsDir, "meeting-xyz");
     mkdirSync(meetingDir, { recursive: true });
     const transcriptPath = join(meetingDir, "transcript.jsonl");
-    writeFileSync(
-      transcriptPath,
-      '{"t":0,"text":"hello"}\n',
-      "utf-8",
-    );
+    writeFileSync(transcriptPath, '{"t":0,"text":"hello"}\n', "utf-8");
     const before = snapshotTree(workspaceDir);
 
     createMeetsDirMigration.run(workspaceDir);

package/src/__tests__/workspace-migration-memory-v2-init.test.ts

@@ -50,7 +50,9 @@ function snapshotTree(
 ): Record<string, { mtimeMs: number; content: string }> {
   const out: Record<string, { mtimeMs: number; content: string }> = {};
   function walk(dir: string): void {
-    if (!existsSync(dir)) return;
+    if (!existsSync(dir)) {
+      return;
+    }
     for (const entry of readdirSync(dir, { withFileTypes: true })) {
       const abs = join(dir, entry.name);
       if (entry.isDirectory()) {

package/src/__tests__/workspace-migration-seed-device-id.test.ts

@@ -48,7 +48,9 @@ function makeLockfile(assistants: Array<Record<string, unknown>>): string {
 function setupFs(fileContents: Record<string, string>): void {
   existsSyncFn.mockImplementation((path: string) => path in fileContents);
   readFileSyncFn.mockImplementation((path: string, _enc: string) => {
-    if (path in fileContents) return fileContents[path];
+    if (path in fileContents) {
+      return fileContents[path];
+    }
     throw new Error(`ENOENT: ${path}`);
   });
 }

package/src/a2a/__tests__/agent-card.test.ts

@@ -5,7 +5,6 @@ import { buildAgentCard } from "../agent-card.js";
 describe("buildAgentCard", () => {
   const BASE_PARAMS = {
     assistantName: "Alice",
-    baseUrl: "https://example.com",
   };
 
   test("includes all required top-level fields", () => {
@@ -21,15 +20,12 @@ describe("buildAgentCard", () => {
     expect(card.skills).toBeDefined();
   });
 
-  test("interface URL is baseUrl + /a2a/message:send", () => {
+  // A2A message exchange runs over the authenticated invite flow, so there is
+  // no peer-callable protocol endpoint for the card to point at.
+  test("advertises no protocol interfaces", () => {
     const card = buildAgentCard(BASE_PARAMS);
 
-    expect(card.supported_interfaces).toHaveLength(1);
-    expect(card.supported_interfaces[0].url).toBe(
-      "https://example.com/a2a/message:send",
-    );
-    expect(card.supported_interfaces[0].protocol_binding).toBe("JSONRPC");
-    expect(card.supported_interfaces[0].protocol_version).toBe("1.0");
+    expect(card.supported_interfaces).toEqual([]);
   });
 
   test("push_notifications capability is true", () => {
@@ -53,7 +49,7 @@ describe("buildAgentCard", () => {
   test("defaults description when omitted", () => {
     const card = buildAgentCard(BASE_PARAMS);
 
-    expect(card.description).toBe("Alice — a Vellum AI assistant");
+    expect(card.description).toBe("Alice - a Vellum AI assistant");
   });
 
   test("uses explicit description when provided", () => {
@@ -83,16 +79,4 @@ describe("buildAgentCard", () => {
       tags: ["chat"],
     });
   });
-
-  test("constructs correct interface URL with trailing-slash base", () => {
-    const card = buildAgentCard({
-      ...BASE_PARAMS,
-      baseUrl: "https://example.com/",
-    });
-
-    // The URL is constructed by simple concatenation; callers normalize the base.
-    expect(card.supported_interfaces[0].url).toBe(
-      "https://example.com//a2a/message:send",
-    );
-  });
 });

package/src/a2a/agent-card.ts

@@ -3,34 +3,30 @@
  *
  * `buildAgentCard()` constructs a spec-compliant agent card from explicit
  * parameters. `getAgentCard()` is a convenience wrapper that reads the
- * assistant name and public base URL from workspace config.
+ * assistant name from workspace config.
  */
 
-import { getConfig } from "../config/loader.js";
 import { getAssistantName } from "../daemon/identity-helpers.js";
-import { getPublicBaseUrl } from "../inbound/public-ingress-urls.js";
 import type { AgentCard } from "./protocol-types.js";
 
 export interface BuildAgentCardParams {
   assistantName: string;
   assistantDescription?: string;
-  baseUrl: string;
 }
 
+/**
+ * A2A message exchange runs over the authenticated invite flow, so no
+ * peer-callable protocol interface is exposed and the card advertises none.
+ * An interface entry here would send peers at a URL nothing serves.
+ */
 export function buildAgentCard(params: BuildAgentCardParams): AgentCard {
   return {
     name: params.assistantName,
     description:
       params.assistantDescription ??
-      `${params.assistantName} — a Vellum AI assistant`,
+      `${params.assistantName} - a Vellum AI assistant`,
     version: "1.0.0",
-    supported_interfaces: [
-      {
-        url: `${params.baseUrl}/a2a/message:send`,
-        protocol_binding: "JSONRPC",
-        protocol_version: "1.0",
-      },
-    ],
+    supported_interfaces: [],
     capabilities: {
       streaming: false,
       push_notifications: true,
@@ -50,9 +46,7 @@ export function buildAgentCard(params: BuildAgentCardParams): AgentCard {
 }
 
 export function getAgentCard(): AgentCard {
-  const config = getConfig();
-  const assistantName = getAssistantName() ?? "Vellum Assistant";
-  const baseUrl = getPublicBaseUrl(config);
-
-  return buildAgentCard({ assistantName, baseUrl });
+  return buildAgentCard({
+    assistantName: getAssistantName() ?? "Vellum Assistant",
+  });
 }

package/src/acp/__tests__/helpers/exec-file-stub.ts

@@ -73,7 +73,9 @@ export function installExecFileStub(): ExecFileStubHandle {
       const key = `${command} ${args[0]}`;
       const script = execScripts.get(key);
       queueMicrotask(() => {
-        if (!callback) return;
+        if (!callback) {
+          return;
+        }
         if (!script) {
           callback(new Error(`No script for ${key}`), "", "");
           return;

package/src/acp/__tests__/prepare-agent-env.test.ts

@@ -28,7 +28,9 @@ mock.module("../../tools/credentials/metadata-store.js", () => ({
   getCredentialMetadata: (service: string, field: string) => {
     const key = `${service}/${field}`;
     const entry = metadataStore.get(key);
-    if (!entry) return undefined;
+    if (!entry) {
+      return undefined;
+    }
     return {
       credentialId: `cred-${key}`,
       service,

package/src/acp/agent-process.ts

@@ -252,16 +252,22 @@ export class AcpAgentProcess {
    */
   private selectEnvVarAuthMethod(): AuthMethod | undefined {
     const env = this.spawnedEnv;
-    if (!env) return undefined;
+    if (!env) {
+      return undefined;
+    }
 
     return this.authMethods.find((method) => {
-      if (!isEnvVarMethod(method)) return false;
+      if (!isEnvVarMethod(method)) {
+        return false;
+      }
 
       // `vars` is required by the SDK type, but agent responses aren't
       // runtime-validated — tolerate an out-of-spec agent omitting it so the
       // caller gets the friendly auth error instead of a TypeError.
       const requiredVars = (method.vars ?? []).filter((v) => !v.optional);
-      if (requiredVars.length === 0) return false;
+      if (requiredVars.length === 0) {
+        return false;
+      }
 
       return requiredVars.every((v) => {
         const value = env[v.name];
@@ -290,7 +296,9 @@ export class AcpAgentProcess {
     try {
       return await op();
     } catch (err) {
-      if (!isAuthRequiredError(err)) throw err;
+      if (!isAuthRequiredError(err)) {
+        throw err;
+      }
 
       // The agent may have exited between the auth_required rejection and
       // this retry path; fail with the standard not-spawned error.
@@ -322,7 +330,9 @@ export class AcpAgentProcess {
    * `"Login with ChatGPT" (chatgpt), "Use OPENAI_API_KEY" (env var OPENAI_API_KEY)`.
    */
   private describeAuthMethods(): string {
-    if (this.authMethods.length === 0) return "none";
+    if (this.authMethods.length === 0) {
+      return "none";
+    }
 
     return this.authMethods
       .map((method) => {
@@ -439,7 +449,9 @@ export class AcpAgentProcess {
    * Whether the child process is still running.
    */
   get isAlive(): boolean {
-    if (!this.proc) return false;
+    if (!this.proc) {
+      return false;
+    }
     // ChildProcess.exitCode is null while process is still running
     // exitCode is null while the process is still running
     return this.proc.exitCode == null;

package/src/acp/auto-install.test.ts

@@ -208,7 +208,9 @@ describe("resolveAgentWithAutoInstall - resolution order", () => {
   test("binary missing + bun present: installs then resolves to the real binary", async () => {
     let installed = false;
     which.setWhich((cmd) => {
-      if (cmd === "bun") return BUN_BIN;
+      if (cmd === "bun") {
+        return BUN_BIN;
+      }
       if (cmd === "claude-agent-acp" && installed) {
         return "/usr/local/bin/claude-agent-acp";
       }
@@ -224,7 +226,9 @@ describe("resolveAgentWithAutoInstall - resolution order", () => {
     const result = await resolveAgentWithAutoInstall("claude");
 
     expect(result.resolved.ok).toBe(true);
-    if (!result.resolved.ok) return;
+    if (!result.resolved.ok) {
+      return;
+    }
     // The resolved command is the REAL binary, not a `bun x` wrapper.
     expect(result.resolved.agent.command).toBe("claude-agent-acp");
     expect(result.autoInstalledPackage).toBe(
@@ -273,7 +277,9 @@ describe("resolveAgentWithAutoInstall - resolution order", () => {
     const result = await resolveAgentWithAutoInstall("codex");
 
     expect(result.resolved.ok).toBe(true);
-    if (!result.resolved.ok) return;
+    if (!result.resolved.ok) {
+      return;
+    }
     expect(result.resolved.agent.command).toBe("codex-acp");
     expect(execFileMock).not.toHaveBeenCalled();
   });

package/src/acp/auto-install.ts

@@ -136,10 +136,14 @@ export function ensureAdapterInstalled(
   }
 
   const inFlight = installPromises.get(command);
-  if (inFlight) return inFlight;
+  if (inFlight) {
+    return inFlight;
+  }
 
   const promise = runInstall(bunPath, command, packageName).then((result) => {
-    if (!result.installed) installPromises.delete(command);
+    if (!result.installed) {
+      installPromises.delete(command);
+    }
     return result;
   });
   installPromises.set(command, promise);

package/src/acp/failure-error.ts

@@ -18,11 +18,14 @@ export function deriveFailureError(ackMessage: string, stderr: string): string {
 
   // Most precise: a structured adapter error — prefer it over the ack.
   const jsonMessage = lastJsonErrorMessage(clean);
-  if (jsonMessage) return jsonMessage;
+  if (jsonMessage) {
+    return jsonMessage;
+  }
 
   // An already-specific ack is preserved when stderr has no better detail.
-  if (ackMessage.length > 0 && ackMessage !== "Internal error")
+  if (ackMessage.length > 0 && ackMessage !== "Internal error") {
     return ackMessage;
+  }
 
   // Generic/empty ack: fall back to the last meaningful stderr line.
   return lastNonEmptyLine(clean) ?? ackMessage;
@@ -105,7 +108,9 @@ function lastNonEmptyLine(text: string): string | null {
   const lines = text.split("\n");
   for (let i = lines.length - 1; i >= 0; i--) {
     const trimmed = lines[i].trim();
-    if (trimmed.length > 0) return trimmed;
+    if (trimmed.length > 0) {
+      return trimmed;
+    }
   }
   return null;
 }

package/src/acp/prepare-agent-env.ts

@@ -164,7 +164,9 @@ async function injectOptionalCredential(
   envVar: string,
   usageDescription: string,
 ): Promise<void> {
-  if (env[envVar]) return;
+  if (env[envVar]) {
+    return;
+  }
   const missReason = await injectCredential(
     env,
     field,