@vellumai/assistant 0.8.4 → 0.8.6

package/src/__tests__/skill-projection.benchmark.test.ts

@@ -23,7 +23,7 @@ mock.module("../util/logger.js", () => ({
 }));
 
 // Mock config loader and feature flags to avoid filesystem reads on CI.
-// getConfig returns a minimal config; all feature flags default to enabled.
+// The benchmark fixture treats every feature flag as enabled.
 mock.module("../config/loader.js", () => ({
   getConfig: () => ({}),
   loadConfig: () => ({}),
@@ -102,23 +102,16 @@ mock.module("../tools/skills/skill-tool-factory.js", () => ({
     entries: Array<{ name: string; description: string; input_schema: object }>,
     skillId: string,
     _skillDir: string,
-    versionHash: string,
-    bundled?: boolean,
+    _versionHash: string,
+    _bundled?: boolean,
   ) =>
     entries.map((e) => ({
       name: e.name,
       description: e.description,
       category: "skill",
       defaultRiskLevel: "low",
-      origin: "skill" as const,
-      ownerSkillId: skillId,
-      ownerSkillVersionHash: versionHash,
-      ownerSkillBundled: bundled,
-      getDefinition: () => ({
-        name: e.name,
-        description: e.description,
-        input_schema: e.input_schema,
-      }),
+      owner: { kind: "skill" as const, id: skillId },
+      input_schema: e.input_schema,
       execute: async () => ({ content: "", isError: false }),
     })),
 }));
@@ -170,7 +163,8 @@ mock.module("../tools/registry.js", () => ({
   },
   unregisterSkillTools: (skillId: string) => {
     for (const [name, t] of benchmarkRegistry) {
-      if ((t as { ownerSkillId?: string }).ownerSkillId === skillId)
+      const owner = (t as { owner?: { kind: string; id: string } }).owner;
+      if (owner?.kind === "skill" && owner.id === skillId)
         benchmarkRegistry.delete(name);
     }
   },

package/src/__tests__/skill-tool-factory.test.ts

@@ -73,53 +73,23 @@ afterAll(async () => {
 
 describe("createSkillTool", () => {
   test("produces a tool with correct name, description, and category", () => {
-    const tool = createSkillTool(
-      makeEntry(),
-      "my-skill",
-      "/skills/my-skill",
-      "v1:test",
-    );
+    const tool = createSkillTool(makeEntry(), "/skills/my-skill", "v1:test");
 
     expect(tool.name).toBe("test_tool");
     expect(tool.description).toBe("A test tool");
     expect(tool.category).toBe("testing");
   });
 
-  test("sets origin to skill and ownerSkillId", () => {
-    const tool = createSkillTool(
-      makeEntry(),
-      "weather-skill",
-      "/skills/weather",
-      "v1:test",
-    );
-
-    expect(tool.origin).toBe("skill");
-    expect(tool.ownerSkillId).toBe("weather-skill");
-  });
-
-  test("sets ownerSkillVersionHash from versionHash", () => {
-    const hash = "v1:abc123def456";
-    const tool = createSkillTool(
-      makeEntry(),
-      "my-skill",
-      "/skills/my-skill",
-      hash,
-    );
-
-    expect(tool.ownerSkillVersionHash).toBe(hash);
-  });
+  // Removed "sets origin to skill" test — the factory no longer stamps an
+  // origin/kind on the Tool. Ownership is recorded by `registerSkillTools`
+  // in the registry; see registry.test.ts.
 
   test.each([
     ["low", RiskLevel.Low],
     ["medium", RiskLevel.Medium],
     ["high", RiskLevel.High],
   ] as const)('maps risk "%s" to RiskLevel.%s', (risk, expected) => {
-    const tool = createSkillTool(
-      makeEntry({ risk }),
-      "sk",
-      "/skills/sk",
-      "v1:test",
-    );
+    const tool = createSkillTool(makeEntry({ risk }), "/skills/sk", "v1:test");
 
     expect(tool.defaultRiskLevel).toBe(expected);
   });
@@ -140,12 +110,11 @@ describe("createSkillTool", () => {
         description: "Scrape a URL",
         input_schema: schema,
       }),
-      "scraper",
       "/skills/scraper",
       "v1:test",
     );
 
-    const def = tool.getDefinition();
+    const def = tool;
 
     expect(def.name).toBe("web_scrape");
     expect(def.description).toBe("Scrape a URL");
@@ -160,7 +129,6 @@ describe("createSkillTool", () => {
     const hash = computeSkillVersionHash(tempDir);
     const tool = createSkillTool(
       makeEntry({ executor: "echo.ts" }),
-      "my-skill",
       tempDir,
       hash,
     );
@@ -179,12 +147,13 @@ describe("createSkillTool", () => {
     const hash = computeSkillVersionHash(tempDir);
     const tool = createSkillTool(
       makeEntry({ executor: "nonexistent.ts" }),
-      "my-skill",
       tempDir,
       hash,
     );
 
-    const result = await tool.execute({}, makeContext());
+    // Provide valid input so we reach the executor (the default schema
+    // declares `query` as required).
+    const result = await tool.execute({ query: "x" }, makeContext());
 
     expect(result.isError).toBe(true);
     expect(result.content).toContain("Failed to load skill tool script");
@@ -205,7 +174,6 @@ describe("createSkillToolsFromManifest", () => {
 
     const tools = createSkillToolsFromManifest(
       entries,
-      "multi-skill",
       "/skills/multi",
       "v1:test",
     );
@@ -219,54 +187,15 @@ describe("createSkillToolsFromManifest", () => {
     ]);
   });
 
-  test("all created tools share the same skillId and origin", () => {
-    const entries: SkillToolEntry[] = [
-      makeEntry({ name: "alpha" }),
-      makeEntry({ name: "beta" }),
-    ];
-
-    const tools = createSkillToolsFromManifest(
-      entries,
-      "shared-skill",
-      "/skills/shared",
-      "v1:test",
-    );
-
-    for (const tool of tools) {
-      expect(tool.origin).toBe("skill");
-      expect(tool.ownerSkillId).toBe("shared-skill");
-    }
-  });
+  // Removed "all created tools share the same origin" — same reason as the
+  // single-tool case above: ownership is recorded by `registerSkillTools` in
+  // the registry, not stamped onto each Tool by the factory.
 
   test("returns an empty array when given no entries", () => {
-    const tools = createSkillToolsFromManifest(
-      [],
-      "empty-skill",
-      "/skills/empty",
-      "v1:test",
-    );
+    const tools = createSkillToolsFromManifest([], "/skills/empty", "v1:test");
 
     expect(tools).toEqual([]);
   });
-
-  test("passes versionHash through to all created tools", () => {
-    const hash = "v1:deadbeef";
-    const entries: SkillToolEntry[] = [
-      makeEntry({ name: "alpha" }),
-      makeEntry({ name: "beta" }),
-    ];
-
-    const tools = createSkillToolsFromManifest(
-      entries,
-      "versioned-skill",
-      "/skills/versioned",
-      hash,
-    );
-
-    for (const tool of tools) {
-      expect(tool.ownerSkillVersionHash).toBe(hash);
-    }
-  });
 });
 
 // ---------------------------------------------------------------------------
@@ -278,7 +207,6 @@ describe("createSkillTool — unknown parameter validation", () => {
     const hash = computeSkillVersionHash(tempDir);
     const tool = createSkillTool(
       makeEntry({ executor: "echo.ts" }),
-      "my-skill",
       tempDir,
       hash,
     );
@@ -289,8 +217,9 @@ describe("createSkillTool — unknown parameter validation", () => {
     );
 
     expect(result.isError).toBe(true);
+    expect(result.content).toContain('Invalid input for tool "test_tool"');
     expect(result.content).toContain('Unknown parameter "unsubscribe"');
-    expect(result.content).toContain("Supported parameters");
+    expect(result.content).toContain("Supported:");
     expect(result.content).toContain('"query"');
   });
 
@@ -298,7 +227,6 @@ describe("createSkillTool — unknown parameter validation", () => {
     const hash = computeSkillVersionHash(tempDir);
     const tool = createSkillTool(
       makeEntry({ executor: "echo.ts" }),
-      "my-skill",
       tempDir,
       hash,
     );
@@ -309,16 +237,15 @@ describe("createSkillTool — unknown parameter validation", () => {
     );
 
     expect(result.isError).toBe(true);
-    expect(result.content).toContain("Unknown parameters");
-    expect(result.content).toContain('"foo"');
-    expect(result.content).toContain('"bar"');
+    expect(result.content).toContain('Invalid input for tool "test_tool"');
+    expect(result.content).toContain('Unknown parameter "foo"');
+    expect(result.content).toContain('Unknown parameter "bar"');
   });
 
   test("allows input with only known parameters", async () => {
     const hash = computeSkillVersionHash(tempDir);
     const tool = createSkillTool(
       makeEntry({ executor: "echo.ts" }),
-      "my-skill",
       tempDir,
       hash,
     );
@@ -338,7 +265,6 @@ describe("createSkillTool — unknown parameter validation", () => {
           properties: { query: { type: "string" } },
         },
       }),
-      "my-skill",
       tempDir,
       hash,
     );
@@ -355,7 +281,6 @@ describe("createSkillTool — unknown parameter validation", () => {
         executor: "echo.ts",
         input_schema: { type: "object" },
       }),
-      "my-skill",
       tempDir,
       hash,
     );
@@ -366,6 +291,85 @@ describe("createSkillTool — unknown parameter validation", () => {
   });
 });
 
+// ---------------------------------------------------------------------------
+// createSkillTool — required / type / enum validation
+// ---------------------------------------------------------------------------
+
+describe("createSkillTool — required/type/enum validation", () => {
+  test("rejects missing required field with self-correcting message", async () => {
+    const hash = computeSkillVersionHash(tempDir);
+    const tool = createSkillTool(
+      makeEntry({ executor: "echo.ts" }),
+      tempDir,
+      hash,
+    );
+
+    const result = await tool.execute({}, makeContext());
+
+    expect(result.isError).toBe(true);
+    expect(result.content).toContain('Invalid input for tool "test_tool"');
+    expect(result.content).toContain("query is required");
+  });
+
+  test("rejects wrong type with `must be a string` message", async () => {
+    const hash = computeSkillVersionHash(tempDir);
+    const tool = createSkillTool(
+      makeEntry({ executor: "echo.ts" }),
+      tempDir,
+      hash,
+    );
+
+    const result = await tool.execute({ query: 123 }, makeContext());
+
+    expect(result.isError).toBe(true);
+    expect(result.content).toContain('Invalid input for tool "test_tool"');
+    expect(result.content).toContain("query must be a string");
+  });
+
+  test("rejects enum violation with `must be one of` message", async () => {
+    const hash = computeSkillVersionHash(tempDir);
+    const tool = createSkillTool(
+      makeEntry({
+        executor: "echo.ts",
+        input_schema: {
+          type: "object",
+          properties: { mode: { type: "string", enum: ["a", "b"] } },
+        },
+      }),
+      tempDir,
+      hash,
+    );
+
+    const result = await tool.execute({ mode: "c" }, makeContext());
+
+    expect(result.isError).toBe(true);
+    expect(result.content).toContain('Invalid input for tool "test_tool"');
+    expect(result.content).toContain('mode must be one of "a", "b"');
+  });
+
+  test("passes valid input through to the executor unchanged", async () => {
+    const hash = computeSkillVersionHash(tempDir);
+    const tool = createSkillTool(
+      makeEntry({
+        executor: "echo.ts",
+        input_schema: {
+          type: "object",
+          properties: { mode: { type: "string", enum: ["a", "b"] } },
+          required: ["mode"],
+        },
+      }),
+      tempDir,
+      hash,
+    );
+
+    const result = await tool.execute({ mode: "a" }, makeContext());
+
+    expect(result.isError).toBe(false);
+    const parsed = JSON.parse(result.content);
+    expect(parsed.input).toEqual({ mode: "a" });
+  });
+});
+
 // ---------------------------------------------------------------------------
 // createSkillTool — expectedSkillVersionHash plumbing
 // ---------------------------------------------------------------------------
@@ -376,7 +380,6 @@ describe("createSkillTool — version hash plumbing to runner", () => {
     const hash = computeSkillVersionHash(tempDir);
     const tool = createSkillTool(
       makeEntry({ executor: "echo.ts" }),
-      "my-skill",
       tempDir,
       hash,
     );
@@ -389,7 +392,5 @@ describe("createSkillTool — version hash plumbing to runner", () => {
     const parsed = JSON.parse(result.content);
     expect(parsed.input).toEqual({ query: "test" });
     expect(parsed.workingDir).toBe("/my/project");
-    // Confirm the tool still has the hash stored
-    expect(tool.ownerSkillVersionHash).toBe(hash);
   });
 });

package/src/__tests__/slack-channel-config.test.ts

@@ -154,7 +154,6 @@ import {
   setSlackChannelConfig,
 } from "../daemon/handlers/config-slack-channel.js";
 import { credentialKey } from "../security/credential-key.js";
-import { _setStorePath } from "../security/encrypted-store.js";
 import * as secureKeys from "../security/secure-keys.js";
 import {
   _resetBackend,
@@ -167,11 +166,12 @@ import {
   listCredentialMetadata,
   upsertCredentialMetadata,
 } from "../tools/credentials/metadata-store.js";
+import { setStorePathForTesting } from "./encrypted-store-test-helpers.js";
 
 afterAll(() => {
   globalThis.fetch = originalFetch;
   _setMetadataPath(null);
-  _setStorePath(null);
+  setStorePathForTesting(null);
   _resetBackend();
   if (originalVellumDev === undefined) {
     delete process.env.VELLUM_DEV;
@@ -187,7 +187,7 @@ describe("Slack channel config handler", () => {
     globalThis.fetch = originalFetch;
     rmSync(secureStorePath, { force: true });
     rmSync(metadataPath, { force: true });
-    _setStorePath(secureStorePath);
+    setStorePathForTesting(secureStorePath);
     _resetBackend();
     _setMetadataPath(metadataPath);
   });

package/src/__tests__/subagent-call-site-routing.test.ts

@@ -87,7 +87,7 @@ class FakeConversation {
     return Promise.resolve();
   }
   persistUserMessage() {
-    return "msg-id";
+    return { id: "msg-id", deduplicated: false };
   }
   runAgentLoop() {
     return Promise.resolve();
@@ -134,9 +134,17 @@ mock.module("../providers/registry.js", () => ({
 mock.module("../providers/inference/connections.js", () => ({
   getConnection: (_db: unknown, name: string) => {
     if (name === "anthropic-conn")
-      return { name: "anthropic-conn", provider: "anthropic", auth: { type: "platform" } };
+      return {
+        name: "anthropic-conn",
+        provider: "anthropic",
+        auth: { type: "platform" },
+      };
     if (name === "openai-conn")
-      return { name: "openai-conn", provider: "openai", auth: { type: "platform" } };
+      return {
+        name: "openai-conn",
+        provider: "openai",
+        auth: { type: "platform" },
+      };
     return null;
   },
 }));

package/src/__tests__/subagent-disposal.test.ts

@@ -14,7 +14,7 @@ interface FakeManagedSubagent {
       content: Array<{ type: string; text: string }>;
     }>;
     sendToClient: (msg: ServerMessage) => void;
-    persistUserMessage?: (msg: string) => string;
+    persistUserMessage?: () => { id: string; deduplicated: boolean };
     runAgentLoop?: () => Promise<void>;
     enqueueMessage?: () => { rejected: boolean; queued: boolean };
     usageStats: {
@@ -64,7 +64,8 @@ function injectFakeSubagent(
   const internals = asInternals(manager);
 
   internals.subagents.set(subagentId, {
-    conversation: conversation === undefined ? makeFakeConversation() : conversation,
+    conversation:
+      conversation === undefined ? makeFakeConversation() : conversation,
     state,
     parentSendToClient: parentSendToClient ?? (() => {}),
   });
@@ -104,7 +105,10 @@ describe("SubagentManager terminal disposal", () => {
     injectFakeSubagent(manager, subagentId, state);
 
     const managed = asInternals(manager).subagents.get(subagentId)!;
-    managed.conversation!.persistUserMessage = () => "msg-1";
+    managed.conversation!.persistUserMessage = () => ({
+      id: "msg-1",
+      deduplicated: false,
+    });
     managed.conversation!.runAgentLoop = async () => {};
 
     await asInternals(manager).runSubagent(subagentId, "Do something");
@@ -127,7 +131,10 @@ describe("SubagentManager terminal disposal", () => {
     injectFakeSubagent(manager, subagentId, state);
 
     const managed = asInternals(manager).subagents.get(subagentId)!;
-    managed.conversation!.persistUserMessage = () => "msg-1";
+    managed.conversation!.persistUserMessage = () => ({
+      id: "msg-1",
+      deduplicated: false,
+    });
     managed.conversation!.runAgentLoop = async () => {
       throw new Error("LLM error");
     };
@@ -148,7 +155,10 @@ describe("SubagentManager terminal disposal", () => {
     injectFakeSubagent(manager, subagentId, state);
 
     const managed = asInternals(manager).subagents.get(subagentId)!;
-    managed.conversation!.persistUserMessage = () => "msg-1";
+    managed.conversation!.persistUserMessage = () => ({
+      id: "msg-1",
+      deduplicated: false,
+    });
     managed.conversation!.runAgentLoop = async () => {
       throw new Error("Conversation aborted");
     };
@@ -167,7 +177,10 @@ describe("SubagentManager terminal disposal", () => {
     injectFakeSubagent(manager, subagentId, state);
 
     const managed = asInternals(manager).subagents.get(subagentId)!;
-    managed.conversation!.persistUserMessage = () => "msg-1";
+    managed.conversation!.persistUserMessage = () => ({
+      id: "msg-1",
+      deduplicated: false,
+    });
     managed.conversation!.runAgentLoop = async () => {};
 
     await asInternals(manager).runSubagent(subagentId, "Do something");
@@ -269,7 +282,10 @@ describe("SubagentManager terminal disposal", () => {
       outputTokens: 200,
       estimatedCost: 0.05,
     };
-    managed.conversation!.persistUserMessage = () => "msg-1";
+    managed.conversation!.persistUserMessage = () => ({
+      id: "msg-1",
+      deduplicated: false,
+    });
     managed.conversation!.runAgentLoop = async () => {};
 
     await asInternals(manager).runSubagent(subagentId, "Do something");
@@ -291,7 +307,10 @@ describe("SubagentManager terminal disposal", () => {
     injectFakeSubagent(manager, subagentId, state);
 
     const managed = asInternals(manager).subagents.get(subagentId)!;
-    managed.conversation!.persistUserMessage = () => "msg-1";
+    managed.conversation!.persistUserMessage = () => ({
+      id: "msg-1",
+      deduplicated: false,
+    });
     managed.conversation!.runAgentLoop = async () => {};
     // Simulate that a message was enqueued during the run.
     managed.hadEnqueuedMessages = true;

package/src/__tests__/subagent-fork-notifications.test.ts

@@ -13,14 +13,14 @@ const capturedNotifications: {
 
 mock.module("../daemon/conversation-store.js", () => ({
   findConversation: (id: string) => ({
-    enqueueMessage: (content: string) => {
+    enqueueMessage: (options: { content: string }) => {
       capturedNotifications.push({
         parentConversationId: id,
-        message: content,
+        message: options.content,
       });
       return { queued: true };
     },
-    persistUserMessage: async () => "mock-msg",
+    persistUserMessage: async () => ({ id: "mock-msg", deduplicated: false }),
     runAgentLoop: async () => {},
   }),
   addConversation: () => {},
@@ -46,7 +46,7 @@ interface FakeManagedSubagent {
     }>;
     sendToClient: (msg: ServerMessage) => void;
     loadFromDb?: () => Promise<void>;
-    persistUserMessage?: (msg: string) => string;
+    persistUserMessage?: () => { id: string; deduplicated: boolean };
     runAgentLoop?: () => Promise<void>;
     usageStats: {
       inputTokens: number;
@@ -152,7 +152,10 @@ describe("Fork completion notifications", () => {
     injectFakeSubagent(manager, subagentId, state);
 
     const managed = asInternals(manager).subagents.get(subagentId)!;
-    managed.conversation!.persistUserMessage = () => "msg-1";
+    managed.conversation!.persistUserMessage = () => ({
+      id: "msg-1",
+      deduplicated: false,
+    });
     managed.conversation!.runAgentLoop = async () => {};
 
     await asInternals(manager).runSubagent(subagentId, "Analyze data");
@@ -171,7 +174,10 @@ describe("Fork completion notifications", () => {
     injectFakeSubagent(manager, subagentId, state);
 
     const managed = asInternals(manager).subagents.get(subagentId)!;
-    managed.conversation!.persistUserMessage = () => "msg-1";
+    managed.conversation!.persistUserMessage = () => ({
+      id: "msg-1",
+      deduplicated: false,
+    });
     managed.conversation!.runAgentLoop = async () => {};
 
     await asInternals(manager).runSubagent(subagentId, "Analyze data");
@@ -195,7 +201,10 @@ describe("Fork completion notifications", () => {
     injectFakeSubagent(manager, subagentId, state);
 
     const managed = asInternals(manager).subagents.get(subagentId)!;
-    managed.conversation!.persistUserMessage = () => "msg-1";
+    managed.conversation!.persistUserMessage = () => ({
+      id: "msg-1",
+      deduplicated: false,
+    });
     managed.conversation!.runAgentLoop = async () => {
       throw new Error("Context too large");
     };
@@ -260,7 +269,10 @@ describe("Regular sub-agent notifications are unchanged", () => {
     injectFakeSubagent(manager, subagentId, state);
 
     const managed = asInternals(manager).subagents.get(subagentId)!;
-    managed.conversation!.persistUserMessage = () => "msg-1";
+    managed.conversation!.persistUserMessage = () => ({
+      id: "msg-1",
+      deduplicated: false,
+    });
     managed.conversation!.runAgentLoop = async () => {};
 
     await asInternals(manager).runSubagent(subagentId, "Do something");
@@ -283,7 +295,10 @@ describe("Regular sub-agent notifications are unchanged", () => {
     injectFakeSubagent(manager, subagentId, state);
 
     const managed = asInternals(manager).subagents.get(subagentId)!;
-    managed.conversation!.persistUserMessage = () => "msg-1";
+    managed.conversation!.persistUserMessage = () => ({
+      id: "msg-1",
+      deduplicated: false,
+    });
     managed.conversation!.runAgentLoop = async () => {
       throw new Error("Something went wrong");
     };

package/src/__tests__/subagent-fork-spawn.test.ts

@@ -17,7 +17,7 @@ interface FakeManagedSubagent {
     dispose: () => void;
     messages: Message[];
     sendToClient: (msg: ServerMessage) => void;
-    persistUserMessage?: (msg: string) => string;
+    persistUserMessage?: () => { id: string; deduplicated: boolean };
     runAgentLoop?: () => Promise<void>;
     enqueueMessage?: () => { rejected: boolean; queued: boolean };
     injectInheritedContext?: (messages: Message[]) => void;
@@ -127,7 +127,10 @@ describe("SubagentManager fork spawn", () => {
 
     const injectedMessages: Message[][] = [];
     const fakeConversation = makeFakeConversation();
-    fakeConversation.persistUserMessage = () => "msg-1";
+    fakeConversation.persistUserMessage = () => ({
+      id: "msg-1",
+      deduplicated: false,
+    });
     fakeConversation.runAgentLoop = async () => {};
     fakeConversation.injectInheritedContext = (msgs: Message[]) => {
       injectedMessages.push(msgs);
@@ -197,7 +200,10 @@ describe("SubagentManager fork spawn", () => {
 
     let injectCalled = false;
     const fakeConversation = makeFakeConversation();
-    fakeConversation.persistUserMessage = () => "msg-1";
+    fakeConversation.persistUserMessage = () => ({
+      id: "msg-1",
+      deduplicated: false,
+    });
     fakeConversation.runAgentLoop = async () => {};
     fakeConversation.injectInheritedContext = () => {
       injectCalled = true;
@@ -272,7 +278,10 @@ describe("SubagentManager fork spawn", () => {
     const subagentId = "sub-fork-role";
 
     const fakeConversation = makeFakeConversation();
-    fakeConversation.persistUserMessage = () => "msg-1";
+    fakeConversation.persistUserMessage = () => ({
+      id: "msg-1",
+      deduplicated: false,
+    });
     fakeConversation.runAgentLoop = async () => {};
     fakeConversation.injectInheritedContext = () => {};
     fakeConversation.setSubagentAllowedTools = () => {};