@vellumai/assistant 0.8.1 → 0.8.3

package/src/__tests__/openrouter-provider-only.test.ts

@@ -116,7 +116,7 @@ describe("OpenRouter provider.only plumbing", () => {
       expect(extras.provider).toBe(undefined);
     });
 
-    test("still carries reasoning flag alongside provider.only", () => {
+    test("enables thinking with default detailed summary alongside provider.only", () => {
       const provider = new ProbeOpenRouterProvider(
         "fake-key",
         "x-ai/grok-4.20-beta",
@@ -128,12 +128,12 @@ describe("OpenRouter provider.only plumbing", () => {
         },
       });
       expect(extras).toEqual({
-        reasoning: { enabled: true },
+        reasoning: { enabled: true, summary: "detailed" },
         provider: { only: ["xAI"] },
       });
     });
 
-    test("disabled thinking keeps reasoning disabled alongside provider.only", () => {
+    test("disabled thinking keeps reasoning disabled and omits summary", () => {
       const provider = new ProbeOpenRouterProvider(
         "fake-key",
         "x-ai/grok-4.20-beta",
@@ -149,5 +149,53 @@ describe("OpenRouter provider.only plumbing", () => {
         provider: { only: ["xAI"] },
       });
     });
+
+    test("nests effort under reasoning and maps `max` to xhigh", () => {
+      const provider = new ProbeOpenRouterProvider(
+        "fake-key",
+        "moonshotai/kimi-k2.6",
+      );
+      const extras = provider.probeExtras({
+        config: {
+          thinking: { enabled: true },
+          effort: "max",
+        },
+      });
+      expect(extras).toEqual({
+        reasoning: { enabled: true, effort: "xhigh", summary: "detailed" },
+      });
+    });
+
+    test("honors a per-call summary override", () => {
+      const provider = new ProbeOpenRouterProvider(
+        "fake-key",
+        "moonshotai/kimi-k2.6",
+      );
+      const extras = provider.probeExtras({
+        config: {
+          thinking: { enabled: true },
+          openrouter: { reasoning: { summary: "concise" } },
+        },
+      });
+      expect(extras).toEqual({
+        reasoning: { enabled: true, summary: "concise" },
+      });
+    });
+
+    test("ignores an invalid summary override and falls back to detailed", () => {
+      const provider = new ProbeOpenRouterProvider(
+        "fake-key",
+        "moonshotai/kimi-k2.6",
+      );
+      const extras = provider.probeExtras({
+        config: {
+          thinking: { enabled: true },
+          openrouter: { reasoning: { summary: "verbose" } },
+        },
+      });
+      expect(extras).toEqual({
+        reasoning: { enabled: true, summary: "detailed" },
+      });
+    });
   });
 });

package/src/__tests__/openrouter-token-estimation.test.ts

@@ -5,7 +5,11 @@ import { OpenRouterProvider } from "../providers/openrouter/client.js";
 import type { Message } from "../providers/types.js";
 
 /** Build a minimal valid PNG header encoding the given dimensions. */
-function makePngBase64(width: number, height: number, paddingBytes = 0): string {
+function makePngBase64(
+  width: number,
+  height: number,
+  paddingBytes = 0,
+): string {
   const header = Buffer.alloc(24);
   header[0] = 0x89;
   header[1] = 0x50;
@@ -41,13 +45,13 @@ describe("OpenRouterProvider token estimation routing", () => {
     expect(provider.tokenEstimationProvider).toBe("openrouter");
   });
 
-  test("estimatePromptTokens applies Anthropic image scaling when routed via OpenRouter", () => {
+  test("estimatePromptTokens applies dimension-based image scaling when routed via OpenRouter to Anthropic", () => {
     const provider = new OpenRouterProvider(
       "fake-key",
       "anthropic/claude-opus-4-6",
     );
     // 1920x1080 screenshot with ~200 KB of pixel data → base64/4 would be ~65k
-    // tokens; dimension-based Anthropic rules land around 1.6k tokens.
+    // tokens; dimension-based rules land around 1.6k tokens.
     const messages: Message[] = [
       {
         role: "user",
@@ -68,33 +72,38 @@ describe("OpenRouterProvider token estimation routing", () => {
       providerName: provider.tokenEstimationProvider,
     });
 
-    // Dimension-based estimate should be well under 5k; base64/4 would exceed 50k.
     expect(estimated).toBeLessThan(5_000);
   });
 
-  test("estimatePromptTokens falls back to base64/4 for non-Anthropic OpenRouter models", () => {
-    const provider = new OpenRouterProvider("fake-key", "x-ai/grok-4.20-beta");
-    const messages: Message[] = [
-      {
-        role: "user",
-        content: [
-          {
-            type: "image",
-            source: {
-              type: "base64",
-              media_type: "image/png",
-              data: makePngBase64(1920, 1080, 200_000),
+  test("estimatePromptTokens applies dimension-based image scaling for non-Anthropic OpenRouter models", () => {
+    // A naive base64/4 estimate on a 1920x1080 screenshot (~200 KB) lands near
+    // 65k tokens and trips spurious compaction long before the real context
+    // window fills. Vision models on OpenRouter — both anthropic/* and
+    // non-Anthropic (Kimi K2.6, Grok, etc.) — must use the dimension-based
+    // formula.
+    for (const model of ["moonshotai/kimi-k2.6", "x-ai/grok-4.20-beta"]) {
+      const provider = new OpenRouterProvider("fake-key", model);
+      const messages: Message[] = [
+        {
+          role: "user",
+          content: [
+            {
+              type: "image",
+              source: {
+                type: "base64",
+                media_type: "image/png",
+                data: makePngBase64(1920, 1080, 200_000),
+              },
             },
-          },
-        ],
-      },
-    ];
+          ],
+        },
+      ];
 
-    const estimated = estimatePromptTokens(messages, "system", {
-      providerName: provider.tokenEstimationProvider,
-    });
+      const estimated = estimatePromptTokens(messages, "system", {
+        providerName: provider.tokenEstimationProvider,
+      });
 
-    // Base64/4 heuristic on ~200 KB of image data → far more than 10k tokens.
-    expect(estimated).toBeGreaterThan(50_000);
+      expect(estimated).toBeLessThan(5_000);
+    }
   });
 });

package/src/__tests__/overflow-reduce-pipeline.test.ts

@@ -453,7 +453,6 @@ describe("overflow-reduce pipeline", () => {
         manifest: {
           name: "spy-overflow",
           version: "0.0.1",
-          requires: { pluginRuntime: "v1", overflowReduceApi: "v1" },
         },
         middleware: { overflowReduce: spy },
       };
@@ -512,7 +511,6 @@ describe("overflow-reduce pipeline", () => {
         manifest: {
           name: "short-circuit-overflow",
           version: "0.0.1",
-          requires: { pluginRuntime: "v1", overflowReduceApi: "v1" },
         },
         middleware: { overflowReduce: shortCircuit },
       });

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

@@ -267,7 +267,6 @@ describe("persistence pipeline", () => {
       manifest: {
         name: "mock-persistence",
         version: "0.0.1",
-        requires: { pluginRuntime: "v1" },
       },
       middleware: { persistence: redirect },
     };
@@ -352,7 +351,6 @@ describe("persistence pipeline", () => {
       manifest: {
         name: "late-user-plugin",
         version: "0.0.1",
-        requires: { pluginRuntime: "v1" },
       },
       middleware: { persistence: userMiddleware },
     });

package/src/__tests__/{managed-proxy-context.test.ts → platform-proxy-context.test.ts}

@@ -32,7 +32,7 @@ import {
   hasManagedProxyPrereqs,
   managedFallbackEnabledFor,
   resolveManagedProxyContext,
-} from "../providers/managed-proxy/context.js";
+} from "../providers/platform-proxy/context.js";
 
 describe("resolveManagedProxyContext", () => {
   beforeEach(() => {
@@ -117,8 +117,13 @@ describe("buildManagedBaseUrl", () => {
     );
   });
 
+  test("returns managed URL for fireworks", async () => {
+    expect(await buildManagedBaseUrl("fireworks")).toBe(
+      "https://platform.example.com/v1/runtime-proxy/fireworks",
+    );
+  });
+
   test("returns undefined for non-managed providers", async () => {
-    expect(await buildManagedBaseUrl("fireworks")).toBeUndefined();
     expect(await buildManagedBaseUrl("openrouter")).toBeUndefined();
     expect(await buildManagedBaseUrl("ollama")).toBeUndefined();
   });

package/src/__tests__/platform.test.ts

@@ -16,6 +16,7 @@ import {
   getWorkspaceConfigPath,
   getWorkspaceDir,
   getWorkspaceHooksDir,
+  getWorkspacePluginsDir,
   getWorkspacePromptPath,
   getWorkspaceSkillsDir,
   getXdgVellumConfigDirName,
@@ -161,6 +162,7 @@ describe("workspace path primitives", () => {
     expect(getWorkspaceConfigPath()).toBe(join(ws, "config.json"));
     expect(getWorkspaceSkillsDir()).toBe(join(ws, "skills"));
     expect(getWorkspaceHooksDir()).toBe(join(ws, "hooks"));
+    expect(getWorkspacePluginsDir()).toBe(join(ws, "plugins"));
     expect(getWorkspacePromptPath("IDENTITY.md")).toBe(join(ws, "IDENTITY.md"));
     expect(getWorkspacePromptPath("SOUL.md")).toBe(join(ws, "SOUL.md"));
   });

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

@@ -0,0 +1,125 @@
+/**
+ * Smoke tests for the workspace-level `@vellumai/plugin-api` shim.
+ *
+ *   - shim files are materialized at `<workspaceDir>/node_modules/@vellumai/plugin-api/`
+ *   - the shim's index.js re-binds each runtime export from globalThis
+ *   - the shim is idempotent across re-runs
+ *   - a fake plugin in `<workspaceDir>/plugins/<name>/` can resolve the
+ *     bare `@vellumai/plugin-api` specifier via Node-style walk-up,
+ *     proving the end-to-end import path works for real user plugins
+ *
+ * As plugin-api's runtime surface grows in follow-up PRs, the shim's
+ * generated export list expands automatically — the test below covers
+ * the generator (`buildShimSource`) directly so we don't need to
+ * update assertions every time an export is added.
+ */
+
+import { mkdir, mkdtemp, readFile, writeFile } from "node:fs/promises";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { describe, expect, test } from "bun:test";
+
+import {
+  PLUGIN_API_EXPORTS,
+  PLUGIN_API_REGISTRY_KEY,
+} from "../embedded/plugin-api.js";
+import {
+  buildShimSource,
+  ensurePluginApiShim,
+} from "../plugins/ensure-plugin-api-shim.js";
+
+const SHIM_REL_PATH = "node_modules/@vellumai/plugin-api";
+
+describe("buildShimSource", () => {
+  test("emits a globalThis trampoline + one binding per export", () => {
+    const source = buildShimSource(
+      ["foo", "bar"],
+      Symbol.for("vellum.plugin-api.v1"),
+    );
+    expect(source).toBe(
+      `const api = globalThis[Symbol.for("vellum.plugin-api.v1")];\n` +
+        `export const foo = api.foo;\n` +
+        `export const bar = api.bar;\n`,
+    );
+  });
+
+  test("handles an empty export list (today's types-only surface)", () => {
+    const source = buildShimSource(
+      [],
+      Symbol.for("vellum.plugin-api.v1"),
+    );
+    expect(source).toBe(
+      `const api = globalThis[Symbol.for("vellum.plugin-api.v1")];\n`,
+    );
+  });
+});
+
+describe("ensurePluginApiShim", () => {
+  test("creates a resolvable @vellumai/plugin-api package under workspaceDir", async () => {
+    const workspaceDir = await mkdtemp(join(tmpdir(), "plugin-api-shim-"));
+    await ensurePluginApiShim({ workspaceDir });
+
+    const shimDir = join(workspaceDir, SHIM_REL_PATH);
+    const indexJs = await readFile(join(shimDir, "index.js"), "utf8");
+    expect(indexJs).toBe(buildShimSource());
+
+    const pkg = JSON.parse(
+      await readFile(join(shimDir, "package.json"), "utf8"),
+    );
+    expect(pkg.name).toBe("@vellumai/plugin-api");
+    expect(pkg.type).toBe("module");
+    expect(pkg.main).toBe("./index.js");
+    expect(typeof pkg.version).toBe("string");
+  });
+
+  test("is idempotent — re-running yields the same shim contents", async () => {
+    const workspaceDir = await mkdtemp(join(tmpdir(), "plugin-api-shim-"));
+    await ensurePluginApiShim({ workspaceDir });
+    const first = await readFile(
+      join(workspaceDir, SHIM_REL_PATH, "index.js"),
+      "utf8",
+    );
+
+    await ensurePluginApiShim({ workspaceDir });
+    const second = await readFile(
+      join(workspaceDir, SHIM_REL_PATH, "index.js"),
+      "utf8",
+    );
+    expect(second).toBe(first);
+  });
+
+  test("globalThis is populated with the plugin-api namespace", () => {
+    // Importing the embed wrapper has the side effect of installing the
+    // namespace on globalThis. By the time this test runs (any earlier
+    // test in the file has already imported it), the registry must be
+    // populated.
+    const namespace = (globalThis as Record<symbol, unknown>)[
+      PLUGIN_API_REGISTRY_KEY
+    ];
+    expect(namespace).toBeDefined();
+    // Exports list is non-null but may be empty until runtime exports
+    // migrate in later PRs.
+    expect(Array.isArray(PLUGIN_API_EXPORTS)).toBe(true);
+  });
+
+  test("a fake user plugin can resolve @vellumai/plugin-api via Node-style walk-up", async () => {
+    const workspaceDir = await mkdtemp(join(tmpdir(), "plugin-api-shim-"));
+    await ensurePluginApiShim({ workspaceDir });
+
+    const pluginDir = join(workspaceDir, "plugins", "fake-plugin");
+    await mkdir(pluginDir, { recursive: true });
+    await writeFile(
+      join(pluginDir, "register.js"),
+      `import * as api from "@vellumai/plugin-api";\nexport { api };\n`,
+    );
+
+    // Resolution walks up: plugins/fake-plugin → plugins → workspaceDir
+    // → workspaceDir/node_modules/@vellumai/plugin-api → shim → globalThis
+    // → 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")
+    );
+    expect(mod.api).toBeDefined();
+  });
+});

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

@@ -43,7 +43,6 @@ import {
 import { runShutdownHooks } from "../daemon/shutdown-registry.js";
 import { RiskLevel } from "../permissions/types.js";
 import {
-  ASSISTANT_API_VERSIONS,
   getInjectors,
   getMiddlewaresFor,
   registerPlugin,
@@ -84,7 +83,6 @@ function buildPlugin(
     onShutdown?: () => Promise<void>;
   } = {},
   options: {
-    requires?: Record<string, string>;
     requiresCredential?: string[];
     requiresFlag?: string[];
   } = {},
@@ -111,7 +109,6 @@ function buildPlugin(
     manifest: {
       name,
       version: "0.0.1",
-      requires: options.requires ?? { pluginRuntime: "v1" },
       ...(options.requiresCredential
         ? { requiresCredential: options.requiresCredential }
         : {}),
@@ -161,10 +158,6 @@ describe("plugin bootstrap", () => {
     );
     expect(existsSync(ctx.pluginStorageDir)).toBe(true);
     expect(ctx.assistantVersion).toBe("9.9.9-test");
-    // apiVersions must surface the canonical capability table from the
-    // registry so plugins can negotiate at runtime.
-    expect(ctx.apiVersions).toBe(ASSISTANT_API_VERSIONS);
-    expect(ctx.apiVersions.pluginRuntime).toEqual(["v1"]);
   });
 
   test("credential resolution: init receives the resolved value under credentials[key]", async () => {
@@ -215,29 +208,15 @@ describe("plugin bootstrap", () => {
     expect(msg).toContain("absent-key");
   });
 
-  test("version mismatch: registration surfaces a clear error naming the plugin", () => {
-    // The assistant only exposes pluginRuntime@v1 — asking for v99 must fail
-    // registration with the plugin name in the message. The error is raised
-    // at registerPlugin() rather than bootstrap, because the registry is the
-    // single authoritative point of capability validation.
-    const plugin = buildPlugin(
-      "from-the-future",
-      {},
-      { requires: { pluginRuntime: "v99" } },
-    );
-
-    let caught: unknown;
-    try {
-      registerPlugin(plugin);
-    } catch (err) {
-      caught = err;
-    }
-    expect(caught).toBeInstanceOf(PluginExecutionError);
-    const msg = (caught as PluginExecutionError).message;
-    expect(msg).toContain("from-the-future");
-    expect(msg).toContain("pluginRuntime");
-    expect(msg).toContain("v99");
-    expect((caught as PluginExecutionError).pluginName).toBe("from-the-future");
+  test("version mismatch: external plugin loader rejects when peerDependency unsatisfied", async () => {
+    // Host-compat negotiation lives in the external-plugin loader against
+    // `peerDependencies["@vellumai/plugin-api"]`. The registry no longer
+    // re-validates a manifest-level `requires` block — the loader is the
+    // single authoritative point. End-to-end coverage of the loader path
+    // lives in `external-plugin-loader.test.ts`; this test asserts the
+    // bootstrap doesn't gain its own validation surface.
+    const plugin = buildPlugin("compat-claim-checked-upstream");
+    expect(() => registerPlugin(plugin)).not.toThrow();
   });
 
   test("plugin init throw: bootstrap throws a PluginExecutionError naming the plugin", async () => {
@@ -395,13 +374,8 @@ describe("plugin bootstrap", () => {
           {
             name: "gated-off-tool",
             description: "should not be registered",
-            category: "plugin-test",
             defaultRiskLevel: RiskLevel.Low,
-            getDefinition: () => ({
-              name: "gated-off-tool",
-              description: "should not be registered",
-              input_schema: { type: "object", properties: {}, required: [] },
-            }),
+            input_schema: { type: "object", properties: {}, required: [] },
             execute: async () => ({ content: "nope", isError: false }),
           },
         ],

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

@@ -0,0 +1,68 @@
+/**
+ * Tests for the `globalThis.__vellumPluginRuntime` bridge.
+ *
+ * The bridge exists so workspace-local plugins (`<workspaceDir>/plugins/*`)
+ * can register with the daemon's bundled module instances even when the
+ * daemon is a `bun --compile` binary. Absolute-path imports against a
+ * compiled binary load fresh disk copies into a disjoint module graph; the
+ * bridge sidesteps that by attaching a stable handle to globalThis.
+ */
+
+import { afterEach, beforeEach, describe, expect, test } from "bun:test";
+
+import {
+  getPluginRuntime,
+  installPluginRuntime,
+  uninstallPluginRuntimeForTests,
+} from "../plugins/external-api.js";
+import { registerPlugin } from "../plugins/registry.js";
+import { assistantEventHub } from "../runtime/assistant-event-hub.js";
+import { getSecureKeyAsync } from "../security/secure-keys.js";
+
+describe("plugin external-api bridge", () => {
+  beforeEach(() => {
+    uninstallPluginRuntimeForTests();
+  });
+
+  afterEach(() => {
+    uninstallPluginRuntimeForTests();
+  });
+
+  test("installs a runtime handle on globalThis", () => {
+    expect(getPluginRuntime()).toBeUndefined();
+    installPluginRuntime();
+    const runtime = getPluginRuntime();
+    expect(runtime).toBeDefined();
+    expect(runtime?.version).toBe(1);
+  });
+
+  test("exposes the canonical registerPlugin / hub / secrets references", () => {
+    installPluginRuntime();
+    const runtime = getPluginRuntime();
+    expect(runtime?.registerPlugin).toBe(registerPlugin);
+    expect(runtime?.assistantEventHub).toBe(assistantEventHub);
+    expect(runtime?.getSecureKeyAsync).toBe(getSecureKeyAsync);
+  });
+
+  test("plugins can read the runtime via the documented globalThis key", () => {
+    installPluginRuntime();
+    // Mirror the access pattern documented for plugin authors.
+    const runtime = (
+      globalThis as { __vellumPluginRuntime?: { version: number } }
+    ).__vellumPluginRuntime;
+    expect(runtime).toBeDefined();
+    expect(runtime?.version).toBe(1);
+  });
+
+  test("install is idempotent — repeat calls preserve the same handle", () => {
+    installPluginRuntime();
+    const first = getPluginRuntime();
+    installPluginRuntime();
+    installPluginRuntime();
+    expect(getPluginRuntime()).toBe(first);
+  });
+
+  test("getPluginRuntime returns undefined when the bridge is not installed", () => {
+    expect(getPluginRuntime()).toBeUndefined();
+  });
+});

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

@@ -9,7 +9,6 @@
 import { beforeEach, describe, expect, test } from "bun:test";
 
 import {
-  ASSISTANT_API_VERSIONS,
   closeRegistration,
   getInjectors,
   getMiddlewaresFor,
@@ -30,13 +29,11 @@ import {
 function buildPlugin(
   name: string,
   extras: Partial<Omit<Plugin, "manifest">> = {},
-  requiresOverride?: Record<string, string>,
 ): Plugin {
   return {
     manifest: {
       name,
       version: "0.0.1",
-      requires: requiresOverride ?? { pluginRuntime: "v1" },
     },
     ...extras,
   };
@@ -106,7 +103,6 @@ describe("plugin registry", () => {
     const bad = {
       manifest: {
         version: "0.0.1",
-        requires: { pluginRuntime: "v1" },
       },
     } as unknown as Plugin;
     expect(() => registerPlugin(bad)).toThrow(/manifest\.name is required/);
@@ -148,84 +144,11 @@ describe("plugin registry", () => {
     const bad = {
       manifest: {
         name: "missing-version",
-        requires: { pluginRuntime: "v1" },
       },
     } as unknown as Plugin;
     expect(() => registerPlugin(bad)).toThrow(/manifest\.version is required/);
   });
 
-  test("throws when manifest.requires is missing", () => {
-    const bad = {
-      manifest: { name: "missing-requires", version: "0.0.1" },
-    } as unknown as Plugin;
-    expect(() => registerPlugin(bad)).toThrow(/manifest\.requires is required/);
-  });
-
-  test("throws when requires.pluginRuntime is missing", () => {
-    const plugin = buildPlugin(
-      "no-runtime",
-      {},
-      // Valid shape but no pluginRuntime entry.
-      { memoryApi: "v1" },
-    );
-    expect(() => registerPlugin(plugin)).toThrow(PluginExecutionError);
-    expect(() => registerPlugin(plugin)).toThrow(/pluginRuntime/);
-  });
-
-  test("throws with version-mismatch message when a required version is not exposed", () => {
-    // The assistant seeds memoryApi with ["v1"]. Requesting v2 must fail.
-    const plugin = buildPlugin(
-      "too-new",
-      {},
-      {
-        pluginRuntime: "v1",
-        memoryApi: "v2",
-      },
-    );
-
-    expect(() => registerPlugin(plugin)).toThrow(PluginExecutionError);
-
-    // Sanity-check the assistant actually exposes only v1 for memoryApi so
-    // this test fails loudly if the capability table ever adds v2.
-    expect(ASSISTANT_API_VERSIONS.memoryApi).toEqual(["v1"]);
-
-    try {
-      registerPlugin(plugin);
-      throw new Error("expected registerPlugin to throw");
-    } catch (err) {
-      expect(err).toBeInstanceOf(PluginExecutionError);
-      const msg = (err as PluginExecutionError).message;
-      // Error message must reference plugin name, API, required version,
-      // and the versions the assistant exposes.
-      expect(msg).toContain("too-new");
-      expect(msg).toContain("memoryApi");
-      expect(msg).toContain("v2");
-      expect(msg).toContain("v1");
-      expect((err as PluginExecutionError).pluginName).toBe("too-new");
-    }
-  });
-
-  test("throws with clear message when a required capability is unknown", () => {
-    const plugin = buildPlugin(
-      "asks-for-mystery",
-      {},
-      {
-        pluginRuntime: "v1",
-        thisDoesNotExist: "v1",
-      },
-    );
-    expect(() => registerPlugin(plugin)).toThrow(PluginExecutionError);
-    try {
-      registerPlugin(plugin);
-      throw new Error("expected registerPlugin to throw");
-    } catch (err) {
-      const msg = (err as PluginExecutionError).message;
-      expect(msg).toContain("asks-for-mystery");
-      expect(msg).toContain("thisDoesNotExist");
-      expect(msg).toContain("(none)");
-    }
-  });
-
   test("getInjectors returns injectors sorted by order ascending", () => {
     const high: Injector = {
       name: "high-order",

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

@@ -111,7 +111,6 @@ function buildPlugin(
     manifest: {
       name,
       version: "0.0.1",
-      requires: { pluginRuntime: "v1" },
     },
     ...rest,
     ...(mergedHooks ? { hooks: mergedHooks } : {}),

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

@@ -80,7 +80,6 @@ function buildSkillPlugin(
     manifest: {
       name,
       version: "0.0.1",
-      requires: { pluginRuntime: "v1" },
     },
     skills,
     ...extras,
@@ -204,7 +203,6 @@ describe("plugin skill contributions", () => {
       manifest: {
         name: "no-skills-plugin",
         version: "0.0.1",
-        requires: { pluginRuntime: "v1" },
       },
     });