@vellumai/assistant 0.8.5 → 0.8.6

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

@@ -31,10 +31,7 @@ mock.module("../security/secure-keys.js", () => ({
   getSecureKeyAsync: getSecureKeyAsyncMock,
 }));
 
-import {
-  _setOverridesForTesting,
-  clearFeatureFlagOverridesCache,
-} from "../config/assistant-feature-flags.js";
+import { clearFeatureFlagOverridesCache } from "../config/assistant-feature-flags.js";
 import type { AssistantConfig } from "../config/schema.js";
 import {
   bootstrapPlugins,
@@ -54,6 +51,7 @@ import {
   PluginExecutionError,
   type PluginInitContext,
 } from "../plugins/types.js";
+import { setOverridesForTesting } from "./feature-flag-test-helpers.js";
 
 // Redirect plugin storage directory creation into a per-process temp tree so
 // the test doesn't touch the developer's real ~/.vellum.
@@ -125,7 +123,7 @@ describe("plugin bootstrap", () => {
     getSecureKeyAsyncMock.mockReset();
     getSecureKeyAsyncMock.mockImplementation(async () => undefined);
     // Reset feature-flag cache so tests start from a known state. Individual
-    // tests that exercise `requiresFlag` use `_setOverridesForTesting(...)`
+    // tests that exercise `requiresFlag` use `setOverridesForTesting(...)`
     // to install their own overrides.
     clearFeatureFlagOverridesCache();
     // Clean storage directory between runs so nothing leaks across cases.
@@ -335,11 +333,11 @@ describe("plugin bootstrap", () => {
   //   - no shutdown hook entry is installed (nothing to tear down later).
   // Plugins without `requiresFlag` are unaffected.
   //
-  // Uses `_setOverridesForTesting` to control the resolver deterministically
+  // Uses `setOverridesForTesting` to control the resolver deterministically
   // — no disk writes, no gateway IPC, no reliance on registry defaults.
 
   test("requiresFlag enabled: plugin inits normally", async () => {
-    _setOverridesForTesting({ "plugin-gated-enabled": true });
+    setOverridesForTesting({ "plugin-gated-enabled": true });
 
     let initFired = false;
     const plugin = buildPlugin(
@@ -359,7 +357,7 @@ describe("plugin bootstrap", () => {
   });
 
   test("requiresFlag disabled: init does not fire and no tools/routes/skills are registered", async () => {
-    _setOverridesForTesting({ "plugin-gated-disabled": false });
+    setOverridesForTesting({ "plugin-gated-disabled": false });
 
     let initFired = false;
     // Attach tool/route/skill contributions alongside init. If gating works,
@@ -440,7 +438,7 @@ describe("plugin bootstrap", () => {
   test("requiresFlag: one disabled flag out of several skips the plugin", async () => {
     // When ANY listed flag is disabled, the plugin is skipped wholesale —
     // this prevents sneaky partial activation on AND semantics.
-    _setOverridesForTesting({
+    setOverridesForTesting({
       "plugin-multi-a": true,
       "plugin-multi-b": false,
     });
@@ -469,7 +467,7 @@ describe("plugin bootstrap", () => {
     // injectors still ran on every pipeline invocation and system-prompt
     // assembly even though `init()` had never fired to set up the state they
     // depended on.
-    _setOverridesForTesting({ "plugin-middleware-disabled": false });
+    setOverridesForTesting({ "plugin-middleware-disabled": false });
 
     const gatedMiddleware: PipelineMiddlewareMap["llmCall"] = async (
       args,
@@ -506,7 +504,7 @@ describe("plugin bootstrap", () => {
   });
 
   test("requiresFlag disabled: no shutdown hook entry installed for the skipped plugin", async () => {
-    _setOverridesForTesting({ "plugin-shutdown-flag": false });
+    setOverridesForTesting({ "plugin-shutdown-flag": false });
 
     let shutdownFired = false;
     const plugin = buildPlugin(

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

@@ -6,9 +6,11 @@
  *
  * - Registering a plugin with `tools: Tool[]`, running `bootstrapPlugins`,
  *   and observing the contributed tool via `getAllTools()` / `getTool()`.
- * - Tool ownership metadata (`origin: "plugin"`, `ownerPluginId: <plugin>`)
- *   stamped authoritatively by `registerPluginTools` regardless of what the
- *   plugin author set on the incoming object.
+ * - Tool ownership (`owner: { kind: "plugin", id: <plugin> }`) recorded
+ *   authoritatively by `registerPluginTools` into the registry's
+ *   `ownersByName` map (queried via `getToolOwner(name)`), regardless of
+ *   what the plugin author set on the incoming object. The `Tool` itself
+ *   carries no ownership field — the bootstrap is the only writer.
  * - Shutdown hook unregistering the contributed tools so the registry is
  *   clean again after teardown.
  * - Direct `registerPluginTools` / `unregisterPluginTools` semantics,
@@ -55,6 +57,7 @@ import {
   getAllTools,
   getPluginRefCount,
   getTool,
+  getToolOwner,
   registerPluginTools,
   unregisterPluginTools,
 } from "../tools/registry.js";
@@ -164,13 +167,17 @@ describe("plugin tool contributions", () => {
 
     const retrieved = getTool("plugin-contrib-tool");
     expect(retrieved).toBeDefined();
-    // Ownership metadata must be stamped authoritatively by the bootstrap —
-    // the registry uses it to drive ref-counting and conflict detection when
-    // the plugin shuts down or is hot-reloaded. Plugin tools live in their
-    // own `origin: "plugin"` namespace, disjoint from real skills, so a
-    // plugin name that happens to match a skill id cannot collide.
-    expect(retrieved?.origin).toBe("plugin");
-    expect(retrieved?.ownerPluginId).toBe("alpha-contributor");
+    // Ownership is recorded authoritatively by the bootstrap into the
+    // registry's `ownersByName` map (keyed by tool name, accessed via
+    // `getToolOwner(name)`) — the registry uses it to drive ref-counting
+    // and conflict detection when the plugin shuts down or is hot-reloaded.
+    // Plugin tools live in their own namespace, disjoint from real skills,
+    // so a plugin name that happens to match a skill id cannot collide.
+    // Ownership is not stamped on the `Tool` object itself.
+    expect(getToolOwner("plugin-contrib-tool")).toEqual({
+      kind: "plugin",
+      id: "alpha-contributor",
+    });
 
     // The tool surfaces in the global `getAllTools()` snapshot, which is
     // what downstream consumers (tool-manifest, session projection) read.
@@ -248,22 +255,23 @@ describe("registerPluginTools / unregisterPluginTools helpers", () => {
     __resetRegistryForTesting();
   });
 
-  test("registerPluginTools stamps category, origin, and ownerPluginId from the plugin name", () => {
-    // Even if the plugin author hands in a tool with no category or ownership
-    // metadata, the helper fills it in so the tool can be registered and
-    // unregistered consistently.
+  test("registerPluginTools stamps category and records ownership in the registry", () => {
+    // Even if the plugin author hands in a tool with no category, the
+    // helper fills it in and records ownership in the registry's
+    // `ownersByName` map — the tool itself never carries an `owner` field,
+    // so plugin authors can't spoof ownership by forging one.
     const accepted = registerPluginTools("my-plugin", [
       makeFakeTool("pt_stamped"),
     ]);
     expect(accepted).toHaveLength(1);
     expect(accepted[0]?.category).toBe("plugin");
-    expect(accepted[0]?.origin).toBe("plugin");
-    expect(accepted[0]?.ownerPluginId).toBe("my-plugin");
+    expect(getToolOwner("pt_stamped")).toEqual({
+      kind: "plugin",
+      id: "my-plugin",
+    });
 
     const retrieved = getTool("pt_stamped");
     expect(retrieved?.category).toBe("plugin");
-    expect(retrieved?.origin).toBe("plugin");
-    expect(retrieved?.ownerPluginId).toBe("my-plugin");
   });
 
   test("registerPluginTools exposes provider-safe aliases for unsafe plugin tool names", async () => {
@@ -313,33 +321,28 @@ describe("registerPluginTools / unregisterPluginTools helpers", () => {
     expect(getTool(paddedAlias!)).toBeDefined();
   });
 
-  test("registerPluginTools overwrites any pre-existing ownership metadata", () => {
+  test("registerPluginTools ignores forged ownership fields on the incoming tool", () => {
     // A plugin author could (maliciously or mistakenly) hand in a tool
-    // pre-tagged with another skill's or plugin's ID. The helper must
-    // overwrite it so the bootstrap is always the source of truth for
-    // ownership — and it must clear cross-origin fields (ownerSkillId /
-    // ownerMcpServerId / ownerSkillBundled / ownerSkillVersionHash) so the
-    // stamped tool cannot leak across namespaces or spoof bundled-skill
-    // auto-allow.
+    // pre-tagged with another skill's or plugin's ID. The `Tool` type now
+    // carries no ownership field at all, so any such forgery is purely
+    // inert extra data — the registry only populates `ownersByName` from
+    // the first argument to `register*Tools`, which is the single source
+    // of truth for ownership and cannot be spoofed by forging fields on
+    // the manifest.
     //
-    // The narrow `ToolDefinition` shape doesn't expose these ownership
-    // fields, so the cast through `unknown` simulates a hostile or
-    // transpiled artifact that arrives with spoofed fields baked in —
-    // the bootstrap-side defense is the second layer that must hold.
+    // Cast through `unknown` to simulate a hostile or transpiled artifact
+    // arriving with extra fields baked in.
     const spoofed = {
       ...makeFakeTool("pt_spoof"),
       origin: "skill",
-      ownerSkillId: "some-other-skill",
-      ownerSkillBundled: true,
-      ownerSkillVersionHash: "deadbeef",
+      owner: { kind: "skill", id: "some-other-skill" },
     } as unknown as LoadedTool;
     registerPluginTools("my-plugin", [spoofed]);
-    const retrieved = getTool("pt_spoof");
-    expect(retrieved?.origin).toBe("plugin");
-    expect(retrieved?.ownerPluginId).toBe("my-plugin");
-    expect(retrieved?.ownerSkillId).toBeUndefined();
-    expect(retrieved?.ownerSkillBundled).toBeUndefined();
-    expect(retrieved?.ownerSkillVersionHash).toBeUndefined();
+    expect(getTool("pt_spoof")).toBeDefined();
+    expect(getToolOwner("pt_spoof")).toEqual({
+      kind: "plugin",
+      id: "my-plugin",
+    });
   });
 
   test("unregisterPluginTools removes the plugin's tools", () => {

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

@@ -24,6 +24,7 @@ mock.module("../memory/conversation-crud.js", () => ({
   provenanceFromTrustContext: () => ({}),
   setConversationOriginChannelIfUnset: () => {},
   setConversationOriginInterfaceIfUnset: () => {},
+  reserveMessage: mock(async () => ({ id: "msg-reserve" })),
 }));
 
 mock.module("../memory/conversation-disk-view.js", () => ({
@@ -84,12 +85,14 @@ type Deferred<T> = {
 };
 type PersistUserMessageMock = ReturnType<
   typeof mock<
-    (
-      content: string,
-      attachments: unknown[],
-      requestId?: string,
-      metadata?: Record<string, unknown>,
-    ) => Promise<string>
+    (options: {
+      content: string;
+      attachments?: unknown[];
+      requestId?: string;
+      metadata?: Record<string, unknown>;
+      displayContent?: string;
+      clientMessageId?: string;
+    }) => Promise<{ id: string; deduplicated: boolean }>
   >
 >;
 type RunAgentLoopMock = ReturnType<
@@ -209,12 +212,14 @@ function makeConversation(): TestConversation {
       estimatedCost: 0,
     },
     persistUserMessage: mock(
-      async (
-        _content: string,
-        _attachments: unknown[],
-        _requestId?: string,
-        _metadata?: Record<string, unknown>,
-      ) => "persisted-user-message-id",
+      async (_options: {
+        content: string;
+        attachments?: unknown[];
+        requestId?: string;
+        metadata?: Record<string, unknown>;
+        displayContent?: string;
+        clientMessageId?: string;
+      }) => ({ id: "persisted-user-message-id", deduplicated: false }),
     ),
     runAgentLoop: mock(async (..._args: unknown[]) => {
       await loopDeferred.promise;
@@ -259,9 +264,9 @@ describe("processMessageInBackground Slack option propagation", () => {
 
     expect(result).toEqual({ messageId: "persisted-user-message-id" });
     expect(activeConversation.persistUserMessage).toHaveBeenCalledTimes(1);
-    expect(activeConversation.persistUserMessage.mock.calls[0][3]).toEqual({
-      slackInbound,
-    });
+    expect(
+      activeConversation.persistUserMessage.mock.calls[0][0].metadata,
+    ).toEqual({ slackInbound });
     expect(activeConversation.runAgentLoop).toHaveBeenCalledTimes(1);
 
     activeConversation.__loopDeferred.resolve();
@@ -324,7 +329,7 @@ describe("processMessageInBackground Slack option propagation", () => {
 
     expect(activeConversation.persistUserMessage).toHaveBeenCalledTimes(1);
     expect(
-      activeConversation.persistUserMessage.mock.calls[0][3],
+      activeConversation.persistUserMessage.mock.calls[0][0].metadata,
     ).toBeUndefined();
     expect(activeConversation.runAgentLoop.mock.calls[0][3]).toEqual({
       isInteractive: false,

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

@@ -50,6 +50,7 @@ mock.module("../memory/conversation-crud.js", () => ({
   provenanceFromTrustContext: () => ({}),
   setConversationOriginChannelIfUnset: () => {},
   setConversationOriginInterfaceIfUnset: () => {},
+  reserveMessage: mock(async () => ({ id: "msg-reserve" })),
 }));
 
 mock.module("../memory/conversation-disk-view.js", () => ({
@@ -181,21 +182,18 @@ function makeTestConversation() {
     getTurnChannelContext: () => turnChannelContext,
     getTurnInterfaceContext: () => turnInterfaceContext,
     getMessages: () => messages,
-    persistUserMessage: async (
-      content: string,
-      attachments: UserMessageAttachment[],
-      requestId?: string,
-      metadata?: Record<string, unknown>,
-      displayContent?: string,
-    ) =>
-      persistQueuedMessageBody(
-        messagingCtx,
-        content,
-        attachments,
-        requestId ?? "req-display-content",
-        metadata,
-        displayContent,
-      ),
+    persistUserMessage: async (options: {
+      content: string;
+      attachments?: UserMessageAttachment[];
+      requestId?: string;
+      metadata?: Record<string, unknown>;
+      displayContent?: string;
+      clientMessageId?: string;
+    }) =>
+      persistQueuedMessageBody(messagingCtx, {
+        ...options,
+        requestId: options.requestId ?? "req-display-content",
+      }),
     runAgentLoop,
     updateClient: () => {},
     getCurrentSender: () => undefined,
@@ -340,9 +338,9 @@ describe("processMessage displayContent", () => {
     const modelContent =
       '<external_content source="slack">\n\n</external_content>';
 
-    await conversation.persistUserMessage(
-      modelContent,
-      [
+    await conversation.persistUserMessage({
+      content: modelContent,
+      attachments: [
         {
           id: "att-1",
           filename: "attachment.pdf",
@@ -350,10 +348,9 @@ describe("processMessage displayContent", () => {
           data: Buffer.from("pdf bytes").toString("base64"),
         },
       ],
-      "req-display-content",
-      undefined,
-      "",
-    );
+      requestId: "req-display-content",
+      displayContent: "",
+    });
 
     expect(addMessageCalls).toHaveLength(1);
     const persistedBlocks = JSON.parse(addMessageCalls[0]!.content);

package/src/__tests__/provider-catalog-visibility.test.ts

@@ -1,16 +1,16 @@
 import { afterEach, beforeEach, describe, expect, test } from "bun:test";
 
-import { _setOverridesForTesting } from "../config/assistant-feature-flags.js";
 import type { AssistantConfig } from "../config/schema.js";
 import { PROVIDER_CATALOG } from "../providers/model-catalog.js";
 import { getVisibleProviderCatalog } from "../providers/provider-catalog-visibility.js";
+import { setOverridesForTesting } from "./feature-flag-test-helpers.js";
 
 beforeEach(() => {
-  _setOverridesForTesting({});
+  setOverridesForTesting({});
 });
 
 afterEach(() => {
-  _setOverridesForTesting({});
+  setOverridesForTesting({});
 });
 
 /** Minimal AssistantConfig stub for feature-flag resolution. */
@@ -20,7 +20,7 @@ function makeConfig(): AssistantConfig {
 
 describe("getVisibleProviderCatalog", () => {
   test("hides openai-compatible endpoints by default", () => {
-    _setOverridesForTesting({});
+    setOverridesForTesting({});
 
     const visible = getVisibleProviderCatalog(makeConfig());
 
@@ -28,7 +28,7 @@ describe("getVisibleProviderCatalog", () => {
   });
 
   test("shows openai-compatible endpoints when its flag is enabled", () => {
-    _setOverridesForTesting({ "openai-compatible-endpoints": true });
+    setOverridesForTesting({ "openai-compatible-endpoints": true });
 
     const visible = getVisibleProviderCatalog(makeConfig());
 
@@ -43,7 +43,7 @@ describe("getVisibleProviderCatalog", () => {
         if (model.featureFlag) allFlags[model.featureFlag] = true;
       }
     }
-    _setOverridesForTesting(allFlags);
+    setOverridesForTesting(allFlags);
 
     const visible = getVisibleProviderCatalog(makeConfig());
     expect(visible.length).toBe(PROVIDER_CATALOG.length);
@@ -58,7 +58,7 @@ describe("getVisibleProviderCatalog", () => {
         if (model.featureFlag) allFlags[model.featureFlag] = true;
       }
     }
-    _setOverridesForTesting({ ...allFlags, "test-provider-flag": false });
+    setOverridesForTesting({ ...allFlags, "test-provider-flag": false });
 
     const original = [...PROVIDER_CATALOG];
     PROVIDER_CATALOG.push({
@@ -87,7 +87,7 @@ describe("getVisibleProviderCatalog", () => {
   });
 
   test("hides a model whose featureFlag is disabled but keeps the provider", () => {
-    _setOverridesForTesting({ "test-model-flag": false });
+    setOverridesForTesting({ "test-model-flag": false });
 
     const original = [...PROVIDER_CATALOG];
     PROVIDER_CATALOG.push({
@@ -121,7 +121,7 @@ describe("getVisibleProviderCatalog", () => {
   });
 
   test("hides a provider entirely when all its models are flagged off", () => {
-    _setOverridesForTesting({
+    setOverridesForTesting({
       "flag-a": false,
       "flag-b": false,
     });