@vellumai/assistant 0.8.7-dev.202606052232.2ddc989 → 0.8.8

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

@@ -2,19 +2,26 @@
  * Tests for the plugin registry (PR 13).
  *
  * Covers successful registration, required-field and duplicate-name
- * validation, capability-version negotiation error messaging, and
- * registration order.
+ * validation, capability-version negotiation error messaging, injector
+ * ordering, and middleware collection order.
  */
 
 import { beforeEach, describe, expect, test } from "bun:test";
 
 import {
   closeRegistration,
+  getMiddlewaresFor,
   getRegisteredPlugins,
   registerPlugin,
   resetPluginRegistryForTests,
 } from "../plugins/registry.js";
-import { type Plugin, PluginExecutionError } from "../plugins/types.js";
+import {
+  type CompactionArgs,
+  type CompactionResult,
+  type Middleware,
+  type Plugin,
+  PluginExecutionError,
+} from "../plugins/types.js";
 
 /** Build a minimal, valid plugin with the given name and optional extras. */
 function buildPlugin(
@@ -140,6 +147,45 @@ describe("plugin registry", () => {
     expect(() => registerPlugin(bad)).toThrow(/manifest\.version is required/);
   });
 
+  test("getMiddlewaresFor returns middleware in registration order", () => {
+    const firstMw: Middleware<CompactionArgs, CompactionResult> = async (
+      args,
+      next,
+    ) => next(args);
+    const secondMw: Middleware<CompactionArgs, CompactionResult> = async (
+      args,
+      next,
+    ) => next(args);
+
+    registerPlugin(
+      buildPlugin("plugin-first", { middleware: { compaction: firstMw } }),
+    );
+    registerPlugin(
+      buildPlugin("plugin-second", { middleware: { compaction: secondMw } }),
+    );
+
+    const middlewares = getMiddlewaresFor("compaction");
+    expect(middlewares).toHaveLength(2);
+    // Identity comparison proves the middleware instances come back in
+    // registration order — outer→inner composition semantics belong to the
+    // pipeline runner (PR 12), not the registry.
+    expect(middlewares[0]).toBe(firstMw);
+    expect(middlewares[1]).toBe(secondMw);
+  });
+
+  test("getMiddlewaresFor skips plugins without a middleware for the pipeline", () => {
+    const mw: Middleware<CompactionArgs, CompactionResult> = async (
+      args,
+      next,
+    ) => next(args);
+    registerPlugin(buildPlugin("bare"));
+    registerPlugin(buildPlugin("has-mw", { middleware: { compaction: mw } }));
+
+    const middlewares = getMiddlewaresFor("compaction");
+    expect(middlewares).toHaveLength(1);
+    expect(middlewares[0]).toBe(mw);
+  });
+
   test("getRegisteredPlugins reflects registration order", () => {
     registerPlugin(buildPlugin("one"));
     registerPlugin(buildPlugin("two"));

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

@@ -13,10 +13,18 @@ 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 Middleware,
+  type OverflowReduceArgs,
+  type OverflowReduceResult,
   type Plugin,
   PluginExecutionError,
   type PluginInitContext,
   type PluginManifest,
+  PluginTimeoutError,
   type TurnContext,
 } from "../plugins/types.js";
 import type { Tool } from "../tools/types.js";
@@ -30,6 +38,7 @@ const sampleTurnContext: TurnContext = {
   requestId: "req-abc",
   conversationId: "conv-xyz",
   turnIndex: 0,
+  pluginName: "sample-plugin",
   trust: sampleTrust,
 };
 
@@ -43,6 +52,43 @@ describe("plugin core types", () => {
       config: { parse: (input: unknown) => input },
     };
 
+    // `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.
+    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);
+
     const sampleTool: Tool = {
       name: "sample-tool",
       description: "Sample plugin tool",
@@ -86,10 +132,34 @@ describe("plugin core types", () => {
           body: "## Sample\n\nPlugin-provided skill body.",
         },
       ],
+      middleware: {
+        compaction: compactionPassthrough,
+        overflowReduce: overflowReducePassthrough,
+        circuitBreaker: circuitPassthrough,
+      },
     } satisfies Plugin;
 
     // Minimal runtime check so the test body is non-empty.
     expect(plugin.manifest.name).toBe("sample-plugin");
+    expect(plugin.middleware.compaction).toBe(compactionPassthrough);
+  });
+
+  test("PluginTimeoutError carries pipeline, plugin, and elapsed fields", () => {
+    const err = new PluginTimeoutError("compaction", "sample-plugin", 30000);
+    expect(err).toBeInstanceOf(Error);
+    expect(err.name).toBe("PluginTimeoutError");
+    expect(err.pipeline).toBe("compaction");
+    expect(err.pluginName).toBe("sample-plugin");
+    expect(err.elapsedMs).toBe(30000);
+    expect(err.message).toContain("compaction");
+    expect(err.message).toContain("30000");
+    expect(err.message).toContain("sample-plugin");
+  });
+
+  test("PluginTimeoutError omits plugin suffix when unknown", () => {
+    const err = new PluginTimeoutError("circuitBreaker", undefined, 1234);
+    expect(err.pluginName).toBeUndefined();
+    expect(err.message).not.toContain("offending plugin");
   });
 
   test("PluginExecutionError carries the plugin name and message", () => {

package/src/__tests__/reaction-persistence.test.ts

@@ -27,7 +27,7 @@ mock.module("../config/env.js", () => ({
 }));
 
 const _conversationMocks = new Map<string, unknown>();
-mock.module("../daemon/conversation-registry.js", () => ({
+mock.module("../daemon/conversation-store.js", () => ({
   findConversation: (id: string) => _conversationMocks.get(id),
 }));
 

package/src/__tests__/send-endpoint-busy.test.ts

@@ -91,14 +91,11 @@ mock.module("../config/loader.js", () => ({
 let _conversationFactory: (() => Conversation) | undefined;
 let _approvalGenerator: unknown;
 
-mock.module("../daemon/conversation-registry.js", () => ({
+mock.module("../daemon/conversation-store.js", () => ({
   findConversation: () => {
     if (!_conversationFactory) return undefined;
     return _conversationFactory();
   },
-}));
-
-mock.module("../daemon/conversation-store.js", () => ({
   getOrCreateConversation: async (..._args: unknown[]) => {
     if (!_conversationFactory)
       throw new Error("_conversationFactory not set in test");

package/src/__tests__/skill-feature-flags-integration.test.ts

@@ -5,8 +5,6 @@
  * parses it via the real frontmatter parser, and verifies that `skillFlagKey()`
  * returns the correct key and `resolveSkillStates()` correctly gates the skill.
  */
-import { readFileSync } from "node:fs";
-import { fileURLToPath } from "node:url";
 import { afterEach, beforeEach, describe, expect, test } from "bun:test";
 
 import { isAssistantFeatureFlagEnabled } from "../config/assistant-feature-flags.js";
@@ -227,34 +225,3 @@ describe("frontmatter feature-flag integration", () => {
     expect(resolvedOff.length).toBe(0);
   });
 });
-
-// ---------------------------------------------------------------------------
-// Bundled ACP skill: discoverability when ACP is disabled
-// ---------------------------------------------------------------------------
-
-describe("bundled acp skill discoverability", () => {
-  test("acp skill resolves with the flag off and config.acp disabled (no frontmatter flag gate)", () => {
-    // The ACP skill carries its own first-time-setup instructions, so it must
-    // stay visible even when the acp flag and config.acp.enabled are both off.
-    // Runtime enforcement happens in the ACP tools via isAcpEnabled instead.
-    const skillMdPath = fileURLToPath(
-      new URL("../config/bundled-skills/acp/SKILL.md", import.meta.url),
-    );
-    const skillMd = readFileSync(skillMdPath, "utf8");
-
-    const skill = buildSkillSummary("acp", skillMd);
-    expect(skill).not.toBeNull();
-    expect(skill!.featureFlag).toBeUndefined();
-    expect(skillFlagKey(skill!)).toBeUndefined();
-
-    // acp flag at its registry default (off) and config.acp disabled.
-    const config = makeConfig({
-      acp: { enabled: false, maxConcurrentSessions: 4, agents: {} },
-    } as Partial<AssistantConfig>);
-
-    const resolved = resolveSkillStates([skill!], config);
-    expect(resolved.length).toBe(1);
-    expect(resolved[0].summary.id).toBe("acp");
-    expect(resolved[0].state).toBe("enabled");
-  });
-});

package/src/__tests__/subagent-call-site-routing.test.ts

@@ -174,7 +174,7 @@ import { LLMSchema } from "../config/schemas/llm.js";
 import {
   clearConversations,
   setConversation,
-} from "../daemon/conversation-registry.js";
+} from "../daemon/conversation-store.js";
 import { CallSiteRoutingProvider } from "../providers/call-site-routing.js";
 import { SubagentManager } from "../subagent/manager.js";
 

package/src/__tests__/subagent-fork-notifications.test.ts

@@ -11,7 +11,7 @@ const capturedNotifications: {
   message: string;
 }[] = [];
 
-mock.module("../daemon/conversation-registry.js", () => ({
+mock.module("../daemon/conversation-store.js", () => ({
   findConversation: (id: string) => ({
     enqueueMessage: (options: { content: string }) => {
       capturedNotifications.push({
@@ -23,6 +23,8 @@ mock.module("../daemon/conversation-registry.js", () => ({
     persistUserMessage: async () => ({ id: "mock-msg", deduplicated: false }),
     runAgentLoop: async () => {},
   }),
+  addConversation: () => {},
+  removeConversation: () => {},
 }));
 
 mock.module("../runtime/assistant-event-hub.js", () => ({

package/src/__tests__/subagent-fork-spawn.test.ts

@@ -4,7 +4,7 @@ import {
   clearConversations,
   findConversation,
   setConversation,
-} from "../daemon/conversation-registry.js";
+} from "../daemon/conversation-store.js";
 import type { ServerMessage } from "../daemon/message-protocol.js";
 import type { Message } from "../providers/types.js";
 import { SubagentManager } from "../subagent/manager.js";

package/src/__tests__/subagent-manager-notify.test.ts

@@ -11,7 +11,7 @@ const capturedNotifications: {
   message: string;
 }[] = [];
 
-mock.module("../daemon/conversation-registry.js", () => ({
+mock.module("../daemon/conversation-store.js", () => ({
   findConversation: (id: string) => ({
     enqueueMessage: (options: { content: string }) => {
       capturedNotifications.push({
@@ -23,6 +23,8 @@ mock.module("../daemon/conversation-registry.js", () => ({
     persistUserMessage: async () => ({ id: "mock-msg", deduplicated: false }),
     runAgentLoop: async () => {},
   }),
+  addConversation: () => {},
+  removeConversation: () => {},
 }));
 
 mock.module("../runtime/assistant-event-hub.js", () => ({

package/src/__tests__/subagent-notify-parent.test.ts

@@ -36,7 +36,7 @@ mock.module("../memory/conversation-crud.js", () => ({
  */
 const capturedMessages: string[] = [];
 
-mock.module("../daemon/conversation-registry.js", () => ({
+mock.module("../daemon/conversation-store.js", () => ({
   findConversation: (_id: string) => ({
     enqueueMessage: (options: { content: string }) => {
       capturedMessages.push(options.content);
@@ -45,6 +45,8 @@ mock.module("../daemon/conversation-registry.js", () => ({
     persistUserMessage: async () => ({ id: "mock-msg", deduplicated: false }),
     runAgentLoop: async () => {},
   }),
+  addConversation: () => {},
+  removeConversation: () => {},
 }));
 
 mock.module("../runtime/assistant-event-hub.js", () => ({

package/src/__tests__/subagent-spawn-tool-fork.test.ts

@@ -32,7 +32,7 @@ mock.module("../memory/conversation-crud.js", () => ({
 import {
   clearConversations,
   setConversation,
-} from "../daemon/conversation-registry.js";
+} from "../daemon/conversation-store.js";
 import type { Message } from "../providers/types.js";
 import { getSubagentManager } from "../subagent/index.js";
 import { executeSubagentSpawn } from "../tools/subagent/spawn.js";