@vellumai/assistant 0.10.8 → 0.10.9-dev.202607152225.ec6fdbf

package/src/cli/commands/webhooks.help.ts

@@ -0,0 +1,95 @@
+/** Declarative help for the `assistant webhooks` command. */
+
+import type { CliCommandHelp } from "../lib/cli-command-help.js";
+
+export const webhooksHelp: CliCommandHelp = {
+  name: "webhooks",
+  description: "Manage webhook callback URLs for external integrations",
+  options: [
+    { flags: "--json", description: "Machine-readable compact JSON output" },
+  ],
+  helpText: `
+Resolves a stable callback URL that external services (Telegram, Twilio,
+email providers, OAuth) should use to reach this assistant.
+
+On platform-managed assistants, this registers a callback route with the
+platform gateway. On self-hosted assistants, it uses the configured
+ingress.publicBaseUrl.
+
+The webhook path is derived from the type: underscores become path
+separators, prefixed with webhooks/.
+
+  telegram       → webhooks/telegram
+  twilio_voice   → webhooks/twilio/voice
+  twilio_status  → webhooks/twilio/status
+  resend         → webhooks/resend
+
+Examples:
+  $ assistant webhooks register telegram
+  $ assistant webhooks register resend --source "@bot_handle"
+  $ assistant webhooks list
+  $ assistant webhooks list --json`,
+  subcommands: [
+    {
+      name: "register",
+      args: "<type>",
+      description:
+        "Get a callback URL for a webhook type, registering with the platform if needed",
+      options: [
+        {
+          flags: "--path <path>",
+          description: "Override the derived webhook path",
+        },
+        {
+          flags: "--source <label>",
+          description:
+            "Human-readable source label for admin display (e.g. bot handle, phone number)",
+        },
+      ],
+      helpText: `
+Resolves a callback URL for the given webhook type. On platform-managed
+assistants (IS_PLATFORM=true), registers a callback route with the platform
+gateway and returns the stable external URL. On self-hosted assistants,
+reads ingress.publicBaseUrl from config and appends the webhook path.
+
+Arguments:
+  type   The webhook type to register. The path is derived automatically:
+         underscores become path separators, prefixed with webhooks/.
+
+           telegram       → webhooks/telegram
+           twilio_voice   → webhooks/twilio/voice
+           twilio_status  → webhooks/twilio/status
+           resend         → webhooks/resend
+           mailgun        → webhooks/mailgun
+           email          → webhooks/email
+           oauth_callback → webhooks/oauth/callback
+
+Options:
+  --path <path>     Override the derived webhook path.
+  --source <label>  Human-readable source label (e.g. bot handle, phone number)
+                    for admin display.
+
+Examples:
+  $ assistant webhooks register telegram --source "@my_bot"
+  $ assistant webhooks register twilio_voice --json
+  $ assistant webhooks register resend --json
+  $ assistant webhooks register custom_provider --path webhooks/my-provider --json`,
+    },
+    {
+      name: "list",
+      description: "List registered webhook callback routes",
+      helpText: `
+Lists all webhook callback routes registered with the platform for this
+assistant. Only available when platform credentials are configured (either
+via IS_PLATFORM or 'assistant platform connect').
+
+Self-hosted assistants without platform credentials do not have a persistent
+webhook registry — use 'assistant webhooks register <type>' to resolve URLs
+on demand.
+
+Examples:
+  $ assistant webhooks list
+  $ assistant webhooks list --json`,
+    },
+  ],
+};

package/src/cli/commands/webhooks.ts

@@ -10,137 +10,61 @@
 import type { Command } from "commander";
 
 import { cliIpcCall, exitFromIpcResult } from "../../ipc/cli-client.js";
+import { applyCommandHelp, subcommand } from "../lib/cli-command-help.js";
 import { registerCommand } from "../lib/register-command.js";
 import { log } from "../logger.js";
 import { shouldOutputJson, writeOutput } from "../output.js";
+import { webhooksHelp } from "./webhooks.help.js";
 
 export function registerWebhooksCommand(program: Command): void {
   registerCommand(program, {
-    name: "webhooks",
+    name: webhooksHelp.name,
     transport: "ipc",
-    description: "Manage webhook callback URLs for external integrations",
+    description: webhooksHelp.description,
     build: (webhooks) => {
-      webhooks.option("--json", "Machine-readable compact JSON output");
-      webhooks.addHelpText(
-        "after",
-        `
-Resolves a stable callback URL that external services (Telegram, Twilio,
-email providers, OAuth) should use to reach this assistant.
-
-On platform-managed assistants, this registers a callback route with the
-platform gateway. On self-hosted assistants, it uses the configured
-ingress.publicBaseUrl.
-
-The webhook path is derived from the type: underscores become path
-separators, prefixed with webhooks/.
-
-  telegram       → webhooks/telegram
-  twilio_voice   → webhooks/twilio/voice
-  twilio_status  → webhooks/twilio/status
-  resend         → webhooks/resend
-
-Examples:
-  $ assistant webhooks register telegram
-  $ assistant webhooks register resend --source "@bot_handle"
-  $ assistant webhooks list
-  $ assistant webhooks list --json`,
-      );
+      applyCommandHelp(webhooks, webhooksHelp);
 
       // -----------------------------------------------------------------------
       // webhooks register <type>
       // -----------------------------------------------------------------------
 
-      webhooks
-        .command("register <type>")
-        .description(
-          "Get a callback URL for a webhook type, registering with the platform if needed",
-        )
-        .addHelpText(
-          "after",
-          `
-Resolves a callback URL for the given webhook type. On platform-managed
-assistants (IS_PLATFORM=true), registers a callback route with the platform
-gateway and returns the stable external URL. On self-hosted assistants,
-reads ingress.publicBaseUrl from config and appends the webhook path.
-
-Arguments:
-  type   The webhook type to register. The path is derived automatically:
-         underscores become path separators, prefixed with webhooks/.
-
-           telegram       → webhooks/telegram
-           twilio_voice   → webhooks/twilio/voice
-           twilio_status  → webhooks/twilio/status
-           resend         → webhooks/resend
-           mailgun        → webhooks/mailgun
-           email          → webhooks/email
-           oauth_callback → webhooks/oauth/callback
-
-Options:
-  --path <path>     Override the derived webhook path.
-  --source <label>  Human-readable source label (e.g. bot handle, phone number)
-                    for admin display.
-
-Examples:
-  $ assistant webhooks register telegram --source "@my_bot"
-  $ assistant webhooks register twilio_voice --json
-  $ assistant webhooks register resend --json
-  $ assistant webhooks register custom_provider --path webhooks/my-provider --json`,
-        )
-        .option("--path <path>", "Override the derived webhook path")
-        .option(
-          "--source <label>",
-          "Human-readable source label for admin display (e.g. bot handle, phone number)",
-        )
-        .action(
-          async (
-            type: string,
-            opts: { path?: string; source?: string },
-            cmd: Command,
-          ) => {
-            const r = await cliIpcCall<{
-              callbackUrl: string;
-              type: string;
-              path: string;
-              mode: "platform" | "self-hosted";
-            }>("webhooks_register", {
-              body: {
-                type,
-                path: opts.path,
-                source: opts.source,
-              },
-            });
-            if (!r.ok) return exitFromIpcResult({ ok: false, error: r.error, statusCode: r.statusCode }, cmd);
-            if (shouldOutputJson(cmd)) {
-              writeOutput(cmd, { ok: true, ...r.result });
-            } else {
-              process.stdout.write(r.result!.callbackUrl + "\n");
-            }
-          },
-        );
+      subcommand(webhooks, "register").action(
+        async (
+          type: string,
+          opts: { path?: string; source?: string },
+          cmd: Command,
+        ) => {
+          const r = await cliIpcCall<{
+            callbackUrl: string;
+            type: string;
+            path: string;
+            mode: "platform" | "self-hosted";
+          }>("webhooks_register", {
+            body: {
+              type,
+              path: opts.path,
+              source: opts.source,
+            },
+          });
+          if (!r.ok)
+            return exitFromIpcResult(
+              { ok: false, error: r.error, statusCode: r.statusCode },
+              cmd,
+            );
+          if (shouldOutputJson(cmd)) {
+            writeOutput(cmd, { ok: true, ...r.result });
+          } else {
+            process.stdout.write(r.result!.callbackUrl + "\n");
+          }
+        },
+      );
 
       // -----------------------------------------------------------------------
       // webhooks list
       // -----------------------------------------------------------------------
 
-      webhooks
-        .command("list")
-        .description("List registered webhook callback routes")
-        .addHelpText(
-          "after",
-          `
-Lists all webhook callback routes registered with the platform for this
-assistant. Only available when platform credentials are configured (either
-via IS_PLATFORM or 'assistant platform connect').
-
-Self-hosted assistants without platform credentials do not have a persistent
-webhook registry — use 'assistant webhooks register <type>' to resolve URLs
-on demand.
-
-Examples:
-  $ assistant webhooks list
-  $ assistant webhooks list --json`,
-        )
-        .action(async (_opts: Record<string, unknown>, cmd: Command) => {
+      subcommand(webhooks, "list").action(
+        async (_opts: Record<string, unknown>, cmd: Command) => {
           const r = await cliIpcCall<{
             routes: Array<{
               id: string;
@@ -151,7 +75,11 @@ Examples:
               source_identifier: string | null;
             }>;
           }>("webhooks_list", {});
-          if (!r.ok) return exitFromIpcResult({ ok: false, error: r.error, statusCode: r.statusCode }, cmd);
+          if (!r.ok)
+            return exitFromIpcResult(
+              { ok: false, error: r.error, statusCode: r.statusCode },
+              cmd,
+            );
           if (shouldOutputJson(cmd)) {
             writeOutput(cmd, { ok: true, routes: r.result!.routes });
           } else {
@@ -170,7 +98,8 @@ Examples:
               }
             }
           }
-        });
+        },
+      );
     },
   });
 }

package/src/cli/index.help.ts

@@ -11,13 +11,104 @@
  * the memory indexer no longer needs `buildCliProgramTree()`.
  */
 
+import { appsHelp } from "./commands/apps.help.js";
 import { attachmentHelp } from "./commands/attachment.help.js";
 import { auditHelp } from "./commands/audit.help.js";
 import { authHelp } from "./commands/auth.help.js";
+import { avatarHelp } from "./commands/avatar.help.js";
+import { backupHelp } from "./commands/backup.help.js";
+import { bashHelp } from "./commands/bash.help.js";
+import { browserHelp } from "./commands/browser.help.js";
+import { cacheHelp } from "./commands/cache.help.js";
+import { changelogHelp } from "./commands/changelog.help.js";
+import { channelVerificationSessionsHelp } from "./commands/channel-verification-sessions.help.js";
+import { channelsHelp } from "./commands/channels/index.help.js";
+import { clientsHelp } from "./commands/clients.help.js";
+import { completionsHelp } from "./commands/completions.help.js";
+import { configHelp } from "./commands/config.help.js";
+import { contactsHelp } from "./commands/contacts.help.js";
+import { conversationsHelp } from "./commands/conversations.help.js";
+import { credentialsHelp } from "./commands/credentials.help.js";
+import { dbHelp } from "./commands/db/index.help.js";
+import { domainHelp } from "./commands/domain.help.js";
+import { emailHelp } from "./commands/email.help.js";
+import { gatewayHelp } from "./commands/gateway.help.js";
+import { imageGenerationHelp } from "./commands/image-generation.help.js";
+import { inferenceHelp, llmHelp } from "./commands/inference.help.js";
+import { keysHelp } from "./commands/keys.help.js";
+import { mcpHelp } from "./commands/mcp.help.js";
+import { memoryHelp } from "./commands/memory/index.help.js";
+import { monitoringHelp } from "./commands/monitoring.help.js";
+import { notificationsHelp } from "./commands/notifications.help.js";
+import { oauthHelp } from "./commands/oauth/index.help.js";
+import { pendingHelp } from "./commands/pending.help.js";
+import { platformHelp } from "./commands/platform/index.help.js";
+import { pluginsHelp } from "./commands/plugins.help.js";
+import { psHelp } from "./commands/ps.help.js";
+import { routesHelp } from "./commands/routes.help.js";
+import { schedulesHelp } from "./commands/schedules.help.js";
+import { sequenceHelp } from "./commands/sequence.help.js";
+import { skillsHelp } from "./commands/skills.help.js";
+import { statusHelp } from "./commands/status.help.js";
+import { sttHelp } from "./commands/stt.help.js";
+import { telemetryHelp } from "./commands/telemetry.help.js";
+import { toolsHelp } from "./commands/tools.help.js";
+import { trustHelp } from "./commands/trust.help.js";
+import { ttsHelp } from "./commands/tts.help.js";
+import { uiHelp } from "./commands/ui.help.js";
+import { usageHelp } from "./commands/usage.help.js";
+import { watchersHelp } from "./commands/watchers.help.js";
+import { webhooksHelp } from "./commands/webhooks.help.js";
 import type { CliCommandHelp } from "./lib/cli-command-help.js";
 
 export const CLI_COMMAND_HELP: readonly CliCommandHelp[] = [
+  appsHelp,
   attachmentHelp,
   auditHelp,
   authHelp,
+  avatarHelp,
+  backupHelp,
+  bashHelp,
+  browserHelp,
+  cacheHelp,
+  changelogHelp,
+  channelVerificationSessionsHelp,
+  channelsHelp,
+  clientsHelp,
+  completionsHelp,
+  configHelp,
+  contactsHelp,
+  conversationsHelp,
+  credentialsHelp,
+  dbHelp,
+  domainHelp,
+  emailHelp,
+  gatewayHelp,
+  imageGenerationHelp,
+  inferenceHelp,
+  keysHelp,
+  llmHelp,
+  mcpHelp,
+  memoryHelp,
+  notificationsHelp,
+  oauthHelp,
+  pendingHelp,
+  platformHelp,
+  pluginsHelp,
+  monitoringHelp,
+  psHelp,
+  routesHelp,
+  schedulesHelp,
+  sequenceHelp,
+  skillsHelp,
+  statusHelp,
+  sttHelp,
+  telemetryHelp,
+  toolsHelp,
+  trustHelp,
+  ttsHelp,
+  uiHelp,
+  usageHelp,
+  watchersHelp,
+  webhooksHelp,
 ];

package/src/cli/lib/__tests__/global-json-option.test.ts

@@ -0,0 +1,97 @@
+import { describe, expect, it } from "bun:test";
+
+import { Command } from "commander";
+
+import { registerGlobalJsonOption } from "../global-json-option.js";
+
+function hasJsonOption(cmd: Command): boolean {
+  return cmd.options.some((opt) => opt.long === "--json");
+}
+
+describe("registerGlobalJsonOption", () => {
+  it("adds --json to leaf commands (including nested leaves)", () => {
+    const program = new Command();
+    program.name("assistant");
+    const memory = program.command("memory");
+    const items = memory.command("items");
+    const list = items.command("list");
+    const status = program.command("status");
+
+    registerGlobalJsonOption(program);
+
+    expect(hasJsonOption(list)).toBe(true);
+    expect(hasJsonOption(status)).toBe(true);
+  });
+
+  it("does NOT add --json to group commands (would steal the flag from subcommands)", () => {
+    const program = new Command();
+    program.name("assistant");
+    const clients = program.command("clients");
+    const list = clients.command("list");
+
+    registerGlobalJsonOption(program);
+
+    // Commander consumes a recognized option at the outermost declaring
+    // command, so a group-level --json would swallow `clients list --json`
+    // before the leaf action reads it.
+    expect(hasJsonOption(clients)).toBe(false);
+    expect(hasJsonOption(list)).toBe(true);
+  });
+
+  it("keeps `<group> <leaf> --json` bound to the leaf's own opts", () => {
+    const program = new Command();
+    program.name("assistant").exitOverride();
+    const clients = program.command("clients");
+    let leafJson: unknown;
+    clients.command("list").action((opts: { json?: boolean }) => {
+      leafJson = opts.json;
+    });
+
+    registerGlobalJsonOption(program);
+
+    program.parse(["node", "assistant", "clients", "list", "--json"]);
+    expect(leafJson).toBe(true);
+  });
+
+  it("does not duplicate --json on a command that already declares it", () => {
+    const program = new Command();
+    program.name("assistant");
+    const sub = program.command("nodes");
+    sub.option("--json", "Machine-readable compact JSON output");
+
+    registerGlobalJsonOption(program);
+
+    const jsonOptions = sub.options.filter((opt) => opt.long === "--json");
+    expect(jsonOptions).toHaveLength(1);
+    // The original description is preserved, not overwritten.
+    expect(jsonOptions[0]!.description).toBe(
+      "Machine-readable compact JSON output",
+    );
+  });
+
+  it("leaves the root program without a --json option", () => {
+    const program = new Command();
+    program.name("assistant");
+    program.command("status");
+
+    registerGlobalJsonOption(program);
+
+    expect(hasJsonOption(program)).toBe(false);
+  });
+
+  it("makes --json parse without error on a command that lacked it", () => {
+    const program = new Command();
+    program.name("assistant").exitOverride();
+    let seenJson: unknown;
+    program.command("status").action((opts: { json?: boolean }) => {
+      seenJson = opts.json;
+    });
+
+    registerGlobalJsonOption(program);
+
+    expect(() =>
+      program.parse(["node", "assistant", "status", "--json"]),
+    ).not.toThrow();
+    expect(seenJson).toBe(true);
+  });
+});

package/src/cli/lib/__tests__/install-from-github.test.ts

@@ -78,14 +78,14 @@ function makeContentsFetch(opts: {
     const prefix = apiPath ? `${apiPath}/` : "";
     const direct = new Map<string, boolean>();
     for (const key of Object.keys(tree)) {
-      if (!key.startsWith(prefix)) continue;
+      if (!key.startsWith(prefix)) {continue;}
       const remainder = key.slice(prefix.length);
-      if (!remainder) continue;
+      if (!remainder) {continue;}
       const seg = remainder.split("/")[0]!;
       const isDir = remainder.includes("/") || tree[`${prefix}${seg}`] === null;
       direct.set(seg, (direct.get(seg) ?? false) || isDir);
     }
-    if (direct.size === 0) return null;
+    if (direct.size === 0) {return null;}
     return Array.from(direct.entries()).map(([name, isDir]) => {
       const path = `${prefix}${name}`;
       return isDir
@@ -157,7 +157,7 @@ function fakeGitRunner(opts: {
     opts.calls?.push([...args]);
     switch (args[0]) {
       case "fetch": {
-        if (opts.fetchError) throw opts.fetchError;
+        if (opts.fetchError) {throw opts.fetchError;}
         mkdirSync(join(cwd, ".git"), { recursive: true });
         writeFileSync(join(cwd, ".git", "config"), "[core]\n");
         for (const [rel, content] of Object.entries(opts.tree)) {
@@ -686,6 +686,114 @@ describe("installPlugin — marketplace resolution", () => {
     expect(hook).not.toContain("description: terse mode");
   });
 
+  test("a trusted pre-resolved source still overlays the curated adapter stub", async () => {
+    // GIVEN caveman's pin already resolved (as the offline bundled catalog
+    // does) — so no marketplace manifest is served — but the real curated
+    // adapter stub IS available to overlay
+    const fetch = makeContentsFetch({ tree: readRealCavemanStub() });
+    const runGit = fakeGitRunner({
+      tree: {
+        "package.json": JSON.stringify({
+          name: "caveman-installer",
+          version: "0.1.0",
+        }),
+        "skills/caveman/SKILL.md":
+          "---\nname: caveman\n---\n\nCAVEMAN MODE. Drop filler words.",
+      },
+      commit: CAVEMAN_SHA,
+    });
+
+    // WHEN we install from trusted pre-resolved coordinates
+    const result = await installPlugin(
+      {
+        name: "caveman",
+        trustedSource: {
+          owner: "JuliusBrussee",
+          repo: "caveman",
+          rootPath: "",
+          ref: CAVEMAN_SHA,
+        },
+      },
+      { fetch, runGit, workspacePluginsDir: pluginsDir },
+    );
+
+    // THEN the adapter overlay ran (the stub was NOT skipped): the manifest was
+    // normalized and the pre-model-call hook synthesized from the ruleset
+    const target = join(pluginsDir, "caveman");
+    expect(result.commit).toBe(CAVEMAN_SHA);
+    const pkg = JSON.parse(readFileSync(join(target, "package.json"), "utf-8"));
+    expect(pkg.name).toBe("caveman");
+    expect(pkg.peerDependencies["@vellumai/plugin-api"]).toBeString();
+    expect(pkg.scripts?.postinstall).toBeUndefined();
+    const hook = readFileSync(
+      join(target, "hooks", "pre-model-call.ts"),
+      "utf-8",
+    );
+    expect(hook).toContain("CAVEMAN MODE. Drop filler words.");
+  });
+
+  test("fetches the offline adapter stub at the canonical ref, not the external content commit", async () => {
+    // GIVEN caveman's pin already resolved (offline bundled catalog) with the
+    // real curated stub. `trustedSource` names the EXTERNAL content repo, and
+    // its `ref` is caveman's content commit — which does NOT exist in this repo,
+    // where the stub lives. Model production: the canonical repo resolves the
+    // stub only at `main` (DEFAULT_PLUGIN_REF) and 404s any other ref.
+    const base = makeContentsFetch({ tree: readRealCavemanStub() });
+    const stubRefs: string[] = [];
+    const stubContentsPrefix = `https://api.github.com/repos/${CANON_REPO}/contents/plugins/caveman`;
+    const fetch: FetchLike = async (input, init) => {
+      const url = typeof input === "string" ? input : input.toString();
+      if (url.startsWith(stubContentsPrefix)) {
+        const ref = new URL(url).searchParams.get("ref") ?? "";
+        stubRefs.push(ref);
+        if (ref !== "main") {
+          return new Response("No commit found for the ref", { status: 404 });
+        }
+      }
+      return base(url, init);
+    };
+    const runGit = fakeGitRunner({
+      tree: {
+        "package.json": JSON.stringify({
+          name: "caveman-installer",
+          version: "0.1.0",
+        }),
+        "skills/caveman/SKILL.md":
+          "---\nname: caveman\n---\n\nCAVEMAN MODE. Drop filler words.",
+      },
+      commit: CAVEMAN_SHA,
+    });
+
+    // WHEN we install from trusted pre-resolved (external) coordinates
+    await installPlugin(
+      {
+        name: "caveman",
+        trustedSource: {
+          owner: "JuliusBrussee",
+          repo: "caveman",
+          rootPath: "",
+          ref: CAVEMAN_SHA,
+        },
+      },
+      { fetch, runGit, workspacePluginsDir: pluginsDir },
+    );
+
+    // THEN the stub was fetched from the canonical repo at `main`, never at the
+    // external content commit (they live in different repos, so the content SHA
+    // would 404 against this repo and silently skip the overlay)
+    expect(stubRefs.length).toBeGreaterThan(0);
+    expect(stubRefs).not.toContain(CAVEMAN_SHA);
+    for (const ref of stubRefs) {
+      expect(ref).toBe("main");
+    }
+    // AND because the stub resolved, the adapter overlay still ran
+    const pkg = JSON.parse(
+      readFileSync(join(pluginsDir, "caveman", "package.json"), "utf-8"),
+    );
+    expect(pkg.name).toBe("caveman");
+    expect(pkg.peerDependencies["@vellumai/plugin-api"]).toBeString();
+  });
+
   test("falls back to the stub manifest when the upstream ships no package.json", async () => {
     // GIVEN caveman is whitelisted with the real curated adapter stub
     const fetch = makeContentsFetch({
@@ -1097,6 +1205,38 @@ describe("installPlugin — direct (untrusted) install", () => {
     ).rejects.toBeInstanceOf(PluginSourceUnavailableError);
     expect(readdirSync(pluginsDir)).toEqual([]);
   });
+
+  test("synthesizes a minimal package.json when the upstream repo ships none", async () => {
+    // GIVEN a plugin tree with no package.json at all
+    const fetch = makeContentsFetch({ tree: {} });
+    const runGit = fakeGitRunner({
+      tree: { "hooks/init.ts": "//", "README.md": "# bare" },
+      commit: "f".repeat(40),
+    });
+
+    // WHEN we install directly
+    await installPlugin(
+      {
+        name: "bare-plugin",
+        directSource: {
+          owner: "owner",
+          repo: "bare",
+          rootPath: "",
+          ref: "HEAD",
+        },
+      },
+      { fetch, runGit, workspacePluginsDir: pluginsDir },
+    );
+
+    // THEN a minimal package.json is synthesized with the install name and
+    // the default plugin-api peer dependency range
+    const pkgPath = join(pluginsDir, "bare-plugin", "package.json");
+    expect(existsSync(pkgPath)).toBe(true);
+    const pkg = JSON.parse(readFileSync(pkgPath, "utf-8"));
+    expect(pkg.name).toBe("bare-plugin");
+    expect(pkg.version).toBe("0.0.0");
+    expect(pkg.peerDependencies["@vellumai/plugin-api"]).toBeDefined();
+  });
 });
 
 describe("sanitizePluginName", () => {