@vellumai/assistant 0.8.0 → 0.8.2

package/src/__tests__/user-plugin-loader.test.ts

@@ -81,7 +81,6 @@ registerPlugin({
   manifest: {
     name: "my-plugin",
     version: "0.0.1",
-    requires: { pluginRuntime: "v1" },
   },
 });
 `,
@@ -111,7 +110,6 @@ registerPlugin({
   manifest: {
     name: "good-plugin",
     version: "0.0.1",
-    requires: { pluginRuntime: "v1" },
   },
 });
 `,
@@ -151,7 +149,6 @@ registerPlugin({
   manifest: {
     name: "hanging-plugin",
     version: "0.0.1",
-    requires: { pluginRuntime: "v1" },
   },
 });
 `,
@@ -163,7 +160,6 @@ registerPlugin({
   manifest: {
     name: "healthy-plugin",
     version: "0.0.1",
-    requires: { pluginRuntime: "v1" },
   },
 });
 `,
@@ -198,7 +194,6 @@ registerPlugin({
   manifest: {
     name: "slow-late-plugin",
     version: "0.0.1",
-    requires: { pluginRuntime: "v1" },
   },
 });
 `,
@@ -230,4 +225,147 @@ registerPlugin({
     await loadUserPlugins();
     expect(getRegisteredPlugins()).toHaveLength(0);
   });
+
+  describe("experimental plugin framework branch", () => {
+    /**
+     * Write a directory-convention plugin (package.json + optional
+     * hooks/tools default exports). Mirrors `writePlugin()` above but
+     * targets the new experimental loader path.
+     */
+    function writeExperimentalPlugin(
+      name: string,
+      pkg: Record<string, unknown>,
+      files: Record<string, string> = {},
+    ): void {
+      const pluginDir = join(PLUGINS_DIR, name);
+      mkdirSync(pluginDir, { recursive: true });
+      writeFileSync(
+        join(pluginDir, "package.json"),
+        JSON.stringify(pkg, null, 2),
+      );
+      for (const [rel, body] of Object.entries(files)) {
+        const parts = rel.split("/");
+        parts.pop();
+        if (parts.length > 0) {
+          mkdirSync(join(pluginDir, ...parts), { recursive: true });
+        }
+        writeFileSync(join(pluginDir, rel), body);
+      }
+    }
+
+    test("loads a plugin via the package.json branch and registers it", async () => {
+      writeExperimentalPlugin(
+        "experimental-one",
+        { name: "experimental-one", version: "0.1.0" },
+        {
+          "hooks/init.ts":
+            "export default async function init(_ctx: unknown): Promise<void> {}\n",
+        },
+      );
+
+      await loadUserPlugins();
+
+      const names = getRegisteredPlugins().map((p) => p.manifest.name);
+      expect(names).toContain("experimental-one");
+      const registered = getRegisteredPlugins().find(
+        (p) => p.manifest.name === "experimental-one",
+      );
+      expect(typeof registered?.hooks?.init).toBe("function");
+    });
+
+    test("strips npm scope from package.json name", async () => {
+      writeExperimentalPlugin("scoped", {
+        name: "@vellumai/cool-plugin",
+        version: "0.1.0",
+      });
+
+      await loadUserPlugins();
+
+      const names = getRegisteredPlugins().map((p) => p.manifest.name);
+      expect(names).toContain("cool-plugin");
+    });
+
+    test("a broken experimental plugin is logged and skipped without affecting others", async () => {
+      // Plugin A has a malformed package.json; Plugin B is a healthy
+      // legacy register.ts. The loader must isolate A's failure and still
+      // register B — same per-plugin contract as the legacy path.
+      const brokenDir = join(PLUGINS_DIR, "broken-experimental");
+      mkdirSync(brokenDir, { recursive: true });
+      writeFileSync(join(brokenDir, "package.json"), "{ not valid json");
+
+      writePlugin(
+        "healthy-legacy",
+        `
+registerPlugin({
+  manifest: {
+    name: "healthy-legacy",
+    version: "0.0.1",
+  },
+});
+`,
+      );
+
+      await loadUserPlugins();
+
+      const names = getRegisteredPlugins().map((p) => p.manifest.name);
+      expect(names).toContain("healthy-legacy");
+      expect(names).not.toContain("broken-experimental");
+    });
+
+    test("experimental and legacy plugins coexist in one workspace", async () => {
+      writeExperimentalPlugin("new-style", {
+        name: "new-style",
+        version: "0.1.0",
+      });
+      writePlugin(
+        "old-style",
+        `
+registerPlugin({
+  manifest: {
+    name: "old-style",
+    version: "0.0.1",
+  },
+});
+`,
+      );
+
+      await loadUserPlugins();
+
+      const names = getRegisteredPlugins()
+        .map((p) => p.manifest.name)
+        .sort();
+      expect(names).toEqual(["new-style", "old-style"]);
+    });
+
+    test("package.json branch wins over a stale register.ts in the same dir", async () => {
+      // A migrated plugin may keep its old register.ts on disk while it
+      // adopts the new convention. The package.json gate takes the
+      // experimental path and the legacy register.ts is never imported,
+      // so the plugin must register exactly once.
+      const dir = join(PLUGINS_DIR, "migrated");
+      mkdirSync(dir, { recursive: true });
+      writeFileSync(
+        join(dir, "package.json"),
+        JSON.stringify({ name: "migrated", version: "0.1.0" }),
+      );
+      // A register.ts that would double-register if both paths fired.
+      const registryPath = join(
+        import.meta.dir,
+        "..",
+        "plugins",
+        "registry.ts",
+      );
+      writeFileSync(
+        join(dir, "register.ts"),
+        `import { registerPlugin } from ${JSON.stringify(registryPath)};
+registerPlugin({ manifest: { name: "migrated", version: "0.0.1", requires: { pluginRuntime: "v1" } } });
+`,
+      );
+
+      await loadUserPlugins();
+
+      const names = getRegisteredPlugins().map((p) => p.manifest.name);
+      expect(names.filter((n) => n === "migrated")).toHaveLength(1);
+    });
+  });
 });

package/src/__tests__/vercel-config.test.ts

@@ -0,0 +1,168 @@
+import { beforeEach, describe, expect, mock, test } from "bun:test";
+
+import { credentialKey } from "../security/credential-key.js";
+
+let secureKeyStore: Record<string, string> = {};
+
+// Track metadata upsert calls to verify policy
+let lastUpsertCall: {
+  service: string;
+  field: string;
+  policy: Record<string, unknown> | undefined;
+} | null = null;
+let metadataDeleted: { service: string; field: string } | null = null;
+
+mock.module("../security/secure-keys.js", () => ({
+  getSecureKeyAsync: async (account: string) =>
+    secureKeyStore[account] ?? undefined,
+  setSecureKeyAsync: async (account: string, value: string) => {
+    secureKeyStore[account] = value;
+    return true;
+  },
+  deleteSecureKeyAsync: async (account: string) => {
+    if (account in secureKeyStore) {
+      delete secureKeyStore[account];
+      return "deleted" as const;
+    }
+    return "not-found" as const;
+  },
+}));
+
+mock.module("../tools/credentials/metadata-store.js", () => ({
+  deleteCredentialMetadata: (service: string, field: string) => {
+    metadataDeleted = { service, field };
+    return true;
+  },
+  upsertCredentialMetadata: (
+    service: string,
+    field: string,
+    policy?: Record<string, unknown>,
+  ) => {
+    lastUpsertCall = { service, field, policy };
+    return {};
+  },
+}));
+
+mock.module("../util/logger.js", () => ({
+  getLogger: () =>
+    new Proxy({} as Record<string, unknown>, {
+      get: () => () => {},
+    }),
+}));
+
+import {
+  deleteVercelConfig,
+  getVercelConfig,
+  setVercelConfig,
+} from "../daemon/handlers/config-vercel.js";
+
+describe("Vercel config handler", () => {
+  beforeEach(() => {
+    secureKeyStore = {};
+    lastUpsertCall = null;
+    metadataDeleted = null;
+  });
+
+  // -- setVercelConfig --
+
+  describe("setVercelConfig", () => {
+    test("stores token and returns success", async () => {
+      const result = await setVercelConfig("vl_test_token_123");
+
+      expect(result.success).toBe(true);
+      expect(result.hasToken).toBe(true);
+      expect(secureKeyStore[credentialKey("vercel", "api_token")]).toBe(
+        "vl_test_token_123",
+      );
+    });
+
+    test("metadata does not include bash in allowedTools", async () => {
+      await setVercelConfig("vl_test_token_123");
+
+      expect(lastUpsertCall).not.toBeNull();
+      const tools = lastUpsertCall!.policy?.allowedTools as string[];
+      expect(tools).not.toContain("bash");
+    });
+
+    test("metadata does not include deploy in allowedTools", async () => {
+      await setVercelConfig("vl_test_token_123");
+
+      expect(lastUpsertCall).not.toBeNull();
+      const tools = lastUpsertCall!.policy?.allowedTools as string[];
+      expect(tools).not.toContain("deploy");
+    });
+
+    test("metadata explicitly clears injection templates", async () => {
+      await setVercelConfig("vl_test_token_123");
+
+      expect(lastUpsertCall).not.toBeNull();
+      expect(lastUpsertCall!.policy?.injectionTemplates).toBeNull();
+    });
+
+    test("publish_page and unpublish_page remain in allowedTools", async () => {
+      await setVercelConfig("vl_test_token_123");
+
+      expect(lastUpsertCall).not.toBeNull();
+      const tools = lastUpsertCall!.policy?.allowedTools as string[];
+      expect(tools).toContain("publish_page");
+      expect(tools).toContain("unpublish_page");
+    });
+
+    test("allowedTools contains only publish_page and unpublish_page", async () => {
+      await setVercelConfig("vl_test_token_123");
+
+      expect(lastUpsertCall).not.toBeNull();
+      const tools = lastUpsertCall!.policy?.allowedTools as string[];
+      expect(tools).toEqual(["publish_page", "unpublish_page"]);
+    });
+
+    test("returns error when apiToken is not provided", async () => {
+      const result = await setVercelConfig(undefined);
+
+      expect(result.success).toBe(false);
+      expect(result.hasToken).toBe(false);
+      expect(result.error).toBeDefined();
+    });
+  });
+
+  // -- getVercelConfig --
+
+  describe("getVercelConfig", () => {
+    test("returns hasToken true when token exists", async () => {
+      secureKeyStore[credentialKey("vercel", "api_token")] = "some-token";
+      const result = await getVercelConfig();
+
+      expect(result.hasToken).toBe(true);
+      expect(result.success).toBe(true);
+    });
+
+    test("returns hasToken false when no token exists", async () => {
+      const result = await getVercelConfig();
+
+      expect(result.hasToken).toBe(false);
+      expect(result.success).toBe(true);
+    });
+  });
+
+  // -- deleteVercelConfig --
+
+  describe("deleteVercelConfig", () => {
+    test("removes both secure key and metadata", async () => {
+      secureKeyStore[credentialKey("vercel", "api_token")] = "token-to-delete";
+
+      const result = await deleteVercelConfig();
+
+      expect(result.success).toBe(true);
+      expect(result.hasToken).toBe(false);
+      // Secure key should be removed
+      expect(
+        secureKeyStore[credentialKey("vercel", "api_token")],
+      ).toBeUndefined();
+      // Metadata should be deleted
+      expect(metadataDeleted).toEqual({
+        service: "vercel",
+        field: "api_token",
+      });
+    });
+  });
+});

package/src/__tests__/voice-session-bridge.test.ts

@@ -1183,6 +1183,204 @@ describe("voice-session-bridge", () => {
     expect(handleSecretCalls[0].delivery).toBe("store");
   });
 
+  test("forcePromptSideEffects does not leak when persistUserMessage fails", async () => {
+    const conversation = createConversation(
+      "voice bridge forcePromptSideEffects leak test",
+    );
+
+    const session = {
+      isProcessing: () => false,
+      forcePromptSideEffects: false,
+      callSessionId: undefined as string | undefined,
+      persistUserMessage: async () => {
+        throw new Error("simulated persistence failure");
+      },
+      memoryPolicy: {
+        scopeId: "default",
+        includeDefaultFallback: false,
+      },
+      setChannelCapabilities: () => {},
+      setAssistantId: () => {},
+      setTrustContext: () => {},
+      setCommandIntent: () => {},
+      setTurnChannelContext: () => {},
+      setTurnInterfaceContext: () => {},
+      setVoiceCallControlPrompt: () => {},
+      updateClient: () => {},
+      ensureActorScopedHistory: async () => {},
+      runAgentLoop: async () => {},
+      handleConfirmationResponse: () => {},
+      abort: () => {},
+    } as unknown as Conversation & { forcePromptSideEffects: boolean };
+
+    injectDeps(() => session);
+
+    // Non-guardian voice would normally set forcePromptSideEffects = true.
+    // The setup must fail before that assignment happens so the flag stays
+    // false and cannot leak into subsequent non-voice turns.
+    let caught: Error | null = null;
+    try {
+      await startVoiceTurn({
+        conversationId: conversation.id,
+        content: "Hello",
+        isInbound: true,
+        trustContext: {
+          sourceChannel: "phone",
+          trustClass: "trusted_contact",
+        },
+        onTextDelta: () => {},
+        onComplete: () => {},
+        onError: () => {},
+      });
+    } catch (err) {
+      caught = err as Error;
+    }
+
+    expect(caught?.message).toBe("simulated persistence failure");
+    expect(session.forcePromptSideEffects).toBe(false);
+  });
+
+  test("turn state does not leak when persistUserMessage fails", async () => {
+    const conversation = createConversation(
+      "voice bridge turn state leak test",
+    );
+
+    const lastSetterValue: Record<string, unknown> = {};
+    const recordLast =
+      (name: string) =>
+      (value: unknown): void => {
+        lastSetterValue[name] = value;
+      };
+    const session = {
+      isProcessing: () => false,
+      forcePromptSideEffects: false,
+      callSessionId: undefined as string | undefined,
+      persistUserMessage: async () => {
+        throw new Error("simulated persistence failure");
+      },
+      memoryPolicy: {
+        scopeId: "default",
+        includeDefaultFallback: false,
+      },
+      setChannelCapabilities: recordLast("setChannelCapabilities"),
+      setAssistantId: recordLast("setAssistantId"),
+      setTrustContext: recordLast("setTrustContext"),
+      setCommandIntent: recordLast("setCommandIntent"),
+      setTurnChannelContext: recordLast("setTurnChannelContext"),
+      setTurnInterfaceContext: recordLast("setTurnInterfaceContext"),
+      setVoiceCallControlPrompt: recordLast("setVoiceCallControlPrompt"),
+      updateClient: () => {},
+      ensureActorScopedHistory: async () => {},
+      runAgentLoop: async () => {},
+      handleConfirmationResponse: () => {},
+      abort: () => {},
+    } as unknown as Conversation & {
+      forcePromptSideEffects: boolean;
+      callSessionId?: string;
+    };
+    session.callSessionId = "session-leak-test-precondition";
+
+    injectDeps(() => session);
+
+    let caught: Error | null = null;
+    try {
+      await startVoiceTurn({
+        conversationId: conversation.id,
+        voiceSessionId: "session-leak-test",
+        content: "Hello",
+        isInbound: true,
+        trustContext: {
+          sourceChannel: "phone",
+          trustClass: "trusted_contact",
+        },
+        onTextDelta: () => {},
+        onComplete: () => {},
+        onError: () => {},
+      });
+    } catch (err) {
+      caught = err as Error;
+    }
+
+    expect(caught?.message).toBe("simulated persistence failure");
+    expect(lastSetterValue.setChannelCapabilities).toBeNull();
+    expect(lastSetterValue.setTrustContext).toBeNull();
+    expect(lastSetterValue.setCommandIntent).toBeNull();
+    expect(lastSetterValue.setAssistantId).toBe("self");
+    expect(lastSetterValue.setVoiceCallControlPrompt).toBeNull();
+    expect(session.callSessionId).toBeUndefined();
+    expect(session.forcePromptSideEffects).toBe(false);
+  });
+
+  test("cleanup on early persistUserMessage throw does not detach prior client sender", async () => {
+    const conversation = createConversation(
+      "voice bridge sender detach guard test",
+    );
+
+    const updateClientCalls: Array<{
+      callback: unknown;
+      replace: boolean | undefined;
+    }> = [];
+
+    const session = {
+      isProcessing: () => false,
+      forcePromptSideEffects: false,
+      callSessionId: undefined as string | undefined,
+      persistUserMessage: async () => {
+        throw new Error("persist failed before bridge installed callback");
+      },
+      memoryPolicy: {
+        scopeId: "default",
+        includeDefaultFallback: false,
+      },
+      setChannelCapabilities: () => {},
+      setAssistantId: () => {},
+      setTrustContext: () => {},
+      setCommandIntent: () => {},
+      setTurnChannelContext: () => {},
+      setTurnInterfaceContext: () => {},
+      setVoiceCallControlPrompt: () => {},
+      updateClient: (callback: unknown, replace?: boolean) => {
+        updateClientCalls.push({ callback, replace });
+      },
+      ensureActorScopedHistory: async () => {},
+      runAgentLoop: async () => {},
+      handleConfirmationResponse: () => {},
+      abort: () => {},
+    } as unknown as Conversation & {
+      forcePromptSideEffects: boolean;
+      callSessionId?: string;
+    };
+
+    injectDeps(() => session);
+
+    let caught: Error | null = null;
+    try {
+      await startVoiceTurn({
+        conversationId: conversation.id,
+        voiceSessionId: "session-sender-detach-test",
+        content: "Hello",
+        isInbound: true,
+        trustContext: {
+          sourceChannel: "phone",
+          trustClass: "trusted_contact",
+        },
+        onTextDelta: () => {},
+        onComplete: () => {},
+        onError: () => {},
+      });
+    } catch (err) {
+      caught = err as Error;
+    }
+
+    expect(caught?.message).toBe(
+      "persist failed before bridge installed callback",
+    );
+    // The bridge never reached its `conversation.updateClient(...)` install
+    // site, so cleanup must not touch updateClient — otherwise it would
+    // detach a sender installed by a prior turn on the same conversation.
+    expect(updateClientCalls).toEqual([]);
+  });
+
   test("pre-aborted signal triggers immediate abort", async () => {
     const conversation = createConversation("voice bridge pre-abort test");
     let abortCalled = false;

package/src/__tests__/web-search-catalog-parity.test.ts

@@ -0,0 +1,108 @@
+import { readFileSync } from "node:fs";
+import { join } from "node:path";
+import { describe, expect, test } from "bun:test";
+
+import {
+  SEARCH_PROVIDER_CATALOG,
+  type SearchProviderCatalogEntry,
+} from "../providers/search-provider-catalog.js";
+
+/**
+ * Parity guard: daemon TS catalog vs the two generated JSON copies.
+ *
+ * The daemon maintains its canonical search-provider catalog in
+ * `assistant/src/providers/search-provider-catalog.ts`.
+ * `assistant/scripts/sync-web-search-catalog.ts` writes two byte-identical
+ * artifacts:
+ *   - `meta/web-search-provider-catalog.json` — primary cross-package artifact.
+ *   - `clients/shared/Resources/web-search-provider-catalog.json` — SwiftPM
+ *     resource bundled into `VellumAssistantShared` (Swift cannot reach
+ *     files outside a target's source directory).
+ *
+ * These tests enforce structural equality between the TS catalog and the
+ * meta/ copy, plus byte equality between the meta/ copy and the SwiftPM
+ * mirror. CI fails when any of the three drift.
+ */
+
+interface JsonCatalogEntry {
+  id: string;
+  displayName: string;
+  displayNameLong?: string;
+  kind: "managed" | "byok";
+  apiKeyPrefix?: string;
+  envVar?: string;
+  secretKey?: string;
+  fallbackOrder?: number;
+  privacyPolicyUrl?: string;
+}
+
+interface JsonCatalog {
+  version: number;
+  providers: JsonCatalogEntry[];
+}
+
+const META_JSON_PATH = join(
+  process.cwd(),
+  "..",
+  "meta/web-search-provider-catalog.json",
+);
+const SWIFTPM_MIRROR_PATH = join(
+  process.cwd(),
+  "..",
+  "clients/shared/Resources/web-search-provider-catalog.json",
+);
+
+function loadJsonCatalog(): JsonCatalog {
+  return JSON.parse(readFileSync(META_JSON_PATH, "utf-8"));
+}
+
+function entryToPlain(
+  entry: SearchProviderCatalogEntry,
+): Record<string, unknown> {
+  // Project the TS entry into the same shape the JSON serializer emits:
+  // field order matches `sync-web-search-catalog.ts`, optional fields are
+  // omitted (not serialized as undefined).
+  const out: Record<string, unknown> = {
+    id: entry.id,
+    displayName: entry.displayName,
+  };
+  if (entry.displayNameLong !== undefined) {
+    out.displayNameLong = entry.displayNameLong;
+  }
+  out.kind = entry.kind;
+  if (entry.apiKeyPrefix !== undefined) out.apiKeyPrefix = entry.apiKeyPrefix;
+  if (entry.envVar !== undefined) out.envVar = entry.envVar;
+  if (entry.secretKey !== undefined) out.secretKey = entry.secretKey;
+  if (entry.fallbackOrder !== undefined) out.fallbackOrder = entry.fallbackOrder;
+  if (entry.privacyPolicyUrl !== undefined) {
+    out.privacyPolicyUrl = entry.privacyPolicyUrl;
+  }
+  return out;
+}
+
+describe("web-search catalog parity (TS canonical vs meta/ JSON)", () => {
+  test("provider list and metadata match exactly", () => {
+    const json = loadJsonCatalog();
+    const expected = SEARCH_PROVIDER_CATALOG.map(
+      entryToPlain,
+    ) as unknown as JsonCatalogEntry[];
+    expect(json.providers).toEqual(expected);
+  });
+
+  test("provider order matches declaration order", () => {
+    const json = loadJsonCatalog();
+    expect(json.providers.map((p) => p.id)).toEqual(
+      SEARCH_PROVIDER_CATALOG.map((p) => p.id),
+    );
+  });
+
+  test("SwiftPM mirror is byte-identical to meta/ copy", () => {
+    // The generator writes both files from the same serializer; this guard
+    // catches any case where one copy is regenerated without the other.
+    // Byte equality is required because SwiftPM bundles the resource verbatim
+    // and the meta/ JSON is consumed as a cross-package artifact.
+    const metaBytes = readFileSync(META_JSON_PATH);
+    const swiftPmBytes = readFileSync(SWIFTPM_MIRROR_PATH);
+    expect(swiftPmBytes.equals(metaBytes)).toBe(true);
+  });
+});