@plasm_lang/vercel-agent 0.3.77 → 0.3.78

package/README.md

@@ -152,9 +152,16 @@ npm run smoke:stubs:matrix
 npm run agent -- "your prompt"   # requires AI_GATEWAY_API_KEY (Vercel AI Gateway)
 ```
 
-### Dev server (`npm run dev` / `plasm-agent dev`)
+### Dev server (`plasm-agent dev`)
 
-When stdin is a TTY, `plasm-agent dev` starts the server **and** opens an interactive terminal client (eve-style). Use `--no-tui` or `PLASM_DEV_NO_TUI=1` for headless mode. Attach later with `plasm-agent chat --url http://127.0.0.1:3000`.
+**Default:** Nitro dev server with **Vercel routing parity** (channels, cron, `/plasm/v1/info`) — same `vercelPlasmHandler` as deploy. Init scaffolds `nitro.config.ts` + `routes/[...path].ts` and adds `nitropack` as a devDependency.
+
+```bash
+plasm-agent dev                    # Nitro (default)
+plasm-agent dev --interactive      # in-process server + TUI when TTY
+plasm-agent dev --interactive --no-tui
+plasm-agent chat --url http://127.0.0.1:3000
+```
 
 Slash commands in the TUI: `/help`, `/info`, `/model`, `/channels`, `/catalogs`, `/new`, `/quit`.
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@plasm_lang/vercel-agent",
-  "version": "0.3.77",
+  "version": "0.3.78",
   "description": "Catalog-native TypeScript agent framework (Plasm CGS/CML, Vercel AI SDK, Nitro-oriented)",
   "license": "GPL-3.0-or-later",
   "repository": {
@@ -26,6 +26,9 @@
     "src",
     "bin",
     "scripts/plasm-node.mjs",
+    "scripts/plasm-cli.ts",
+    "scripts/build-stubs.ts",
+    "scripts/register-plasm-loader.mjs",
     "scripts/resolve-ts-extension.mjs",
     "agent",
     "README.md"
@@ -54,7 +57,7 @@
   "dependencies": {
     "@ai-sdk/otel": "^1.0.0-beta.6",
     "@opentelemetry/api": "^1.9.0",
-    "@plasm_lang/engine": "^0.3.77",
+    "@plasm_lang/engine": "^0.3.78",
     "@vercel/blob": "^0.27.3",
     "@vercel/connect": "^0.2.6",
     "@vercel/kv": "^3.0.0",
@@ -63,7 +66,7 @@
     "js-yaml": "^4.1.0",
     "pg": "^8.22.0",
     "workflow": "^4.5.0",
-    "zod": "^3.24.0"
+    "zod": "^3.25.76"
   },
   "devDependencies": {
     "@types/js-yaml": "^4.0.9",

package/scripts/build-stubs.ts

@@ -0,0 +1,27 @@
+#!/usr/bin/env node
+/**
+ * Scan agent/catalogs/ and emit TypeScript stubs to agent/.plasm/stubs/<entry_id>.ts
+ */
+import path from "node:path";
+import { fileURLToPath } from "node:url";
+
+import { generateAllStubs } from "../src/stubs/generator.js";
+
+const packageRoot = path.dirname(path.dirname(fileURLToPath(import.meta.url)));
+const agentRoot = path.join(packageRoot, "agent");
+
+async function main() {
+  const results = await generateAllStubs(agentRoot);
+  if (!results.length) {
+    console.error("no catalogs found under agent/catalogs/");
+    process.exit(1);
+  }
+  for (const result of results) {
+    console.log(`${result.entryId}\t${result.catalogCgsHash}\t${result.outPath}`);
+  }
+}
+
+main().catch((err) => {
+  console.error(err);
+  process.exit(1);
+});

package/scripts/plasm-cli.ts

@@ -0,0 +1,161 @@
+#!/usr/bin/env node
+/**
+ * TypeScript CLI for @plasm_lang/vercel-agent (not the Rust plasm-server TUI).
+ */
+import path from "node:path";
+
+import { runPlasmBuild } from "../src/cli/build.js";
+import {
+  installDevServerShutdown,
+  startDevServerForProject,
+} from "../src/cli/dev.js";
+import { startNitroDevForProject } from "../src/cli/nitro-dev.js";
+import { runDevTui } from "../src/dev/client/repl.js";
+import { collectProjectInfo, formatPlasmInfoHuman } from "../src/cli/info.js";
+import { runPlasmInit, formatInitSuccess } from "../src/cli/init.js";
+import { runPlasmLink } from "../src/cli/link.js";
+import {
+  requireAgentProject,
+  readPackageName,
+  resolveAgentProject,
+} from "../src/cli/project-root.js";
+import { loadAgentEnv } from "../src/load-env.js";
+
+loadAgentEnv();
+
+const args = process.argv.slice(2);
+const command = args[0];
+
+function flag(name: string): boolean {
+  return args.includes(name);
+}
+
+function optionValue(flagName: string): string | undefined {
+  const index = args.indexOf(flagName);
+  if (index < 0) return undefined;
+  const value = args[index + 1];
+  if (!value || value.startsWith("-")) return undefined;
+  return value;
+}
+
+function initTargetDir(): string {
+  for (let i = 1; i < args.length; i++) {
+    const arg = args[i];
+    if (arg.startsWith("-")) {
+      if (arg === "--template") i++;
+      continue;
+    }
+    return arg;
+  }
+  return process.cwd();
+}
+
+async function cmdInit(): Promise<void> {
+  const template = optionValue("--template");
+  const target = initTargetDir();
+  const project = await runPlasmInit(target, { template });
+  console.log(formatInitSuccess(project, { template }));
+}
+
+async function cmdInfo(): Promise<void> {
+  const project = await requireAgentProject();
+  const packageName = await readPackageName(project.projectRoot);
+  const info = await collectProjectInfo({
+    projectRoot: project.projectRoot,
+    agentRoot: project.agentRoot,
+    packageName,
+  });
+  if (flag("--json")) {
+    console.log(JSON.stringify(info, null, 2));
+    return;
+  }
+  console.log(formatPlasmInfoHuman(info));
+}
+
+async function cmdLink(): Promise<void> {
+  const project = await requireAgentProject();
+  const result = await runPlasmLink(project.projectRoot);
+  for (const line of result.messages) console.log(line);
+  if (!result.linked && !result.envPulled) process.exitCode = 1;
+}
+
+async function cmdBuild(): Promise<void> {
+  const project = await requireAgentProject();
+  const result = await runPlasmBuild(project);
+  console.log(`Built ${result.stubs.length} stub(s)`);
+  console.log(`manifest: ${result.manifestPath}`);
+  for (const stub of result.stubs) {
+    console.log(`  - ${stub.entryId} → ${path.relative(project.projectRoot, stub.outPath)}`);
+  }
+}
+
+async function cmdDev(): Promise<void> {
+  const project = await requireAgentProject();
+  if (flag("--interactive")) {
+    const handle = await startDevServerForProject({
+      project,
+      tui: flag("--no-tui") ? false : "auto",
+    });
+    installDevServerShutdown(handle);
+    return;
+  }
+  await startNitroDevForProject(project);
+}
+
+async function cmdChat(): Promise<void> {
+  const urlFlag = args.find((a, i) => args[i - 1] === "--url");
+  const baseUrl = urlFlag ?? process.env.PLASM_DEV_URL ?? "http://127.0.0.1:3000";
+  await runDevTui({ baseUrl });
+}
+
+async function main(): Promise<void> {
+  if (!command || command === "--help" || command === "-h") {
+    console.log(`plasm-agent — @plasm_lang/vercel-agent CLI
+
+Commands:
+  init [dir] [--template NAME]  Scaffold agent project (templates: mcp-radar)
+  info [--json] Project + catalog diagnostics
+  link          vercel link + env pull (AI Gateway key)
+  build         CGS stubs + .plasm/discovery/manifest.json
+  dev [--interactive] [--no-tui]  Nitro dev (Vercel routing parity; default). --interactive for TUI/sessions.
+  chat [--url URL]  Terminal client for a running dev server
+`);
+    return;
+  }
+
+  switch (command) {
+    case "init":
+      await cmdInit();
+      break;
+    case "info": {
+      const resolved = await resolveAgentProject();
+      if (!resolved) {
+        console.error("No agent project found. Run `plasm-agent init` first.");
+        process.exitCode = 1;
+        return;
+      }
+      await cmdInfo();
+      break;
+    }
+    case "link":
+      await cmdLink();
+      break;
+    case "build":
+      await cmdBuild();
+      break;
+    case "dev":
+      await cmdDev();
+      break;
+    case "chat":
+      await cmdChat();
+      break;
+    default:
+      console.error(`Unknown command: ${command}`);
+      process.exitCode = 1;
+  }
+}
+
+await main().catch((err) => {
+  console.error(err);
+  process.exit(1);
+});

package/scripts/register-plasm-loader.mjs

@@ -0,0 +1,6 @@
+import { register } from "node:module";
+import path from "node:path";
+import { fileURLToPath, pathToFileURL } from "node:url";
+
+const root = path.dirname(fileURLToPath(import.meta.url));
+register(pathToFileURL(path.join(root, "resolve-ts-extension.mjs")));

package/src/cli/init.ts

@@ -9,7 +9,7 @@ export interface InitOptions {
   template?: string;
 }
 
-const SKIP_TEMPLATE_DIRS = new Set(["node_modules", ".plasm"]);
+const SKIP_TEMPLATE_DIRS = new Set(["node_modules", ".plasm", ".nitro", ".output", "server"]);
 const SKIP_TEMPLATE_FILES = new Set(["package-lock.json"]);
 
 function plasmAgentPackageRoot(): string {
@@ -55,6 +55,7 @@ async function patchBootstrapPackageJson(
     name?: string;
     scripts?: Record<string, string>;
     dependencies?: Record<string, string>;
+    devDependencies?: Record<string, string>;
   };
   pkg.name = path.basename(projectRoot);
   const engineRoot = path.resolve(packageRoot, "../plasm-engine");
@@ -72,12 +73,17 @@ async function patchBootstrapPackageJson(
     build: "plasm-agent build",
     "vercel-build": "plasm-agent build",
     dev: "plasm-agent dev",
+    "dev:interactive": "plasm-agent dev --interactive",
     info: "plasm-agent info",
     deploy: "vercel deploy",
     ...pkg.scripts,
     eval: `${nodeRunner} scripts/run-evals.ts`,
     "smoke:channel": `${nodeRunner} scripts/smoke-channel.ts`,
   };
+  pkg.devDependencies = {
+    ...pkg.devDependencies,
+    nitropack: "^2.13.4",
+  };
   await writeFile(pkgPath, `${JSON.stringify(pkg, null, 2)}\n`, "utf8");
 }
 
@@ -98,6 +104,7 @@ async function runTemplateInit(
   await copyTemplate(templateRoot, projectRoot);
   await patchBootstrapPackageJson(projectRoot, plasmAgentPackageRoot());
   await writeVercelScaffold(projectRoot, template);
+  await writeNitroScaffold(projectRoot);
   return { projectRoot, agentRoot };
 }
 
@@ -249,18 +256,72 @@ export default async function handler(
 }
 `;
 
+const NITRO_CONFIG_TS = `import { defineNitroConfig } from "nitropack/config";
+
+export default defineNitroConfig({
+  compatibilityDate: "2026-06-26",
+  srcDir: ".",
+  ignore: ["api/**"],
+  devServer: {
+    port: Number(process.env.PORT ?? 3000),
+    host: process.env.HOST ?? "127.0.0.1",
+  },
+  typescript: {
+    strict: false,
+  },
+  externals: {
+    inline: ["@plasm_lang/engine"],
+  },
+});
+`;
+
+const NITRO_CATCHALL_ROUTE_TS = `import path from "node:path";
+
+import { fromNodeMiddleware } from "h3";
+
+import agentDefinition from "../agent/agent.js";
+import { createPlasmApp, vercelPlasmHandler } from "@plasm_lang/vercel-agent";
+
+const agentRoot = path.join(process.cwd(), "agent");
+
+let appPromise: ReturnType<typeof createPlasmApp> | undefined;
+
+async function plasmApp() {
+  appPromise ??= createPlasmApp({
+    agentRoot,
+    definition: agentDefinition,
+    mode: "prod",
+    sessions: false,
+  });
+  return appPromise;
+}
+
+export default fromNodeMiddleware(async (req, res) => {
+  const app = await plasmApp();
+  await new Promise<void>((resolve, reject) => {
+    res.once("finish", () => resolve());
+    res.once("error", reject);
+    void vercelPlasmHandler(app)(req, res).catch(reject);
+  });
+});
+`;
+
 const PACKAGE_JSON_TEMPLATE = {
   name: "my-plasm-agent",
   private: true,
   type: "module",
   scripts: {
     dev: "plasm-agent dev",
+    "dev:interactive": "plasm-agent dev --interactive",
     build: "plasm-agent build",
     "vercel-build": "plasm-agent build",
     info: "plasm-agent info",
     deploy: "vercel deploy",
   },
   dependencies: {} as Record<string, string>,
+  devDependencies: {
+    nitropack: "^2.13.4",
+  },
 };
 
 async function writeVercelScaffold(
@@ -279,6 +340,16 @@ async function writeVercelScaffold(
   );
 }
 
+async function writeNitroScaffold(projectRoot: string): Promise<void> {
+  await mkdir(path.join(projectRoot, "routes"), { recursive: true });
+  await writeFile(path.join(projectRoot, "nitro.config.ts"), NITRO_CONFIG_TS, "utf8");
+  await writeFile(
+    path.join(projectRoot, "routes", "[...path].ts"),
+    NITRO_CATCHALL_ROUTE_TS,
+    "utf8",
+  );
+}
+
 function packageJsonScaffold(): Record<string, unknown> {
   return {
     ...PACKAGE_JSON_TEMPLATE,
@@ -335,6 +406,7 @@ export async function runPlasmInit(
   }
 
   await writeVercelScaffold(projectRoot);
+  await writeNitroScaffold(projectRoot);
 
   return { projectRoot, agentRoot };
 }
@@ -353,7 +425,8 @@ export function formatInitSuccess(
       "  plasm-agent link          # pull AI_GATEWAY_API_KEY from Vercel",
       "  plasm-agent build",
       "  npm run smoke:channel",
-      "  plasm-agent dev           # local dev server + TUI",
+      "  plasm-agent dev           # Nitro dev server (Vercel routing parity)",
+      "  plasm-agent dev --interactive  # optional TUI + sessions + hot reload",
       "  vercel deploy             # production (channels + cron)",
     ].join("\n");
   }
@@ -366,7 +439,8 @@ export function formatInitSuccess(
     "  npm install",
     "  plasm-agent link      # pull AI_GATEWAY_API_KEY from Vercel",
     "  plasm-agent build     # generate CGS stubs + discovery manifest",
-    "  plasm-agent dev       # HTTP dev server (sessions + SSE)",
+    "  plasm-agent dev       # Nitro dev server (Vercel routing parity)",
+    "  plasm-agent dev --interactive  # optional TUI + sessions",
     "  vercel deploy         # production on Vercel",
   ].join("\n");
 }

package/src/cli/nitro-dev.ts

@@ -0,0 +1,73 @@
+import { spawn, type ChildProcess } from "node:child_process";
+import { access } from "node:fs/promises";
+import path from "node:path";
+import { fileURLToPath } from "node:url";
+
+import type { ResolvedAgentProject } from "./project-root.js";
+
+function plasmAgentPackageRoot(): string {
+  return path.resolve(path.dirname(fileURLToPath(import.meta.url)), "../..");
+}
+
+async function assertNitroScaffold(projectRoot: string): Promise<void> {
+  const required = [
+    path.join(projectRoot, "nitro.config.ts"),
+    path.join(projectRoot, "routes", "[...path].ts"),
+  ];
+  for (const filePath of required) {
+    try {
+      await access(filePath);
+    } catch {
+      throw new Error(
+        `Missing ${path.relative(projectRoot, filePath)} — run \`plasm-agent init\` to scaffold Nitro dev`,
+      );
+    }
+  }
+}
+
+function nitroBin(projectRoot: string): string {
+  return path.join(projectRoot, "node_modules", ".bin", "nitro");
+}
+
+export async function startNitroDevForProject(project: ResolvedAgentProject): Promise<void> {
+  await assertNitroScaffold(project.projectRoot);
+
+  const loader = path.join(plasmAgentPackageRoot(), "scripts", "register-plasm-loader.mjs");
+  const nodeOptions = [
+    "--experimental-strip-types",
+    "--experimental-transform-types",
+    `--import=${loader}`,
+  ].join(" ");
+
+  const bin = nitroBin(project.projectRoot);
+  try {
+    await access(bin);
+  } catch {
+    throw new Error(
+      "nitropack is not installed — run `npm install` in the project root (init adds nitropack as a devDependency)",
+    );
+  }
+
+  const child: ChildProcess = spawn(bin, ["dev"], {
+    cwd: project.projectRoot,
+    env: {
+      ...process.env,
+      NODE_OPTIONS: nodeOptions,
+    },
+    stdio: "inherit",
+  });
+
+  const wait = new Promise<number>((resolve, reject) => {
+    child.on("error", reject);
+    child.on("close", (code) => resolve(code ?? 0));
+  });
+
+  for (const signal of ["SIGINT", "SIGTERM"] as const) {
+    process.on(signal, () => {
+      child.kill(signal);
+    });
+  }
+
+  const exitCode = await wait;
+  process.exit(exitCode);
+}

package/src/engine/create-host-transport.ts

@@ -1,6 +1,13 @@
 import { createDefaultHostTransport } from "./host-transport.js";
+import { connectAuthOptionsForEntry } from "./connect-auth.js";
 import type { HostTransportFn } from "./napi-binding.js";
 
+/** Outbound HTTP for CGS stub live execute: Connect only when configured for the catalog. */
+export function createStubHostTransport(entryId?: string): HostTransportFn {
+  const useConnect = connectAuthOptionsForEntry(entryId)?.connector != null;
+  return createDefaultHostTransport({ useConnect });
+}
+
 /** Production host transport: env bearer → Vercel Connect `getToken()` → fetch. */
 export function createProductionHostTransport(): HostTransportFn {
   return createDefaultHostTransport({ useConnect: true });

package/src/index.ts

@@ -130,7 +130,7 @@ export type {
 export { StubPlasmEngine, NapiPlasmEngine, createEngine, isNativeEngineAvailable } from "./engine/napi-binding.js";
 export { createDefaultHostTransport } from "./engine/host-transport.js";
 export type { HostTransportOptions } from "./engine/host-transport.js";
-export { createProductionHostTransport } from "./engine/create-host-transport.js";
+export { createProductionHostTransport, createStubHostTransport } from "./engine/create-host-transport.js";
 export { loadAgentEnv } from "./load-env.js";
 export {
   connectorUidForEntry,

package/src/stubs/catalog-client.ts

@@ -1,5 +1,5 @@
 import type { HostTransportFn } from "../engine/napi-binding.js";
-import { createProductionHostTransport } from "../engine/create-host-transport.js";
+import { createStubHostTransport } from "../engine/create-host-transport.js";
 import {
   createEngine,
   type DryRunResult,
@@ -143,7 +143,7 @@ export async function executeRows<TRow>(
     options?.transport ??
     (process.env.PLASM_STUB_USE_MOCK_TRANSPORT === "1"
       ? createFixtureMockTransport()
-      : createProductionHostTransport());
+      : createStubHostTransport(builder.entryId));
 
   if (typeof bound.run !== "function") {
     throw new Error("executeRows: program builder missing run()");

package/src/tools/harness-tools.ts

@@ -1,58 +1,59 @@
-import { tool } from "ai";
+import { tool, type ToolSet } from "ai";
 import { z } from "zod";
 
 import type { SkillDefinition } from "../authoring/define-skill.js";
 import type { SubagentRegistry } from "../authoring/subagent-loader.js";
+import { toolInput } from "./tool-input.js";
+
+const readSkillInputSchema = z.object({
+  name: z.string().min(1).describe("Skill name from the index"),
+});
 
 export function createHarnessTools(options: {
   skills?: SkillDefinition[];
   subagents?: SubagentRegistry;
-}) {
+}): ToolSet {
+  const tools: ToolSet = {};
   const skillByName = new Map((options.skills ?? []).map((s) => [s.name, s]));
 
-  const readSkill =
-    skillByName.size > 0
-      ? {
-          read_skill: tool({
-            description:
-              "Load full text for a filesystem skill by name. Use when the skill index in the system prompt is not enough.",
-            inputSchema: z.object({
-              name: z.string().min(1).describe("Skill name from the index"),
-            }),
-            execute: async ({ name }: { name: string }) => {
-              const skill = skillByName.get(name);
-              if (!skill) {
-                return `Unknown skill "${name}". Available: ${[...skillByName.keys()].join(", ")}`;
-              }
-              return skill.body.trim();
-            },
-          }),
+  if (skillByName.size > 0) {
+    tools.read_skill = tool({
+      description:
+        "Load full text for a filesystem skill by name. Use when the skill index in the system prompt is not enough.",
+      inputSchema: toolInput(readSkillInputSchema),
+      execute: async ({ name }: { name: string }) => {
+        const skill = skillByName.get(name);
+        if (!skill) {
+          return `Unknown skill "${name}". Available: ${[...skillByName.keys()].join(", ")}`;
         }
-      : {};
+        return skill.body.trim();
+      },
+    });
+  }
 
   const subagentNames = options.subagents?.list().map((s) => s.name) ?? [];
-  const delegateSubagent =
-    subagentNames.length > 0 && options.subagents
-      ? {
-          delegate_subagent: tool({
-            description:
-              "Delegate a sub-task to a filesystem-isolated child agent. Each subagent has its own catalogs and session scope.",
-            inputSchema: z.object({
-              name: z
-                .string()
-                .min(1)
-                .describe(`Subagent name. One of: ${subagentNames.join(", ")}`),
-              message: z.string().min(1).describe("User message for the child agent turn"),
-            }),
-            execute: async ({ name, message }: { name: string; message: string }) => {
-              const result = await options.subagents!.delegate(name, message);
-              return `${result.text}\n\n(steps: ${result.steps})`;
-            },
-          }),
-        }
-      : {};
+  if (subagentNames.length > 0 && options.subagents) {
+    const subagents = options.subagents;
+    tools.delegate_subagent = tool({
+      description:
+        "Delegate a sub-task to a filesystem-isolated child agent. Each subagent has its own catalogs and session scope.",
+      inputSchema: toolInput(
+        z.object({
+          name: z
+            .string()
+            .min(1)
+            .describe(`Subagent name. One of: ${subagentNames.join(", ")}`),
+          message: z.string().min(1).describe("User message for the child agent turn"),
+        }),
+      ),
+      execute: async ({ name, message }: { name: string; message: string }) => {
+        const result = await subagents.delegate(name, message);
+        return `${result.text}\n\n(steps: ${result.steps})`;
+      },
+    });
+  }
 
-  return { ...readSkill, ...delegateSubagent };
+  return tools;
 }
 
 export function renderSkillIndex(skills: SkillDefinition[]): string {

package/src/tools/plasm-tools.ts

@@ -1,4 +1,4 @@
-import { tool } from "ai";
+import { tool, type ToolSet } from "ai";
 import { z } from "zod";
 
 import type { AgentRuntime } from "../runtime/agent-runtime.js";
@@ -8,89 +8,98 @@ import {
   PLASM_RUN_TOOL_DESCRIPTION,
   PLASM_TOOL_DESCRIPTION,
 } from "./descriptions.js";
+import { toolInput } from "./tool-input.js";
 
 const seedSchema = z.object({
   api: z.string().describe("Registry entry_id / catalog api"),
   entity: z.string().describe("CGS entity name from discovery or prior knowledge"),
 });
 
-export function createPlasmTools(runtime: AgentRuntime) {
+const discoverInputSchema = z.object({
+  intent: z
+    .string()
+    .min(1)
+    .describe(
+      "One plain-language task description for the whole user goal. Returns catalog api/entity picks — not program symbols.",
+    ),
+});
+
+const plasmContextInputSchema = z.object({
+  intent: z
+    .string()
+    .min(1)
+    .describe(
+      "Stable string for one user goal (same value every turn for that goal — do not rotate per message).",
+    ),
+  seeds: z
+    .array(seedSchema)
+    .min(1)
+    .describe("Non-empty array of {api, entity} capability picks"),
+  ranked_capabilities: z
+    .array(z.string())
+    .nullable()
+    .optional()
+    .describe(
+      "Optional capability wire names from discover_capabilities. Omit on expand; null or [] clears.",
+    ),
+});
+
+const plasmInputSchema = z.object({
+  logical_session_ref: z
+    .string()
+    .describe("Same logical_session_ref returned by plasm_context"),
+  program: z
+    .string()
+    .min(1)
+    .describe("Plasm source program using e#/m#/p#/r# from the session teaching TSV"),
+  reasoning: z
+    .string()
+    .optional()
+    .describe("Optional short note explaining the intent of this call"),
+});
+
+const plasmRunInputSchema = z.object({
+  logical_session_ref: z
+    .string()
+    .describe("Same logical_session_ref returned by plasm_context"),
+  plan_commit_ref: z
+    .string()
+    .describe("Executable plan token (pcN) from a prior plasm dry-run"),
+  reasoning: z
+    .string()
+    .optional()
+    .describe("Optional short note explaining the intent of this call"),
+});
+
+export function createPlasmTools(runtime: AgentRuntime): ToolSet {
   return {
     discover_capabilities: tool({
       description: DISCOVER_TOOL_DESCRIPTION,
-      inputSchema: z.object({
-        intent: z
-          .string()
-          .min(1)
-          .describe(
-            "One plain-language task description for the whole user goal. Returns catalog api/entity picks — not program symbols.",
-          ),
-      }),
+      inputSchema: toolInput(discoverInputSchema),
       execute: async ({ intent }) => runtime.discoverCapabilities({ intent }),
     }),
 
     plasm_context: tool({
       description: PLASM_CONTEXT_TOOL_DESCRIPTION,
-      inputSchema: z.object({
-        intent: z
-          .string()
-          .min(1)
-          .describe(
-            "Stable string for one user goal (same value every turn for that goal — do not rotate per message).",
-          ),
-        seeds: z
-          .array(seedSchema)
-          .min(1)
-          .describe("Non-empty array of {api, entity} capability picks"),
-        ranked_capabilities: z
-          .array(z.string())
-          .nullable()
-          .optional()
-          .describe(
-            "Optional capability wire names from discover_capabilities. Omit on expand; null or [] clears.",
-          ),
-      }),
+      inputSchema: toolInput(plasmContextInputSchema),
       execute: async ({ intent, seeds, ranked_capabilities }) =>
         runtime.plasmContext({
           intent,
-          seeds,
+          seeds: seeds as Array<{ api: string; entity: string }>,
           rankedCapabilities: ranked_capabilities,
         }),
     }),
 
     plasm: tool({
       description: PLASM_TOOL_DESCRIPTION,
-      inputSchema: z.object({
-        logical_session_ref: z
-          .string()
-          .describe("Same logical_session_ref returned by plasm_context"),
-        program: z
-          .string()
-          .min(1)
-          .describe("Plasm source program using e#/m#/p#/r# from the session teaching TSV"),
-        reasoning: z
-          .string()
-          .optional()
-          .describe("Optional short note explaining the intent of this call"),
-      }),
+      inputSchema: toolInput(plasmInputSchema),
       execute: async ({ logical_session_ref, program, reasoning }) =>
         runtime.plasm({ logicalSessionRef: logical_session_ref, program, reasoning }),
     }),
 
     plasm_run: tool({
       description: PLASM_RUN_TOOL_DESCRIPTION,
-      inputSchema: z.object({
-        logical_session_ref: z
-          .string()
-          .describe("Same logical_session_ref returned by plasm_context"),
-        plan_commit_ref: z
-          .string()
-          .describe("Executable plan token (pcN) from a prior plasm dry-run"),
-        reasoning: z
-          .string()
-          .optional()
-          .describe("Optional short note explaining the intent of this call"),
-      }),
+      inputSchema: toolInput(plasmRunInputSchema),
       execute: async ({ logical_session_ref, plan_commit_ref, reasoning }) =>
         runtime.plasmRun({
           logicalSessionRef: logical_session_ref,

package/src/tools/tool-input.ts

@@ -0,0 +1,9 @@
+import { zodSchema, type FlexibleSchema } from "ai";
+import type { z } from "zod";
+
+/** Wrap Zod for AI SDK `tool()` — avoids TS2589 deep instantiation during Vercel typecheck. */
+export function toolInput<T extends z.ZodTypeAny>(
+  schema: T,
+): FlexibleSchema<z.infer<T>> {
+  return zodSchema(schema);
+}