@vellumai/assistant 0.12.2-staging.5 → 0.12.2-staging.7

package/scripts/generate-bundled-plugin-packages.ts

@@ -0,0 +1,29 @@
+#!/usr/bin/env bun
+
+import { writeFileSync } from "node:fs";
+import { join, resolve } from "node:path";
+
+import { buildBundledPluginPackages } from "./bundled-plugin-packages.js";
+
+const repoRoot = resolve(import.meta.dir, "../..");
+const output = {
+  version: 1,
+  packages: buildBundledPluginPackages(repoRoot),
+};
+
+if (process.argv.includes("--check")) {
+  console.log("✓ Local marketplace packages are valid");
+} else {
+  writeFileSync(
+    join(
+      repoRoot,
+      "assistant",
+      "src",
+      "cli",
+      "lib",
+      "bundled-plugin-packages.json",
+    ),
+    `${JSON.stringify(output, null, 2)}\n`,
+  );
+  console.log("✓ Generated bundled local plugin packages");
+}

package/scripts/postinstall.ts

@@ -0,0 +1,33 @@
+import { spawnSync } from "node:child_process";
+import { existsSync } from "node:fs";
+import { join, resolve } from "node:path";
+
+const repoRoot = resolve(import.meta.dir, "../..");
+
+// Repository setup is best-effort, including installs outside a Git checkout.
+function run(command: string, args: string[]): boolean {
+  return (
+    spawnSync(command, args, {
+      cwd: repoRoot,
+      stdio: ["ignore", "inherit", "ignore"],
+      windowsHide: true,
+    }).status === 0
+  );
+}
+
+if (!run("git", ["config", "core.hooksPath"])) {
+  run("git", ["config", "core.hooksPath", ".githooks"]);
+}
+
+const syncScript = join(repoRoot, "meta", "sync-bundled-copies.ts");
+if (existsSync(syncScript) && run(process.execPath, ["run", syncScript])) {
+  run(process.execPath, [
+    "run",
+    join(
+      repoRoot,
+      "assistant",
+      "scripts",
+      "generate-bundled-plugin-packages.ts",
+    ),
+  ]);
+}

package/scripts/smoke-desktop-browser-cli.ts

@@ -42,6 +42,7 @@ const manager = new DesktopSessionManager({
   renderWallpaper: async () => null,
 });
 const control = new DesktopAutomationLease({
+  notify: async () => {},
   enabled: () => true,
   ready: () =>
     !coldInstall || desktopDependencyInstaller.getStatus().state === "ready",

package/scripts/test.ts

@@ -62,26 +62,28 @@ const EXPERIMENTAL_FILES = new Set([
 const KNOWN_BROKEN_FILES = new Set<string>([]);
 
 // ---------------------------------------------------------------------------
-// Feature-flag registry sync
+// Bundled catalog sync
 // ---------------------------------------------------------------------------
 
-// Ensure the bundled feature-flag-registry.json exists before running tests.
-// The canonical copy lives at meta/feature-flags/feature-flag-registry.json and
-// is synced into assistant/src/ and gateway/src/. CI runs this as a dedicated
-// step; locally postinstall handles it — but when node_modules is symlinked
-// (e.g. worktrees) postinstall never fires, so the bundled copy can be missing
-// and feature-flag-registry-bundled.test.ts fails. Running the sync here is
-// idempotent and cheap (two file copies).
-function syncFeatureFlagRegistry(): void {
+// Ensure generated catalog inputs exist before tests. Locally, postinstall may
+// not run in worktrees that share node_modules, so the static JSON imports can
+// otherwise be missing.
+function syncBundledCatalog(): void {
   const syncScript = join("..", "meta", "sync-bundled-copies.ts");
   if (!existsSync(syncScript)) {
     return;
   }
-  Bun.spawnSync(["bun", "run", "meta/sync-bundled-copies.ts"], {
-    cwd: join(process.cwd(), ".."),
+  const result = Bun.spawnSync(["bun", "run", "sync:bundled-catalog"], {
+    cwd: process.cwd(),
     stdout: "ignore",
-    stderr: "ignore",
+    stderr: "pipe",
+    windowsHide: true,
   });
+  if (result.exitCode !== 0) {
+    throw new Error(
+      `Failed to generate bundled catalog inputs: ${result.stderr.toString()}`,
+    );
+  }
 }
 
 // ---------------------------------------------------------------------------
@@ -514,7 +516,7 @@ async function buildMigratedFixture(outWorkspaceDir: string): Promise<void> {
 // ---------------------------------------------------------------------------
 
 async function main(): Promise<void> {
-  syncFeatureFlagRegistry();
+  syncBundledCatalog();
 
   let testFiles = collectTestFiles();
   if (testFiles.length === 0) {

package/src/__tests__/agent-loop.test.ts

@@ -1977,6 +1977,130 @@ describe("AgentLoop", () => {
     expect(calls[0].tools).not.toEqual(dummyTools);
   });
 
+  test("onToolsSent observes the exact tool array of every provider call", async () => {
+    const perCall: ToolDefinition[][] = [
+      [
+        {
+          name: "first",
+          description: "First",
+          input_schema: { type: "object" },
+        },
+      ],
+      [
+        {
+          name: "second",
+          description: "Second",
+          input_schema: { type: "object" },
+        },
+      ],
+    ];
+    let resolveCount = 0;
+    const sent: ToolDefinition[][] = [];
+
+    const { provider, calls } = createMockProvider([
+      toolUseResponse("t1", "first", {}),
+      textResponse("Done"),
+    ]);
+    const loop = new AgentLoop({
+      provider: provider,
+      systemPrompt: "system",
+      conversationId: "test-conversation",
+      toolExecutor: async () => ({ content: "result", isError: false }),
+      resolveTools: () => perCall[resolveCount++]!,
+      onToolsSent: (tools) => {
+        sent.push(tools);
+      },
+    });
+    await loop.run({
+      requestId: "test-request",
+      messages: [userMessage],
+      onEvent: () => {},
+      trust: { sourceChannel: "vellum", trustClass: "unknown" },
+    });
+
+    // One observation per provider call, each the array that call sent.
+    expect(sent).toHaveLength(2);
+    expect(calls[0].tools).toEqual(sent[0]);
+    expect(calls[1].tools).toEqual(sent[1]);
+    expect(sent.map((tools) => tools.map((t) => t.name))).toEqual([
+      ["first"],
+      ["second"],
+    ]);
+  });
+
+  test("onToolsSent sees the provider-native web_search tool the loop appends", async () => {
+    const dynamicTools: ToolDefinition[] = [
+      {
+        name: "dynamic_tool",
+        description: "Dynamic",
+        input_schema: { type: "object" },
+      },
+    ];
+    const sent: ToolDefinition[][] = [];
+
+    const { provider, calls } = createMockProvider([textResponse("Hi")]);
+    Object.assign(provider, { supportsNativeWebSearch: true });
+    const loop = new AgentLoop({
+      provider: provider,
+      systemPrompt: "system",
+      conversationId: "test-conversation",
+      config: { enableNativeWebSearch: true },
+      resolveTools: () => dynamicTools,
+      onToolsSent: (tools) => {
+        sent.push(tools);
+      },
+    });
+    await loop.run({
+      requestId: "test-request",
+      messages: [userMessage],
+      onEvent: () => {},
+      trust: { sourceChannel: "vellum", trustClass: "unknown" },
+    });
+
+    // The resolver never saw web_search; the observer sees the wire array.
+    expect(sent).toHaveLength(1);
+    expect(sent[0]!.map((t) => t.name)).toEqual(["dynamic_tool", "web_search"]);
+    expect(calls[0].tools).toEqual(sent[0]);
+  });
+
+  test("onToolsSent does not fire for a call cancelled before the request leaves", async () => {
+    // A pre-model-call hook runs after tool resolution and before the send;
+    // aborting there is the window Codex flagged: tools resolved, never sent.
+    const controller = new AbortController();
+    registerPlugin({
+      manifest: { name: "abort-before-send", version: "0.0.1" },
+      hooks: {
+        "pre-model-call": async (ctx) => {
+          controller.abort();
+          return ctx;
+        },
+      },
+    });
+    const sent: ToolDefinition[][] = [];
+    const { provider } = createMockProvider([textResponse("never")]);
+    const loop = new AgentLoop({
+      provider: provider,
+      systemPrompt: "system",
+      conversationId: "test-conversation",
+      resolveTools: () => dummyTools,
+      onToolsSent: (tools) => {
+        sent.push(tools);
+      },
+    });
+
+    await loop
+      .run({
+        requestId: "test-request",
+        messages: [userMessage],
+        onEvent: () => {},
+        trust: { sourceChannel: "vellum", trustClass: "unknown" },
+        signal: controller.signal,
+      })
+      .catch(() => {});
+
+    expect(sent).toEqual([]);
+  });
+
   // 28. Tool list can change between turns
   test("resolveTools can return different tools on each turn", async () => {
     const toolsPerTurn: ToolDefinition[][] = [

package/src/__tests__/approval-interception-trust-gates.test.ts

@@ -149,6 +149,46 @@ describe("approval interception trust-class gates", () => {
     expect(sessionMock).toHaveBeenCalled();
   });
 
+  test("guardian apr: callback naming no approval action is consumed as a stale button, never routed as text", async () => {
+    _anchorPrincipalId = "guardian-principal-1";
+    const sessionMock = registerPendingInteraction(
+      "req-guardian-retired-1",
+      CONVERSATION_ID,
+      TOOL_NAME,
+      TOOL_INPUT,
+    );
+
+    // The channel normalizers copy callback data into the message content, so
+    // a button press arrives with both set to the same string.
+    const callbackData = "apr:req-guardian-retired-1:approve_always";
+    const result = await handleApprovalInterception({
+      conversationId: CONVERSATION_ID,
+      callbackData,
+      content: callbackData,
+      conversationExternalId: REQUESTER_CHAT,
+      sourceChannel: "telegram",
+      actorExternalId: "guardian-user-1",
+      replyCallbackUrl: "https://gateway.test/deliver",
+      trustCtx: {
+        sourceChannel: "telegram",
+        trustClass: "guardian",
+        requesterExternalUserId: "guardian-user-1",
+        guardianExternalUserId: "guardian-user-1",
+        guardianPrincipalId: "guardian-principal-1",
+      },
+      assistantId: ASSISTANT_ID,
+    });
+
+    expect(result.handled).toBe(true);
+    expect(result.type).toBe("stale_ignored");
+    // No decision, and no reply: the text parsers never saw the callback.
+    expect(sessionMock).not.toHaveBeenCalled();
+    expect(deliverSpy).not.toHaveBeenCalled();
+    expect(pendingInteractions.getByConversation(CONVERSATION_ID)).toHaveLength(
+      1,
+    );
+  });
+
   test("guardian apr: callback with a principal NOT matching the anchor is rejected before any decision", async () => {
     _anchorPrincipalId = "the-real-guardian-principal";
     const sessionMock = registerPendingInteraction(

package/src/__tests__/channel-approval.test.ts

@@ -1,6 +1,5 @@
 import { describe, expect, test } from "bun:test";
 
-import type { ApprovalAction } from "../runtime/channel-approval-types.js";
 import { parseCallbackData } from "../runtime/routes/channel-route-shared.js";
 
 // ═══════════════════════════════════════════════════════════════════════════
@@ -19,19 +18,15 @@ describe("parseCallbackData", () => {
     expect(result!.source).toBe("button");
   });
 
-  test.each<[string, string]>([
-    ["apr:req-123:approve_10m", "approve_once"],
-    ["apr:req-123:approve_conversation", "approve_once"],
-    ["apr:req-123:approve_always", "approve_once"],
-  ])(
-    'maps legacy action "%s" to %s (backward compat)',
-    (data, expectedAction) => {
-      const result = parseCallbackData(data);
-      expect(result).not.toBeNull();
-      expect(result!.action).toBe(expectedAction as ApprovalAction);
-      expect(result!.requestId).toBe("req-123");
-    },
-  );
+  // The parser never maps one action id onto another: an id outside the
+  // approval vocabulary is no action, whatever it resembles.
+  test.each([
+    "apr:req-123:approve_10m",
+    "apr:req-123:approve_conversation",
+    "apr:req-123:approve_always",
+  ])('returns null for the unrecognized action id in "%s"', (data) => {
+    expect(parseCallbackData(data)).toBeNull();
+  });
 
   test("every channel's button press attributes as the button modality", () => {
     for (const channel of ["slack", "telegram", "whatsapp", "discord"]) {

package/src/__tests__/conversation-agent-loop.test.ts

@@ -18,6 +18,7 @@ import {
   queueConversationNotice,
   resetConversationNoticesForTests,
 } from "../daemon/conversation-notices.js";
+import { desktopAutomationLease } from "../desktop/desktop-automation-lease.js";
 import { getConversationDirName } from "../persistence/conversation-directories.js";
 import type { UserPromptSubmitContext } from "../plugin-api/types.js";
 import { resetPluginRegistryAndRegisterDefaults } from "../plugins/defaults/index.js";
@@ -1663,6 +1664,30 @@ describe("session-agent-loop", () => {
     });
   });
 
+  test("releases desktop control before a completed turn accepts another message", async () => {
+    const events: AssistantEvent[] = [];
+    const ctx = makeCtx();
+    const release = spyOn(desktopAutomationLease, "releaseForConversation");
+    const setProcessing = ctx.setProcessing.bind(ctx);
+    ctx.setProcessing = (processing) => {
+      if (!processing) {
+        expect(release).toHaveBeenCalledWith(ctx.conversationId);
+      }
+      setProcessing(processing);
+    };
+    try {
+      await runAgentLoopImpl(ctx, "hello", "msg-1", (event) =>
+        events.push(event),
+      );
+      expect(events.some((event) => event.type === "message_complete")).toBe(
+        true,
+      );
+      expect(release).toHaveBeenCalledTimes(1);
+    } finally {
+      release.mockRestore();
+    }
+  });
+
   describe("tool execution errors via agent loop", () => {
     test("error events from agent loop are classified and emitted", async () => {
       const events: AssistantEvent[] = [];

package/src/__tests__/db-conversation-tool-surface.test.ts

@@ -0,0 +1,144 @@
+/**
+ * Tests for the per-conversation wire tool-surface record
+ * (`persistence/conversation-tool-surface.ts`): the resolver records the
+ * tools array a live turn sends, fork wakes read it back verbatim, and an
+ * unchanged surface is never rewritten.
+ */
+
+import { Database } from "bun:sqlite";
+import { afterEach, beforeEach, describe, expect, test } from "bun:test";
+
+import { drizzle } from "drizzle-orm/bun-sqlite";
+
+import {
+  getConversationToolSurface,
+  hashConversationToolSurface,
+  recordConversationToolSurface,
+} from "../persistence/conversation-tool-surface.js";
+import { clearStoredDb, setStoredDb } from "../persistence/db-singleton.js";
+import { migrateCreateConversationToolSurfaces } from "../persistence/migrations/378-create-conversation-tool-surfaces.js";
+import * as schema from "../persistence/schema/index.js";
+import type { ToolDefinition } from "../providers/types.js";
+
+let sqlite: Database;
+
+beforeEach(() => {
+  sqlite = new Database(":memory:");
+  sqlite.run("PRAGMA foreign_keys = ON");
+  sqlite.run(/*sql*/ `CREATE TABLE conversations (id TEXT PRIMARY KEY)`);
+  sqlite.query(`INSERT INTO conversations (id) VALUES (?)`).run("conv-1");
+  const db = drizzle(sqlite, { schema });
+  migrateCreateConversationToolSurfaces(db);
+  setStoredDb("main", db, () => sqlite.close());
+});
+
+afterEach(() => {
+  clearStoredDb("main");
+});
+
+const TOOLS: ToolDefinition[] = [
+  {
+    name: "remember",
+    description: "Save a fact",
+    input_schema: { type: "object", properties: { content: {} } },
+  },
+  { name: "bell_jingle", description: "Ring", input_schema: {} },
+];
+
+function storedRow(): { tools_hash: string; updated_at: number } | null {
+  return sqlite
+    .query(
+      `SELECT tools_hash, updated_at FROM conversation_tool_surfaces WHERE conversation_id = ?`,
+    )
+    .get("conv-1") as { tools_hash: string; updated_at: number } | null;
+}
+
+describe("recordConversationToolSurface", () => {
+  test("stores the array and returns its content hash", () => {
+    const hash = recordConversationToolSurface("conv-1", TOOLS);
+
+    expect(hash).toBe(hashConversationToolSurface(TOOLS));
+    expect(storedRow()?.tools_hash).toBe(hash);
+    expect(getConversationToolSurface("conv-1")).toEqual(TOOLS);
+  });
+
+  test("replays the exact array, including key order and extra fields", () => {
+    const serverTool = {
+      type: "web_search_20250305",
+      name: "web_search",
+      max_uses: 5,
+    } as unknown as ToolDefinition;
+    const tools = [...TOOLS, serverTool];
+
+    recordConversationToolSurface("conv-1", tools);
+
+    expect(JSON.stringify(getConversationToolSurface("conv-1"))).toBe(
+      JSON.stringify(tools),
+    );
+  });
+
+  test("an unchanged surface with a known hash skips the write", () => {
+    const hash = recordConversationToolSurface("conv-1", TOOLS);
+    const before = storedRow()!.updated_at;
+    sqlite
+      .query(
+        `UPDATE conversation_tool_surfaces SET updated_at = ? WHERE conversation_id = ?`,
+      )
+      .run(before - 1000, "conv-1");
+
+    recordConversationToolSurface("conv-1", TOOLS, hash);
+
+    expect(storedRow()!.updated_at).toBe(before - 1000);
+  });
+
+  test("an unchanged surface with no known hash compares against the stored row before writing", () => {
+    recordConversationToolSurface("conv-1", TOOLS);
+    const marker = 42;
+    sqlite
+      .query(
+        `UPDATE conversation_tool_surfaces SET updated_at = ? WHERE conversation_id = ?`,
+      )
+      .run(marker, "conv-1");
+
+    // A freshly loaded conversation knows no hash yet; the stored row matches,
+    // so nothing is rewritten.
+    recordConversationToolSurface("conv-1", TOOLS, undefined);
+
+    expect(storedRow()!.updated_at).toBe(marker);
+  });
+
+  test("a changed surface overwrites the stored one", () => {
+    const first = recordConversationToolSurface("conv-1", TOOLS);
+    const changed = TOOLS.slice(0, 1);
+
+    const second = recordConversationToolSurface("conv-1", changed, first);
+
+    expect(second).not.toBe(first);
+    expect(storedRow()?.tools_hash).toBe(second);
+    expect(getConversationToolSurface("conv-1")).toEqual(changed);
+  });
+});
+
+describe("getConversationToolSurface", () => {
+  test("returns null when no turn has recorded a surface", () => {
+    expect(getConversationToolSurface("conv-1")).toBeNull();
+  });
+
+  test("returns null for an unreadable stored payload", () => {
+    sqlite
+      .query(
+        /*sql*/ `INSERT INTO conversation_tool_surfaces (conversation_id, tools_json, tools_hash, updated_at) VALUES (?, ?, ?, ?)`,
+      )
+      .run("conv-1", "not json", "h", 1);
+
+    expect(getConversationToolSurface("conv-1")).toBeNull();
+  });
+
+  test("the row cascades with its conversation", () => {
+    recordConversationToolSurface("conv-1", TOOLS);
+
+    sqlite.query(`DELETE FROM conversations WHERE id = ?`).run("conv-1");
+
+    expect(getConversationToolSurface("conv-1")).toBeNull();
+  });
+});

package/src/__tests__/managed-store.test.ts

@@ -332,6 +332,127 @@ describe("createManagedSkill", () => {
     expect(content).toContain("Overwritten");
   });
 
+  test("an overwrite keeps the frontmatter the call omits and replaces the body", () => {
+    createManagedSkill({
+      id: "kept",
+      name: "Kept",
+      description: "V1",
+      bodyMarkdown: "Old body.",
+      emoji: "📊",
+      includes: ["csv-basics"],
+      activationHints: ["user asks for the weekly report"],
+      avoidWhen: ["the report is monthly"],
+      category: "productivity",
+    });
+
+    const result = createManagedSkill({
+      id: "kept",
+      name: "Kept",
+      description: "V2",
+      bodyMarkdown: "New body.",
+      overwrite: true,
+    });
+    expect(result.created).toBe(true);
+
+    const catalog = loadSkillCatalog(undefined, [join(TEST_DIR, "skills")]);
+    const skill = catalog.find((s) => s.id === "kept")!;
+    expect(skill.description).toBe("V2");
+    expect(skill.emoji).toBe("📊");
+    expect(skill.includes).toEqual(["csv-basics"]);
+    expect(skill.activationHints).toEqual(["user asks for the weekly report"]);
+    expect(skill.avoidWhen).toEqual(["the report is monthly"]);
+    expect(skill.category).toBe("productivity");
+    expect(readFileSync(result.path, "utf-8")).toContain("New body.");
+    expect(readFileSync(result.path, "utf-8")).not.toContain("Old body.");
+  });
+
+  test("an overwrite carries through frontmatter the tool does not own", () => {
+    const dir = join(TEST_DIR, "skills", "hand-edited");
+    mkdirSync(dir, { recursive: true });
+    writeFileSync(
+      join(dir, "SKILL.md"),
+      [
+        "---",
+        'name: "Hand Edited"',
+        'description: "Has fields the tool never writes"',
+        "metadata:",
+        "  custom: kept",
+        "  vellum:",
+        '    display-name: "Hand Edited Skill"',
+        "    platforms:",
+        "      - macos",
+        "    always-candidate: true",
+        '    emoji: "📊"',
+        "---",
+        "",
+        "Old body.",
+        "",
+      ].join("\n"),
+    );
+
+    const result = createManagedSkill({
+      id: "hand-edited",
+      name: "Hand Edited",
+      description: "V2",
+      bodyMarkdown: "New body.",
+      overwrite: true,
+      category: "productivity",
+    });
+    expect(result.created).toBe(true);
+
+    const fm = parseYaml(
+      readFileSync(result.path, "utf-8").match(/^---\n([\s\S]*?)\n---/)![1],
+    );
+    expect(fm.metadata.custom).toBe("kept");
+    expect(fm.metadata.vellum["display-name"]).toBe("Hand Edited Skill");
+    expect(fm.metadata.vellum.platforms).toEqual(["macos"]);
+    expect(fm.metadata.vellum["always-candidate"]).toBe(true);
+    expect(fm.metadata.vellum.emoji).toBe("📊");
+    expect(fm.metadata.vellum.category).toBe("productivity");
+    const skill = loadSkillCatalog(undefined, [join(TEST_DIR, "skills")]).find(
+      (s) => s.id === "hand-edited",
+    )!;
+    expect(skill.displayName).toBe("Hand Edited Skill");
+    expect(skill.platforms).toEqual(["macos"]);
+    expect(skill.alwaysCandidate).toBe(true);
+  });
+
+  test("an overwrite replaces a field it passes and clears one passed empty", () => {
+    createManagedSkill({
+      id: "patched",
+      name: "Patched",
+      description: "V1",
+      bodyMarkdown: "Body.",
+      emoji: "📊",
+      includes: ["csv-basics"],
+      activationHints: ["old hint"],
+      avoidWhen: ["the report is monthly"],
+      category: "productivity",
+    });
+
+    createManagedSkill({
+      id: "patched",
+      name: "Patched",
+      description: "V2",
+      bodyMarkdown: "Body.",
+      overwrite: true,
+      emoji: "🚀",
+      activationHints: ["new hint"],
+      avoidWhen: [],
+      category: "",
+    });
+
+    const catalog = loadSkillCatalog(undefined, [join(TEST_DIR, "skills")]);
+    const skill = catalog.find((s) => s.id === "patched")!;
+    expect(skill.emoji).toBe("🚀");
+    expect(skill.activationHints).toEqual(["new hint"]);
+    // Omitted: kept.
+    expect(skill.includes).toEqual(["csv-basics"]);
+    // Passed empty: cleared.
+    expect(skill.avoidWhen).toBeUndefined();
+    expect(skill.category).toBeUndefined();
+  });
+
   test("writes category to frontmatter and round-trips through catalog load", () => {
     createManagedSkill({
       id: "categorized-skill",

package/src/__tests__/plugin-import-boundary-guard.test.ts

@@ -248,7 +248,6 @@ const BASELINE: Record<string, readonly string[]> = {
     "../../../util/sqlite-retry.js",
     "../../../util/strip-comment-lines.js",
     "../../../util/truncate.js",
-    "../../../util/unicode.js",
     "../../../util/worker-compute.js",
     "../../../util/worker-memory.js",
     "../../../util/worker-process.js",