@vellumai/assistant 0.8.5 → 0.8.7-dev.202606052118.34cd356

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,
@@ -37,11 +39,7 @@ mock.module("../security/secure-keys.js", () => ({
   getSecureKeyAsync: getSecureKeyAsyncMock,
 }));
 
-import type { AssistantConfig } from "../config/schema.js";
-import {
-  bootstrapPlugins,
-  type DaemonContext,
-} from "../daemon/external-plugins-bootstrap.js";
+import { bootstrapPlugins } from "../daemon/external-plugins-bootstrap.js";
 import { runShutdownHooks } from "../daemon/shutdown-registry.js";
 import { RiskLevel } from "../permissions/types.js";
 import {
@@ -55,14 +53,11 @@ import {
   getAllTools,
   getPluginRefCount,
   getTool,
+  getToolOwner,
   registerPluginTools,
   unregisterPluginTools,
 } from "../tools/registry.js";
-import type {
-  LoadedTool,
-  ToolContext,
-  ToolExecutionResult,
-} from "../tools/types.js";
+import type { Tool, ToolContext, ToolExecutionResult } from "../tools/types.js";
 
 // Redirect plugin-storage-directory creation into a per-process temp tree so
 // the test doesn't touch the developer's real ~/.vellum. This matches the
@@ -73,22 +68,14 @@ const TEST_WORKSPACE_DIR = join(
 );
 process.env.VELLUM_WORKSPACE_DIR = TEST_WORKSPACE_DIR;
 
-const fakeConfig = {} as unknown as AssistantConfig;
-const fakeCtx: DaemonContext = {
-  config: fakeConfig,
-  assistantVersion: "9.9.9-test",
-};
-
-function makeFakeTool(
-  name: string,
-  extras: Partial<LoadedTool> = {},
-): LoadedTool {
+function makeFakeTool(name: string, extras: Partial<Tool> = {}): Tool {
   return {
     name,
     description: `Fake ${name}`,
     defaultRiskLevel: RiskLevel.Low,
     executionTarget: "sandbox",
     input_schema: { type: "object", properties: {}, required: [] },
+    category: "",
     async execute(
       _input: Record<string, unknown>,
       _context: ToolContext,
@@ -160,17 +147,21 @@ describe("plugin tool contributions", () => {
     });
     registerPlugin(plugin);
 
-    await bootstrapPlugins(fakeCtx);
+    await bootstrapPlugins();
 
     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.
@@ -185,7 +176,7 @@ describe("plugin tool contributions", () => {
     });
     registerPlugin(plugin);
 
-    await bootstrapPlugins(fakeCtx);
+    await bootstrapPlugins();
     expect(getTool("bravo-tool")).toBeDefined();
 
     await runShutdownHooks("test-shutdown");
@@ -198,7 +189,7 @@ describe("plugin tool contributions", () => {
     const plugin = buildPlugin("no-tools", { async init() {} });
     registerPlugin(plugin);
 
-    await bootstrapPlugins(fakeCtx);
+    await bootstrapPlugins();
     // No tool should have been registered.
     expect(getAllTools()).toHaveLength(0);
 
@@ -222,7 +213,7 @@ describe("plugin tool contributions", () => {
 
     expect(getTool("charlie-tool")).toBeUndefined();
 
-    await bootstrapPlugins(fakeCtx);
+    await bootstrapPlugins();
     expect(getTool("charlie-tool")).toBeDefined();
   });
 
@@ -238,7 +229,7 @@ describe("plugin tool contributions", () => {
     });
     registerPlugin(plugin);
 
-    await expect(bootstrapPlugins(fakeCtx)).rejects.toThrow(/delta-broken/);
+    await expect(bootstrapPlugins()).rejects.toThrow(/delta-broken/);
     expect(getTool("delta-tool")).toBeUndefined();
   });
 });
@@ -248,22 +239,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 +305,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",
-    } as unknown as LoadedTool;
+      owner: { kind: "skill", id: "some-other-skill" },
+    } as unknown as Tool;
     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__/plugin-types.test.ts

@@ -13,40 +13,17 @@ import { describe, expect, test } from "bun:test";
 import type { TrustContext } from "../daemon/trust-context.js";
 import { RiskLevel } from "../permissions/types.js";
 import {
-  type CircuitBreakerArgs,
-  type CircuitBreakerResult,
   type CompactionArgs,
   type CompactionResult,
-  type EmptyResponseArgs,
-  type EmptyResponseResult,
-  type EstimateArgs,
-  type EstimateResult,
-  type Injector,
-  type LLMCallArgs,
-  type LLMCallResult,
-  type MemoryArgs,
-  type MemoryResult,
   type Middleware,
-  type OverflowReduceArgs,
-  type OverflowReduceResult,
-  type PersistArgs,
-  type PersistResult,
   type Plugin,
   PluginExecutionError,
   type PluginInitContext,
   type PluginManifest,
   PluginTimeoutError,
-  type TitleArgs,
-  type TitleResult,
-  type ToolErrorArgs,
-  type ToolErrorDecision,
-  type ToolExecuteArgs,
-  type ToolExecuteResult,
-  type ToolResultTruncateArgs,
-  type ToolResultTruncateResult,
   type TurnContext,
 } from "../plugins/types.js";
-import type { LoadedTool } from "../tools/types.js";
+import type { Tool } from "../tools/types.js";
 
 const sampleTrust: TrustContext = {
   sourceChannel: "vellum",
@@ -71,148 +48,21 @@ describe("plugin core types", () => {
       config: { parse: (input: unknown) => input },
     };
 
-    // Generic passthrough — typed per slot below because per-pipeline
-    // arg/result types have diverged from the early `{input: unknown}` /
-    // `{output: unknown}` placeholders as individual pipeline wrap-up PRs
-    // land.
-    function passthroughFor<A, R>(): Middleware<A, R> {
-      return async (args, next, _ctx) => next(args);
-    }
-    const passthrough: Middleware<
-      { input: unknown },
-      { output: unknown }
-    > = async (args, next, _ctx) => next(args);
-    const passthroughHistoryRepair = passthroughFor<
-      import("../plugins/types.js").HistoryRepairArgs,
-      import("../plugins/types.js").HistoryRepairResult
-    >();
-
-    // `llmCall` has concrete arg/result types (upgraded in PR 15).
-    const llmCallPassthrough: Middleware<LLMCallArgs, LLMCallResult> = async (
-      args,
-      next,
-      _ctx,
-    ) => next(args);
-
-    // `toolExecute` has concrete arg/result types (refined in PR 16).
-    const toolExecutePassthrough: Middleware<
-      ToolExecuteArgs,
-      ToolExecuteResult
-    > = async (args, next, _ctx) => next(args);
-
-    // `toolResultTruncate` has a concrete args/result shape (PR 17) so we
-    // need a dedicated passthrough for that slot.
-    const truncatePassthrough: Middleware<
-      ToolResultTruncateArgs,
-      ToolResultTruncateResult
-    > = async (args, _next, _ctx) => ({
-      content: args.content,
-      truncated: false,
-    });
-
-    // The `emptyResponse` slot has concrete args/result types; use a
-    // dedicated passthrough so the `satisfies Plugin` check stays honest.
-    const emptyResponsePassthrough: Middleware<
-      EmptyResponseArgs,
-      EmptyResponseResult
-    > = async (args, next, _ctx) => next(args);
-
-    // The `toolError` slot has concrete args/result types (PR 19); use a
-    // dedicated passthrough so the shape-only test keeps compiling as types
-    // get tightened.
-    const toolErrorPassthrough: Middleware<
-      ToolErrorArgs,
-      ToolErrorDecision
-    > = async (args, next, _ctx) => next(args);
-
-    // `memoryRetrieval` has a concrete typed signature (MemoryArgs →
-    // MemoryResult) introduced in PR 20, so it can't use the generic
-    // `{ input }` passthrough above.
-    const memoryPassthrough: Middleware<MemoryArgs, MemoryResult> = async (
-      args,
-      next,
-      _ctx,
-    ) => next(args);
-
-    // `tokenEstimate` has a concrete arg/result shape (refined in the
-    // tokenEstimate-pipeline PR), so its middleware can't share the generic
-    // `{ input, output }` passthrough. A slot-specific passthrough keeps the
-    // shape-only assertion honest across type-refinement PRs.
-    const tokenEstimatePassthrough: Middleware<
-      EstimateArgs,
-      EstimateResult
-    > = async (args, next, _ctx) => next(args);
-
-    // `overflowReduce` has a concrete arg/result shape (PR 23). Uses a
-    // dedicated passthrough that returns a structurally-correct result so
-    // `satisfies Plugin` keeps verifying the signature.
-    const overflowReducePassthrough: Middleware<
-      OverflowReduceArgs,
-      OverflowReduceResult
-    > = async (args, _next, _ctx) => ({
-      messages: args.messages,
-      runMessages: args.runMessages,
-      injectionMode: "full",
-      reducerState: {
-        appliedTiers: [],
-        injectionMode: "full",
-        exhausted: true,
-      },
-      reducerCompacted: false,
-      attempts: 0,
-    });
-
-    // Slot-specific passthrough for the `compaction` pipeline — PR 25
-    // narrowed its args/result away from the generic `{ input: unknown }`
-    // placeholder, so the generic `passthrough` no longer satisfies its
-    // middleware signature. This dedicated middleware keeps the shape-only
-    // assertion for the slot without forcing every other slot to narrow.
+    // The `compaction` slot has a concrete arg/result shape, so it needs a
+    // dedicated passthrough whose middleware signature matches — keeping the
+    // shape-only `satisfies Plugin` assertion meaningful for the slot.
     const compactionPassthrough: Middleware<
       CompactionArgs,
       CompactionResult
     > = async (args, next, _ctx) => next(args);
 
-    // `circuitBreaker` carries a concrete arg shape (pipeline wrapping
-    // landed ahead of the other slots) so it needs its own passthrough
-    // rather than reusing the generic placeholder.
-    const circuitPassthrough: Middleware<
-      CircuitBreakerArgs,
-      CircuitBreakerResult
-    > = async (args, next, _ctx) => next(args);
-
-    // `persistence` has concrete discriminated-union arg/result types
-    // (upgraded from the initial `{ input }/{ output }` placeholder in PR 27)
-    // so it gets its own passthrough rather than sharing the generic one
-    // above.
-    const persistPassthrough: Middleware<PersistArgs, PersistResult> = async (
-      args,
-      next,
-      _ctx,
-    ) => next(args);
-
-    // The `titleGenerate` slot now has concrete arg/result types (PR 28)
-    // rather than the placeholder `{ input/output: unknown }` shape, so it
-    // needs its own passthrough implementation.
-    const titlePassthrough: Middleware<TitleArgs, TitleResult> = async (
-      args,
-      next,
-      _ctx,
-    ) => next(args);
-
-    const injector: Injector = {
-      name: "sample-injector",
-      order: 10,
-      async produce(_ctx) {
-        return { id: "sample-block", text: "hello", meta: { kind: "demo" } };
-      },
-    };
-
-    const sampleTool: LoadedTool = {
+    const sampleTool: Tool = {
       name: "sample-tool",
       description: "Sample plugin tool",
       defaultRiskLevel: RiskLevel.Low,
       executionTarget: "sandbox",
       input_schema: { type: "object", properties: {}, required: [] },
+      category: "",
       async execute() {
         return { content: "ok", isError: false };
       },
@@ -249,29 +99,14 @@ describe("plugin core types", () => {
           body: "## Sample\n\nPlugin-provided skill body.",
         },
       ],
-      injectors: [injector],
       middleware: {
-        turn: passthrough,
-        llmCall: llmCallPassthrough,
-        toolExecute: toolExecutePassthrough,
-        memoryRetrieval: memoryPassthrough,
-        historyRepair: passthroughHistoryRepair,
-        tokenEstimate: tokenEstimatePassthrough,
         compaction: compactionPassthrough,
-        overflowReduce: overflowReducePassthrough,
-        persistence: persistPassthrough,
-        titleGenerate: titlePassthrough,
-        toolResultTruncate: truncatePassthrough,
-        emptyResponse: emptyResponsePassthrough,
-        toolError: toolErrorPassthrough,
-        circuitBreaker: circuitPassthrough,
       },
     } satisfies Plugin;
 
     // Minimal runtime check so the test body is non-empty.
     expect(plugin.manifest.name).toBe("sample-plugin");
-    expect(plugin.middleware.turn).toBe(passthrough);
-    expect(plugin.middleware.historyRepair).toBe(passthroughHistoryRepair);
+    expect(plugin.middleware.compaction).toBe(compactionPassthrough);
   });
 
   test("PluginTimeoutError carries pipeline, plugin, and elapsed fields", () => {
@@ -287,7 +122,7 @@ describe("plugin core types", () => {
   });
 
   test("PluginTimeoutError omits plugin suffix when unknown", () => {
-    const err = new PluginTimeoutError("llmCall", undefined, 1234);
+    const err = new PluginTimeoutError("compaction", undefined, 1234);
     expect(err.pluginName).toBeUndefined();
     expect(err.message).not.toContain("offending plugin");
   });

package/src/__tests__/prechat-onboarding-contract.test.ts

@@ -299,6 +299,29 @@ describe("pre-chat onboarding contract", () => {
       expect(bootstrap).not.toContain(expectedJson);
     });
 
+    test("renders prior assistants in first-run context", () => {
+      writeFileSync(
+        join(TEST_DIR, "BOOTSTRAP.md"),
+        "# Bootstrap\n\nOnboarding.",
+      );
+
+      const context: OnboardingContext = {
+        tools: [],
+        tasks: [],
+        tone: "warm",
+        userName: "Alex",
+        priorAssistants: ["chatgpt", "claude", "perplexity"],
+      };
+
+      const result = buildSystemPrompt({ onboardingContext: context });
+      const bootstrap = bootstrapBlock(result);
+
+      expect(bootstrap).toContain("## First-Run User Context");
+      expect(bootstrap).toContain(
+        "- Prior AI assistants used: ChatGPT, Claude, Perplexity",
+      );
+    });
+
     test("empty tools/tasks arrays result in no Daily tools / Common work lines", () => {
       writeFileSync(
         join(TEST_DIR, "BOOTSTRAP.md"),

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;
@@ -249,19 +254,18 @@ describe("processMessageInBackground Slack option propagation", () => {
     const result = await processMessageInBackground(
       "conv-background-slack",
       "Reply from Slack",
-      undefined,
       {
         slackInbound,
+        sourceChannel: "slack",
+        sourceInterface: "slack",
       },
-      "slack",
-      "slack",
     );
 
     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();
@@ -275,21 +279,21 @@ describe("processMessageInBackground Slack option propagation", () => {
     const processing = processMessage(
       "conv-background-slack",
       "Reply from Slack",
-      undefined,
       {
         onEvent: (msg) => {
           observedMessages.push(msg);
         },
+        sourceChannel: "slack",
+        sourceInterface: "slack",
       },
-      "slack",
-      "slack",
     );
 
     await waitForRunAgentLoopCall();
 
-    const loopOnEvent = activeConversation.runAgentLoop.mock.calls[0][2] as
-      | ((msg: unknown) => void)
+    const loopOptions = activeConversation.runAgentLoop.mock.calls[0][2] as
+      | { onEvent?: (msg: unknown) => void }
       | undefined;
+    const loopOnEvent = loopOptions?.onEvent;
     const delta = {
       type: "assistant_text_delta",
       text: "Working on it.",
@@ -316,20 +320,22 @@ describe("processMessageInBackground Slack option propagation", () => {
     await processMessageInBackground(
       "conv-background-slack",
       "Regular background wake",
-      undefined,
-      undefined,
-      "vellum",
-      "web",
+      {
+        sourceChannel: "vellum",
+        sourceInterface: "web",
+      },
     );
 
     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,
-      isUserMessage: true,
-    });
+    expect(activeConversation.runAgentLoop.mock.calls[0][2]).toEqual(
+      expect.objectContaining({
+        isInteractive: false,
+        isUserMessage: true,
+      }),
+    );
 
     activeConversation.__loopDeferred.resolve();
   });