@vellumai/assistant 0.10.3-dev.202606301343.ebf8f0b → 0.10.3-dev.202606301559.bafb7ae

package/openapi.yaml

@@ -7213,22 +7213,6 @@ paths:
       responses:
         "200":
           description: Successful response
-  /v1/conversations/{id}/regenerate:
-    post:
-      operationId: conversations_by_id_regenerate_post
-      summary: Regenerate response
-      description: Re-run the assistant for the last user message in a conversation.
-      tags:
-        - conversations
-      parameters:
-        - name: id
-          in: path
-          required: true
-          schema:
-            type: string
-      responses:
-        "202":
-          description: Successful response
   /v1/conversations/{id}/slash:
     post:
       operationId: conversations_by_id_slash_post
@@ -17894,6 +17878,11 @@ paths:
                   type: string
                 clientTimezone:
                   type: string
+                clientOs:
+                  description:
+                    Client OS surface ("web" | "ios" | "macos" | "android"), reported separately from `interface`. Drives the
+                    per-turn `client_os` context only; does not affect transport/host-proxy capabilities.
+                  type: string
                 clientMessageId:
                   type: string
                   description:

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@vellumai/assistant",
-  "version": "0.10.3-dev.202606301343.ebf8f0b",
+  "version": "0.10.3-dev.202606301559.bafb7ae",
   "license": "MIT",
   "type": "module",
   "exports": {

package/src/__tests__/background-workers-disk-pressure.test.ts

@@ -186,6 +186,7 @@ mock.module("../persistence/jobs-store.js", () => ({
   enqueuePruneOldConversationsJob: mock(() => "job-prune-conv"),
   enqueuePruneOldLlmRequestLogsJob: mock(() => "job-prune-llm"),
   enqueuePruneOldTraceEventsJob: mock(() => "job-prune-trace"),
+  enqueuePruneOldToolInvocationsJob: mock(() => "job-prune-tool"),
   failMemoryJob: mock(() => {}),
   failStalledJobs: mockFailStalledJobs,
   getMemoryJobCounts: mock(() => ({})),

package/src/__tests__/cancel-resolves-conversation-key.test.ts

@@ -51,7 +51,6 @@ mock.module("../daemon/handlers/conversations.js", () => ({
   switchConversation: async () => null,
   clearAllConversations: async () => 0,
   undoLastMessage: async () => null,
-  regenerateResponse: async () => null,
 }));
 
 import { getOrCreateConversation } from "../persistence/conversation-key-store.js";

package/src/__tests__/conversation-clear-safety.test.ts

@@ -33,7 +33,6 @@ mock.module("../daemon/handlers/conversations.js", () => ({
   },
   switchConversation: async () => null,
   undoLastMessage: async () => null,
-  regenerateResponse: async () => null,
 }));
 
 import {

package/src/__tests__/conversation-delete-schedule-cleanup.test.ts

@@ -26,7 +26,6 @@ mock.module("../daemon/handlers/conversations.js", () => ({
   clearAllConversations: async () => 0,
   switchConversation: async () => null,
   undoLastMessage: async () => null,
-  regenerateResponse: async () => null,
 }));
 
 import type { Database } from "bun:sqlite";

package/src/__tests__/conversation-error.test.ts

@@ -520,24 +520,6 @@ describe("classifyConversationError", () => {
     });
   });
 
-  describe("regenerate phase", () => {
-    it("returns REGENERATE_FAILED with nested classification info", () => {
-      const ctx: ErrorContext = { phase: "regenerate" };
-      const result = classifyConversationError(new Error("ECONNREFUSED"), ctx);
-      expect(result.code).toBe("REGENERATE_FAILED");
-      expect(result.retryable).toBe(true);
-      expect(result.userMessage).toContain("regenerate");
-      expect(result.errorCategory).toContain("regenerate:");
-    });
-
-    it("returns REGENERATE_FAILED for generic errors", () => {
-      const ctx: ErrorContext = { phase: "regenerate" };
-      const result = classifyConversationError(new Error("unknown issue"), ctx);
-      expect(result.code).toBe("REGENERATE_FAILED");
-      expect(result.retryable).toBe(true);
-    });
-  });
-
   describe("generic errors", () => {
     it("classifies unknown errors as CONVERSATION_PROCESSING_FAILED with error summary", () => {
       const result = classifyConversationError(

package/src/__tests__/conversation-history-web-search.test.ts

@@ -82,8 +82,6 @@ mock.module("../persistence/embeddings/qdrant-client.js", () => ({
 import {
   consolidateAssistantMessages,
   findLastUndoableUserMessageIndex,
-  type HistoryConversationContext,
-  regenerate,
 } from "../daemon/conversation-history.js";
 import type { ContentBlock, Message } from "../providers/types.js";
 
@@ -347,141 +345,6 @@ describe("isUndoableUserMessage with web_search_tool_result", () => {
   });
 });
 
-// ── Test 4: regenerate handles conversations with web_search_tool_result ─
-
-describe("regenerate with web_search_tool_result", () => {
-  beforeEach(() => {
-    dbMessages = [];
-    deletedMessageIds = [];
-    updatedMessages = [];
-  });
-
-  test("regenerate skips web_search_tool_result-only user messages when finding last real user message", async () => {
-    const conversationId = "conv-ws-regen";
-
-    // DB messages: user → assistant(server_tool_use) → user(web_search_tool_result) → assistant(text)
-    dbMessages = [
-      makeDbMessage(
-        "msg-u1",
-        conversationId,
-        "user",
-        [{ type: "text", text: "search for X" }],
-        1000,
-      ),
-      makeDbMessage(
-        "msg-a1",
-        conversationId,
-        "assistant",
-        [
-          {
-            type: "server_tool_use",
-            id: "srvtoolu_regen",
-            name: "web_search",
-            input: { query: "X" },
-          },
-        ],
-        2000,
-      ),
-      makeDbMessage(
-        "msg-ws",
-        conversationId,
-        "user",
-        [
-          {
-            type: "web_search_tool_result",
-            tool_use_id: "srvtoolu_regen",
-            content: [],
-          },
-        ],
-        3000,
-      ),
-      makeDbMessage(
-        "msg-a2",
-        conversationId,
-        "assistant",
-        [{ type: "text", text: "Results here." }],
-        4000,
-      ),
-    ];
-
-    // In-memory messages matching DB
-    const inMemoryMessages: Message[] = [
-      {
-        role: "user",
-        content: [{ type: "text", text: "search for X" }],
-      },
-      {
-        role: "assistant",
-        content: [
-          {
-            type: "server_tool_use",
-            id: "srvtoolu_regen",
-            name: "web_search",
-            input: { query: "X" },
-          },
-        ],
-      },
-      {
-        role: "user",
-        content: [
-          {
-            type: "web_search_tool_result",
-            tool_use_id: "srvtoolu_regen",
-            content: [],
-          },
-        ],
-      },
-      {
-        role: "assistant",
-        content: [{ type: "text", text: "Results here." }],
-      },
-    ];
-
-    let agentLoopCalled = false;
-    let agentLoopContent = "";
-    let agentLoopUserMessageId = "";
-
-    const events: Array<{ type: string; message?: string }> = [];
-
-    let processing = false;
-    const session: HistoryConversationContext = {
-      conversationId,
-      traceEmitter: {
-        emit: () => {},
-      } as unknown as HistoryConversationContext["traceEmitter"],
-      sendToClient: (msg) => events.push(msg),
-      messages: [...inMemoryMessages],
-      isProcessing: () => processing,
-      setProcessing: (value: boolean) => {
-        processing = value;
-      },
-      abortController: null,
-      async runAgentLoop(content, userMessageId) {
-        agentLoopCalled = true;
-        agentLoopContent = content;
-        agentLoopUserMessageId = userMessageId;
-      },
-    };
-
-    await regenerate(session);
-
-    // regenerate should find the real user message (msg-u1) and skip the
-    // web_search_tool_result-only message (msg-ws).
-    // BUG: Currently, regenerate only checks for tool_result in the
-    // `parsed.every(b => b.type === "tool_result")` check, so msg-ws
-    // is treated as a real user message, and regenerate gets confused.
-
-    expect(agentLoopCalled).toBe(true);
-    expect(agentLoopUserMessageId).toBe("msg-u1");
-    expect(agentLoopContent).toBe("search for X");
-
-    // Messages after the user message should be deleted
-    expect(deletedMessageIds).toContain("msg-a1");
-    expect(deletedMessageIds).toContain("msg-ws");
-    expect(deletedMessageIds).toContain("msg-a2");
-  });
-});
-
 // ── Test 5: ensureToolPairing preserves server_tool_use / web_search_tool_result pairs ─
 
 describe("ensureToolPairing with server_tool_use / web_search_tool_result", () => {

package/src/__tests__/conversation-process-callsite.test.ts

@@ -431,4 +431,41 @@ describe("processMessage callSite threading", () => {
 
     expect(conversation.clientTimezone).toBe("Europe/London");
   });
+
+  test("applies clientOs in the create and reuse transport metadata path", async () => {
+    mockConversation = {
+      id: "conv-store-client-os",
+      contextSummary: null,
+      contextCompactedMessageCount: 0,
+      totalInputTokens: 0,
+      totalOutputTokens: 0,
+      totalEstimatedCost: 0,
+    };
+    mockDbMessages = [];
+    clearCaptured();
+    clearAllActiveConversations();
+
+    // `interface` is always the transport surface (here "web"); the OS is
+    // carried separately as `clientOs` and must be applied on both the create
+    // and reuse paths so each turn reflects its own surface.
+    const conversation = await getOrCreateConversation("conv-store-client-os", {
+      transport: {
+        channelId: "vellum",
+        interfaceId: "web",
+        clientOs: "macos",
+      },
+    });
+
+    expect(conversation.clientOs).toBe("macos");
+
+    await getOrCreateConversation("conv-store-client-os", {
+      transport: {
+        channelId: "vellum",
+        interfaceId: "web",
+        clientOs: "ios",
+      },
+    });
+
+    expect(conversation.clientOs).toBe("ios");
+  });
 });

package/src/__tests__/conversation-queue.test.ts

@@ -681,6 +681,49 @@ describe("Conversation message queue", () => {
     expect(events3.some((e) => e.type === "message_complete")).toBe(true);
   });
 
+  test("[experimental] queued passthrough siblings from different client OS do NOT batch", async () => {
+    // Post-decouple, web/iOS/macOS all report interfaceId "web", so the
+    // interface-based batch split no longer separates them. A batched turn
+    // applies only the head's clientOs, so messages from different OS surfaces
+    // must split into separate runs rather than coalesce under one OS.
+    const conversation = makeConversation();
+    await conversation.loadFromDb();
+
+    const p1 = conversation.processMessage({
+      content: "msg-1",
+      attachments: [],
+      onEvent: () => {},
+      requestId: "req-1",
+    });
+    await waitForPendingRun(1);
+
+    // Two siblings on the same transport interface ("web") but different OS.
+    conversation.enqueueMessage({
+      content: "msg-2",
+      onEvent: () => {},
+      requestId: "req-2",
+      transport: { channelId: "vellum", interfaceId: "web", clientOs: "macos" },
+    });
+    conversation.enqueueMessage({
+      content: "msg-3",
+      onEvent: () => {},
+      requestId: "req-3",
+      transport: { channelId: "vellum", interfaceId: "web", clientOs: "ios" },
+    });
+    expect(conversation.getQueueDepth()).toBe(2);
+
+    // Drain: msg-2 (macos) is the batch head; msg-3 (ios) has a different
+    // clientOs, so it must NOT join the batch.
+    await resolveRun(0);
+    await p1;
+    await waitForPendingRun(2);
+    await resolveRun(1);
+    await waitForPendingRun(3);
+
+    // Three runs total (msg-1, msg-2, msg-3) — msg-3 was not batched with msg-2.
+    expect(pendingRuns.length).toBe(3);
+  });
+
   test("message_queued and message_dequeued events are emitted", async () => {
     const conversation = makeConversation();
     await conversation.loadFromDb();

package/src/__tests__/conversation-routes-slash-commands.test.ts

@@ -6,7 +6,9 @@
  *   do NOT trigger the agent loop.
  * - Regular messages pass through to the agent loop unchanged.
  */
-import { beforeEach, describe, expect, mock, test } from "bun:test";
+import { existsSync, rmSync, writeFileSync } from "node:fs";
+import { join } from "node:path";
+import { afterEach, beforeEach, describe, expect, mock, test } from "bun:test";
 
 mock.module("../config/env.js", () => ({ isHttpAuthDisabled: () => true }));
 
@@ -302,6 +304,7 @@ function makeConversation() {
     forceCompact,
     setPreactivatedSkillIds,
     drainQueue: async () => {},
+    warmPromptCache: () => {},
     getMessages: () => messages,
     assistantId: "self",
     trustContext: undefined,
@@ -545,3 +548,45 @@ describe("handleSendMessage slash command interception", () => {
     expect(ipcCallMock).not.toHaveBeenCalled();
   });
 });
+
+// The first-message wake-up greeting ("Wake up, my friend!") is served as a
+// canned response that skips the agent loop, just like a slash command. Its
+// user row must still carry the client-generated idempotency nonce so the web
+// client can reconcile its optimistic row against the persisted one — otherwise
+// the greeting renders twice (see the "two wakeup messages" staging report).
+describe("handleSendMessage canned wake-up greeting", () => {
+  // `isWakeUpGreeting` resolves BOOTSTRAP.md via getWorkspacePromptPath, which
+  // is rooted at VELLUM_WORKSPACE_DIR (the per-test temp workspace).
+  const bootstrapPath = join(process.env.VELLUM_WORKSPACE_DIR!, "BOOTSTRAP.md");
+
+  beforeEach(() => {
+    addMessageMock.mockClear();
+    // `isWakeUpGreeting` only treats the message as the wake-up greeting when
+    // BOOTSTRAP.md exists at the workspace prompt path (i.e. a first run).
+    writeFileSync(bootstrapPath, "# Bootstrap\n\nFirst run.");
+  });
+
+  afterEach(() => {
+    if (existsSync(bootstrapPath)) rmSync(bootstrapPath, { force: true });
+  });
+
+  test("persists the clientMessageId on the user row", async () => {
+    const { conversation, runAgentLoop } = makeConversation();
+    const res = await callHandler(
+      (args) => handleSendMessage(args, makeDeps(conversation)),
+      makeRequest("Wake up, my friend!", {
+        clientMessageId: "nonce-wake-123",
+      }),
+      undefined,
+      202,
+    );
+
+    expect(res.status).toBe(202);
+    // Canned greeting path: user + assistant rows persisted, agent loop skipped.
+    expect(runAgentLoop).not.toHaveBeenCalled();
+    const userCall = addMessageMock.mock.calls.find((c) => c[1] === "user");
+    expect(userCall).toBeDefined();
+    const options = userCall?.[3] as { clientMessageId?: string } | undefined;
+    expect(options?.clientMessageId).toBe("nonce-wake-123");
+  });
+});

package/src/__tests__/job-handler-registry-guard.test.ts

@@ -53,6 +53,7 @@ const NON_PLUGIN_JOB_TYPES = [
   "prune_old_conversations",
   "prune_old_llm_request_logs",
   "prune_old_trace_events",
+  "prune_old_tool_invocations",
   "build_conversation_summary",
   "media_processing",
   "conversation_analyze",

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

@@ -453,7 +453,12 @@ describe("validateCompanionPath", () => {
   });
 
   test("rejects store-owned top-level files", () => {
-    for (const reserved of ["SKILL.md", "install-meta.json", "version.json"]) {
+    for (const reserved of [
+      "SKILL.md",
+      "install-meta.json",
+      "version.json",
+      "TOOLS.json",
+    ]) {
       expect(validateCompanionPath(skillDir, reserved).error).toContain(
         "store-owned",
       );
@@ -463,6 +468,38 @@ describe("validateCompanionPath", () => {
       validateCompanionPath(skillDir, "references/SKILL.md").error,
     ).toBeUndefined();
   });
+
+  test("rejects a top-level TOOLS.json companion to block planting executable tools", () => {
+    // TOOLS.json is the manifest the skill loader scans to register (and
+    // dynamically import) executable tools. A scaffold author must never be
+    // able to plant one — otherwise an instruction-only managed skill becomes a
+    // code-injection surface.
+    expect(validateCompanionPath(skillDir, "TOOLS.json").error).toContain(
+      "store-owned",
+    );
+  });
+
+  test("rejects case variants of reserved names (case-insensitive filesystems)", () => {
+    // On macOS (case-insensitive FS), `tools.json` resolves to the same file
+    // the scanner reads as `TOOLS.json`, so a varied-case name must be rejected
+    // too — otherwise the guard is trivially bypassed. Same for SKILL.md.
+    for (const variant of [
+      "tools.json",
+      "Tools.json",
+      "TOOLS.JSON",
+      "skill.md",
+      "Skill.MD",
+      "INSTALL-META.JSON",
+    ]) {
+      expect(validateCompanionPath(skillDir, variant).error).toContain(
+        "store-owned",
+      );
+    }
+    // Nested case variants remain allowed — only top-level is scanned.
+    expect(
+      validateCompanionPath(skillDir, "references/tools.json").error,
+    ).toBeUndefined();
+  });
 });
 
 describe("createManagedSkill companion files", () => {
@@ -604,6 +641,43 @@ describe("createManagedSkill companion files", () => {
     ).toBe(false);
   });
 
+  test("rejects a TOOLS.json companion and writes nothing", () => {
+    // Planting a TOOLS.json declaring execution_target/risk would let a
+    // scaffolded skill register attacker-controlled tools. The reserved-name
+    // check must reject it before any write, leaving no SKILL.md or manifest.
+    const result = createManagedSkill({
+      id: "tools-manifest",
+      name: "Tools Manifest",
+      description: "Tries to plant a tool manifest",
+      bodyMarkdown: "Body.",
+      files: [
+        {
+          path: "TOOLS.json",
+          content: JSON.stringify({
+            version: 1,
+            tools: [
+              {
+                name: "pwn",
+                description: "x",
+                category: "x",
+                risk: "low",
+                input_schema: { type: "object" },
+                executor: "tools/pwn.ts",
+                execution_target: "host",
+              },
+            ],
+          }),
+        },
+      ],
+    });
+
+    expect(result.created).toBe(false);
+    expect(result.error).toContain("store-owned");
+    const skillDir = join(TEST_DIR, "skills", "tools-manifest");
+    expect(existsSync(join(skillDir, "TOOLS.json"))).toBe(false);
+    expect(existsSync(join(skillDir, "SKILL.md"))).toBe(false);
+  });
+
   test("overwrite re-writes companion files", () => {
     createManagedSkill({
       id: "overwrite-files",

package/src/__tests__/mtime-cache.test.ts

@@ -629,6 +629,25 @@ describe("plugin runtime activation", () => {
     expect(existsSync(shutdownMarker)).toBe(true);
   });
 
+  test("a user plugin's shutdown hook is surfaced through the unified hook lookup", async () => {
+    // Plugin `shutdown` hooks fire at daemon shutdown through the same
+    // getHooksFor/runHook pipeline as every other lifecycle hook. Prove the
+    // user-land side is discoverable that way: the plugin's shutdown hook is
+    // returned by the unified per-name lookup and runs when invoked.
+    const dir = freshPluginDir("shutdown-hook-plugin");
+    writePackageJson(dir, { ...SIMPLE_PKG, name: "shutdown-hook-plugin" });
+    const shutdownMarker = join(ROOT, "user-shutdown.log");
+    writeMarkerHook(dir, "shutdown", shutdownMarker, "bye");
+
+    await populateCacheAtBoot();
+
+    const shutdownHooks = await getUserHooksFor("shutdown");
+    expect(shutdownHooks).toHaveLength(1);
+
+    await shutdownHooks[0]!({ assistantVersion: "test", reason: "shutdown" });
+    expect(existsSync(shutdownMarker)).toBe(true);
+  });
+
   test("disabling a plugin at runtime tears down its tools", async () => {
     const dir = freshPluginDir("disable-plugin");
     writePackageJson(dir, { ...SIMPLE_PKG, name: "disable-plugin" });

package/src/__tests__/plugin-bootstrap.test.ts

@@ -7,7 +7,8 @@
  * - Version-mismatch registration fails with an error that names the plugin
  *   (the registry enforces this at `registerPlugin` time, so bootstrap never
  *   sees the malformed plugin).
- * - Shutdown hook walks plugins in reverse registration order.
+ * - Plugins' `shutdown` hooks fire through the unified `runHook(HOOKS.SHUTDOWN)`
+ *   pipeline; flag-gated and `.disabled` plugins are excluded from that dispatch.
  *
  * `resetPluginRegistryForTests()` isolates registry state between cases.
  */
@@ -20,9 +21,10 @@ import { beforeEach, describe, expect, test } from "bun:test";
 
 import { clearFeatureFlagOverridesCache } from "../config/assistant-feature-flags.js";
 import { bootstrapPlugins } from "../daemon/external-plugins-bootstrap.js";
-import { runShutdownHooks } from "../daemon/shutdown-registry.js";
 import { RiskLevel } from "../permissions/types.js";
+import { HOOKS } from "../plugin-api/constants.js";
 import { registerDefaultPlugins } from "../plugins/defaults/index.js";
+import { runHook } from "../plugins/pipeline.js";
 import {
   closeRegistration,
   getRegisteredPlugins,
@@ -233,7 +235,7 @@ describe("plugin bootstrap", () => {
     expect(names).toContain("default-title-generate");
   });
 
-  test("shutdown order: onShutdown fires in reverse registration order", async () => {
+  test("shutdown: onShutdown fires through the runHook pipeline in registration order", async () => {
     const callOrder: string[] = [];
     registerPlugin(
       buildPlugin("first-registered", {
@@ -251,12 +253,15 @@ describe("plugin bootstrap", () => {
     );
 
     await bootstrapPlugins();
-    await runShutdownHooks("test-shutdown");
+    // The plugins' `shutdown` hooks fire through the unified pipeline — the same
+    // dispatch path (and registration order) as every other lifecycle hook, so
+    // the first plugin to register runs first.
+    await runHook(HOOKS.SHUTDOWN, {
+      assistantVersion: APP_VERSION,
+      reason: "shutdown",
+    });
 
-    // The last plugin to register must shut down first; the first to register
-    // shuts down last. Symmetric tear-down around registration order is the
-    // whole point of the reverse walk.
-    expect(callOrder).toEqual(["second-registered", "first-registered"]);
+    expect(callOrder).toEqual(["first-registered", "second-registered"]);
   });
 
   test("empty registry: bootstrap seeds the first-party defaults without throwing", async () => {
@@ -463,11 +468,14 @@ describe("plugin bootstrap", () => {
     registerPlugin(plugin);
 
     await bootstrapPlugins();
-    await runShutdownHooks("test-shutdown");
+    await runHook(HOOKS.SHUTDOWN, {
+      assistantVersion: APP_VERSION,
+      reason: "shutdown",
+    });
 
-    // The shutdown hook is a single registered callback that walks a
-    // snapshot taken at bootstrap. A skipped plugin should never appear in
-    // that snapshot, so its `onShutdown` must never fire.
+    // A flag-gated plugin is dropped from the registry at bootstrap
+    // (`unregisterPlugin`), so it never appears in the `getHooksFor("shutdown")`
+    // the pipeline dispatches — its `onShutdown` must never fire.
     expect(shutdownFired).toBe(false);
   });
 
@@ -549,8 +557,14 @@ describe("plugin bootstrap", () => {
     await writeFile(join(sentinelDir, ".disabled"), "");
 
     await bootstrapPlugins();
-    await runShutdownHooks("test-shutdown");
+    await runHook(HOOKS.SHUTDOWN, {
+      assistantVersion: APP_VERSION,
+      reason: "shutdown",
+    });
 
+    // A `.disabled` plugin keeps its hooks registered but they are filtered out
+    // at read time by `isPluginDisabled` inside `getHooksFor`, so the pipeline
+    // dispatch skips its `onShutdown` too.
     expect(shutdownFired).toBe(false);
 
     await rm(sentinelDir, { recursive: true, force: true });