@vellumai/assistant 0.8.4 → 0.8.6

package/src/__tests__/persistence-pipeline.test.ts

@@ -25,6 +25,8 @@ import {
   createConversation,
   getMessageById,
   getMessages,
+  reserveMessage,
+  updateMessageContent,
   updateMessageMetadata,
 } from "../memory/conversation-crud.js";
 import { getDb } from "../memory/db-connection.js";
@@ -44,6 +46,7 @@ import type {
   PersistAddResult,
   PersistArgs,
   PersistDeleteResult,
+  PersistReserveResult,
   PersistResult,
   Plugin,
   TurnContext,
@@ -215,6 +218,80 @@ describe("persistence pipeline", () => {
     expect(getMessages(conv.id)).toHaveLength(0);
   });
 
+  test("default plugin: reserve op pre-allocates an empty assistant row", async () => {
+    registerPlugin(defaultPersistencePlugin);
+
+    const conv = createConversation();
+
+    const result = (await runPipeline<PersistArgs, PersistResult>(
+      "persistence",
+      getMiddlewaresFor("persistence"),
+      defaultPersistenceTerminal,
+      {
+        op: "reserve",
+        conversationId: conv.id,
+        role: "assistant",
+        metadata: { reservedFor: "anchor" },
+      },
+      makeCtx({ conversationId: conv.id }),
+      DEFAULT_TIMEOUTS.persistence,
+    )) as PersistReserveResult;
+
+    expect(result.op).toBe("reserve");
+    expect(result.message.id).toBeTruthy();
+    expect(result.message.role).toBe("assistant");
+    // Reserve places an empty JSON array so consumers that parse content
+    // observe a no-content payload.
+    expect(result.message.content).toBe("[]");
+
+    // Row must exist with the expected shape and live in the conversation.
+    const row = getMessageById(result.message.id, conv.id);
+    expect(row).not.toBeNull();
+    expect(row?.content).toBe("[]");
+    expect(JSON.parse(row!.metadata!)).toEqual({ reservedFor: "anchor" });
+    expect(getMessages(conv.id).map((m) => m.id)).toContain(result.message.id);
+  });
+
+  test("default plugin: updateContent op overwrites an existing row's content", async () => {
+    registerPlugin(defaultPersistencePlugin);
+
+    const conv = createConversation();
+
+    // Reserve first, then overwrite — exactly the B3 sequence consumers will
+    // follow.
+    const reserved = await reserveMessage(conv.id, "assistant");
+    expect(getMessageById(reserved.id, conv.id)?.content).toBe("[]");
+
+    const result = await runPipeline<PersistArgs, PersistResult>(
+      "persistence",
+      getMiddlewaresFor("persistence"),
+      defaultPersistenceTerminal,
+      {
+        op: "updateContent",
+        messageId: reserved.id,
+        content: JSON.stringify([{ type: "text", text: "Hello" }]),
+      },
+      makeCtx({ conversationId: conv.id }),
+      DEFAULT_TIMEOUTS.persistence,
+    );
+    expect(result).toEqual({ op: "updateContent" });
+
+    // Content updated in place; row id unchanged.
+    const row = getMessageById(reserved.id, conv.id);
+    expect(row).not.toBeNull();
+    expect(JSON.parse(row!.content)).toEqual([{ type: "text", text: "Hello" }]);
+
+    // Direct-call parity: a fresh reserve + direct updateMessageContent
+    // should land the same content shape.
+    const baselineReserved = await reserveMessage(conv.id, "assistant");
+    updateMessageContent(
+      baselineReserved.id,
+      JSON.stringify([{ type: "text", text: "Hello" }]),
+    );
+    const baselineRow = getMessageById(baselineReserved.id, conv.id);
+    expect(baselineRow?.content).toBe(row?.content);
+  });
+
   test("custom plugin: short-circuits every op onto a mock in-memory store", async () => {
     type Stored = {
       id: string;
@@ -249,6 +326,33 @@ describe("persistence pipeline", () => {
               },
             };
           }
+          case "reserve": {
+            const id = `mock-${nextId++}`;
+            mockStore.set(id, {
+              id,
+              conversationId: args.conversationId,
+              role: args.role,
+              content: "[]",
+              metadata: { ...(args.metadata ?? {}) },
+            });
+            return {
+              op: "reserve",
+              message: {
+                id,
+                conversationId: args.conversationId,
+                role: args.role,
+                content: "[]",
+                createdAt: 123,
+              },
+            };
+          }
+          case "updateContent": {
+            const existing = mockStore.get(args.messageId);
+            if (existing) {
+              existing.content = args.content;
+            }
+            return { op: "updateContent" };
+          }
           case "update": {
             const existing = mockStore.get(args.messageId);
             if (existing) {
@@ -298,6 +402,40 @@ describe("persistence pipeline", () => {
     expect(addResult.message.id).toBe("mock-1");
     expect(mockStore.size).toBe(1);
 
+    const reserveResult = (await runPipeline<PersistArgs, PersistResult>(
+      "persistence",
+      getMiddlewaresFor("persistence"),
+      defaultPersistenceTerminal,
+      {
+        op: "reserve",
+        conversationId: conv.id,
+        role: "assistant",
+        metadata: { reservedFor: "mock-anchor" },
+      },
+      makeCtx({ conversationId: conv.id }),
+      DEFAULT_TIMEOUTS.persistence,
+    )) as PersistReserveResult;
+    expect(reserveResult.op).toBe("reserve");
+    expect(reserveResult.message.id).toBe("mock-2");
+    expect(reserveResult.message.content).toBe("[]");
+    expect(mockStore.get("mock-2")?.content).toBe("[]");
+
+    await runPipeline<PersistArgs, PersistResult>(
+      "persistence",
+      getMiddlewaresFor("persistence"),
+      defaultPersistenceTerminal,
+      {
+        op: "updateContent",
+        messageId: "mock-2",
+        content: '[{"type":"text","text":"finalized"}]',
+      },
+      makeCtx({ conversationId: conv.id }),
+      DEFAULT_TIMEOUTS.persistence,
+    );
+    expect(mockStore.get("mock-2")?.content).toBe(
+      '[{"type":"text","text":"finalized"}]',
+    );
+
     await runPipeline<PersistArgs, PersistResult>(
       "persistence",
       getMiddlewaresFor("persistence"),
@@ -326,7 +464,7 @@ describe("persistence pipeline", () => {
     expect(delResult.op).toBe("delete");
     expect(mockStore.has("mock-1")).toBe(false);
 
-    // The real DB must not have been touched by any of the three ops.
+    // The real DB must not have been touched by any of the ops.
     expect(getMessages(conv.id)).toHaveLength(dbRowsBefore);
   });
 

package/src/__tests__/persistence-secret-redaction.test.ts

@@ -40,6 +40,7 @@ mock.module("../config/loader.js", () => ({
 }));
 
 interface AddMessageCall {
+  id: string;
   conversationId: string;
   role: string;
   content: string;
@@ -53,13 +54,41 @@ mock.module("../memory/conversation-crud.js", () => ({
     content: string,
     metadata?: Record<string, unknown>,
   ) => {
-    addMessageCalls.push({ conversationId, role, content, metadata });
-    return { id: `mock-msg-${addMessageCalls.length}` };
+    const id = `mock-msg-${addMessageCalls.length + 1}`;
+    addMessageCalls.push({ id, conversationId, role, content, metadata });
+    return { id };
   },
   getConversation: () => null,
   getMessageById: () => null,
-  updateMessageContent: () => {},
+  updateMessageContent: (messageId: string, content: string) => {
+    // Mirror updateContent into the same capture array so existing
+    // `lastPersisted("assistant")` assertions continue to find the row that
+    // was reserved at `llm_call_started` time.
+    const call = addMessageCalls.find((c) => c.id === messageId);
+    if (call) call.content = content;
+  },
   provenanceFromTrustContext: () => ({}),
+  reserveMessage: mock(
+    async (
+      conversationId: string,
+      role: string,
+      metadata?: Record<string, unknown>,
+    ) => {
+      // B3: production code creates the assistant row at `llm_call_started`
+      // via `reserveMessage`, stamping channel metadata at reserve time.
+      // Mirror that into the addMessage capture array so existing
+      // `lastPersisted("assistant")` assertions keep working.
+      const id = `mock-msg-${addMessageCalls.length + 1}-reserve`;
+      addMessageCalls.push({
+        id,
+        conversationId,
+        role,
+        content: "",
+        metadata,
+      });
+      return { id };
+    },
+  ),
 }));
 
 mock.module("../memory/llm-request-log-store.js", () => ({
@@ -84,6 +113,7 @@ import type {
 } from "../daemon/conversation-agent-loop-handlers.js";
 import {
   createEventHandlerState,
+  handleLlmCallStarted,
   handleMessageComplete,
 } from "../daemon/conversation-agent-loop-handlers.js";
 
@@ -164,7 +194,12 @@ describe("persistence-layer secret redaction", () => {
       isError: false,
     });
 
-    await handleMessageComplete(state, makeDeps(), makeMessageCompleteEvent("done"));
+    await handleLlmCallStarted(state, makeDeps());
+    await handleMessageComplete(
+      state,
+      makeDeps(),
+      makeMessageCompleteEvent("done"),
+    );
 
     const persisted = lastPersisted("user");
     const blocks = JSON.parse(persisted.content) as Array<{
@@ -183,7 +218,12 @@ describe("persistence-layer secret redaction", () => {
       isError: false,
     });
 
-    await handleMessageComplete(state, makeDeps(), makeMessageCompleteEvent("done"));
+    await handleLlmCallStarted(state, makeDeps());
+    await handleMessageComplete(
+      state,
+      makeDeps(),
+      makeMessageCompleteEvent("done"),
+    );
 
     const persisted = lastPersisted("user");
     const blocks = JSON.parse(persisted.content) as Array<{
@@ -195,13 +235,19 @@ describe("persistence-layer secret redaction", () => {
   });
 
   test("does not redact non-secret content (UUID, hex hash) in tool result", async () => {
-    const safe = "id=550e8400-e29b-41d4-a716-446655440000 sha=a1b2c3d4e5f6a1b2c3d4e5f6a1b2c3d4e5f6a1b2";
+    const safe =
+      "id=550e8400-e29b-41d4-a716-446655440000 sha=a1b2c3d4e5f6a1b2c3d4e5f6a1b2c3d4e5f6a1b2";
     state.pendingToolResults.set("tool-use-3", {
       content: safe,
       isError: false,
     });
 
-    await handleMessageComplete(state, makeDeps(), makeMessageCompleteEvent("done"));
+    await handleLlmCallStarted(state, makeDeps());
+    await handleMessageComplete(
+      state,
+      makeDeps(),
+      makeMessageCompleteEvent("done"),
+    );
 
     const persisted = lastPersisted("user");
     const blocks = JSON.parse(persisted.content) as Array<{
@@ -224,7 +270,12 @@ describe("persistence-layer secret redaction", () => {
     // Capture the content before handleMessageComplete clears pendingToolResults
     const contentSnapshot = state.pendingToolResults.get("tool-use-4")!.content;
 
-    await handleMessageComplete(state, makeDeps(), makeMessageCompleteEvent("done"));
+    await handleLlmCallStarted(state, makeDeps());
+    await handleMessageComplete(
+      state,
+      makeDeps(),
+      makeMessageCompleteEvent("done"),
+    );
 
     // The snapshot taken from live state before the call must be unmodified
     expect(contentSnapshot).toBe(originalContent);
@@ -239,7 +290,12 @@ describe("persistence-layer secret redaction", () => {
       "ABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789";
     const text = `Your API key is \`${secret}\`. Keep it safe.`;
 
-    await handleMessageComplete(state, makeDeps(), makeMessageCompleteEvent(text));
+    await handleLlmCallStarted(state, makeDeps());
+    await handleMessageComplete(
+      state,
+      makeDeps(),
+      makeMessageCompleteEvent(text),
+    );
 
     const persisted = lastPersisted("assistant");
     const blocks = JSON.parse(persisted.content) as Array<{
@@ -256,7 +312,12 @@ describe("persistence-layer secret redaction", () => {
     const secret = "sk-proj-ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrst";
     const text = `I found this key in the config: ${secret}`;
 
-    await handleMessageComplete(state, makeDeps(), makeMessageCompleteEvent(text));
+    await handleLlmCallStarted(state, makeDeps());
+    await handleMessageComplete(
+      state,
+      makeDeps(),
+      makeMessageCompleteEvent(text),
+    );
 
     const persisted = lastPersisted("assistant");
     const blocks = JSON.parse(persisted.content) as Array<{
@@ -271,7 +332,12 @@ describe("persistence-layer secret redaction", () => {
   test("does not redact non-secret text in assistant message", async () => {
     const safe = "Here is the file list: index.ts, util.ts, main.ts";
 
-    await handleMessageComplete(state, makeDeps(), makeMessageCompleteEvent(safe));
+    await handleLlmCallStarted(state, makeDeps());
+    await handleMessageComplete(
+      state,
+      makeDeps(),
+      makeMessageCompleteEvent(safe),
+    );
 
     const persisted = lastPersisted("assistant");
     const blocks = JSON.parse(persisted.content) as Array<{
@@ -286,7 +352,12 @@ describe("persistence-layer secret redaction", () => {
     // High-entropy but no known credential prefix — should NOT be redacted
     const text = "checksum: 8f14e45fceea167a5a36dedd4bea2543";
 
-    await handleMessageComplete(state, makeDeps(), makeMessageCompleteEvent(text));
+    await handleLlmCallStarted(state, makeDeps());
+    await handleMessageComplete(
+      state,
+      makeDeps(),
+      makeMessageCompleteEvent(text),
+    );
 
     const persisted = lastPersisted("assistant");
     const blocks = JSON.parse(persisted.content) as Array<{

package/src/__tests__/platform-bash-auto-approve.test.ts

@@ -100,7 +100,7 @@ mock.module("../permissions/checker.js", () => ({
 mock.module("../memory/tool-usage-store.js", () => ({
   recordToolInvocation: () => {},
   getRecentInvocations: () => [],
-  rotateToolInvocations: () => 0,
+  rotateToolInvocations: async () => 0,
 }));
 
 mock.module("../tools/registry.js", () => ({
@@ -111,7 +111,7 @@ mock.module("../tools/registry.js", () => ({
       description: "test tool",
       category: "shell",
       defaultRiskLevel: "medium",
-      getDefinition: () => ({}),
+      input_schema: {},
       execute: async () => fakeToolResult,
     };
   },

package/src/__tests__/platform.test.ts

@@ -8,7 +8,7 @@ import {
   getDataDir,
   getDbPath,
   getHistoryPath,
-  getLogPath,
+  getLogsDir,
   getPidPath,
   getSandboxRootDir,
   getSandboxWorkingDir,
@@ -64,7 +64,7 @@ describe("path characterization", () => {
 
     // Sub-paths under workspace/data
     expect(getDbPath()).toBe(join(data, "db", "assistant.db"));
-    expect(getLogPath()).toBe(join(data, "logs", "vellum.log"));
+    expect(getLogsDir()).toBe(join(data, "logs"));
     expect(getHistoryPath()).toBe(join(data, "history"));
     expect(getSandboxRootDir()).toBe(join(data, "sandbox"));
     expect(getSandboxWorkingDir()).toBe(ws);

package/src/__tests__/plugin-api-tool-definition.test.ts

@@ -0,0 +1,92 @@
+/**
+ * Shape tests for the public `ToolDefinition` author-facing tool spec.
+ *
+ * These tests don't exercise runtime behavior — they assert via
+ * `satisfies` that representative tool literals line up with the public
+ * interface. If a later PR breaks a field name or signature in
+ * `assistant/src/plugin-api/types.ts`, this file fails to type-check and
+ * the regression is caught at `tsc --noEmit` / `bun test` time.
+ */
+
+import { describe, expect, test } from "bun:test";
+
+import {
+  RiskLevel,
+  type ToolContext,
+  type ToolDefinition,
+  type ToolExecutionResult,
+} from "../plugin-api/index.js";
+
+describe("ToolDefinition (public author-facing tool spec) ", () => {
+  test("a fully-populated literal satisfies the interface", () => {
+    const tool = {
+      description: "Greet the model in a fixed language.",
+      defaultRiskLevel: RiskLevel.Low,
+      input_schema: {
+        type: "object",
+        properties: {
+          language: { type: "string" },
+        },
+        required: ["language"],
+        additionalProperties: false,
+      },
+      async execute(
+        input: Record<string, unknown>,
+        _ctx: ToolContext,
+      ): Promise<ToolExecutionResult> {
+        return {
+          content: `hello, ${String(input.language)} speaker`,
+          isError: false,
+        };
+      },
+    } as const satisfies ToolDefinition;
+
+    // `as const` propagates literal types and verifies type compatibility,
+    // but the runtime expectations below also smoke-check the structure
+    // for anyone reading the test without TS folded in.
+    expect(typeof tool.execute).toBe("function");
+    expect(tool.defaultRiskLevel).toBe(RiskLevel.Low);
+  });
+
+  test("every field is optional — empty literal satisfies the interface", () => {
+    const tool: ToolDefinition = {};
+    expect(tool).toEqual({});
+  });
+
+  test("every author-facing risk level is permitted", () => {
+    const low: ToolDefinition = { defaultRiskLevel: RiskLevel.Low };
+    const medium: ToolDefinition = { defaultRiskLevel: RiskLevel.Medium };
+    const high: ToolDefinition = { defaultRiskLevel: RiskLevel.High };
+
+    expect(low.defaultRiskLevel).toBe(RiskLevel.Low);
+    expect(medium.defaultRiskLevel).toBe(RiskLevel.Medium);
+    expect(high.defaultRiskLevel).toBe(RiskLevel.High);
+  });
+
+  test("execute receives the public ToolContext", async () => {
+    // Type-only assertion: the execute signature uses the public
+    // ToolContext (narrow base). A daemon-internal field added to the
+    // rich ToolContext that doesn't exist on the narrow one must not be
+    // accessible here. We can't test this at runtime — the assertion
+    // lives in `tsc --noEmit` over this file.
+    const tool: ToolDefinition = {
+      async execute(_input, ctx) {
+        // `ctx` is the public `ToolContext`. Touch
+        // commonly-needed fields to make sure they're present.
+        const _conversationId = ctx.conversationId;
+        const _workingDir = ctx.workingDir;
+        const _signal = ctx.signal;
+        return { content: "ok", isError: false };
+      },
+    };
+    const result = await tool.execute?.(
+      {},
+      {
+        conversationId: "conv-abc",
+        workingDir: "/tmp",
+        signal: new AbortController().signal,
+      } as ToolContext,
+    );
+    expect(result?.isError).toBe(false);
+  });
+});

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

@@ -31,10 +31,7 @@ mock.module("../security/secure-keys.js", () => ({
   getSecureKeyAsync: getSecureKeyAsyncMock,
 }));
 
-import {
-  _setOverridesForTesting,
-  clearFeatureFlagOverridesCache,
-} from "../config/assistant-feature-flags.js";
+import { clearFeatureFlagOverridesCache } from "../config/assistant-feature-flags.js";
 import type { AssistantConfig } from "../config/schema.js";
 import {
   bootstrapPlugins,
@@ -54,6 +51,7 @@ import {
   PluginExecutionError,
   type PluginInitContext,
 } from "../plugins/types.js";
+import { setOverridesForTesting } from "./feature-flag-test-helpers.js";
 
 // Redirect plugin storage directory creation into a per-process temp tree so
 // the test doesn't touch the developer's real ~/.vellum.
@@ -125,7 +123,7 @@ describe("plugin bootstrap", () => {
     getSecureKeyAsyncMock.mockReset();
     getSecureKeyAsyncMock.mockImplementation(async () => undefined);
     // Reset feature-flag cache so tests start from a known state. Individual
-    // tests that exercise `requiresFlag` use `_setOverridesForTesting(...)`
+    // tests that exercise `requiresFlag` use `setOverridesForTesting(...)`
     // to install their own overrides.
     clearFeatureFlagOverridesCache();
     // Clean storage directory between runs so nothing leaks across cases.
@@ -335,11 +333,11 @@ describe("plugin bootstrap", () => {
   //   - no shutdown hook entry is installed (nothing to tear down later).
   // Plugins without `requiresFlag` are unaffected.
   //
-  // Uses `_setOverridesForTesting` to control the resolver deterministically
+  // Uses `setOverridesForTesting` to control the resolver deterministically
   // — no disk writes, no gateway IPC, no reliance on registry defaults.
 
   test("requiresFlag enabled: plugin inits normally", async () => {
-    _setOverridesForTesting({ "plugin-gated-enabled": true });
+    setOverridesForTesting({ "plugin-gated-enabled": true });
 
     let initFired = false;
     const plugin = buildPlugin(
@@ -359,7 +357,7 @@ describe("plugin bootstrap", () => {
   });
 
   test("requiresFlag disabled: init does not fire and no tools/routes/skills are registered", async () => {
-    _setOverridesForTesting({ "plugin-gated-disabled": false });
+    setOverridesForTesting({ "plugin-gated-disabled": false });
 
     let initFired = false;
     // Attach tool/route/skill contributions alongside init. If gating works,
@@ -375,6 +373,7 @@ describe("plugin bootstrap", () => {
             name: "gated-off-tool",
             description: "should not be registered",
             defaultRiskLevel: RiskLevel.Low,
+            executionTarget: "sandbox",
             input_schema: { type: "object", properties: {}, required: [] },
             execute: async () => ({ content: "nope", isError: false }),
           },
@@ -421,8 +420,7 @@ describe("plugin bootstrap", () => {
   });
 
   test("requiresFlag absent: plugin activates unconditionally", async () => {
-    // Deliberately do not set any overrides — the resolver defaults
-    // undeclared keys to `true`, but more importantly a plugin with no
+    // Deliberately do not set any overrides — a plugin with no
     // `requiresFlag` key must not consult the resolver at all.
     let initFired = false;
     const plugin = buildPlugin("no-flag", {
@@ -440,7 +438,7 @@ describe("plugin bootstrap", () => {
   test("requiresFlag: one disabled flag out of several skips the plugin", async () => {
     // When ANY listed flag is disabled, the plugin is skipped wholesale —
     // this prevents sneaky partial activation on AND semantics.
-    _setOverridesForTesting({
+    setOverridesForTesting({
       "plugin-multi-a": true,
       "plugin-multi-b": false,
     });
@@ -469,7 +467,7 @@ describe("plugin bootstrap", () => {
     // injectors still ran on every pipeline invocation and system-prompt
     // assembly even though `init()` had never fired to set up the state they
     // depended on.
-    _setOverridesForTesting({ "plugin-middleware-disabled": false });
+    setOverridesForTesting({ "plugin-middleware-disabled": false });
 
     const gatedMiddleware: PipelineMiddlewareMap["llmCall"] = async (
       args,
@@ -506,7 +504,7 @@ describe("plugin bootstrap", () => {
   });
 
   test("requiresFlag disabled: no shutdown hook entry installed for the skipped plugin", async () => {
-    _setOverridesForTesting({ "plugin-shutdown-flag": false });
+    setOverridesForTesting({ "plugin-shutdown-flag": false });
 
     let shutdownFired = false;
     const plugin = buildPlugin(