@vellumai/assistant 0.8.1 → 0.8.2

package/src/__tests__/oauth-commands-routes.test.ts

@@ -22,6 +22,8 @@ import { beforeEach, describe, expect, mock, test } from "bun:test";
 interface MockProviderRow {
   provider: string;
   managedServiceConfigKey: string | null;
+  baseUrl: string | null;
+  injectionTemplates: string | null;
   pingUrl: string | null;
   pingMethod: string | null;
   pingHeaders: string | null;
@@ -31,6 +33,8 @@ interface MockProviderRow {
 const baseProvider: MockProviderRow = {
   provider: "google",
   managedServiceConfigKey: "google-oauth",
+  baseUrl: "https://api.google.com",
+  injectionTemplates: null,
   pingUrl: null,
   pingMethod: null,
   pingHeaders: null,
@@ -45,7 +49,10 @@ let mockApps: Record<string, unknown> = {};
 let mockTokenValue = "tok-fake";
 let platformAvailable = true;
 let platformAssistantId: string | null = "assistant-1";
-let mockFetchImpl: (path: string, init?: RequestInit) => Promise<{
+let mockFetchImpl: (
+  path: string,
+  init?: RequestInit,
+) => Promise<{
   ok: boolean;
   status: number;
   json: () => Promise<unknown>;
@@ -61,6 +68,7 @@ let mockResolveResponse: {
   headers: Record<string, string>;
   body: unknown;
 } = { status: 200, headers: {}, body: { ok: true } };
+let mockResolveRequests: unknown[] = [];
 
 const mockDisconnectOAuthProvider = mock(() => Promise.resolve());
 const mockSaveRawConfig = mock(() => undefined);
@@ -102,7 +110,10 @@ mock.module("../oauth/oauth-store.js", () => ({
 
 mock.module("../oauth/connection-resolver.js", () => ({
   resolveOAuthConnection: async (_provider: string) => ({
-    request: async () => mockResolveResponse,
+    request: async (req: unknown) => {
+      mockResolveRequests.push(req);
+      return mockResolveResponse;
+    },
   }),
 }));
 
@@ -119,17 +130,19 @@ mock.module("../platform/client.js", () => ({
 }));
 
 mock.module("../security/token-manager.js", () => ({
-  withValidToken: async <T,>(
-    _provider: string,
-    fn: (t: string) => Promise<T>,
-  ) => fn(mockTokenValue),
+  withValidToken: async <T>(_provider: string, fn: (t: string) => Promise<T>) =>
+    fn(mockTokenValue),
 }));
 
 mock.module("../config/loader.js", () => ({
   getConfig: () => ({ services: {} }),
   loadRawConfig: () => ({ services: {} }),
   saveRawConfig: mockSaveRawConfig,
-  setNestedValue: (obj: Record<string, unknown>, path: string, value: unknown) => {
+  setNestedValue: (
+    obj: Record<string, unknown>,
+    path: string,
+    value: unknown,
+  ) => {
     const parts = path.split(".");
     let cur: Record<string, unknown> = obj;
     for (let i = 0; i < parts.length - 1; i++) {
@@ -152,7 +165,11 @@ mock.module("../config/schemas/services.js", () => ({
   },
 }));
 
-import { BadRequestError, InternalError, NotFoundError } from "../runtime/routes/errors.js";
+import {
+  BadRequestError,
+  InternalError,
+  NotFoundError,
+} from "../runtime/routes/errors.js";
 import { ROUTES } from "../runtime/routes/oauth-commands-routes.js";
 import type { RouteHandlerArgs } from "../runtime/routes/types.js";
 
@@ -194,6 +211,7 @@ beforeEach(() => {
     text: async () => "",
   });
   mockResolveResponse = { status: 200, headers: {}, body: { ok: true } };
+  mockResolveRequests = [];
   mockDisconnectOAuthProvider.mockClear();
   mockSaveRawConfig.mockClear();
 });
@@ -430,7 +448,10 @@ describe("GET oauth/status", () => {
     ];
     const result = (await getRoute("GET", "oauth/status").handler(
       makeArgs({ queryParams: { provider: "google" } }),
-    )) as { mode: string; connections: Array<{ id: string; grantedScopes: string[] }> };
+    )) as {
+      mode: string;
+      connections: Array<{ id: string; grantedScopes: string[] }>;
+    };
     expect(result.mode).toBe("byo");
     expect(result.connections).toHaveLength(1);
     expect(result.connections[0]!.id).toBe("conn-1");
@@ -507,7 +528,11 @@ describe("POST oauth/ping", () => {
       ...baseProvider,
       pingUrl: "https://api.google.com/v1/me",
     };
-    mockResolveResponse = { status: 401, headers: {}, body: { error: "unauthorized" } };
+    mockResolveResponse = {
+      status: 401,
+      headers: {},
+      body: { error: "unauthorized" },
+    };
     const result = (await getRoute("POST", "oauth/ping").handler(
       makeArgs({ body: { provider: "google" } }),
     )) as { ok: boolean; status: number; hint?: string };
@@ -543,7 +568,9 @@ describe("POST oauth/token", () => {
     // No active connections registered for google
     await expect(
       getRoute("POST", "oauth/token").handler(
-        makeArgs({ body: { provider: "google", account: "missing@example.com" } }),
+        makeArgs({
+          body: { provider: "google", account: "missing@example.com" },
+        }),
       ),
     ).rejects.toBeInstanceOf(NotFoundError);
   });
@@ -578,6 +605,130 @@ describe("POST oauth/request", () => {
     expect(result.body).toEqual({ hello: "world" });
   });
 
+  test("rejects absolute URL host outside provider base host when no injection templates exist", async () => {
+    await expect(
+      getRoute("POST", "oauth/request").handler(
+        makeArgs({
+          body: { provider: "google", url: "https://attacker.example/v1/me" },
+        }),
+      ),
+    ).rejects.toBeInstanceOf(BadRequestError);
+    expect(mockResolveRequests).toHaveLength(0);
+  });
+
+  test("rejects protocol downgrade for absolute OAuth request URLs", async () => {
+    await expect(
+      getRoute("POST", "oauth/request").handler(
+        makeArgs({
+          body: { provider: "google", url: "http://api.google.com/v1/me" },
+        }),
+      ),
+    ).rejects.toBeInstanceOf(BadRequestError);
+    expect(mockResolveRequests).toHaveLength(0);
+  });
+
+  test("rejects absolute URL host outside provider injection templates", async () => {
+    mockProviders.slack_channel = {
+      ...baseProvider,
+      provider: "slack_channel",
+      managedServiceConfigKey: null,
+      baseUrl: "https://slack.com/api",
+      injectionTemplates: JSON.stringify([
+        {
+          hostPattern: "slack.com",
+          injectionType: "header",
+          headerName: "Authorization",
+          valuePrefix: "Bearer ",
+        },
+      ]),
+    };
+
+    await expect(
+      getRoute("POST", "oauth/request").handler(
+        makeArgs({
+          body: {
+            provider: "slack_channel",
+            url: "https://attacker.example/api/auth.test",
+          },
+        }),
+      ),
+    ).rejects.toBeInstanceOf(BadRequestError);
+    expect(mockResolveRequests).toHaveLength(0);
+  });
+
+  test("allows absolute URL host matching provider injection templates", async () => {
+    mockProviders.slack_channel = {
+      ...baseProvider,
+      provider: "slack_channel",
+      managedServiceConfigKey: null,
+      baseUrl: "https://slack.com/api",
+      injectionTemplates: JSON.stringify([
+        {
+          hostPattern: "slack.com",
+          injectionType: "header",
+          headerName: "Authorization",
+          valuePrefix: "Bearer ",
+        },
+      ]),
+    };
+
+    await getRoute("POST", "oauth/request").handler(
+      makeArgs({
+        body: {
+          provider: "slack_channel",
+          url: "https://slack.com/api/auth.test?team=T123",
+        },
+      }),
+    );
+
+    expect(mockResolveRequests).toEqual([
+      {
+        method: "GET",
+        path: "/api/auth.test",
+        query: { team: "T123" },
+        baseUrl: "https://slack.com",
+      },
+    ]);
+  });
+
+  test("allows cross-host absolute URLs declared by provider injection templates", async () => {
+    mockProviders.google = {
+      ...baseProvider,
+      baseUrl: "https://gmail.googleapis.com/gmail/v1/users/me",
+      injectionTemplates: JSON.stringify([
+        {
+          hostPattern: "gmail.googleapis.com",
+          injectionType: "header",
+          headerName: "Authorization",
+          valuePrefix: "Bearer ",
+        },
+        {
+          hostPattern: "www.googleapis.com",
+          injectionType: "header",
+          headerName: "Authorization",
+          valuePrefix: "Bearer ",
+        },
+      ]),
+    };
+
+    await getRoute("POST", "oauth/request").handler(
+      makeArgs({
+        body: {
+          provider: "google",
+          url: "https://www.googleapis.com/calendar/v3/calendars",
+        },
+      }),
+    );
+
+    expect(mockResolveRequests).toEqual([
+      {
+        method: "GET",
+        path: "/calendar/v3/calendars",
+        baseUrl: "https://www.googleapis.com",
+      },
+    ]);
+  });
+
   test("attaches reconnect hint on 401 response", async () => {
     mockResolveResponse = { status: 401, headers: {}, body: { error: "no" } };
     const result = (await getRoute("POST", "oauth/request").handler(
@@ -681,10 +832,7 @@ describe("GET oauth/managed-connect/poll", () => {
       ],
       text: async () => "",
     });
-    const result = (await getRoute(
-      "GET",
-      "oauth/managed-connect/poll",
-    ).handler(
+    const result = (await getRoute("GET", "oauth/managed-connect/poll").handler(
       makeArgs({ queryParams: { provider: "google" } }),
     )) as {
       ok: boolean;
@@ -696,7 +844,11 @@ describe("GET oauth/managed-connect/poll", () => {
     };
     expect(result.ok).toBe(true);
     expect(result.connections).toEqual([
-      { id: "conn-1", account_label: "alice@example.com", scopes_granted: ["email"] },
+      {
+        id: "conn-1",
+        account_label: "alice@example.com",
+        scopes_granted: ["email"],
+      },
     ]);
   });
 

package/src/__tests__/oauth-provider-profiles.test.ts

@@ -21,6 +21,15 @@ initializeDb();
 seedOAuthProviders();
 
 describe("oauth provider profiles (DB-seeded)", () => {
+  test("google provider row includes Drive in default scopes", () => {
+    const provider = getProvider("google");
+
+    expect(provider).toBeDefined();
+    expect(JSON.parse(provider!.defaultScopes)).toContain(
+      "https://www.googleapis.com/auth/drive",
+    );
+  });
+
   test("google provider row contains bearer injection templates for 3 Google API hosts", () => {
     const provider = getProvider("google");
 

package/src/__tests__/openai-provider.test.ts

@@ -1344,6 +1344,30 @@ describe("OpenRouterProvider reasoning", () => {
     expect(lastCreateParams!.reasoning).toEqual({ enabled: false });
   });
 
+  test("sends OpenRouter app-attribution headers on OpenAI-compatible requests", async () => {
+    const provider = new OpenRouterProvider("or-key", "x-ai/grok-4");
+    await provider.sendMessage([userMsg("hi")], undefined, undefined, {
+      config: {
+        usageAttributionHeaders: {
+          "Vellum-Organization-Id": "org-123",
+        },
+      },
+    });
+
+    expect(lastCreateOptions?.headers).toEqual(
+      expect.objectContaining({
+        "HTTP-Referer": "https://www.vellum.ai",
+        "X-OpenRouter-Title": "Vellum Assistant",
+        "X-OpenRouter-Categories": "personal-agent,cli-agent",
+        "Vellum-Organization-Id": "org-123",
+      }),
+    );
+    expect(lastCreateParams).not.toHaveProperty("HTTP-Referer");
+    expect(lastCreateParams).not.toHaveProperty("X-OpenRouter-Title");
+    expect(lastCreateParams).not.toHaveProperty("X-OpenRouter-Categories");
+    expect(lastCreateParams).not.toHaveProperty("usageAttributionHeaders");
+  });
+
   test("RetryProvider + OpenRouterProvider enables thinking end-to-end", async () => {
     const provider = new OpenRouterProvider("or-key", "x-ai/grok-4");
     const retry = new RetryProvider(provider);

package/src/__tests__/openai-responses-cutover-guard.test.ts

@@ -91,18 +91,26 @@ describe("OpenAI Responses API cutover guard", () => {
     ).toBe(true);
 
     // The factory must NOT instantiate OpenAIChatCompletionsProvider or
-    // OpenAIProvider (the backward-compatible alias) for the "openai" key.
-    // Chat-completions classes may appear in imports but should not be
-    // instantiated in the openai factory entry.
-    const chatCompletionsInstantiations = [
-      ...source.matchAll(/new\s+OpenAIChatCompletionsProvider\s*\(/g),
-      ...source.matchAll(/new\s+OpenAIProvider\s*\(/g),
+    // OpenAIProvider (the backward-compatible alias) inside the `openai:`
+    // factory entry. Other entries (e.g. `zai:`, `deepseek:`, `minimax:`)
+    // may legitimately use OpenAIChatCompletionsProvider since that's the
+    // OpenAI Chat Completions transport for third-party endpoints.
+    const openaiEntryRegion =
+      /(?:^|\s)openai\s*:\s*\([^)]*\)\s*=>\s*[\s\S]{0,400}?(?=\}\s*,\s*[a-z-]+\s*:|\}\s*;)/m.exec(
+        source,
+      )?.[0] ?? "";
+    const chatCompletionsInstantiationsInOpenAi = [
+      ...openaiEntryRegion.matchAll(
+        /new\s+OpenAIChatCompletionsProvider\s*\(/g,
+      ),
+      ...openaiEntryRegion.matchAll(/new\s+OpenAIProvider\s*\(/g),
     ];
     expect(
-      chatCompletionsInstantiations.length,
+      chatCompletionsInstantiationsInOpenAi.length,
       [
-        "adapter-factory.ts must NOT instantiate OpenAIChatCompletionsProvider or",
-        "OpenAIProvider (legacy alias). Use OpenAIResponsesProvider for openai.",
+        "ADAPTER_FACTORIES['openai'] must NOT instantiate",
+        "OpenAIChatCompletionsProvider or OpenAIProvider (legacy alias).",
+        "Use OpenAIResponsesProvider for openai.",
       ].join("\n"),
     ).toBe(0);
 

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(() => {

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 }),
           },
         ],