@vellumai/assistant 0.8.7 → 0.8.8-dev.202606052332.17fc8ea

package/src/__tests__/persist-unsendable-image.test.ts

@@ -0,0 +1,215 @@
+/**
+ * Regression tests for the image-too-large persistence path (JARVIS-1037).
+ *
+ * An image the provider can never accept — over the per-side pixel cap or the
+ * per-image byte cap, and not shrinkable on this host — must be durably swapped
+ * for a text note in its stored message. If it stays in the stored content,
+ * every later turn rehydrates it from the DB and the model reports seeing both
+ * the rejected image and any smaller re-upload. `persistUnsendableImageDowngrades`
+ * makes the swap durable so the rejected upload cannot resurface.
+ *
+ * Uses the real SQLite DB wired up via `test-preload.ts` (per-file temp
+ * workspace).
+ */
+
+import { beforeEach, describe, expect, test } from "bun:test";
+
+import { persistUnsendableImageDowngrades } from "../daemon/persist-unsendable-image.js";
+import {
+  addMessage,
+  createConversation,
+  getMessages,
+} from "../memory/conversation-crud.js";
+import { getDb } from "../memory/db-connection.js";
+import { initializeDb } from "../memory/db-init.js";
+import type { ContentBlock } from "../providers/types.js";
+
+initializeDb();
+
+function resetTables(): void {
+  const db = getDb();
+  db.run("DELETE FROM message_attachments");
+  db.run("DELETE FROM attachments");
+  db.run("DELETE FROM memory_segments");
+  db.run("DELETE FROM memory_embeddings");
+  db.run("DELETE FROM messages");
+  db.run("DELETE FROM conversations");
+}
+
+/**
+ * Build a minimal PNG whose IHDR declares the given dimensions. Only the
+ * 8-byte signature and the width/height fields (read by `parseImageDimensions`)
+ * need to be correct; the rest is padding. `optimizeImageForTransport` cannot
+ * downscale this off macOS (no `sips`), so it stays a no-op — exactly the
+ * host condition that produces an unsendable stored image.
+ */
+function makePngBase64(width: number, height: number, padBytes = 0): string {
+  const header = Buffer.from(
+    Uint8Array.from([
+      0x89,
+      0x50,
+      0x4e,
+      0x47,
+      0x0d,
+      0x0a,
+      0x1a,
+      0x0a, // PNG signature
+      0x00,
+      0x00,
+      0x00,
+      0x0d, // IHDR length (13)
+      0x49,
+      0x48,
+      0x44,
+      0x52, // "IHDR"
+      (width >>> 24) & 0xff,
+      (width >>> 16) & 0xff,
+      (width >>> 8) & 0xff,
+      width & 0xff,
+      (height >>> 24) & 0xff,
+      (height >>> 16) & 0xff,
+      (height >>> 8) & 0xff,
+      height & 0xff,
+      0x08,
+      0x06,
+      0x00,
+      0x00,
+      0x00, // bit depth / color type / etc.
+    ]),
+  ).toString("base64");
+  return padBytes > 0 ? header + "A".repeat(padBytes) : header;
+}
+
+function imageBlock(data: string): ContentBlock {
+  return {
+    type: "image",
+    source: { type: "base64", media_type: "image/png", data },
+  };
+}
+
+function storedContent(conversationId: string): ContentBlock[][] {
+  return getMessages(conversationId).map(
+    (row) => JSON.parse(row.content) as ContentBlock[],
+  );
+}
+
+const PROVIDER_MAX_IMAGE_DIMENSION = 8000;
+
+describe("persistUnsendableImageDowngrades", () => {
+  beforeEach(() => {
+    resetTables();
+  });
+
+  /** A stored image past the provider pixel cap is swapped for a text note. */
+  test("replaces an oversized image block with a text note", async () => {
+    // GIVEN a message holding text plus an image past the pixel cap
+    const conv = createConversation();
+    const oversized = makePngBase64(PROVIDER_MAX_IMAGE_DIMENSION + 1000, 6000);
+    await addMessage(
+      conv.id,
+      "user",
+      JSON.stringify([
+        { type: "text", text: "look at this" },
+        imageBlock(oversized),
+      ]),
+      { skipIndexing: true },
+    );
+
+    // WHEN the downgrade is persisted
+    const rewritten = persistUnsendableImageDowngrades(conv.id);
+
+    // THEN one message is rewritten with no image block left
+    expect(rewritten).toBe(1);
+    const [content] = storedContent(conv.id);
+    expect(content.some((b) => b.type === "image")).toBe(false);
+    // AND the original text is preserved alongside the substituted note
+    expect(content.filter((b) => b.type === "text")).toHaveLength(2);
+  });
+
+  /** The JARVIS-1037 scenario: the rejected original must not resurface next
+   *  to a valid re-upload. */
+  test("re-uploaded smaller image survives while the rejected original is removed", async () => {
+    // GIVEN turn 1 contains an oversized upload that was rejected
+    const conv = createConversation();
+    await addMessage(
+      conv.id,
+      "user",
+      JSON.stringify([imageBlock(makePngBase64(12000, 9000))]),
+      { skipIndexing: true },
+    );
+    // AND turn 2 contains a properly sized re-upload
+    await addMessage(
+      conv.id,
+      "user",
+      JSON.stringify([imageBlock(makePngBase64(800, 600))]),
+      { skipIndexing: true },
+    );
+
+    // WHEN the downgrade is persisted
+    const rewritten = persistUnsendableImageDowngrades(conv.id);
+
+    // THEN only the rejected original is removed
+    expect(rewritten).toBe(1);
+    const [first, second] = storedContent(conv.id);
+    expect(first.some((b) => b.type === "image")).toBe(false);
+    // AND the valid re-upload is left intact
+    expect(second.some((b) => b.type === "image")).toBe(true);
+  });
+
+  /** Sendable images are never disturbed by the recovery path. */
+  test("leaves a normally-sized image untouched", async () => {
+    // GIVEN a message with an image well within provider limits
+    const conv = createConversation();
+    await addMessage(
+      conv.id,
+      "user",
+      JSON.stringify([imageBlock(makePngBase64(1024, 768))]),
+      { skipIndexing: true },
+    );
+
+    // WHEN the downgrade is persisted
+    const rewritten = persistUnsendableImageDowngrades(conv.id);
+
+    // THEN nothing is rewritten and the image remains
+    expect(rewritten).toBe(0);
+    const [content] = storedContent(conv.id);
+    expect(content.some((b) => b.type === "image")).toBe(true);
+  });
+
+  /** The byte-size cap is enforced independently of pixel dimensions. */
+  test("removes an image whose payload exceeds the per-image byte cap", async () => {
+    // GIVEN an image within the pixel cap but with a payload over 5 MB
+    const conv = createConversation();
+    const huge = makePngBase64(1000, 1000, 6 * 1024 * 1024);
+    await addMessage(conv.id, "user", JSON.stringify([imageBlock(huge)]), {
+      skipIndexing: true,
+    });
+
+    // WHEN the downgrade is persisted
+    const rewritten = persistUnsendableImageDowngrades(conv.id);
+
+    // THEN the oversized-payload image is removed
+    expect(rewritten).toBe(1);
+    const [content] = storedContent(conv.id);
+    expect(content.some((b) => b.type === "image")).toBe(false);
+  });
+
+  /** Re-running after a rewrite is a safe no-op (no image blocks remain). */
+  test("is idempotent — a second run rewrites nothing", async () => {
+    // GIVEN a conversation whose oversized image has already been downgraded
+    const conv = createConversation();
+    await addMessage(
+      conv.id,
+      "user",
+      JSON.stringify([imageBlock(makePngBase64(10000, 10000))]),
+      { skipIndexing: true },
+    );
+    expect(persistUnsendableImageDowngrades(conv.id)).toBe(1);
+
+    // WHEN the downgrade runs a second time
+    const secondRun = persistUnsendableImageDowngrades(conv.id);
+
+    // THEN nothing further is rewritten
+    expect(secondRun).toBe(0);
+  });
+});

package/src/__tests__/persistence-secret-redaction.test.ts

@@ -149,6 +149,7 @@ function makeDeps(): EventHandlerDeps {
       userMessageInterface: "macos",
       assistantMessageInterface: "macos",
     } as EventHandlerDeps["turnInterfaceContext"],
+    applyCompaction: async () => {},
   } as EventHandlerDeps;
 }
 

package/src/__tests__/pkb-autoinject.test.ts

@@ -6,7 +6,7 @@ import { afterEach, beforeEach, describe, expect, test } from "bun:test";
 import {
   getPkbAutoInjectList,
   readAutoinjectList,
-} from "../daemon/conversation-runtime-assembly.js";
+} from "../memory/pkb/autoinject.js";
 
 const PKB_DEFAULT_FILES = [
   "INDEX.md",
@@ -80,10 +80,7 @@ describe("readAutoinjectList", () => {
       "INDEX.md\ncustom-topic.md\n",
       "utf-8",
     );
-    expect(readAutoinjectList(pkbDir)).toEqual([
-      "INDEX.md",
-      "custom-topic.md",
-    ]);
+    expect(readAutoinjectList(pkbDir)).toEqual(["INDEX.md", "custom-topic.md"]);
   });
 
   test("strips blank lines and whitespace", () => {

package/src/__tests__/plugin-api-shim.test.ts

@@ -44,10 +44,7 @@ describe("buildShimSource", () => {
   });
 
   test("handles an empty export list (today's types-only surface)", () => {
-    const source = buildShimSource(
-      [],
-      Symbol.for("vellum.plugin-api.v1"),
-    );
+    const source = buildShimSource([], Symbol.for("vellum.plugin-api.v1"));
     expect(source).toBe(
       `const api = globalThis[Symbol.for("vellum.plugin-api.v1")];\n`,
     );
@@ -109,7 +106,7 @@ describe("ensurePluginApiShim", () => {
     const pluginDir = join(workspaceDir, "plugins", "fake-plugin");
     await mkdir(pluginDir, { recursive: true });
     await writeFile(
-      join(pluginDir, "register.js"),
+      join(pluginDir, "probe.js"),
       `import * as api from "@vellumai/plugin-api";\nexport { api };\n`,
     );
 
@@ -118,7 +115,7 @@ describe("ensurePluginApiShim", () => {
     // → plugin-api namespace. If any link in that chain is broken, this
     // import throws.
     const mod: { api: Record<string, unknown> } = await import(
-      join(pluginDir, "register.js")
+      join(pluginDir, "probe.js")
     );
     expect(mod.api).toBeDefined();
   });

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

@@ -38,14 +38,11 @@ import { RiskLevel } from "../permissions/types.js";
 import { registerDefaultPlugins } from "../plugins/defaults/index.js";
 import {
   closeRegistration,
-  getInjectors,
-  getMiddlewaresFor,
   getRegisteredPlugins,
   registerPlugin,
   resetPluginRegistryForTests,
 } from "../plugins/registry.js";
 import {
-  type PipelineMiddlewareMap,
   type Plugin,
   PluginExecutionError,
   type PluginInitContext,
@@ -342,8 +339,8 @@ describe("plugin bootstrap", () => {
     // THEN the defaults are still registered, ahead of the user plugin, so the
     // middleware onion order is unchanged
     const names = getRegisteredPlugins().map((p) => p.manifest.name);
-    expect(names).toContain("default-llm-call");
-    expect(names.indexOf("default-llm-call")).toBeLessThan(
+    expect(names).toContain("default-compaction");
+    expect(names.indexOf("default-compaction")).toBeLessThan(
       names.indexOf("user-after-defaults"),
     );
   });
@@ -486,47 +483,24 @@ describe("plugin bootstrap", () => {
     expect(initFired).toBe(false);
   });
 
-  test("requiresFlag disabled: plugin middleware and injectors are dropped from the registry", async () => {
-    // Regression: prior to the unregisterPlugin() call on the flag-gated skip
-    // path, `getMiddlewaresFor()` and `getInjectors()` iterated over every
-    // entry in `registeredPlugins` — so a gated-off plugin's middleware and
-    // 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 });
-
-    const gatedMiddleware: PipelineMiddlewareMap["llmCall"] = async (
-      args,
-      next,
-    ) => next(args);
+  test("requiresFlag disabled: the skipped plugin is removed from the registry", async () => {
+    // Regression: a flag-gated skip must call `unregisterPlugin()` so the
+    // gated-off plugin does not linger in `registeredPlugins` with its
+    // `init()` never having fired to set up the state it depends on.
+    setOverridesForTesting({ "plugin-registry-disabled": false });
+
     const plugin = buildPlugin(
-      "gated-middleware",
-      {
-        middleware: { llmCall: gatedMiddleware },
-        injectors: [
-          {
-            name: "gated-middleware-injector",
-            order: 100,
-            async produce() {
-              return null;
-            },
-          },
-        ],
-      },
-      { requiresFlag: ["plugin-middleware-disabled"] },
+      "gated-registry",
+      {},
+      { requiresFlag: ["plugin-registry-disabled"] },
     );
     registerPlugin(plugin);
 
     await bootstrapPlugins();
 
-    // Neither the middleware slot nor the injector list should expose the
-    // flag-gated plugin's contributions. The default plugins also contribute
-    // llmCall middleware / injectors, so we key on identity rather than
-    // asserting empty lists.
-    expect(getMiddlewaresFor("llmCall")).not.toContain(gatedMiddleware);
-    expect(
-      getInjectors().some((i) => i.name === "gated-middleware-injector"),
-    ).toBe(false);
+    // The gated-off plugin must not survive in the registry snapshot.
+    const names = getRegisteredPlugins().map((p) => p.manifest.name);
+    expect(names).not.toContain("gated-registry");
   });
 
   test("requiresFlag disabled: no shutdown hook entry installed for the skipped plugin", async () => {

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

@@ -2,28 +2,19 @@
  * Tests for the plugin registry (PR 13).
  *
  * Covers successful registration, required-field and duplicate-name
- * validation, capability-version negotiation error messaging, injector
- * ordering, and middleware collection order.
+ * validation, capability-version negotiation error messaging, and
+ * registration order.
  */
 
 import { beforeEach, describe, expect, test } from "bun:test";
 
 import {
   closeRegistration,
-  getInjectors,
-  getMiddlewaresFor,
   getRegisteredPlugins,
   registerPlugin,
   resetPluginRegistryForTests,
 } from "../plugins/registry.js";
-import {
-  type CompactionArgs,
-  type CompactionResult,
-  type Injector,
-  type Middleware,
-  type Plugin,
-  PluginExecutionError,
-} from "../plugins/types.js";
+import { type Plugin, PluginExecutionError } from "../plugins/types.js";
 
 /** Build a minimal, valid plugin with the given name and optional extras. */
 function buildPlugin(
@@ -149,70 +140,6 @@ describe("plugin registry", () => {
     expect(() => registerPlugin(bad)).toThrow(/manifest\.version is required/);
   });
 
-  test("getInjectors returns injectors sorted by order ascending", () => {
-    const high: Injector = {
-      name: "high-order",
-      order: 20,
-      async produce() {
-        return null;
-      },
-    };
-    const low: Injector = {
-      name: "low-order",
-      order: 10,
-      async produce() {
-        return null;
-      },
-    };
-
-    // Register the higher-order plugin first so registration order alone
-    // would produce the wrong sequence — the test proves sort-by-order wins.
-    registerPlugin(buildPlugin("high", { injectors: [high] }));
-    registerPlugin(buildPlugin("low", { injectors: [low] }));
-
-    const injectors = getInjectors();
-    expect(injectors.map((i) => i.name)).toEqual(["low-order", "high-order"]);
-  });
-
-  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

@@ -12,40 +12,11 @@ import { describe, expect, test } from "bun:test";
 
 import type { TrustContext } from "../daemon/trust-context.js";
 import { RiskLevel } from "../permissions/types.js";
-import type {
-  ToolResultTruncateArgs,
-  ToolResultTruncateResult,
-} from "../plugins/defaults/tool-result-truncate/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 TurnContext,
 } from "../plugins/types.js";
 import type { Tool } from "../tools/types.js";
@@ -59,7 +30,6 @@ const sampleTurnContext: TurnContext = {
   requestId: "req-abc",
   conversationId: "conv-xyz",
   turnIndex: 0,
-  pluginName: "sample-plugin",
   trust: sampleTrust,
 };
 
@@ -73,134 +43,6 @@ 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.
-    const passthrough: Middleware<
-      { input: unknown },
-      { output: unknown }
-    > = async (args, next, _ctx) => next(args);
-    // `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.
-    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: Tool = {
       name: "sample-tool",
       description: "Sample plugin tool",
@@ -244,45 +86,10 @@ describe("plugin core types", () => {
           body: "## Sample\n\nPlugin-provided skill body.",
         },
       ],
-      injectors: [injector],
-      middleware: {
-        turn: passthrough,
-        llmCall: llmCallPassthrough,
-        toolExecute: toolExecutePassthrough,
-        memoryRetrieval: memoryPassthrough,
-        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);
-  });
-
-  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("llmCall", undefined, 1234);
-    expect(err.pluginName).toBeUndefined();
-    expect(err.message).not.toContain("offending plugin");
   });
 
   test("PluginExecutionError carries the plugin name and message", () => {