@vellumai/assistant 0.11.3 → 0.11.4-dev.202608190019.b94dbf2

package/src/__tests__/plugin-api-webhook-url.test.ts

@@ -26,7 +26,7 @@ describe("resolveWebhookUrl", () => {
     });
 
     expect(url).toBe(
-      "https://callbacks.vellum.ai/abc/webhooks/plugins/imessage/events-photon",
+      "https://callbacks.vellum.ai/abc/webhooks/plugins/imessage/events-photon/",
     );
     expect(spy.mock.calls[0]![1]).toBe(
       "webhooks/plugins/imessage/events-photon",
@@ -124,10 +124,10 @@ describe("resolveWebhookUrl", () => {
     }
   });
 
-  test("hands the vendor a URL with no trailing slash", async () => {
-    // The platform appends one, and a provider delivers to the URL it was
-    // given verbatim. The gateway matches the declared path, which never ends
-    // in a slash, so a registration carrying one 404s every delivery.
+  test("hands the vendor a URL with a trailing slash", async () => {
+    // Django in front of managed callbacks canonicalizes onto `/`. A vendor
+    // given the slashless spelling is 301'd, and clients that follow a 301
+    // on POST typically retry as GET and drop the body.
     const spy = spyOn(registration, "resolveCallbackUrl").mockResolvedValue(
       "https://callbacks.vellum.ai/abc/webhooks/plugins/imessage/events-comms/",
     );
@@ -135,13 +135,16 @@ describe("resolveWebhookUrl", () => {
     await expect(
       resolveWebhookUrl({ plugin: "imessage", path: "events-comms" }),
     ).resolves.toBe(
-      "https://callbacks.vellum.ai/abc/webhooks/plugins/imessage/events-comms",
+      "https://callbacks.vellum.ai/abc/webhooks/plugins/imessage/events-comms/",
+    );
+    expect(spy.mock.calls[0]![1]).toBe(
+      "webhooks/plugins/imessage/events-comms",
     );
     spy.mockRestore();
   });
 
   test("leaves a URL carrying a query string alone", async () => {
-    // Trimming there would cut into the query rather than the path.
+    // Appending there would cut into the query rather than the path.
     const spy = spyOn(registration, "resolveCallbackUrl").mockResolvedValue(
       "https://example.test/webhooks/plugins/imessage/events-comms?token=abc/",
     );

package/src/__tests__/plugin-disabled-state.test.ts

@@ -22,6 +22,7 @@ import {
   getRegisteredInjectors,
   registerPluginInjectors,
 } from "../plugins/injector-registry.js";
+import { resetPluginCacheForTests } from "../plugins/mtime-cache.js";
 import {
   registerPlugin,
   resetPluginRegistryForTests,
@@ -85,6 +86,7 @@ function makeFakeTool(name: string): Tool {
 
 beforeEach(() => {
   resetPluginRegistryForTests();
+  resetPluginCacheForTests();
   clearInjectorRegistry();
 });
 

package/src/__tests__/plugin-effective-enabled-set.test.ts

@@ -8,14 +8,18 @@
  * non-null Set is an allowlist, `null` means no restriction. This suite locks
  * the contract that the hook gather sites honor it:
  *  - `getHooksFor(name, { conversationId })` resolves the conversation's scope
- *    and excludes in-process default-plugin hooks outside it; omitting the
+ *    and excludes user-plugin hooks outside it. First-party default plugins
+ *    always remain (they are core runtime, not per-chat toggles). Omitting the
  *    conversationId imposes no restriction.
+ *  - `getUserHooksFor` returns those same in-process default-plugin hooks
+ *    (plus user-land hooks), not only filesystem plugins.
  *  - `collectUserHookEntries(name, dirs, set)` excludes user-land plugin hooks
  *    outside the set, while standalone workspace hooks (not owned by a plugin)
  *    still run.
  *
  * The per-chat scope layers on top of (does not replace) the global
- * `.disabled` sentinel check — a plugin excluded by either is excluded.
+ * `.disabled` sentinel check. A user plugin excluded by either is excluded.
+ * A first-party default plugin is excluded only by `.disabled`.
  * Injectors are intentionally NOT per-chat scoped (see
  * `getRegisteredInjectors`): they run inside already-scoped plugin hooks, and
  * every injector-contributing plugin is a first-party default.
@@ -39,7 +43,8 @@ import {
   collectUserHookEntries,
   resetHookCacheForTests,
 } from "../hooks/hook-loader.js";
-import { getHooksFor } from "../hooks/registry.js";
+import { getHooksFor, getUserHooksFor } from "../hooks/registry.js";
+import { resetPluginCacheForTests } from "../plugins/mtime-cache.js";
 import {
   registerPlugin,
   resetPluginRegistryForTests,
@@ -66,6 +71,7 @@ function buildPlugin(
 describe("getHooksFor per-chat plugin scope (in-process default hooks)", () => {
   beforeEach(() => {
     resetPluginRegistryForTests();
+    resetPluginCacheForTests();
     resolveScopeMock.mockReset();
     resolveScopeMock.mockImplementation(() => null);
   });
@@ -136,6 +142,52 @@ describe("getHooksFor per-chat plugin scope (in-process default hooks)", () => {
       await getHooksFor("user-prompt-submit", { conversationId: "c1" }),
     ).toHaveLength(0);
   });
+
+  test("getUserHooksFor returns in-process default plugin hooks", async () => {
+    registerPlugin(
+      buildPlugin("default-memory", {
+        "user-prompt-submit": () => Promise.resolve(),
+      }),
+    );
+    expect(await getUserHooksFor("user-prompt-submit")).toHaveLength(1);
+  });
+
+  test("a first-party default plugin's hooks run even when the chat scope omits it", async () => {
+    let ran = 0;
+    registerPlugin(
+      buildPlugin("default-memory", {
+        "user-prompt-submit": () => {
+          ran++;
+          return Promise.resolve();
+        },
+      }),
+    );
+    resolveScopeMock.mockImplementation(() => new Set(["user-a"]));
+
+    const hooks = await getHooksFor("user-prompt-submit", {
+      conversationId: "c1",
+    });
+    expect(hooks).toHaveLength(1);
+    await hooks[0]!({});
+    expect(ran).toBe(1);
+  });
+
+  test("a workspace-disabled first-party default is still excluded", async () => {
+    registerPlugin(
+      buildPlugin("default-memory", {
+        "user-prompt-submit": () => Promise.resolve(),
+      }),
+    );
+    const dir = join(getWorkspacePluginsDir(), "default-memory");
+    mkdirSync(dir, { recursive: true });
+    writeFileSync(join(dir, ".disabled"), "");
+    try {
+      expect(await getHooksFor("user-prompt-submit")).toHaveLength(0);
+      expect(await getUserHooksFor("user-prompt-submit")).toHaveLength(0);
+    } finally {
+      rmSync(dir, { recursive: true, force: true });
+    }
+  });
 });
 
 describe("collectUserHookEntries per-chat plugin scope (user-land hooks)", () => {

package/src/__tests__/plugin-execution-context.test.ts

@@ -0,0 +1,73 @@
+import { describe, expect, test } from "bun:test";
+
+import {
+  getCurrentPluginName,
+  runInPluginContext,
+  runOutsidePluginContext,
+} from "../plugins/plugin-execution-context.js";
+
+describe("plugin execution context", () => {
+  test("reports no plugin outside any context", () => {
+    expect(getCurrentPluginName()).toBeUndefined();
+  });
+
+  test("marks the plugin for the duration of the call", () => {
+    const seen = runInPluginContext("acme", () => getCurrentPluginName());
+    expect(seen).toBe("acme");
+    expect(getCurrentPluginName()).toBeUndefined();
+  });
+
+  test("carries across await boundaries", async () => {
+    const seen = await runInPluginContext("acme", async () => {
+      await Promise.resolve();
+      return getCurrentPluginName();
+    });
+    expect(seen).toBe("acme");
+  });
+
+  test("the innermost plugin wins when contexts nest", () => {
+    const seen = runInPluginContext("outer", () =>
+      runInPluginContext("inner", () => getCurrentPluginName()),
+    );
+    expect(seen).toBe("inner");
+  });
+
+  describe("runOutsidePluginContext", () => {
+    // Host code reached from a plugin (a default tool run during a turn a
+    // plugin route started) is not the plugin's code and must not borrow its
+    // identity, or a scoped API would attribute that work to the plugin.
+    test("clears a surrounding plugin context", () => {
+      const seen = runInPluginContext("acme", () =>
+        runOutsidePluginContext(() => getCurrentPluginName()),
+      );
+      expect(seen).toBeUndefined();
+    });
+
+    test("keeps the context cleared across await boundaries", async () => {
+      const seen = await runInPluginContext("acme", () =>
+        runOutsidePluginContext(async () => {
+          await Promise.resolve();
+          return getCurrentPluginName();
+        }),
+      );
+      expect(seen).toBeUndefined();
+    });
+
+    test("restores the plugin context for work after it", () => {
+      const seen = runInPluginContext("acme", () => {
+        runOutsidePluginContext(() => getCurrentPluginName());
+        return getCurrentPluginName();
+      });
+      expect(seen).toBe("acme");
+    });
+
+    test("a plugin context inside it scopes to the inner plugin", () => {
+      const seen = runInPluginContext("acme", () =>
+        runOutsidePluginContext(() =>
+          runInPluginContext("other", () => getCurrentPluginName()),
+        ),
+      );
+      expect(seen).toBe("other");
+    });
+  });
+});

package/src/__tests__/plugin-import-boundary-guard.test.ts

@@ -99,7 +99,6 @@ const BASELINE: Record<string, readonly string[]> = {
     "../../../../../security/untrusted-content.js",
     "../../../../api/events/memory-recalled.js",
     "../../../../api/responses/memory-v3-selection-log.js",
-    "../../../../channels/types.js",
     "../../../../config/assistant-feature-flags.js",
     "../../../../config/default-profile-catalog.js",
     "../../../../config/loader.js",
@@ -234,6 +233,11 @@ const BASELINE: Record<string, readonly string[]> = {
     "../../../util/worker-memory.js",
     "../../../util/worker-process.js",
     "../../types.js",
+    // The memory jobs worker runs as its own OS process and hosts real agent
+    // conversations, so it registers the host's default-plugin hook and
+    // injector surface at startup (hooks only, no init hooks). Host-owned
+    // composition with no plugin-api equivalent.
+    "../../worker-plugin-surface.js",
     "../injection-presence.js",
     "../injector-order.js",
     "@qdrant/js-client-rest",

package/src/__tests__/plugin-import-boundary-reverse-guard.test.ts

@@ -22,6 +22,7 @@ import { Glob } from "bun";
  *     barrel. Bundled defaults are compiled into the daemon, so the barrel is
  *     their loading mechanism: the in-process analog of loading an external
  *     plugin from its manifest.
+ *   - `src/plugins/defaults/worker-entrypoints.ts`, the compiled sidecar loader.
  *   - Imports of modules directly under `defaults/` (e.g.
  *     `injector-order.js`) — those are host-level shared modules, not plugin
  *     internals.
@@ -47,8 +48,11 @@ import { Glob } from "bun";
 const DEFAULTS_REL = join("src", "plugins", "defaults");
 const DEFAULTS_ABS = join(process.cwd(), DEFAULTS_REL);
 
-/** The bundled-plugin registration barrel — the sanctioned host→plugin edge. */
-const COMPOSITION_ROOT = join(DEFAULTS_REL, "index.ts");
+/** Bundled-plugin composition roots allowed to load plugin internals. */
+const COMPOSITION_ROOTS = new Set([
+  join(DEFAULTS_REL, "index.ts"),
+  join(DEFAULTS_REL, "worker-entrypoints.ts"),
+]);
 
 /**
  * Allowed host→plugin reaches: plugin name → sorted list of host files (paths
@@ -95,7 +99,6 @@ const BASELINE: Record<string, readonly string[]> = {
     "src/daemon/handlers/skills.ts",
     "src/daemon/skill-memory-refresh.ts",
     "src/daemon/tool-side-effects.ts",
-    "src/daemon/trust-context.ts",
     "src/home/feed-source-enrichment.ts",
     "src/permissions/checker.ts",
     "src/persistence/conversation-crud.ts",
@@ -151,7 +154,7 @@ function collectHostFiles(): HostFile[] {
       if (norm.split(sep).includes("__tests__")) {
         continue;
       }
-      if (norm === COMPOSITION_ROOT) {
+      if (COMPOSITION_ROOTS.has(norm)) {
         continue;
       }
       // A file at least two segments below defaults/ belongs to a plugin —

package/src/__tests__/plugin-secret-pattern-contribution.test.ts

@@ -34,8 +34,8 @@ import {
 } from "bun:test";
 
 import { bootstrapPlugins } from "../daemon/external-plugins-bootstrap.js";
+import { getUserHooksFor } from "../hooks/registry.js";
 import {
-  getUserHooksFor,
   populateCacheAtBoot,
   reconcilePluginSourcesNow,
   resetPluginCacheForTests,

package/src/__tests__/post-compaction-reinjection-idempotency.test.ts

@@ -20,6 +20,7 @@ import { applyRuntimeInjections } from "../daemon/conversation-runtime-assembly.
 import { registerDefaultPluginInjectors } from "../plugins/defaults/index.js";
 import { stripTailInjectionsForReinjection } from "../plugins/defaults/memory/tail-reinjection-strip.js";
 import type { Message } from "../providers/types.js";
+import { asConversation } from "./helpers/mock-conversation.js";
 
 // Populate the injector registry with the default plugins' injectors the way
 // bootstrap does in production, so `applyRuntimeInjections` walks a non-empty
@@ -160,13 +161,19 @@ describe("applyRuntimeInjections re-injection idempotency", () => {
   // a frozen temporal snapshot so the non-presence-gated `<turn_context>` block
   // is produced every assembly.
   function seedConversation(): void {
-    setConversation(FALLBACK_CONVERSATION_ID, {
-      conversationId: FALLBACK_CONVERSATION_ID,
-      workingDir: "/sandbox",
-      workspaceTopLevelContext: WORKSPACE_BLOCK,
-      workspaceTopLevelDirty: false,
-      currentTurnTemporalSnapshot: { clientTimezone: null },
-    } as never);
+    setConversation(
+      FALLBACK_CONVERSATION_ID,
+      asConversation({
+        conversationId: FALLBACK_CONVERSATION_ID,
+        workingDir: "/sandbox",
+        workspaceTopLevelContext: WORKSPACE_BLOCK,
+        workspaceTopLevelDirty: false,
+        currentTurnTemporalSnapshot: {
+          clientTimezone: null,
+          timeSinceLastMessage: null,
+        },
+      }),
+    );
   }
 
   afterEach(() => {

package/src/__tests__/provider-commit-message-generator.test.ts

@@ -62,6 +62,7 @@ const mockProvider: Provider = {
 let resolvedProvider: {
   provider: Provider;
   configuredProviderName: string;
+  entryRouted?: boolean;
 } | null = {
   provider: mockProvider,
   configuredProviderName: "anthropic",
@@ -352,4 +353,23 @@ describe("ProviderCommitMessageGenerator", () => {
     expect(result.source).toBe("llm");
     expect(result.message).toBe(commitMsg);
   });
+
+  // 14. Entry-routed profile — the row's own credential signed resolution,
+  // so no generic per-vendor key needs to exist for the preflight to pass.
+  test("entry-routed result — skips the vendor API-key preflight", async () => {
+    mockSecureKeys = {};
+    resolvedProvider = {
+      provider: mockProvider,
+      configuredProviderName: "anthropic",
+      entryRouted: true,
+    };
+    const commitMsg = "fix: entry-route commit";
+    mockSendMessage.mockResolvedValueOnce(makeSuccessResponse(commitMsg));
+    const gen = getCommitMessageGenerator();
+    const result = await gen.generateCommitMessage(baseContext, {
+      changedFiles: baseContext.changedFiles,
+    });
+    expect(result.source).toBe("llm");
+    expect(result.message).toBe(commitMsg);
+  });
 });

package/src/__tests__/proxy-approval-callback.test.ts

@@ -34,6 +34,7 @@ function makeContext(overrides?: Partial<Conversation>): Conversation {
     workingDir: "/tmp/test-project",
     abortController: null,
     sendToClient: () => {},
+    emit: () => {},
     surfacesByAppId: new Map(),
     ...overrides,
   } as unknown as Conversation;

package/src/__tests__/qdrant-manager.test.ts

@@ -20,7 +20,10 @@ import {
 
 const testDataDir = process.env.VELLUM_WORKSPACE_DIR!;
 
-import { QdrantManager } from "../persistence/embeddings/qdrant-manager.js";
+import {
+  QdrantManager,
+  resolveQdrantReleaseAsset,
+} from "../persistence/embeddings/qdrant-manager.js";
 
 /**
  * Short timeouts so tests complete fast but with enough headroom for CI and
@@ -96,6 +99,16 @@ describe("QdrantManager", () => {
     });
   });
 
+  test("selects the pinned Windows x64 zip release", () => {
+    expect(resolveQdrantReleaseAsset("win32", "x64")).toEqual({
+      binaryName: "qdrant.exe",
+      filename: "qdrant-x86_64-pc-windows-msvc.zip",
+      format: "zip",
+      sha256:
+        "9d3b1d1fa58566bc71709347c4c9b83a0111d23a550daa93c3ee48e3150c4470",
+    });
+  });
+
   // ── getUrl ───────────────────────────────────────────────────
 
   describe("getUrl", () => {