@plasm_lang/vercel-agent 0.3.111 → 0.3.113

package/templates/mcp-radar/lib/run-radar.ts

@@ -1,214 +1,112 @@
-import {
-  type AuthoringContext,
-} from "@plasm_lang/vercel-agent";
+import { type AuthoringContext } from "@plasm_lang/vercel-agent";
 
+import { drainRunAudit, resetRunAudit } from "./run-audit.js";
 import {
-  addSeenIds,
-  appendProofRun,
   gatewayConfigured,
   loadLastRun,
-  loadSeenState,
   saveLastRun,
-  saveSeenState,
   tavilyConfigured,
-} from "./proof-store.js";
+} from "./radar-state.js";
 
+/** Stable intent — same string on every radar turn (`plasm_context` session reuse). */
 export const MCP_RADAR_INTENT =
   "track MCP innovations from Hacker News and corroborate with Tavily web search";
 
-export const MCP_SEARCH_QUERY = "MCP OR Model Context Protocol";
-
-export interface HnStoryCandidate {
-  id: string;
-  title?: string;
-  url?: string;
-}
-
 export interface RadarRunOptions {
   force?: boolean;
+  reset?: boolean;
 }
 
 export interface RadarRunResult {
   ok: boolean;
   skipped: boolean;
   reason?: string;
-  candidates: HnStoryCandidate[];
-  newCandidates: HnStoryCandidate[];
   agentText?: string;
   error?: string;
 }
 
-type HnStubModule = {
-  item_search?: (
-    input: { query: string; tags?: string; per_page?: number },
-    options?: { transport?: unknown },
-  ) => Promise<Array<{ id?: string | number; title?: string; url?: string }>>;
-};
-
-export async function preflightHnMcpStories(ctx: AuthoringContext): Promise<HnStoryCandidate[]> {
-  try {
-    const mod = (await ctx.importStub("hackernews")) as HnStubModule;
-    if (typeof mod.item_search !== "function") return [];
-    const rows = await mod.item_search(
-      { query: MCP_SEARCH_QUERY, tags: "story", per_page: 10 },
-    );
-    return rows
-      .map((row) => ({
-        id: String(row.id ?? ""),
-        title: row.title,
-        url: row.url,
-      }))
-      .filter((row) => row.id.length > 0);
-  } catch (err) {
-    console.warn("[mcp-radar] preflight HN search failed:", err);
-    return [];
-  }
-}
-
-function filterNewCandidates(
-  candidates: HnStoryCandidate[],
-  seenIds: Set<string>,
-  force: boolean,
-): HnStoryCandidate[] {
-  if (force) return candidates;
-  return candidates.filter((c) => !seenIds.has(c.id));
-}
-
-function buildAgentGoal(newCandidates: HnStoryCandidate[], tavily: boolean): string {
-  const lines = newCandidates.map(
-    (c) => `- id=${c.id} title=${JSON.stringify(c.title ?? "")} url=${JSON.stringify(c.url ?? "")}`,
-  );
-  const tavilyNote = tavily
-    ? "Tavily is configured — corroborate each story with web_search."
-    : "Tavily is NOT configured — HN-only synthesis; use Confidence: low.";
-  return [
-    "Produce MCP proof entries for these NEW Hacker News story candidates:",
-    ...lines,
+function buildRadarGoal(options: RadarRunOptions): string {
+  const lines = [
+    "Run one MCP radar scan cycle.",
     "",
-    tavilyNote,
+    "Use the Plasm tool loop only: `plasm_context` → `plasm` → `plasm_run`.",
+    "Follow `agent/instructions.md` and skills `mcp-proof-format`, `proof-publish`.",
+    "HN search, Tavily corroboration, and Proof document read/write are Plasm programs in your session — not TypeScript, not stubs, not chat-only markdown.",
     "",
-    "Use plasm_context with stable intent for hackernews + tavily, then plan and run programs.",
-    "Output markdown proof blocks per the mcp-proof-format skill (### headers).",
-    "Do not skip candidates unless they are clearly unrelated to MCP.",
-  ].join("\n");
+    `Reuse this intent on every plasm_context call: ${JSON.stringify(MCP_RADAR_INTENT)}`,
+  ];
+  if (options.force === true) {
+    lines.push("", "Force: include MCP HN stories even if the Proof doc already mentions them.");
+  }
+  if (options.reset === true) {
+    lines.push("", "Reset: clear the Proof document to `# MCP Innovations Proof Log` before new entries.");
+  }
+  return lines.join("\n");
 }
 
+/** Start the agent loop; all catalog work happens inside Plasm session tools. */
 export async function runRadar(
   ctx: AuthoringContext,
   options: RadarRunOptions = {},
 ): Promise<RadarRunResult> {
-  const force = options.force === true;
-  const seen = await loadSeenState(ctx.agentRoot);
-  const seenSet = new Set(seen.itemIds);
-
-  const candidates = await preflightHnMcpStories(ctx);
-  const newCandidates = filterNewCandidates(candidates, seenSet, force);
-
-  if (!newCandidates.length && !force) {
-    const result: RadarRunResult = {
-      ok: true,
-      skipped: true,
-      reason: candidates.length ? "no_new_stories" : "no_hn_hits",
-      candidates,
-      newCandidates: [],
-    };
-    await saveSeenState(ctx.agentRoot, {
-      ...seen,
-      lastRunAt: new Date().toISOString(),
-      lastRunStatus: "skipped",
-      lastNewCount: 0,
-    });
-    await saveLastRun(ctx.agentRoot, {
-      at: new Date().toISOString(),
-      status: "skipped",
-      newItems: 0,
-      message: result.reason,
-    });
-    return result;
-  }
-
   if (!gatewayConfigured()) {
-    const result: RadarRunResult = {
-      ok: false,
-      skipped: true,
-      reason: "ai_gateway_missing",
-      candidates,
-      newCandidates,
-      error: "AI Gateway is not configured (link project on Vercel or set AI_GATEWAY_API_KEY locally)",
-    };
+    const error =
+      "AI Gateway is not configured (link project on Vercel or set AI_GATEWAY_API_KEY locally)";
     await saveLastRun(ctx.agentRoot, {
       at: new Date().toISOString(),
       status: "error",
-      newItems: 0,
-      message: result.error,
+      message: error,
     });
-    return result;
+    return { ok: false, skipped: true, reason: "ai_gateway_missing", error };
   }
 
-  const toProcess = newCandidates.length ? newCandidates : candidates;
-  const goal = buildAgentGoal(toProcess, tavilyConfigured());
-
   try {
+    resetRunAudit();
     const agent = await ctx.getAgent();
-    const turn = await agent.generate(goal, { resetConversation: false });
+    const turn = await agent.generate(buildRadarGoal(options), { resetConversation: false });
     const runAt = new Date().toISOString();
+    const audit = drainRunAudit();
 
-    if (turn.text.trim()) {
-      await appendProofRun(ctx.agentRoot, { runAt, body: turn.text });
-    }
-
-    const ids = toProcess.map((c) => c.id);
-    await addSeenIds(ctx.agentRoot, ids);
-    await saveSeenState(ctx.agentRoot, {
-      ...(await loadSeenState(ctx.agentRoot)),
-      lastRunAt: runAt,
-      lastRunStatus: "ok",
-      lastNewCount: toProcess.length,
-    });
     await saveLastRun(ctx.agentRoot, {
       at: runAt,
       status: "ok",
-      newItems: toProcess.length,
+      runIds: audit.runIds,
+      logicalSessionRef: audit.logicalSessionRef,
     });
 
     return {
       ok: true,
       skipped: false,
-      candidates,
-      newCandidates: toProcess,
       agentText: turn.text,
     };
   } catch (err) {
     const message = String(err);
-    await saveSeenState(ctx.agentRoot, {
-      ...(await loadSeenState(ctx.agentRoot)),
-      lastRunAt: new Date().toISOString(),
-      lastRunStatus: "error",
-    });
     await saveLastRun(ctx.agentRoot, {
       at: new Date().toISOString(),
       status: "error",
-      newItems: 0,
       message,
     });
     return {
       ok: false,
       skipped: false,
-      candidates,
-      newCandidates: toProcess,
       error: message,
     };
   }
 }
 
 export async function radarStatus(agentRoot: string): Promise<Record<string, unknown>> {
-  const seen = await loadSeenState(agentRoot);
   const last = await loadLastRun(agentRoot);
   return {
     gateway: gatewayConfigured(),
     tavily: tavilyConfigured(),
-    seenCount: seen.itemIds.length,
     lastRun: last,
     intent: MCP_RADAR_INTENT,
+    observability: {
+      operatorRunsUrl: "/operator/runs",
+      operatorSessionsUrl: "/operator/sessions",
+      operatorArchivesUrl: "/operator/archives",
+      runIds: last?.runIds ?? [],
+      logicalSessionRef: last?.logicalSessionRef,
+    },
   };
 }

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

@@ -0,0 +1,42 @@
+#!/usr/bin/env node
+/**
+ * Smoke: MCP Radar channel routes (status, proof link, run with gateway check).
+ */
+import { createPlasmDevServer } from "@plasm_lang/vercel-agent/dev";
+
+import { gatewayConfigured } from "../lib/radar-state.js";
+
+async function main(): Promise<void> {
+  const handle = await createPlasmDevServer({ port: 0 });
+  try {
+    const statusRes = await fetch(`${handle.url}/channel/mcp-radar/status`);
+    if (!statusRes.ok) throw new Error(`status ${statusRes.status}`);
+    const status = (await statusRes.json()) as { gateway?: boolean; intent?: string };
+    if (status.intent == null) throw new Error("status missing intent");
+
+    const proofRes = await fetch(`${handle.url}/channel/mcp-radar/proof`);
+    if (proofRes.status === 404) {
+      console.log("OK: proof route (not configured locally)");
+    } else if (!proofRes.ok) {
+      throw new Error(`proof ${proofRes.status}`);
+    } else {
+      const proof = (await proofRes.json()) as { editor?: string };
+      if (proof.editor !== "proof") throw new Error("proof response missing editor=proof");
+    }
+
+    if (gatewayConfigured()) {
+      console.log("OK: gateway configured for agent runs");
+    } else {
+      console.log("SKIP: gateway not configured locally");
+    }
+
+    console.log(`OK: mcp-radar channel smoke (${handle.url})`);
+  } finally {
+    await handle.close();
+  }
+}
+
+main().catch((err: unknown) => {
+  console.error(err);
+  process.exit(1);
+});

package/templates/mcp-radar/lib/start-mcp-radar.ts

@@ -14,5 +14,6 @@ export async function startMcpRadarRun(
   return start({ workflowId: MCP_RADAR_SCAN_WORKFLOW_ID }, [
     ctx.agentRoot,
     options.force === true,
+    options.reset === true,
   ]);
 }

package/templates/mcp-radar/lib/test-hn-algolia-preflight.mjs

@@ -0,0 +1,27 @@
+#!/usr/bin/env node
+import assert from "node:assert/strict";
+
+import { fetchHnMcpStoriesByDate } from "../lib/hn-algolia-preflight.js";
+import { isMcpRelevant } from "../lib/proof-extract.js";
+import { MCP_SEARCH_QUERY, preflightHnMcpStories } from "../lib/run-radar.js";
+
+const rows = await fetchHnMcpStoriesByDate({
+  query: MCP_SEARCH_QUERY,
+  tags: "story",
+  perPage: 10,
+});
+assert.ok(rows.length > 0, "Algolia should return hits for MCP query");
+
+const mcpRows = rows.filter((r) => isMcpRelevant(r.title, r.url));
+assert.ok(mcpRows.length > 0, "At least one hit should be MCP-relevant");
+assert.equal(
+  mcpRows.some((r) => /hawking|altman|crowdstrike/i.test(r.title ?? "")),
+  false,
+  "Preflight must not return generic top HN stories",
+);
+
+const candidates = await preflightHnMcpStories();
+assert.ok(candidates.length > 0, "preflightHnMcpStories should yield MCP candidates");
+console.log(
+  `hn-algolia-preflight: ok (${candidates.length} MCP candidates, first: ${candidates[0]?.title?.slice(0, 60)})`,
+);

package/templates/mcp-radar/package.json

@@ -4,11 +4,29 @@
   "type": "module",
   "description": "Event-driven MCP innovation radar — Hacker News + Tavily proof log",
   "scripts": {
+    "build": "plasm-agent build",
+    "dev": "plasm-agent dev",
+    "dev:interactive": "plasm-agent dev --interactive",
+    "info": "plasm-agent info",
+    "deploy": "vercel deploy",
+    "eval": "tsx scripts/run-evals.ts",
     "smoke:channel": "tsx scripts/smoke-channel.ts",
-    "eval": "tsx scripts/run-evals.ts"
+    "test:proof-extract": "tsx scripts/test-proof-extract.mjs",
+    "test:hn-preflight": "tsx scripts/test-hn-algolia-preflight.mjs"
+  },
+  "dependencies": {
+    "@ai-sdk/otel": "1.0.14",
+    "@plasm_lang/engine": "0.3.112",
+    "@plasm_lang/vercel-agent": "file:../../plasm-oss/packages/plasm-agent",
+    "@vercel/blob": "0.27.3",
+    "@vercel/functions": "3.7.4",
+    "@vercel/otel": "1.14.2",
+    "ai": "7.0.14",
+    "esbuild": "0.25.12",
+    "workflow": "4.5.0",
+    "zod": "4.3.6"
   },
-  "dependencies": {},
   "devDependencies": {
-    "tsx": "^4.19.4"
+    "tsx": "4.19.4"
   }
 }

package/templates/mcp-radar/scripts/provision-vercel.mjs

@@ -0,0 +1,111 @@
+#!/usr/bin/env node
+/**
+ * Eve-aligned Vercel bootstrap for mcp-radar:
+ * - Sync secrets from monorepo `.env` → Vercel project env
+ * - Link Blob store (OIDC at runtime)
+ */
+import { existsSync, readFileSync } from "node:fs";
+import path from "node:path";
+import { fileURLToPath } from "node:url";
+import { spawnSync } from "node:child_process";
+
+const scriptDir = path.dirname(fileURLToPath(import.meta.url));
+const projectRoot = path.resolve(scriptDir, "..");
+
+function run(command, args, options = {}) {
+  const result = spawnSync(command, args, options);
+  if (result.status !== 0) {
+    process.exit(result.status ?? 1);
+  }
+  return result;
+}
+
+function parseEnvFile(filePath) {
+  const vars = new Map();
+  if (!existsSync(filePath)) return vars;
+  const text = readFileSync(filePath, "utf8");
+  for (const line of text.split(/\r?\n/)) {
+    const trimmed = line.trim();
+    if (!trimmed || trimmed.startsWith("#")) continue;
+    const withoutExport = trimmed.startsWith("export ")
+      ? trimmed.slice("export ".length).trim()
+      : trimmed;
+    const eq = withoutExport.indexOf("=");
+    if (eq <= 0) continue;
+    const key = withoutExport.slice(0, eq).trim();
+    let value = withoutExport.slice(eq + 1).trim();
+    if (
+      (value.startsWith('"') && value.endsWith('"')) ||
+      (value.startsWith("'") && value.endsWith("'"))
+    ) {
+      value = value.slice(1, -1);
+    }
+    vars.set(key, value);
+  }
+  return vars;
+}
+
+function resolveMonorepoEnv() {
+  const files = [];
+  let dir = projectRoot;
+  for (let depth = 0; depth < 8; depth++) {
+    const candidate = path.join(dir, ".env");
+    if (existsSync(candidate)) files.push(candidate);
+    const parent = path.dirname(dir);
+    if (parent === dir) break;
+    dir = parent;
+  }
+  const merged = new Map();
+  for (const file of files.reverse()) {
+    for (const [key, value] of parseEnvFile(file)) {
+      if (value.trim()) merged.set(key, value);
+    }
+  }
+  return merged;
+}
+
+function envAlreadySet(name) {
+  const result = run("vercel", ["env", "ls"], { encoding: "utf8", stdio: ["inherit", "pipe", "inherit"] });
+  return (result.stdout ?? "").includes(name);
+}
+
+function syncEnvVar(name, value) {
+  if (!value?.trim()) {
+    console.warn(`[provision] skip ${name}: not found in monorepo .env`);
+    return;
+  }
+  if (envAlreadySet(name)) {
+    console.log(`[provision] ${name} already set on Vercel — skipping`);
+    return;
+  }
+  for (const target of ["production", "preview"]) {
+    console.log(`[provision] adding ${name} → ${target}…`);
+    run("vercel", ["env", "add", name, target], {
+      input: value,
+      stdio: ["pipe", "inherit", "inherit"],
+    });
+  }
+}
+
+const env = resolveMonorepoEnv();
+
+console.log("Syncing env from monorepo .env → Vercel project…");
+syncEnvVar("TAVILY_API_TOKEN", env.get("TAVILY_API_TOKEN"));
+syncEnvVar("PLASM_TENANT_SCOPE", env.get("PLASM_TENANT_SCOPE") ?? "mcp-radar");
+
+console.log("Linking Vercel Blob store (OIDC, public)…");
+const blobResult = spawnSync(
+  "vercel",
+  ["blob", "create-store", "mcp-radar-proof", "--access", "public", "--yes"],
+  { encoding: "utf8", stdio: ["inherit", "pipe", "inherit"] },
+);
+if (blobResult.status !== 0) {
+  const err = blobResult.stderr ?? blobResult.stdout ?? "";
+  if (err.includes("already exists") || err.includes("(409)")) {
+    console.log("[provision] Blob store mcp-radar-proof already linked — skipping");
+  } else {
+    process.exit(blobResult.status ?? 1);
+  }
+}
+
+console.log("Done. Redeploy production so env + Blob bindings take effect.");

package/templates/mcp-radar/scripts/test-hn-algolia-preflight.mjs

@@ -0,0 +1,27 @@
+#!/usr/bin/env node
+import assert from "node:assert/strict";
+
+import { fetchHnMcpStoriesByDate } from "../lib/hn-algolia-preflight.js";
+import { isMcpRelevant } from "../lib/proof-extract.js";
+import { MCP_SEARCH_QUERY, preflightHnMcpStories } from "../lib/run-radar.js";
+
+const rows = await fetchHnMcpStoriesByDate({
+  query: MCP_SEARCH_QUERY,
+  tags: "story",
+  perPage: 10,
+});
+assert.ok(rows.length > 0, "Algolia should return hits for MCP query");
+
+const mcpRows = rows.filter((r) => isMcpRelevant(r.title, r.url));
+assert.ok(mcpRows.length > 0, "At least one hit should be MCP-relevant");
+assert.equal(
+  mcpRows.some((r) => /hawking|altman|crowdstrike/i.test(r.title ?? "")),
+  false,
+  "Preflight must not return generic top HN stories",
+);
+
+const candidates = await preflightHnMcpStories();
+assert.ok(candidates.length > 0, "preflightHnMcpStories should yield MCP candidates");
+console.log(
+  `hn-algolia-preflight: ok (${candidates.length} MCP candidates, first: ${candidates[0]?.title?.slice(0, 60)})`,
+);

package/templates/mcp-radar/scripts/test-proof-extract.mjs

@@ -0,0 +1,24 @@
+#!/usr/bin/env node
+import assert from "node:assert/strict";
+import { extractProofMarkdown, isMcpRelevant } from "../lib/proof-extract.js";
+
+const raw = `
+The session expired after plasm_context. Tavily is unavailable.
+
+### [MCP Server Guide](https://news.ycombinator.com/item?id=123)
+- **HN**: id 123, score 42
+- **Synthesis**: Example MCP tooling.
+- **Confidence**: low
+
+Some trailing narration about errors.
+`;
+
+const extracted = extractProofMarkdown(raw);
+assert.match(extracted, /^### \[MCP Server Guide\]/);
+assert.doesNotMatch(extracted, /session expired/i);
+assert.doesNotMatch(extracted, /trailing narration/i);
+
+assert.equal(isMcpRelevant("New MCP server for agents", undefined), true);
+assert.equal(isMcpRelevant("Stephen Hawking has died", undefined), false);
+
+console.log("proof-extract: ok");

package/templates/mcp-radar/workflows/mcp-radar-scan.ts

@@ -9,17 +9,17 @@ function workflowDispatchUrl(): string {
   return `http://127.0.0.1:${port}/internal/workflow/dispatch`;
 }
 
-export async function mcpRadarScanWorkflow(_agentRoot: string, force = false) {
+export async function mcpRadarScanWorkflow(_agentRoot: string, force = false, reset = false) {
   "use workflow";
-  return mcpRadarScanStep(force);
+  return mcpRadarScanStep(force, reset);
 }
 
-async function mcpRadarScanStep(force: boolean) {
+async function mcpRadarScanStep(force: boolean, reset: boolean) {
   "use step";
   const response = await fetch(workflowDispatchUrl(), {
     method: "POST",
     headers: { "content-type": "application/json" },
-    body: JSON.stringify({ job: "mcp-radar-scan", force }),
+    body: JSON.stringify({ job: "mcp-radar-scan", force, reset }),
   });
   if (!response.ok) {
     throw new Error(`workflow dispatch failed: ${response.status} ${await response.text()}`);

package/templates/scaffold/agent/instrumentation.ts

@@ -1,18 +1,10 @@
-import path from "node:path";
-import { fileURLToPath } from "node:url";
-
 import { registerOTel } from "@vercel/otel";
 import { OpenTelemetry } from "@ai-sdk/otel";
-import { registerTelemetryIntegration } from "ai";
-
-const agentRoot = path.dirname(fileURLToPath(import.meta.url));
-const serviceName =
-  process.env.PLASM_AGENT_NAME?.trim() || path.basename(path.dirname(agentRoot));
+import { registerTelemetry } from "ai";
 
-/** Eve-shaped OTEL bootstrap — optional export to Braintrust/Datadog via registerOTel. */
 export function register(): void {
-  registerOTel({ serviceName });
-  registerTelemetryIntegration(new OpenTelemetry());
+  registerOTel({ serviceName: "plasm-agent" });
+  registerTelemetry(new OpenTelemetry());
 }
 
 register();