@vellumai/assistant 0.8.5 → 0.8.7

package/src/__tests__/skill-projection-feature-flag.test.ts

@@ -45,6 +45,10 @@ mock.module("../config/skill-state.js", () => ({
 
 // Mock assistant-feature-flags to avoid loading the real module (which
 // triggers file I/O and env-registry imports that hang in test context).
+// The seed-state backdoor is the test-only helper module — we mirror
+// production's design: tests reach into `feature-flag-cache.ts` (or its
+// test-helper wrapper) to seed cached overrides, never through the
+// resolver module itself.
 let _mockOverrides: Record<string, boolean> = {};
 mock.module("../config/assistant-feature-flags.js", () => ({
   isAssistantFeatureFlagEnabled: (key: string, _config: unknown): boolean => {
@@ -55,10 +59,12 @@ mock.module("../config/assistant-feature-flags.js", () => ({
   clearFeatureFlagOverridesCache: () => {
     _mockOverrides = {};
   },
-  _setOverridesForTesting: (overrides: Record<string, boolean>) => {
+  getAssistantFeatureFlagDefaults: () => ({}),
+}));
+mock.module("./feature-flag-test-helpers.js", () => ({
+  setOverridesForTesting: (overrides: Record<string, boolean>) => {
     _mockOverrides = { ...overrides };
   },
-  getAssistantFeatureFlagDefaults: () => ({}),
 }));
 
 mock.module("../skills/active-skill-tools.js", () => {
@@ -109,12 +115,13 @@ mock.module("../skills/tool-manifest.js", () => ({
 }));
 
 mock.module("../tools/skills/skill-tool-factory.js", () => ({
+  // Mirrors the real factory: no skillId in/out — ownership is recorded by
+  // the registry at `registerSkillTools(skillId, tools)` time.
   createSkillToolsFromManifest: (
     entries: SkillToolManifest["tools"],
-    skillId: string,
     _skillDir: string,
-    versionHash: string,
-    bundled?: boolean,
+    _versionHash: string,
+    _bundled?: boolean,
   ): Tool[] => {
     return entries.map((entry) => ({
       name: entry.name,
@@ -122,10 +129,6 @@ mock.module("../tools/skills/skill-tool-factory.js", () => ({
       category: entry.category,
       defaultRiskLevel: RiskLevel.Medium,
       executionTarget: "sandbox" as const,
-      origin: "skill" as const,
-      ownerSkillId: skillId,
-      ownerSkillVersionHash: versionHash,
-      ownerSkillBundled: bundled ?? undefined,
       input_schema: entry.input_schema as object,
       execute: async () => ({ content: "", isError: false }),
     }));
@@ -133,18 +136,14 @@ mock.module("../tools/skills/skill-tool-factory.js", () => ({
 }));
 
 mock.module("../tools/registry.js", () => ({
-  registerSkillTools: (tools: Tool[]) => {
-    const skillIds = new Set<string>();
-    for (const tool of tools) {
-      const skillId = tool.ownerSkillId!;
-      skillIds.add(skillId);
-      const existing = mockRegisteredTools.get(skillId) ?? [];
-      existing.push(tool);
-      mockRegisteredTools.set(skillId, existing);
-    }
-    for (const id of skillIds) {
-      mockSkillRefCount.set(id, (mockSkillRefCount.get(id) ?? 0) + 1);
-    }
+  // Matches the new signature: `registerSkillTools(skillId, tools)`. The
+  // skillId comes from the caller (conversation-skill-tools) and is the
+  // sole source of truth for ownership.
+  registerSkillTools: (skillId: string, tools: Tool[]) => {
+    const existing = mockRegisteredTools.get(skillId) ?? [];
+    existing.push(...tools);
+    mockRegisteredTools.set(skillId, existing);
+    mockSkillRefCount.set(skillId, (mockSkillRefCount.get(skillId) ?? 0) + 1);
     return tools;
   },
   unregisterSkillTools: (skillId: string) => {
@@ -166,6 +165,23 @@ mock.module("../tools/registry.js", () => ({
     }
     return found;
   },
+  // Mirrors the registry's `ownersByName` accessor: derives the owning
+  // skillId from `mockRegisteredTools` keying so the production
+  // `getToolOwner(name)` call in `conversation-skill-tools.ts` resolves to
+  // the same shape the real registry would return.
+  getToolOwner: (
+    name: string,
+  ): { kind: "skill" | "plugin" | "mcp"; id: string } | undefined => {
+    let ownerSkillId: string | undefined;
+    for (const [skillId, tools] of mockRegisteredTools.entries()) {
+      for (const tool of tools) {
+        if (tool.name === name) ownerSkillId = skillId;
+      }
+    }
+    return ownerSkillId === undefined
+      ? undefined
+      : { kind: "skill", id: ownerSkillId };
+  },
   getSkillToolNames: () => {
     const names: string[] = [];
     for (const tools of mockRegisteredTools.values()) {
@@ -212,10 +228,8 @@ mock.module("../util/logger.js", () => ({
 
 const { projectSkillTools, resetSkillToolProjection } =
   await import("../daemon/conversation-skill-tools.js");
-const { _setOverridesForTesting } =
-  (await import("../config/assistant-feature-flags.js")) as {
-    _setOverridesForTesting: (o: Record<string, boolean>) => void;
-  };
+const { setOverridesForTesting } =
+  await import("./feature-flag-test-helpers.js");
 
 // ---------------------------------------------------------------------------
 // Helpers
@@ -289,12 +303,12 @@ describe("projectSkillTools feature flag enforcement", () => {
     mockUnregisteredSkillIds = [];
     mockSkillRefCount = new Map();
     currentConfig = {};
-    _setOverridesForTesting({});
+    setOverridesForTesting({});
     resetSkillToolProjection();
   });
 
   afterEach(() => {
-    _setOverridesForTesting({});
+    setOverridesForTesting({});
   });
 
   test("no skill tools projected for flag OFF skill even with old markers", () => {
@@ -308,7 +322,7 @@ describe("projectSkillTools feature flag enforcement", () => {
     const prevActive = new Map<string, string>();
 
     // Feature flag is OFF — use protected directory override
-    _setOverridesForTesting({ [DECLARED_FLAG_KEY]: false });
+    setOverridesForTesting({ [DECLARED_FLAG_KEY]: false });
 
     const result = projectSkillTools(history, {
       previouslyActiveSkillIds: prevActive,
@@ -329,7 +343,7 @@ describe("projectSkillTools feature flag enforcement", () => {
     const prevActive = new Map<string, string>();
 
     // Feature flag is ON — use protected directory override
-    _setOverridesForTesting({ [DECLARED_FLAG_KEY]: true });
+    setOverridesForTesting({ [DECLARED_FLAG_KEY]: true });
 
     const result = projectSkillTools(history, {
       previouslyActiveSkillIds: prevActive,
@@ -420,7 +434,7 @@ describe("projectSkillTools feature flag enforcement", () => {
     const prevActive = new Map<string, string>();
 
     // Declared skill is OFF; plain-skill has no featureFlag so remains ON.
-    _setOverridesForTesting({ [DECLARED_FLAG_KEY]: false });
+    setOverridesForTesting({ [DECLARED_FLAG_KEY]: false });
 
     const result = projectSkillTools(history, {
       previouslyActiveSkillIds: prevActive,

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

@@ -102,18 +102,15 @@ 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,
+      owner: { kind: "skill" as const, id: skillId },
       input_schema: e.input_schema,
       execute: async () => ({ content: "", isError: false }),
     })),
@@ -166,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,7 +110,6 @@ describe("createSkillTool", () => {
         description: "Scrape a URL",
         input_schema: schema,
       }),
-      "scraper",
       "/skills/scraper",
       "v1:test",
     );
@@ -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__/skills-files-catalog-fallback.test.ts

@@ -306,6 +306,7 @@ describe("getSkillFiles — provider chain fallback", () => {
         kind: "catalog",
         origin: "vellum",
         status: "available",
+        category: "knowledge",
       }),
     };
 
@@ -322,6 +323,7 @@ describe("getSkillFiles — provider chain fallback", () => {
       kind: "catalog",
       origin: "vellum",
       status: "available",
+      category: "knowledge",
     });
     expect(result.files).toHaveLength(2);
     for (const entry of result.files) {
@@ -455,6 +457,7 @@ describe("getSkillFiles — provider chain fallback", () => {
         kind: "catalog",
         origin: "vellum",
         status: "available",
+        category: "knowledge",
       }),
     };
 
@@ -479,6 +482,7 @@ describe("getSkillFiles — provider chain fallback", () => {
         kind: "catalog",
         origin: "vellum",
         status: "available",
+        category: "knowledge",
       }),
     };
 
@@ -504,6 +508,7 @@ describe("getSkillFiles — provider chain fallback", () => {
         kind: "catalog",
         origin: "vellum",
         status: "available",
+        category: "knowledge",
       }),
     };
 
@@ -544,6 +549,7 @@ describe("getSkillFiles — provider chain fallback", () => {
         kind: "catalog",
         origin: "skillssh",
         status: "available",
+        category: "knowledge",
         slug: id,
         sourceRepo: "owner/repo",
         installs: 0,
@@ -603,6 +609,7 @@ describe("getSkillFiles — provider chain fallback", () => {
         kind: "catalog",
         origin: "clawhub",
         status: "available",
+        category: "knowledge",
         slug: "cool-tool",
         author: "someone",
         stars: 5,
@@ -662,6 +669,7 @@ describe("getSkillFiles — provider chain fallback", () => {
         kind: "catalog",
         origin: "vellum",
         status: "available",
+        category: "knowledge",
       }),
     };
     mockSkillsshProvider = {
@@ -678,6 +686,7 @@ describe("getSkillFiles — provider chain fallback", () => {
         kind: "catalog",
         origin: "skillssh",
         status: "available",
+        category: "knowledge",
         slug: "contested-skill",
         sourceRepo: "",
         installs: 0,
@@ -697,6 +706,7 @@ describe("getSkillFiles — provider chain fallback", () => {
         kind: "catalog",
         origin: "clawhub",
         status: "available",
+        category: "knowledge",
         slug: "contested-skill",
         author: "",
         stars: 0,

package/src/__tests__/skillssh-files.test.ts

@@ -384,6 +384,7 @@ describe("toSlimSkill", () => {
     expect(slim!.kind).toBe("catalog");
     expect(slim!.status).toBe("available");
     expect(slim!.origin).toBe("skillssh");
+    expect(slim!.category).toBe("knowledge");
     expect((slim as any).slug).toBe("owner/repo/my-skill");
     expect((slim as any).sourceRepo).toBe("owner/repo");
     expect((slim as any).installs).toBe(0);

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__/starter-task-flow.test.ts

@@ -54,8 +54,8 @@ describe("starter task surface actions", () => {
   test("forwards prompt payload as normal message content", () => {
     const forwarded: string[] = [];
     const ctx = makeContext();
-    ctx.processMessage = async (content) => {
-      forwarded.push(content);
+    ctx.processMessage = async (options) => {
+      forwarded.push(options.content);
       return "ok";
     };
     ctx.pendingSurfaceActions.set("surf-1", { surfaceType: "dynamic_page" });
@@ -74,8 +74,8 @@ describe("starter task surface actions", () => {
   test("falls back to human-readable summary with action data when prompt is absent", () => {
     const forwarded: string[] = [];
     const ctx = makeContext();
-    ctx.processMessage = async (content) => {
-      forwarded.push(content);
+    ctx.processMessage = async (options) => {
+      forwarded.push(options.content);
       return "ok";
     };
     ctx.pendingSurfaceActions.set("surf-2", { surfaceType: "dynamic_page" });
@@ -94,8 +94,8 @@ describe("starter task surface actions", () => {
   test("does not treat prompt-like fields as relay content for non-relay actions", () => {
     const forwarded: string[] = [];
     const ctx = makeContext();
-    ctx.processMessage = async (content) => {
-      forwarded.push(content);
+    ctx.processMessage = async (options) => {
+      forwarded.push(options.content);
       return "ok";
     };
     ctx.pendingSurfaceActions.set("surf-3", { surfaceType: "dynamic_page" });