@vellumai/assistant 0.10.1 → 0.10.2-dev.202606241651.2d2b40d

package/src/__tests__/notification-decision-recipient-context.test.ts

@@ -36,17 +36,36 @@ mock.module("../prompts/system-prompt.js", () => ({
   buildCoreIdentityContext: () => null,
 }));
 
-// ── Guardian contact mock ────────────────────────────────────────────
+// ── Guardian binding + contact notes mocks ───────────────────────────
 
-let mockGuardianResult: {
-  contact: { notes: string | null };
-  channels: Record<string, unknown>[];
-} | null = null;
+// Guardian binding (ACL) is resolved via the gateway pull; notes (INFO) are
+// joined locally by contactId. Tests drive both via mutable slots.
+let guardianDeliveryFixture: Array<{ contactId: string }> = [];
+let contactInfoFixture: Record<string, { notes: string | null } | null> = {};
+
+mock.module("../contacts/guardian-delivery-reader.js", () => ({
+  getGuardianDelivery: async () => guardianDeliveryFixture,
+  anyGuardian: (list: Array<{ contactId: string }>) => list[0],
+}));
 
 mock.module("../contacts/contact-store.js", () => ({
-  listGuardianChannels: () => mockGuardianResult,
+  findContactInfoById: (contactId: string) =>
+    contactInfoFixture[contactId] ?? null,
 }));
 
+const GUARDIAN_CONTACT_ID = "guardian-contact-1";
+
+/** Bind a guardian with the given notes (or no guardian when notes is null). */
+function setGuardian(notes: string | null | undefined): void {
+  if (notes === undefined) {
+    guardianDeliveryFixture = [];
+    contactInfoFixture = {};
+    return;
+  }
+  guardianDeliveryFixture = [{ contactId: GUARDIAN_CONTACT_ID }];
+  contactInfoFixture = { [GUARDIAN_CONTACT_ID]: { notes } };
+}
+
 // ── Provider mock with system prompt capture ──────────────────────────
 
 let configuredProvider: {
@@ -134,15 +153,12 @@ describe("recipient context in notification decision engine", () => {
   beforeEach(() => {
     configuredProvider = null;
     extractedToolUse = null;
-    mockGuardianResult = null;
+    setGuardian(undefined);
     capturedSystemPrompt = undefined;
   });
 
   test("guardian contact notes appear in system prompt as <recipient-context>", async () => {
-    mockGuardianResult = {
-      contact: { notes: "Prefers formal tone. Address as Dr. Smith." },
-      channels: [{ type: "vellum" }],
-    };
+    setGuardian("Prefers formal tone. Address as Dr. Smith.");
     setupLLMProvider();
 
     const signal = makeSignal();
@@ -157,7 +173,7 @@ describe("recipient context in notification decision engine", () => {
   });
 
   test("recipient-context is omitted when no guardian exists", async () => {
-    mockGuardianResult = null;
+    setGuardian(undefined);
     setupLLMProvider();
 
     const signal = makeSignal();
@@ -169,10 +185,7 @@ describe("recipient context in notification decision engine", () => {
   });
 
   test("recipient-context is omitted when guardian notes are null", async () => {
-    mockGuardianResult = {
-      contact: { notes: null },
-      channels: [{ type: "vellum" }],
-    };
+    setGuardian(null);
     setupLLMProvider();
 
     const signal = makeSignal();
@@ -184,10 +197,7 @@ describe("recipient context in notification decision engine", () => {
   });
 
   test("recipient-context is omitted when guardian notes are empty string", async () => {
-    mockGuardianResult = {
-      contact: { notes: "" },
-      channels: [{ type: "vellum" }],
-    };
+    setGuardian("");
     setupLLMProvider();
 
     const signal = makeSignal();
@@ -199,10 +209,7 @@ describe("recipient context in notification decision engine", () => {
   });
 
   test("large guardian notes are truncated to prevent oversized prompts", async () => {
-    mockGuardianResult = {
-      contact: { notes: "N".repeat(3000) },
-      channels: [{ type: "vellum" }],
-    };
+    setGuardian("N".repeat(3000));
     setupLLMProvider();
 
     const signal = makeSignal();
@@ -226,10 +233,7 @@ describe("recipient context in notification decision engine", () => {
   });
 
   test("fallback path works correctly without recipient context", async () => {
-    mockGuardianResult = {
-      contact: { notes: "Prefers formal tone." },
-      channels: [{ type: "vellum" }],
-    };
+    setGuardian("Prefers formal tone.");
     // null provider forces fallback path
     configuredProvider = null;
 
@@ -247,10 +251,7 @@ describe("recipient context in notification decision engine", () => {
   });
 
   test("recipient-context appears after user-preferences in prompt", async () => {
-    mockGuardianResult = {
-      contact: { notes: "Prefers brief updates." },
-      channels: [{ type: "vellum" }],
-    };
+    setGuardian("Prefers brief updates.");
     setupLLMProvider();
 
     const signal = makeSignal();

package/src/__tests__/notification-deep-link.test.ts

@@ -20,6 +20,10 @@ mock.module("../util/logger.js", () => ({
     }),
 }));
 
+mock.module("../contacts/guardian-delivery-reader.js", () => ({
+  getGuardianDelivery: async () => null,
+}));
+
 // Mock destination-resolver for broadcaster tests
 mock.module("../notifications/destination-resolver.js", () => ({
   resolveDestinations: (channels: string[]) => {
@@ -42,6 +46,8 @@ mock.module("../notifications/deliveries-store.js", () => ({
 // can be driven from tests without DB access.
 let mockExistingConversations: Record<string, { id: string }> = {};
 mock.module("../memory/conversation-crud.js", () => ({
+    setConversationProcessingStartedAt: () => {},
+    isConversationProcessing: () => false,
   getConversation: (id: string) => mockExistingConversations[id] ?? null,
 }));
 

package/src/__tests__/notification-guardian-path.test.ts

@@ -68,6 +68,25 @@ mock.module("../notifications/emit-signal.js", () => ({
   },
 }));
 
+// Guardian principalId is resolved from the gateway binding reader. Mirror the
+// seeded vellum binding so dispatch can resolve the principal.
+mock.module("../contacts/guardian-delivery-reader.js", () => ({
+  getGuardianDelivery: async () => [
+    {
+      channelType: "vellum",
+      contactId: "guardian-vellum",
+      principalId: "test-principal-id",
+      address: "local",
+      status: "active",
+    },
+  ],
+  guardianForChannel: (
+    list: Array<{ channelType: string; status: string }>,
+    channelType: string,
+  ) => list.find((g) => g.channelType === channelType && g.status === "active"),
+  anyGuardian: (list: unknown[]) => list[0],
+}));
+
 import {
   createCallSession,
   createPendingQuestion,

package/src/__tests__/outbound-slack-persistence.test.ts

@@ -72,6 +72,8 @@ const persistedRows: Array<{
   metadata: string | null;
 }> = [];
 mock.module("../memory/conversation-crud.js", () => ({
+    setConversationProcessingStartedAt: () => {},
+    isConversationProcessing: () => false,
   addMessage: (
     conversationId: string,
     role: string,

package/src/__tests__/pending-interactions-resolved-event.test.ts

@@ -155,7 +155,7 @@ describe("pendingInteractions.resolve emits interaction_resolved", () => {
 });
 
 describe("removeByConversation emits interaction_resolved per entry", () => {
-  test("emits superseded for every non-host interaction in the conversation", () => {
+  test("emits superseded for every confirmation/secret interaction in the conversation", () => {
     pendingInteractions.register("conf-1", {
       conversationId: "conv-x",
       kind: "confirmation",
@@ -182,13 +182,16 @@ describe("removeByConversation emits interaction_resolved per entry", () => {
     const events = publishedMessages.filter(
       (m) => m.type === "interaction_resolved",
     ) as Extract<ServerMessage, { type: "interaction_resolved" }>[];
-    expect(events).toHaveLength(3);
+    expect(events).toHaveLength(2);
     expect(events.every((e) => e.state === "superseded")).toBe(true);
     const requestIds = new Set(events.map((e) => e.requestId));
-    expect(requestIds).toEqual(new Set(["conf-1", "secret-1", "question-1"]));
+    expect(requestIds).toEqual(new Set(["conf-1", "secret-1"]));
 
-    // host_bash entries survive auto-deny — no event for them.
+    // host_bash and question entries both survive auto-deny — no event for
+    // either. host proxies are settled by their result POST; questions by the
+    // enqueue steer's turn abort (see removeByConversation's skip list).
     expect(pendingInteractions.get("host-bash-1")).toBeDefined();
+    expect(pendingInteractions.get("question-1")).toBeDefined();
     // Unrelated conversation is untouched.
     expect(pendingInteractions.get("conf-other")).toBeDefined();
   });

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

@@ -48,6 +48,8 @@ interface AddMessageCall {
 }
 const addMessageCalls: AddMessageCall[] = [];
 mock.module("../memory/conversation-crud.js", () => ({
+    setConversationProcessingStartedAt: () => {},
+    isConversationProcessing: () => false,
   addMessage: (
     conversationId: string,
     role: string,

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

@@ -4,32 +4,19 @@
  * Covers:
  * - A noop `init()` fires with a valid `PluginInitContext` that exposes every
  *   documented field.
- * - `requiresCredential` entries are resolved through the credential store
- *   helper and arrive in `ctx.credentials`.
  * - Version-mismatch registration fails with an error that names the plugin
  *   (the registry enforces this at `registerPlugin` time, so bootstrap never
  *   sees the malformed plugin).
  * - Shutdown hook walks plugins in reverse registration order.
  *
- * Uses `mock.module` to stub `security/secure-keys.js` so credential
- * resolution doesn't hit the real backend. `resetPluginRegistryForTests()`
- * isolates registry state between cases.
+ * `resetPluginRegistryForTests()` isolates registry state between cases.
  */
 
 import { existsSync } from "node:fs";
 import { rm } from "node:fs/promises";
 import { tmpdir } from "node:os";
 import { join } from "node:path";
-import { beforeEach, describe, expect, mock, test } from "bun:test";
-
-// Mock credential store before importing the bootstrap module so the
-// module-under-test captures the stubbed binding.
-const getSecureKeyAsyncMock = mock(
-  async (_account: string): Promise<string | undefined> => undefined,
-);
-mock.module("../security/secure-keys.js", () => ({
-  getSecureKeyAsync: getSecureKeyAsyncMock,
-}));
+import { beforeEach, describe, expect, test } from "bun:test";
 
 import { clearFeatureFlagOverridesCache } from "../config/assistant-feature-flags.js";
 import { bootstrapPlugins } from "../daemon/external-plugins-bootstrap.js";
@@ -68,7 +55,6 @@ function buildPlugin(
     onShutdown?: () => Promise<void>;
   } = {},
   options: {
-    requiresCredential?: string[];
     requiresFlag?: string[];
   } = {},
 ): Plugin {
@@ -94,9 +80,6 @@ function buildPlugin(
     manifest: {
       name,
       version: "0.0.1",
-      ...(options.requiresCredential
-        ? { requiresCredential: options.requiresCredential }
-        : {}),
       ...(options.requiresFlag ? { requiresFlag: options.requiresFlag } : {}),
     },
     ...rest,
@@ -107,8 +90,6 @@ function buildPlugin(
 describe("plugin bootstrap", () => {
   beforeEach(async () => {
     resetPluginRegistryForTests();
-    getSecureKeyAsyncMock.mockReset();
-    getSecureKeyAsyncMock.mockImplementation(async () => undefined);
     // Reset feature-flag cache so tests start from a known state. Individual
     // tests that exercise `requiresFlag` use `setOverridesForTesting(...)`
     // to install their own overrides.
@@ -133,7 +114,6 @@ describe("plugin bootstrap", () => {
 
     // Every documented field must be present on the context passed to init.
     expect(ctx.config).toBeUndefined(); // no `plugins.alpha` block in fake config
-    expect(ctx.credentials).toEqual({});
     expect(ctx.logger).toBeDefined();
     expect(typeof (ctx.logger as { info: unknown }).info).toBe("function");
     // Storage dir lives under getWorkspaceDir()/plugins-data/<name> and must have
@@ -145,52 +125,6 @@ describe("plugin bootstrap", () => {
     expect(ctx.assistantVersion).toBe(APP_VERSION);
   });
 
-  test("credential resolution: init receives the resolved value under credentials[key]", async () => {
-    getSecureKeyAsyncMock.mockImplementation(async (account: string) => {
-      if (account === "some-key") return "super-secret-value";
-      return undefined;
-    });
-
-    let received: PluginInitContext | undefined;
-    const plugin = buildPlugin(
-      "credentialed",
-      {
-        async init(ctx) {
-          received = ctx;
-        },
-      },
-      { requiresCredential: ["some-key"] },
-    );
-    registerPlugin(plugin);
-
-    await bootstrapPlugins();
-
-    expect(getSecureKeyAsyncMock).toHaveBeenCalledTimes(1);
-    expect(getSecureKeyAsyncMock).toHaveBeenCalledWith("some-key");
-    expect(received?.credentials).toEqual({ "some-key": "super-secret-value" });
-  });
-
-  test("credential resolution: a plugin whose required credential is missing is skipped, not fatal", async () => {
-    // GIVEN a plugin that requires a credential the store cannot resolve
-    getSecureKeyAsyncMock.mockImplementation(async () => undefined);
-    registerPlugin(
-      buildPlugin(
-        "missing-cred",
-        { async init() {} },
-        { requiresCredential: ["absent-key"] },
-      ),
-    );
-
-    // WHEN bootstrap runs
-    // THEN it completes without throwing — the unresolvable credential is
-    // contained to that plugin (same per-plugin isolation as an init throw)
-    await bootstrapPlugins();
-
-    // AND the plugin is dropped from the registry
-    const names = getRegisteredPlugins().map((p) => p.manifest.name);
-    expect(names).not.toContain("missing-cred");
-  });
-
   test("version mismatch: external plugin loader rejects when peerDependency unsatisfied", async () => {
     // Host-compat negotiation lives in the external-plugin loader against
     // `peerDependencies["@vellumai/plugin-api"]`. The registry no longer
@@ -555,11 +489,7 @@ describe("plugin bootstrap", () => {
     registerPlugin(plugin);
 
     // Create the .disabled sentinel in the workspace plugins dir.
-    const sentinelDir = join(
-      TEST_WORKSPACE_DIR,
-      "plugins",
-      "sentinel-off",
-    );
+    const sentinelDir = join(TEST_WORKSPACE_DIR, "plugins", "sentinel-off");
     const { mkdir, writeFile } = await import("node:fs/promises");
     await mkdir(sentinelDir, { recursive: true });
     await writeFile(join(sentinelDir, ".disabled"), "");

package/src/__tests__/plugin-route-contribution.test.ts

@@ -22,26 +22,15 @@
  *     each plugin's shutdown only removes its own route — the other plugin's
  *     route stays live until its own teardown runs.
  *
- * Uses `mock.module` to stub credential resolution — bootstrap otherwise
- * tries to hit the real secure-key backend. `resetPluginRegistryForTests()`
- * isolates plugin-registry state and `resetSkillRoutesForTests()` isolates
- * skill-route-registry state between cases.
+ * `resetPluginRegistryForTests()` isolates plugin-registry state and
+ * `resetSkillRoutesForTests()` isolates skill-route-registry state between
+ * cases.
  */
 
 import { rm } from "node:fs/promises";
 import { tmpdir } from "node:os";
 import { join } from "node:path";
-import { beforeEach, describe, expect, mock, test } from "bun:test";
-
-// Stub the credential store before importing bootstrap so the module binds to
-// the mock. Plugins in these tests don't declare `requiresCredential`, but
-// the mock keeps the test hermetic regardless of what the backend would do.
-const getSecureKeyAsyncMock = mock(
-  async (_account: string): Promise<string | undefined> => undefined,
-);
-mock.module("../security/secure-keys.js", () => ({
-  getSecureKeyAsync: getSecureKeyAsyncMock,
-}));
+import { beforeEach, describe, expect, test } from "bun:test";
 
 import { bootstrapPlugins } from "../daemon/external-plugins-bootstrap.js";
 import { runShutdownHooks } from "../daemon/shutdown-registry.js";
@@ -113,8 +102,6 @@ describe("plugin route contributions", () => {
   beforeEach(async () => {
     resetPluginRegistryForTests();
     resetSkillRoutesForTests();
-    getSecureKeyAsyncMock.mockReset();
-    getSecureKeyAsyncMock.mockImplementation(async () => undefined);
     await rm(TEST_WORKSPACE_DIR, { recursive: true, force: true });
   });
 

package/src/__tests__/plugin-tool-contribution.test.ts

@@ -16,11 +16,9 @@
  * - Direct `registerPluginTools` / `unregisterPluginTools` semantics,
  *   including the plugin-scoped ref count.
  *
- * Uses `mock.module` to stub the credential store so bootstrap doesn't hit
- * the real backend. `resetPluginRegistryForTests()` and
- * `__clearRegistryForTesting()` isolate registry state between cases so
- * this file can run alongside other plugin/tool-registry tests without
- * cross-contamination.
+ * `resetPluginRegistryForTests()` and `__clearRegistryForTesting()` isolate
+ * registry state between cases so this file can run alongside other
+ * plugin/tool-registry tests without cross-contamination.
  */
 
 import { rm } from "node:fs/promises";
@@ -28,17 +26,6 @@ import { tmpdir } from "node:os";
 import { join } from "node:path";
 import { beforeEach, describe, expect, mock, test } from "bun:test";
 
-// Mock the credential store before importing the bootstrap so the module
-// under test captures the stubbed binding. Bootstrap only calls this for
-// plugins that declare `requiresCredential`; the tests in this file don't,
-// so the stub simply returns undefined.
-const getSecureKeyAsyncMock = mock(
-  async (_account: string): Promise<string | undefined> => undefined,
-);
-mock.module("../security/secure-keys.js", () => ({
-  getSecureKeyAsync: getSecureKeyAsyncMock,
-}));
-
 import { bootstrapPlugins } from "../daemon/external-plugins-bootstrap.js";
 import { runShutdownHooks } from "../daemon/shutdown-registry.js";
 import { RiskLevel } from "../permissions/types.js";
@@ -134,8 +121,6 @@ describe("plugin tool contributions", () => {
     // assertions about which tools are present. We don't need any of the
     // eager/host tools for these tests.
     __clearRegistryForTesting();
-    getSecureKeyAsyncMock.mockReset();
-    getSecureKeyAsyncMock.mockImplementation(async () => undefined);
     await rm(TEST_WORKSPACE_DIR, { recursive: true, force: true });
   });
 

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

@@ -38,7 +38,6 @@ describe("plugin core types", () => {
     const manifest: PluginManifest = {
       name: "sample-plugin",
       version: "0.1.0",
-      requiresCredential: ["SAMPLE_API_KEY"],
       requiresFlag: ["sample-feature"],
       config: { parse: (input: unknown) => input },
     };
@@ -61,7 +60,6 @@ describe("plugin core types", () => {
         async init(ctx: PluginInitContext) {
           // Touch every field so refactors that rename any of them break here.
           void ctx.config;
-          void ctx.credentials;
           void ctx.logger;
           void ctx.pluginStorageDir;
           void ctx.assistantVersion;

package/src/__tests__/process-message-background-slack.test.ts

@@ -19,6 +19,8 @@ mock.module("../memory/canonical-guardian-store.js", () => ({
 }));
 
 mock.module("../memory/conversation-crud.js", () => ({
+    setConversationProcessingStartedAt: () => {},
+    isConversationProcessing: () => false,
   addMessage: async () => ({ id: "message-id" }),
   getConversation: () => null,
   provenanceFromTrustContext: () => ({}),

package/src/__tests__/process-message-display-content.test.ts

@@ -37,6 +37,8 @@ mock.module("../memory/attachments-store.js", () => ({
 }));
 
 mock.module("../memory/conversation-crud.js", () => ({
+    setConversationProcessingStartedAt: () => {},
+    isConversationProcessing: () => false,
   addMessage: async (
     conversationId: string,
     role: string,

package/src/__tests__/provider-usage-tracking.test.ts

@@ -200,3 +200,42 @@ describe("UsageTrackingProvider", () => {
     });
   });
 });
+
+describe("native web-search capability survives the wrapper chain", () => {
+  function leaf(supports: boolean | undefined): Provider {
+    return {
+      name: "anthropic",
+      ...(supports === undefined ? {} : { supportsNativeWebSearch: supports }),
+      async sendMessage(): Promise<ProviderResponse> {
+        return {
+          content: [{ type: "text", text: "" }],
+          model: "m",
+          usage: { inputTokens: 0, outputTokens: 0 },
+          stopReason: "end_turn",
+        };
+      },
+    };
+  }
+
+  test("UsageTrackingProvider forwards supportsNativeWebSearch", () => {
+    expect(new UsageTrackingProvider(leaf(true)).supportsNativeWebSearch).toBe(
+      true,
+    );
+    expect(new UsageTrackingProvider(leaf(false)).supportsNativeWebSearch).toBe(
+      false,
+    );
+    expect(
+      new UsageTrackingProvider(leaf(undefined)).supportsNativeWebSearch,
+    ).toBeUndefined();
+  });
+
+  test("CallSiteConfiguredProvider forwards it through a nested wrapper", () => {
+    // The exact chain getConfiguredProvider returns: CallSiteConfigured →
+    // UsageTracking → leaf. The advisor consult reads the flag off the top.
+    const wrapped = new CallSiteConfiguredProvider(
+      new UsageTrackingProvider(leaf(true)),
+      "advisor",
+    );
+    expect(wrapped.supportsNativeWebSearch).toBe(true);
+  });
+});

package/src/__tests__/regenerate-fire-and-forget-trace.test.ts

@@ -23,6 +23,8 @@ let dbMessages: Array<{
 }> = [];
 
 mock.module("../memory/conversation-crud.js", () => ({
+    setConversationProcessingStartedAt: () => {},
+    isConversationProcessing: () => false,
   getMessages: (conversationId: string) =>
     dbMessages.filter((m) => m.conversationId === conversationId),
   deleteMessageById: (messageId: string) => {

package/src/__tests__/registry.test.ts

@@ -36,6 +36,9 @@ function makeFakeTool(name: string): Tool {
     category: "test",
     defaultRiskLevel: RiskLevel.Low,
     executionTarget: "sandbox",
+    // Match the finalized shape the registry stores, so identity comparisons
+    // (`getTool(name)` toEqual coreTool) hold after registration fills defaults.
+    exclusive: false,
     input_schema: { type: "object", properties: {}, required: [] },
     async execute(
       _input: Record<string, unknown>,