@vellumai/assistant 0.10.2-dev.202606250318.5e7cfb0 → 0.10.2

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 confirmation/secret interaction in the conversation", () => {
+  test("emits superseded for every non-host interaction in the conversation", () => {
     pendingInteractions.register("conf-1", {
       conversationId: "conv-x",
       kind: "confirmation",
@@ -182,16 +182,13 @@ 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(2);
+    expect(events).toHaveLength(3);
     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"]));
+    expect(requestIds).toEqual(new Set(["conf-1", "secret-1", "question-1"]));
 
-    // 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).
+    // host_bash entries survive auto-deny — no event for them.
     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,8 +48,6 @@ 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,19 +4,32 @@
  * 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.
  *
- * `resetPluginRegistryForTests()` isolates registry state between cases.
+ * Uses `mock.module` to stub `security/secure-keys.js` so credential
+ * resolution doesn't hit the real backend. `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, test } from "bun:test";
+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 { clearFeatureFlagOverridesCache } from "../config/assistant-feature-flags.js";
 import { bootstrapPlugins } from "../daemon/external-plugins-bootstrap.js";
@@ -55,6 +68,7 @@ function buildPlugin(
     onShutdown?: () => Promise<void>;
   } = {},
   options: {
+    requiresCredential?: string[];
     requiresFlag?: string[];
   } = {},
 ): Plugin {
@@ -80,6 +94,9 @@ function buildPlugin(
     manifest: {
       name,
       version: "0.0.1",
+      ...(options.requiresCredential
+        ? { requiresCredential: options.requiresCredential }
+        : {}),
       ...(options.requiresFlag ? { requiresFlag: options.requiresFlag } : {}),
     },
     ...rest,
@@ -90,6 +107,8 @@ 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.
@@ -114,6 +133,7 @@ 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
@@ -125,6 +145,52 @@ 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
@@ -489,7 +555,11 @@ 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,15 +22,26 @@
  *     each plugin's shutdown only removes its own route — the other plugin's
  *     route stays live until its own teardown runs.
  *
- * `resetPluginRegistryForTests()` isolates plugin-registry state and
- * `resetSkillRoutesForTests()` isolates skill-route-registry state between
- * cases.
+ * 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.
  */
 
 import { rm } from "node:fs/promises";
 import { tmpdir } from "node:os";
 import { join } from "node:path";
-import { beforeEach, describe, expect, test } from "bun:test";
+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 { bootstrapPlugins } from "../daemon/external-plugins-bootstrap.js";
 import { runShutdownHooks } from "../daemon/shutdown-registry.js";
@@ -102,6 +113,8 @@ 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,9 +16,11 @@
  * - Direct `registerPluginTools` / `unregisterPluginTools` semantics,
  *   including the plugin-scoped ref count.
  *
- * `resetPluginRegistryForTests()` and `__clearRegistryForTesting()` isolate
- * registry state between cases so this file can run alongside other
- * plugin/tool-registry tests without cross-contamination.
+ * 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.
  */
 
 import { rm } from "node:fs/promises";
@@ -26,6 +28,17 @@ 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";
@@ -121,6 +134,8 @@ 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,6 +38,7 @@ 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 },
     };
@@ -60,6 +61,7 @@ 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,8 +19,6 @@ 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,8 +37,6 @@ 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-error-scenarios.test.ts

@@ -837,10 +837,9 @@ describe("RetryProvider — streaming response handling", () => {
 
   test("does NOT retry OpenAI/Gemini-shaped 'Request was aborted' (no inner-timeout rewrite at those catch-sites)", async () => {
     // The OpenAI chat-completions, OpenAI responses, and Gemini catch-sites
-    // format their errors as `"<Provider> API error (<status>): Request
-    // was aborted."` (the OpenAI catch-sites render a missing status as
-    // `(unknown status)`; the Anthropic catch-site intentionally omits the
-    // parenthetical) and — unlike the Anthropic
+    // format their errors as `"<Provider> API error (undefined): Request
+    // was aborted."` (note the `(undefined)` parenthetical that the
+    // Anthropic catch-site intentionally omits) and — unlike the Anthropic
     // catch-site — they do NOT rewrite their inner-streamTimeoutMs
     // deadline failures. A provider-agnostic transport-abort predicate
     // would burn three retries on what is by construction a deterministic
@@ -849,7 +848,7 @@ describe("RetryProvider — streaming response handling", () => {
     // wasted retry budget for non-Anthropic providers until their
     // catch-sites grow the same `innerTimeoutFired` distinction.
     const openaiAbortError = new ProviderError(
-      "OpenAI API error (unknown status): Request was aborted.",
+      "OpenAI API error (undefined): Request was aborted.",
       "openai",
       undefined,
     );

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

@@ -200,42 +200,3 @@ 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,8 +23,6 @@ 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,9 +36,6 @@ 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>,
@@ -111,7 +108,7 @@ describe("tool registry dynamic-tools tools", () => {
 
 describe("tool manifest", () => {
   test("eager module tool names list contains expected count", () => {
-    expect(eagerModuleToolNames.length).toBe(12);
+    expect(eagerModuleToolNames.length).toBe(11);
   });
 
   test("explicit tools list includes memory tools", () => {