@vellumai/assistant 0.5.16 → 0.6.1

package/src/__tests__/set-permission-mode.test.ts

@@ -0,0 +1,274 @@
+/**
+ * Tests for the set_permission_mode system tool.
+ *
+ * Verifies:
+ *   - Mode transitions via askBeforeActing and hostAccess
+ *   - Partial updates (only provided fields change)
+ *   - Idempotent calls (setting same value is safe)
+ *   - Error when no fields provided
+ *   - Tool is not registered when permission-controls-v2 flag is off
+ *   - Tool is registered when permission-controls-v2 flag is on
+ */
+
+import { existsSync, mkdirSync, writeFileSync } from "node:fs";
+import { join } from "node:path";
+import {
+  afterAll,
+  afterEach,
+  beforeEach,
+  describe,
+  expect,
+  mock,
+  test,
+} from "bun:test";
+
+// ---------------------------------------------------------------------------
+// Mocks — declared before imports that depend on platform/logger
+// ---------------------------------------------------------------------------
+
+const WORKSPACE_DIR = process.env.VELLUM_WORKSPACE_DIR!;
+const CONFIG_PATH = join(WORKSPACE_DIR, "config.json");
+
+function ensureTestDir(): void {
+  const dirs = [
+    WORKSPACE_DIR,
+    join(WORKSPACE_DIR, "data"),
+    join(WORKSPACE_DIR, "data", "logs"),
+  ];
+  for (const dir of dirs) {
+    if (!existsSync(dir)) mkdirSync(dir, { recursive: true });
+  }
+}
+
+function makeLoggerStub(): Record<string, unknown> {
+  const stub: Record<string, unknown> = {};
+  for (const m of [
+    "info",
+    "warn",
+    "error",
+    "debug",
+    "trace",
+    "fatal",
+    "silent",
+    "child",
+  ]) {
+    stub[m] = m === "child" ? () => makeLoggerStub() : () => {};
+  }
+  return stub;
+}
+
+mock.module("../util/logger.js", () => ({
+  getLogger: () => makeLoggerStub(),
+}));
+
+afterAll(() => {
+  mock.restore();
+});
+
+import { _setOverridesForTesting } from "../config/assistant-feature-flags.js";
+import { invalidateConfigCache } from "../config/loader.js";
+import {
+  getMode,
+  resetForTesting,
+} from "../permissions/permission-mode-store.js";
+import { __clearRegistryForTesting, getTool } from "../tools/registry.js";
+import { registerSystemTools } from "../tools/system/register.js";
+import { setPermissionModeTool } from "../tools/system/set-permission-mode.js";
+import type { ToolContext } from "../tools/types.js";
+
+// ---------------------------------------------------------------------------
+// Helpers
+// ---------------------------------------------------------------------------
+
+function writeConfig(obj: unknown): void {
+  ensureTestDir();
+  writeFileSync(CONFIG_PATH, JSON.stringify(obj, null, 2) + "\n");
+}
+
+function makeContext(): ToolContext {
+  return {
+    workingDir: WORKSPACE_DIR,
+    conversationId: "test-conversation",
+    trustClass: "guardian",
+  };
+}
+
+// ---------------------------------------------------------------------------
+// Setup / teardown
+// ---------------------------------------------------------------------------
+
+beforeEach(() => {
+  ensureTestDir();
+  resetForTesting();
+  invalidateConfigCache();
+  _setOverridesForTesting({});
+  __clearRegistryForTesting();
+  // Write a minimal config so the store initializes cleanly
+  writeConfig({});
+});
+
+afterEach(() => {
+  resetForTesting();
+  invalidateConfigCache();
+  _setOverridesForTesting({});
+  __clearRegistryForTesting();
+});
+
+// ---------------------------------------------------------------------------
+// Tests — tool execution
+// ---------------------------------------------------------------------------
+
+describe("set_permission_mode tool", () => {
+  describe("mode transitions", () => {
+    test("sets askBeforeActing to false", async () => {
+      const result = await setPermissionModeTool.execute(
+        { askBeforeActing: false },
+        makeContext(),
+      );
+
+      expect(result.isError).toBe(false);
+      expect(result.content).toContain("askBeforeActing: false");
+
+      const mode = getMode();
+      expect(mode.askBeforeActing).toBe(false);
+    });
+
+    test("sets hostAccess to true", async () => {
+      const result = await setPermissionModeTool.execute(
+        { hostAccess: true },
+        makeContext(),
+      );
+
+      expect(result.isError).toBe(false);
+      expect(result.content).toContain("hostAccess: true");
+
+      const mode = getMode();
+      expect(mode.hostAccess).toBe(true);
+    });
+
+    test("sets both fields at once", async () => {
+      const result = await setPermissionModeTool.execute(
+        { askBeforeActing: false, hostAccess: true },
+        makeContext(),
+      );
+
+      expect(result.isError).toBe(false);
+      expect(result.content).toContain("askBeforeActing: false");
+      expect(result.content).toContain("hostAccess: true");
+
+      const mode = getMode();
+      expect(mode.askBeforeActing).toBe(false);
+      expect(mode.hostAccess).toBe(true);
+    });
+  });
+
+  describe("partial updates", () => {
+    test("only askBeforeActing changes, hostAccess unchanged", async () => {
+      await setPermissionModeTool.execute(
+        { askBeforeActing: false },
+        makeContext(),
+      );
+
+      const mode = getMode();
+      expect(mode.askBeforeActing).toBe(false);
+      // hostAccess should remain at default (false)
+      expect(mode.hostAccess).toBe(false);
+    });
+
+    test("only hostAccess changes, askBeforeActing unchanged", async () => {
+      await setPermissionModeTool.execute({ hostAccess: true }, makeContext());
+
+      const mode = getMode();
+      // askBeforeActing should remain at default (true)
+      expect(mode.askBeforeActing).toBe(true);
+      expect(mode.hostAccess).toBe(true);
+    });
+  });
+
+  describe("idempotent calls", () => {
+    test("setting askBeforeActing to current value is safe", async () => {
+      // Default is true
+      const result = await setPermissionModeTool.execute(
+        { askBeforeActing: true },
+        makeContext(),
+      );
+
+      expect(result.isError).toBe(false);
+      expect(getMode().askBeforeActing).toBe(true);
+    });
+
+    test("setting hostAccess to current value is safe", async () => {
+      // Default is false
+      const result = await setPermissionModeTool.execute(
+        { hostAccess: false },
+        makeContext(),
+      );
+
+      expect(result.isError).toBe(false);
+      expect(getMode().hostAccess).toBe(false);
+    });
+
+    test("repeated calls produce same result", async () => {
+      await setPermissionModeTool.execute(
+        { askBeforeActing: false, hostAccess: true },
+        makeContext(),
+      );
+      const result = await setPermissionModeTool.execute(
+        { askBeforeActing: false, hostAccess: true },
+        makeContext(),
+      );
+
+      expect(result.isError).toBe(false);
+      const mode = getMode();
+      expect(mode.askBeforeActing).toBe(false);
+      expect(mode.hostAccess).toBe(true);
+    });
+  });
+
+  describe("validation", () => {
+    test("returns error when no fields provided", async () => {
+      const result = await setPermissionModeTool.execute({}, makeContext());
+
+      expect(result.isError).toBe(true);
+      expect(result.content).toContain("at least one");
+    });
+  });
+
+  describe("tool definition", () => {
+    test("has correct name", () => {
+      expect(setPermissionModeTool.name).toBe("set_permission_mode");
+    });
+
+    test("has correct category", () => {
+      expect(setPermissionModeTool.category).toBe("system");
+    });
+
+    test("definition includes both properties", () => {
+      const def = setPermissionModeTool.getDefinition();
+      const schema = def.input_schema as { properties?: Record<string, unknown> };
+      const props = schema.properties as Record<string, unknown>;
+      expect(props).toHaveProperty("askBeforeActing");
+      expect(props).toHaveProperty("hostAccess");
+    });
+  });
+});
+
+// ---------------------------------------------------------------------------
+// Tests — feature flag gating
+// ---------------------------------------------------------------------------
+
+describe("set_permission_mode registration", () => {
+  test("tool is NOT registered when permission-controls-v2 flag is off", () => {
+    _setOverridesForTesting({ "permission-controls-v2": false });
+    registerSystemTools();
+
+    expect(getTool("set_permission_mode")).toBeUndefined();
+  });
+
+  test("tool IS registered when permission-controls-v2 flag is on", () => {
+    _setOverridesForTesting({ "permission-controls-v2": true });
+    registerSystemTools();
+
+    expect(getTool("set_permission_mode")).toBeDefined();
+  });
+});

package/src/__tests__/skill-feature-flags-integration.test.ts

@@ -28,16 +28,16 @@ import { parseFrontmatterFields } from "../skills/frontmatter.js";
 // Fixtures
 // ---------------------------------------------------------------------------
 
-/** A SKILL.md with `feature-flag: contacts` declared in its vellum metadata. */
+/** A SKILL.md with `feature-flag: email-channel` declared in its vellum metadata. */
 const SKILL_MD_WITH_FLAG = `---
-name: "Contacts"
-description: "View and manage contacts"
+name: "Email Setup"
+description: "Set up email integration"
 metadata:
   vellum:
-    feature-flag: contacts
+    feature-flag: email-channel
 ---
 
-Instructions for the contacts skill.
+Instructions for the email setup skill.
 `;
 
 /** A SKILL.md with no feature-flag field at all. */
@@ -128,16 +128,16 @@ describe("frontmatter feature-flag integration", () => {
     expect(metadataObj).toBeTruthy();
 
     const vellum = metadataObj.vellum as Record<string, unknown>;
-    expect(vellum["feature-flag"]).toBe("contacts");
+    expect(vellum["feature-flag"]).toBe("email-channel");
   });
 
   test("skillFlagKey returns correct key for parsed skill", () => {
-    const skill = buildSkillSummary("contacts", SKILL_MD_WITH_FLAG);
+    const skill = buildSkillSummary("email-setup", SKILL_MD_WITH_FLAG);
     expect(skill).not.toBeNull();
-    expect(skill!.featureFlag).toBe("contacts");
+    expect(skill!.featureFlag).toBe("email-channel");
 
     const key = skillFlagKey(skill!);
-    expect(key).toBe("contacts");
+    expect(key).toBe("email-channel");
   });
 
   test("skillFlagKey returns undefined for skill without feature-flag", () => {
@@ -149,27 +149,26 @@ describe("frontmatter feature-flag integration", () => {
     expect(key).toBeUndefined();
   });
 
-  test("resolveSkillStates includes skill with featureFlag when flag defaults to ON", () => {
-    const skill = buildSkillSummary("contacts", SKILL_MD_WITH_FLAG)!;
-    // "contacts" is in the registry with defaultEnabled: true
+  test("resolveSkillStates includes skill with featureFlag when flag is ON", () => {
+    _setOverridesForTesting({
+      "email-channel": true,
+    });
+    const skill = buildSkillSummary("email-setup", SKILL_MD_WITH_FLAG)!;
     const config = makeConfig();
 
     const resolved = resolveSkillStates([skill], config);
-    // Flag defaults to true → skill passes through
     expect(resolved.length).toBe(1);
-    expect(resolved[0].summary.id).toBe("contacts");
+    expect(resolved[0].summary.id).toBe("email-setup");
   });
 
-  test("resolveSkillStates includes skill with featureFlag when flag is ON", () => {
-    _setOverridesForTesting({
-      contacts: true,
-    });
-    const skill = buildSkillSummary("contacts", SKILL_MD_WITH_FLAG)!;
+  test("resolveSkillStates excludes skill with featureFlag when flag defaults to OFF", () => {
+    const skill = buildSkillSummary("email-setup", SKILL_MD_WITH_FLAG)!;
+    // "email-channel" is in the registry with defaultEnabled: false
     const config = makeConfig();
 
     const resolved = resolveSkillStates([skill], config);
-    expect(resolved.length).toBe(1);
-    expect(resolved[0].summary.id).toBe("contacts");
+    // Flag defaults to false → skill is filtered out
+    expect(resolved.length).toBe(0);
   });
 
   test("resolveSkillStates never gates skill without featureFlag", () => {
@@ -192,26 +191,34 @@ describe("frontmatter feature-flag integration", () => {
     const metadataObj = parsed!.fields.metadata as Record<string, unknown>;
     const vellum = metadataObj.vellum as Record<string, unknown>;
     const flagId = vellum["feature-flag"];
-    expect(flagId).toBe("contacts");
+    expect(flagId).toBe("email-channel");
 
     // Step 2: Build SkillSummary (as the catalog loader would)
-    const skill = buildSkillSummary("contacts", SKILL_MD_WITH_FLAG)!;
-    expect(skill.featureFlag).toBe("contacts");
+    const skill = buildSkillSummary("email-setup", SKILL_MD_WITH_FLAG)!;
+    expect(skill.featureFlag).toBe("email-channel");
 
     // Step 3: Derive the flag key
     const key = skillFlagKey(skill);
-    expect(key).toBe("contacts");
+    expect(key).toBe("email-channel");
 
-    // Step 4: Check flag state — "contacts" has defaultEnabled: true in registry
+    // Step 4: Check flag state — "email-channel" has defaultEnabled: false in registry
     const configDefault = makeConfig();
-    expect(isAssistantFeatureFlagEnabled(key!, configDefault)).toBe(true);
+    expect(isAssistantFeatureFlagEnabled(key!, configDefault)).toBe(false);
 
-    // Step 5: resolveSkillStates includes it by default
+    // Step 5: resolveSkillStates excludes it by default (flag is off)
     const resolvedDefault = resolveSkillStates([skill], configDefault);
-    expect(resolvedDefault.length).toBe(1);
-    expect(resolvedDefault[0].summary.id).toBe("contacts");
+    expect(resolvedDefault.length).toBe(0);
+
+    // Step 6: With override enabled, skill passes through
+    _setOverridesForTesting({ [key!]: true });
+    const configOn = makeConfig();
+    expect(isAssistantFeatureFlagEnabled(key!, configOn)).toBe(true);
+
+    const resolvedOn = resolveSkillStates([skill], configOn);
+    expect(resolvedOn.length).toBe(1);
+    expect(resolvedOn[0].summary.id).toBe("email-setup");
 
-    // Step 6: With override disabled, skill is filtered out
+    // Step 7: With override disabled, skill is filtered out
     _setOverridesForTesting({ [key!]: false });
     const configOff = makeConfig();
     expect(isAssistantFeatureFlagEnabled(key!, configOff)).toBe(false);

package/src/__tests__/skill-feature-flags.test.ts

@@ -16,9 +16,9 @@ afterEach(() => {
   _setOverridesForTesting({});
 });
 
-const DECLARED_FLAG_ID = "contacts";
+const DECLARED_FLAG_ID = "sounds";
 const DECLARED_FLAG_KEY = DECLARED_FLAG_ID;
-const DECLARED_SKILL_ID = "contacts";
+const DECLARED_SKILL_ID = "sounds";
 const APP_BUILDER_MULTIFILE_FLAG_KEY = "app-builder-multifile";
 // ---------------------------------------------------------------------------
 // Helpers
@@ -144,7 +144,7 @@ describe("isAssistantFeatureFlagEnabled", () => {
 
   test("falls back to registry default when no override", () => {
     const config = makeConfig();
-    // contacts defaults to true in the registry
+    // sounds defaults to true in the registry
     expect(isAssistantFeatureFlagEnabled(DECLARED_FLAG_KEY, config)).toBe(true);
   });
 
@@ -214,7 +214,7 @@ describe("resolveSkillStates with feature flags", () => {
     const config = makeConfig();
 
     const resolved = resolveSkillStates(catalog, config);
-    // contacts registry default is true, so it passes through
+    // sounds registry default is true, so it passes through
     expect(resolved.length).toBe(1);
     expect(resolved[0].summary.id).toBe(DECLARED_SKILL_ID);
   });
@@ -272,7 +272,7 @@ describe("resolveSkillStates with feature flags", () => {
     const resolved = resolveSkillStates(catalog, config);
     const ids = resolved.map((r) => r.summary.id);
 
-    // contacts and deploy explicitly false; browser explicitly true
+    // sounds and deploy explicitly false; browser explicitly true
     expect(ids).toEqual(["browser"]);
   });
 });
@@ -283,7 +283,7 @@ describe("resolveSkillStates with feature flags", () => {
 
 describe("resolveSkillStates with frontmatter featureFlag", () => {
   test("skill with featureFlag (defaultEnabled: true) is included when no config override", () => {
-    // contacts has defaultEnabled: true in the registry
+    // sounds has defaultEnabled: true in the registry
     const catalog = [makeSkill(DECLARED_SKILL_ID, "bundled", DECLARED_FLAG_ID)];
     const config = makeConfig();
 

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

@@ -12,8 +12,8 @@ const TEST_DIR = process.env.VELLUM_WORKSPACE_DIR!;
 
 let currentConfig: Record<string, unknown> = {};
 
-const DECLARED_SKILL_ID = "contacts";
-const DECLARED_FLAG_KEY = "contacts";
+const DECLARED_SKILL_ID = "sounds";
+const DECLARED_FLAG_KEY = "sounds";
 
 const noopLogger = new Proxy({} as Record<string, unknown>, {
   get: (_target, prop) => (prop === "child" ? () => noopLogger : () => {}),
@@ -39,6 +39,18 @@ mock.module("../config/loader.js", () => ({
   invalidateConfigCache: () => {},
   getNestedValue: () => undefined,
   setNestedValue: () => {},
+  deepMergeOverwrite: (a: unknown) => a,
+  mergeDefaultWorkspaceConfig: () => {},
+  API_KEY_PROVIDERS: [
+    "anthropic",
+    "openai",
+    "gemini",
+    "ollama",
+    "fireworks",
+    "openrouter",
+    "brave",
+    "perplexity",
+  ],
 }));
 
 await import("../tools/skills/load.js");
@@ -86,8 +98,8 @@ describe("skill_load feature flag enforcement", () => {
   test("returns deterministic error for flag OFF skill", async () => {
     writeSkill(
       DECLARED_SKILL_ID,
-      "Contacts",
-      "Toggle contacts behavior",
+      "Sounds",
+      "Toggle sounds behavior",
       "Use the feature.",
     );
     writeFileSync(
@@ -107,8 +119,8 @@ describe("skill_load feature flag enforcement", () => {
   test("loads skill normally when flag is ON", async () => {
     writeSkill(
       DECLARED_SKILL_ID,
-      "Contacts",
-      "Toggle contacts behavior",
+      "Sounds",
+      "Toggle sounds behavior",
       "Use the feature.",
     );
     writeFileSync(
@@ -121,14 +133,14 @@ describe("skill_load feature flag enforcement", () => {
     const result = await executeSkillLoad({ skill: DECLARED_SKILL_ID });
 
     expect(result.isError).toBe(false);
-    expect(result.content).toContain("Skill: Contacts");
+    expect(result.content).toContain("Skill: Sounds");
   });
 
   test("loads skill when flag key is absent (registry defaults to enabled)", async () => {
     writeSkill(
       DECLARED_SKILL_ID,
-      "Contacts",
-      "Toggle contacts behavior",
+      "Sounds",
+      "Toggle sounds behavior",
       "Use the feature.",
     );
     writeFileSync(
@@ -140,8 +152,8 @@ describe("skill_load feature flag enforcement", () => {
 
     const result = await executeSkillLoad({ skill: DECLARED_SKILL_ID });
 
-    // contacts is declared in the registry with defaultEnabled: true
+    // sounds is declared in the registry with defaultEnabled: true
     expect(result.isError).toBe(false);
-    expect(result.content).toContain("Skill: Contacts");
+    expect(result.content).toContain("Skill: Sounds");
   });
 });