@plasm_lang/vercel-agent 0.3.78 → 0.3.81

package/templates/mcp-radar/scripts/run-evals.ts

@@ -0,0 +1,46 @@
+#!/usr/bin/env node
+import path from "node:path";
+import { fileURLToPath } from "node:url";
+
+import { createPlasmAgent } from "../agent/agent.js";
+import {
+  requireLiveEvalGateway,
+  runAllEvals,
+} from "@plasm_lang/vercel-agent";
+
+const packageRoot = path.dirname(path.dirname(fileURLToPath(import.meta.url)));
+const evalsDir = path.join(packageRoot, "evals");
+
+async function main(): Promise<void> {
+  requireLiveEvalGateway();
+
+  const agent = await createPlasmAgent();
+  await agent.bootstrap();
+
+  const results = await runAllEvals(agent, evalsDir);
+  if (!results.length) {
+    console.warn("No evals found in", evalsDir);
+    process.exit(0);
+  }
+
+  let failed = 0;
+  for (const result of results) {
+    if (result.ok) {
+      console.log(
+        `PASS ${result.name} steps=${result.stepCount} tools=[${result.recordedTools.join(", ")}]`,
+      );
+    } else {
+      failed += 1;
+      console.error(`FAIL ${result.name}: ${result.error ?? "unknown error"}`);
+      console.error(`  tools=[${result.recordedTools.join(", ")}] steps=${result.stepCount}`);
+    }
+  }
+
+  if (failed > 0) process.exit(1);
+  console.log(`\nOK: ${results.length} live eval(s) passed`);
+}
+
+main().catch((err: unknown) => {
+  console.error(err);
+  process.exit(1);
+});

package/templates/mcp-radar/scripts/smoke-channel.ts

@@ -0,0 +1,66 @@
+#!/usr/bin/env node
+/**
+ * Smoke: MCP Radar channel routes (status, proof, run with gateway check).
+ */
+import path from "node:path";
+import { fileURLToPath } from "node:url";
+
+import agentDefinition from "../agent/agent.js";
+import { createDevServer } from "@plasm_lang/vercel-agent";
+import { gatewayConfigured } from "../lib/proof-store.js";
+
+const packageRoot = path.dirname(path.dirname(fileURLToPath(import.meta.url)));
+const agentRoot = path.join(packageRoot, "agent");
+const port = 4148 + Math.floor(Math.random() * 100);
+
+async function main(): Promise<void> {
+  const handle = await createDevServer({
+    agentRoot,
+    definition: agentDefinition,
+    port,
+    host: "127.0.0.1",
+    telemetry: false,
+  });
+
+  try {
+    const statusRes = await fetch(`${handle.url}/channel/mcp-radar/status`);
+    if (!statusRes.ok) {
+      const body = await statusRes.text();
+      throw new Error(`status ${statusRes.status}: ${body}`);
+    }
+    const status = (await statusRes.json()) as { intent?: string };
+    if (!status.intent?.includes("MCP")) throw new Error("unexpected status payload");
+
+    const proofRes = await fetch(`${handle.url}/channel/mcp-radar/proof`);
+    if (!proofRes.ok) throw new Error(`proof ${proofRes.status}`);
+    const proof = await proofRes.text();
+    if (!proof.includes("MCP Innovations Proof Log")) {
+      throw new Error("proof markdown missing header");
+    }
+
+    const runRes = await fetch(`${handle.url}/channel/mcp-radar/run`, {
+      method: "POST",
+      headers: { "content-type": "application/json" },
+      body: JSON.stringify({}),
+    });
+    const runBody = (await runRes.json()) as { ok?: boolean; skipped?: boolean; reason?: string };
+    if (!gatewayConfigured()) {
+      if (runBody.reason !== "ai_gateway_missing") {
+        throw new Error(`expected ai_gateway_missing without gateway, got ${JSON.stringify(runBody)}`);
+      }
+      console.log("OK: channel routes (run skipped without AI_GATEWAY_API_KEY)");
+    } else {
+      if (!runBody.ok && !runBody.skipped) {
+        throw new Error(`run failed: ${JSON.stringify(runBody)}`);
+      }
+      console.log("OK: channel routes including run");
+    }
+  } finally {
+    await handle.close();
+  }
+}
+
+main().catch((err: unknown) => {
+  console.error(err);
+  process.exit(1);
+});

package/templates/mcp-radar/vercel.json

@@ -0,0 +1,15 @@
+{
+  "buildCommand": "npx tsx scripts/vercel-build.ts",
+  "rewrites": [{ "source": "/(.*)", "destination": "/api/$1" }],
+  "crons": [
+    {
+      "path": "/internal/cron/mcp-radar-scan",
+      "schedule": "0 */6 * * *"
+    }
+  ],
+  "functions": {
+    "api/**": {
+      "maxDuration": 300
+    }
+  }
+}

package/templates/scaffold/.vercelignore

@@ -0,0 +1,3 @@
+node_modules
+.env*
+agent/.plasm/research

package/templates/scaffold/api/[[...path]].ts

@@ -0,0 +1,23 @@
+import path from "node:path";
+import { fileURLToPath } from "node:url";
+
+import agentDefinition from "../agent/agent.js";
+import { createPlasmApp, vercelPlasmHandler } from "@plasm_lang/vercel-agent/server";
+
+const packageRoot = path.dirname(path.dirname(fileURLToPath(import.meta.url)));
+const agentRoot = path.join(packageRoot, "agent");
+
+let app: Awaited<ReturnType<typeof createPlasmApp>> | undefined;
+
+export default async function handler(
+  req: import("node:http").IncomingMessage,
+  res: import("node:http").ServerResponse,
+): Promise<void> {
+  app ??= await createPlasmApp({
+    agentRoot,
+    definition: agentDefinition,
+    mode: "prod",
+    sessions: false,
+  });
+  await vercelPlasmHandler(app)(req, res);
+}

package/templates/scaffold/nitro.config.ts

@@ -0,0 +1,17 @@
+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"],
+  },
+});

package/templates/scaffold/public/index.html

@@ -0,0 +1,10 @@
+<!doctype html>
+<html lang="en">
+  <head>
+    <meta charset="utf-8" />
+    <title>Plasm Agent</title>
+  </head>
+  <body>
+    <p>Plasm agent — use <code>/plasm/v1/info</code> or your channel routes.</p>
+  </body>
+</html>

package/templates/scaffold/public/index.mcp-radar.html

@@ -0,0 +1,10 @@
+<!doctype html>
+<html lang="en">
+  <head>
+    <meta charset="utf-8" />
+    <title>MCP Radar Agent</title>
+  </head>
+  <body>
+    <p>MCP Radar Agent — use <code>/channel/mcp-radar/status</code> or <code>/plasm/v1/info</code>.</p>
+  </body>
+</html>

package/templates/scaffold/routes/[...path].ts

@@ -0,0 +1,29 @@
+import path from "node:path";
+
+import { fromNodeMiddleware } from "h3";
+
+import agentDefinition from "../agent/agent.js";
+import { createPlasmApp, vercelPlasmHandler } from "@plasm_lang/vercel-agent/server";
+
+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);
+  });
+});

package/templates/scaffold/vercel.default.json

@@ -0,0 +1,4 @@
+{
+  "buildCommand": "plasm-agent build",
+  "rewrites": [{ "source": "/(.*)", "destination": "/api/$1" }]
+}

package/templates/scaffold/vercel.mcp-radar.json

@@ -0,0 +1,15 @@
+{
+  "buildCommand": "plasm-agent build",
+  "rewrites": [{ "source": "/(.*)", "destination": "/api/$1" }],
+  "crons": [
+    {
+      "path": "/internal/cron/mcp-radar-scan",
+      "schedule": "0 */6 * * *"
+    }
+  ],
+  "functions": {
+    "api/**": {
+      "maxDuration": 300
+    }
+  }
+}