@plasm_lang/vercel-agent 0.3.78 → 0.3.80

package/templates/mcp-radar/agent/catalogs/tavily/eval/google-gemma-3-4b-it.latest.human.txt

@@ -0,0 +1,67 @@
+model: google/gemma-3-4b-it
+eval summary: 7 cases | mean score 0.7982 | parse_ok 6/7 | typecheck_ok 6/7
+
+════════════════════════════════════════════════════════════════════════
+Pipeline failures (parse/typecheck never succeeded): 1
+
+▸ tv-07  final_score=0.0000  semantic=0.000
+  goal: Web search for 'rust async' but return only titles and URLs in the result list
+  rounds=2  recovered=false  pipeline_score=0.00
+  ─── attempt 1 ───
+    step 0: ExtractResult{query="rust async", ~str}
+      reason: Search for 'rust async' using full-text search and retrieve relevant ExtractResult entities.
+    validation: FAILED
+      • [parse] step 0 `ExtractResult{query="rust async", ~str}`
+        Fix spelling so identifiers, `=`, `{{}}`, `.`, and parentheses match the SYNTAX block in the prompt.
+        span_offset: 34
+  ─── attempt 2 ───
+    step 0: ExtractResult{query="rust async", ~str}
+      reason: Search for 'rust async' using full-text search and retrieve relevant ExtractResult entities.
+    correction_context_in (feedback from prior round, sent to LLM):
+      {
+        "round": 0,
+        "goal": "Web search for 'rust async' but return only titles and URLs in the result list",
+        "previous_steps": [
+          {
+            "text": "ExtractResult{query=\"rust async\", ~str}",
+            "reasoning": "Search for 'rust async' using full-text search and retrieve relevant ExtractResult entities."
+          }
+        ],
+        "diagnostics": [
+          {
+            "step_index": 0,
+            "expression": "ExtractResult{query=\"rust async\", ~str}",
+            "error": {
+              "correction": "Fix spelling so identifiers, `=`, `{{}}`, `.`, and parentheses match the SYNTAX block in the prompt.",
+              "category": "parse",
+              "span_offset": 34
+            }
+          }
+        ]
+      }
+    validation: FAILED
+      • [parse] step 0 `ExtractResult{query="rust async", ~str}`
+        Fix spelling so identifiers, `=`, `{{}}`, `.`, and parentheses match the SYNTAX block in the prompt.
+        span_offset: 34
+
+
+Expectation gaps (validated, soft score below 1.0): 2
+
+▸ tv-01  blended_score=0.7750  semantic=0.750
+  goal: Research briefing: what are the main risks of LLM prompt injection in 2025?
+  expectation notes:
+    - entities got {"ResearchTask"} want any of ["SearchResult"]
+  final plan (for context):
+    step 0: ResearchTask{query="main risks of LLM prompt injection in 2025"}
+      reason: Retrieve ResearchTasks related to the specified query to initiate the research.
+
+▸ tv-03  blended_score=0.8125  semantic=0.750
+  goal: Crawl the product marketing site up to depth 2 for a competitive summary
+  expectation notes:
+    - entities got {"ResearchTask"} want any of ["ExtractResult"]
+  final plan (for context):
+    step 0: ResearchTask{scope=Source(id), filter=marketing}
+      reason: Start by finding ResearchTasks specifically related to marketing sources.
+
+════════════════════════════════════════════════════════════════════════
+

package/templates/mcp-radar/agent/catalogs/tavily/eval/google-gemma-3-4b-it.latest.json

@@ -0,0 +1,363 @@
+{
+  "cases": [
+    {
+      "attempt_trace": [
+        {
+          "attempt": 1,
+          "diagnostics": [
+            {
+              "error": {
+                "category": "parse",
+                "correction": "Expression: ResearchTask(42).method\n\n`method` is not a valid name after `ResearchTask.` (field, relation, or zero-arg action). Closest names in DOMAIN: model, content, input, status, request_id.\n\nAllowed names (8): content, created_at, input, model, request_id, response_time, sources, status\n\nFor reading scalar fields: `ResearchTask(id)[status,content]`.\n\nTo navigate: `ResearchTask(id).content` (relation or EntityRef).",
+                "span_offset": 17
+              },
+              "expression": "ResearchTask(42).method",
+              "step_index": 0
+            }
+          ],
+          "steps": [
+            {
+              "reasoning": "Retrieve the ResearchTask with ID 42 to access its method.",
+              "text": "ResearchTask(42).method"
+            }
+          ],
+          "validation_ok": false
+        },
+        {
+          "attempt": 2,
+          "correction_context_in": "{\n  \"round\": 0,\n  \"goal\": \"Research briefing: what are the main risks of LLM prompt injection in 2025?\",\n  \"previous_steps\": [\n    {\n      \"text\": \"ResearchTask(42).method\",\n      \"reasoning\": \"Retrieve the ResearchTask with ID 42 to access its method.\"\n    }\n  ],\n  \"diagnostics\": [\n    {\n      \"step_index\": 0,\n      \"expression\": \"ResearchTask(42).method\",\n      \"error\": {\n        \"correction\": \"Expression: ResearchTask(42).method\\n\\n`method` is not a valid name after `ResearchTask.` (field, relation, or zero-arg action). Closest names in DOMAIN: model, content, input, status, request_id.\\n\\nAllowed names (8): content, created_at, input, model, request_id, response_time, sources, status\\n\\nFor reading scalar fields: `ResearchTask(id)[status,content]`.\\n\\nTo navigate: `ResearchTask(id).content` (relation or EntityRef).\",\n        \"category\": \"parse\",\n        \"span_offset\": 17\n      }\n    }\n  ]\n}",
+          "lexicon_notes": [
+            {
+              "emitted": "ResearchTask{query=\"main risks of LLM prompt injection in 2025\"}",
+              "resolved_to": "ResearchTask",
+              "step_index": 0
+            }
+          ],
+          "steps": [
+            {
+              "reasoning": "Retrieve ResearchTasks related to the specified query to initiate the research.",
+              "text": "ResearchTask{query=\"main risks of LLM prompt injection in 2025\"}"
+            }
+          ],
+          "validation_ok": true
+        }
+      ],
+      "chain_match": true,
+      "correction": {
+        "final_full_ok": true,
+        "first_attempt_full_ok": false,
+        "first_attempt_had_errors": true,
+        "pipeline_score": 0.8500000238418579,
+        "recovered": true,
+        "rounds_used": 2
+      },
+      "correction_pipeline_score": 0.8500000238418579,
+      "entity_match": false,
+      "goal": "Research briefing: what are the main risks of LLM prompt injection in 2025?",
+      "id": "tv-01",
+      "notes": [
+        "entities got {\"ResearchTask\"} want any of [\"SearchResult\"]"
+      ],
+      "parse_ok": true,
+      "pred_fields_match": true,
+      "pred_values_match": true,
+      "projection_match": true,
+      "score": 0.7749999761581421,
+      "semantic_score": 0.75,
+      "steps_ok": true,
+      "tags": [
+        "search"
+      ],
+      "typecheck_ok": true
+    },
+    {
+      "attempt_trace": [
+        {
+          "attempt": 1,
+          "steps": [
+            {
+              "reasoning": "To find URLs from the documentation.",
+              "text": "ExtractResult{query=\"urls~str\"}"
+            }
+          ],
+          "validation_ok": true
+        }
+      ],
+      "chain_match": true,
+      "correction": {
+        "final_full_ok": true,
+        "first_attempt_full_ok": true,
+        "first_attempt_had_errors": false,
+        "pipeline_score": 1.0,
+        "recovered": false,
+        "rounds_used": 1
+      },
+      "correction_pipeline_score": 1.0,
+      "entity_match": true,
+      "goal": "Extract readable text from these documentation URLs for offline notes",
+      "id": "tv-02",
+      "notes": [],
+      "parse_ok": true,
+      "pred_fields_match": true,
+      "pred_values_match": true,
+      "projection_match": true,
+      "score": 1.0,
+      "semantic_score": 1.0,
+      "steps_ok": true,
+      "tags": [
+        "extract"
+      ],
+      "typecheck_ok": true
+    },
+    {
+      "attempt_trace": [
+        {
+          "attempt": 1,
+          "lexicon_notes": [
+            {
+              "emitted": "ResearchTask{scope=Source(id), filter=marketing}",
+              "resolved_to": "ResearchTask",
+              "step_index": 0
+            }
+          ],
+          "steps": [
+            {
+              "reasoning": "Start by finding ResearchTasks specifically related to marketing sources.",
+              "text": "ResearchTask{scope=Source(id), filter=marketing}"
+            }
+          ],
+          "validation_ok": true
+        }
+      ],
+      "chain_match": true,
+      "correction": {
+        "final_full_ok": true,
+        "first_attempt_full_ok": true,
+        "first_attempt_had_errors": false,
+        "pipeline_score": 1.0,
+        "recovered": false,
+        "rounds_used": 1
+      },
+      "correction_pipeline_score": 1.0,
+      "entity_match": false,
+      "goal": "Crawl the product marketing site up to depth 2 for a competitive summary",
+      "id": "tv-03",
+      "notes": [
+        "entities got {\"ResearchTask\"} want any of [\"ExtractResult\"]"
+      ],
+      "parse_ok": true,
+      "pred_fields_match": true,
+      "pred_values_match": true,
+      "projection_match": true,
+      "score": 0.8125,
+      "semantic_score": 0.75,
+      "steps_ok": true,
+      "tags": [
+        "crawl"
+      ],
+      "typecheck_ok": true
+    },
+    {
+      "attempt_trace": [
+        {
+          "attempt": 1,
+          "steps": [
+            {
+              "reasoning": "To initiate a research task and obtain its ID.",
+              "text": "ResearchTask(id)"
+            }
+          ],
+          "validation_ok": true
+        }
+      ],
+      "chain_match": true,
+      "correction": {
+        "final_full_ok": true,
+        "first_attempt_full_ok": true,
+        "first_attempt_had_errors": false,
+        "pipeline_score": 1.0,
+        "recovered": false,
+        "rounds_used": 1
+      },
+      "correction_pipeline_score": 1.0,
+      "entity_match": true,
+      "goal": "Start a deep research job on quantum error correction and save the request id",
+      "id": "tv-04",
+      "notes": [],
+      "parse_ok": true,
+      "pred_fields_match": true,
+      "pred_values_match": true,
+      "projection_match": true,
+      "score": 1.0,
+      "semantic_score": 1.0,
+      "steps_ok": true,
+      "tags": [
+        "create"
+      ],
+      "typecheck_ok": true
+    },
+    {
+      "attempt_trace": [
+        {
+          "attempt": 1,
+          "steps": [
+            {
+              "reasoning": "To find the research task associated with the request identifier.",
+              "text": "ResearchTask(req_abc123)"
+            }
+          ],
+          "validation_ok": true
+        }
+      ],
+      "chain_match": true,
+      "correction": {
+        "final_full_ok": true,
+        "first_attempt_full_ok": true,
+        "first_attempt_had_errors": false,
+        "pipeline_score": 1.0,
+        "recovered": false,
+        "rounds_used": 1
+      },
+      "correction_pipeline_score": 1.0,
+      "entity_match": true,
+      "goal": "Poll research task req_abc123 until the report body is ready",
+      "id": "tv-05",
+      "notes": [],
+      "parse_ok": true,
+      "pred_fields_match": true,
+      "pred_values_match": true,
+      "projection_match": true,
+      "score": 1.0,
+      "semantic_score": 1.0,
+      "steps_ok": true,
+      "tags": [
+        "get"
+      ],
+      "typecheck_ok": true
+    },
+    {
+      "attempt_trace": [
+        {
+          "attempt": 1,
+          "steps": [
+            {
+              "reasoning": "The goal is to kick off async research on a topic, and the goal specifies the ResearchTask ID as 42.",
+              "text": "ResearchTask(42)"
+            }
+          ],
+          "validation_ok": true
+        }
+      ],
+      "chain_match": true,
+      "correction": {
+        "final_full_ok": true,
+        "first_attempt_full_ok": true,
+        "first_attempt_had_errors": false,
+        "pipeline_score": 1.0,
+        "recovered": false,
+        "rounds_used": 1
+      },
+      "correction_pipeline_score": 1.0,
+      "entity_match": true,
+      "goal": "Kick off async research on a topic, then fetch status when the user returns",
+      "id": "tv-06",
+      "notes": [],
+      "parse_ok": true,
+      "pred_fields_match": true,
+      "pred_values_match": true,
+      "projection_match": true,
+      "score": 1.0,
+      "semantic_score": 1.0,
+      "steps_ok": true,
+      "tags": [
+        "multi_step"
+      ],
+      "typecheck_ok": true
+    },
+    {
+      "attempt_trace": [
+        {
+          "attempt": 1,
+          "diagnostics": [
+            {
+              "error": {
+                "category": "parse",
+                "correction": "Fix spelling so identifiers, `=`, `{{}}`, `.`, and parentheses match the SYNTAX block in the prompt.",
+                "span_offset": 34
+              },
+              "expression": "ExtractResult{query=\"rust async\", ~str}",
+              "step_index": 0
+            }
+          ],
+          "steps": [
+            {
+              "reasoning": "Search for 'rust async' using full-text search and retrieve relevant ExtractResult entities.",
+              "text": "ExtractResult{query=\"rust async\", ~str}"
+            }
+          ],
+          "validation_ok": false
+        },
+        {
+          "attempt": 2,
+          "correction_context_in": "{\n  \"round\": 0,\n  \"goal\": \"Web search for 'rust async' but return only titles and URLs in the result list\",\n  \"previous_steps\": [\n    {\n      \"text\": \"ExtractResult{query=\\\"rust async\\\", ~str}\",\n      \"reasoning\": \"Search for 'rust async' using full-text search and retrieve relevant ExtractResult entities.\"\n    }\n  ],\n  \"diagnostics\": [\n    {\n      \"step_index\": 0,\n      \"expression\": \"ExtractResult{query=\\\"rust async\\\", ~str}\",\n      \"error\": {\n        \"correction\": \"Fix spelling so identifiers, `=`, `{{}}`, `.`, and parentheses match the SYNTAX block in the prompt.\",\n        \"category\": \"parse\",\n        \"span_offset\": 34\n      }\n    }\n  ]\n}",
+          "diagnostics": [
+            {
+              "error": {
+                "category": "parse",
+                "correction": "Fix spelling so identifiers, `=`, `{{}}`, `.`, and parentheses match the SYNTAX block in the prompt.",
+                "span_offset": 34
+              },
+              "expression": "ExtractResult{query=\"rust async\", ~str}",
+              "step_index": 0
+            }
+          ],
+          "steps": [
+            {
+              "reasoning": "Search for 'rust async' using full-text search and retrieve relevant ExtractResult entities.",
+              "text": "ExtractResult{query=\"rust async\", ~str}"
+            }
+          ],
+          "validation_ok": false
+        }
+      ],
+      "chain_match": false,
+      "correction": {
+        "final_full_ok": false,
+        "first_attempt_full_ok": false,
+        "first_attempt_had_errors": true,
+        "last_failure": [
+          {
+            "error": {
+              "category": "parse",
+              "correction": "Fix spelling so identifiers, `=`, `{{}}`, `.`, and parentheses match the SYNTAX block in the prompt.",
+              "span_offset": 34
+            },
+            "expression": "ExtractResult{query=\"rust async\", ~str}",
+            "step_index": 0
+          }
+        ],
+        "pipeline_score": 0.0,
+        "recovered": false,
+        "rounds_used": 2
+      },
+      "correction_pipeline_score": 0.0,
+      "entity_match": false,
+      "goal": "Web search for 'rust async' but return only titles and URLs in the result list",
+      "id": "tv-07",
+      "notes": [],
+      "parse_ok": false,
+      "pred_fields_match": false,
+      "pred_values_match": false,
+      "projection_match": false,
+      "score": 0.0,
+      "semantic_score": 0.0,
+      "steps_ok": false,
+      "tags": [
+        "search",
+        "projection"
+      ],
+      "typecheck_ok": false
+    }
+  ],
+  "model": "google/gemma-3-4b-it"
+}

package/templates/mcp-radar/agent/catalogs/tavily/mappings.yaml

@@ -0,0 +1,171 @@
+# Tavily REST API — CML mappings. Domain model in domain.yaml.
+#
+# Base URL: Tavily HTTP API (set provider origin with --backend).
+# All endpoints use POST except research_get (GET).
+#
+# All search/extract/crawl/research parameters go in the JSON request body,
+# not the URL query string. The CML `body:` block is used throughout.
+#
+# Null-filtering: CML if/exists expressions emit null for absent optional
+# params; the runtime strips null fields from the body before sending.
+#
+# include_domains / exclude_domains are sent as JSON arrays in the body:
+#   "include_domains": ["reuters.com", "bbc.com"]
+# The `type: var` expression evaluates Value::Array which is serialised as
+# a JSON array in the body (unlike query params where Array → repeated key).
+#
+# research_create returns a single object (not a list), decoded as `single`.
+# research_get polls status — GET /research/{request_id}.
+
+# ── Search ────────────────────────────────────────────────────────────────────
+
+web_search:
+  method: POST
+  path:
+    - { type: literal, value: search }
+  response:
+    items: results
+  body:
+    type: object
+    fields:
+      - [query,               { type: var, name: query }]
+      - [search_depth,        { type: if, condition: { type: exists, var: search_depth },
+                                then_expr: { type: var, name: search_depth },
+                                else_expr: { type: const, value: null } }]
+      - [chunks_per_source,   { type: if, condition: { type: exists, var: chunks_per_source },
+                                then_expr: { type: var, name: chunks_per_source },
+                                else_expr: { type: const, value: null } }]
+      - [max_results,         { type: if, condition: { type: exists, var: max_results },
+                                then_expr: { type: var, name: max_results },
+                                else_expr: { type: const, value: null } }]
+      - [topic,               { type: if, condition: { type: exists, var: topic },
+                                then_expr: { type: var, name: topic },
+                                else_expr: { type: const, value: null } }]
+      - [time_range,          { type: if, condition: { type: exists, var: time_range },
+                                then_expr: { type: var, name: time_range },
+                                else_expr: { type: const, value: null } }]
+      - [start_date,          { type: if, condition: { type: exists, var: start_date },
+                                then_expr: { type: var, name: start_date },
+                                else_expr: { type: const, value: null } }]
+      - [end_date,            { type: if, condition: { type: exists, var: end_date },
+                                then_expr: { type: var, name: end_date },
+                                else_expr: { type: const, value: null } }]
+      - [include_answer,      { type: if, condition: { type: exists, var: include_answer },
+                                then_expr: { type: var, name: include_answer },
+                                else_expr: { type: const, value: null } }]
+      - [include_raw_content, { type: if, condition: { type: exists, var: include_raw_content },
+                                then_expr: { type: var, name: include_raw_content },
+                                else_expr: { type: const, value: null } }]
+      - [include_images,      { type: if, condition: { type: exists, var: include_images },
+                                then_expr: { type: var, name: include_images },
+                                else_expr: { type: const, value: null } }]
+      - [include_favicon,     { type: if, condition: { type: exists, var: include_favicon },
+                                then_expr: { type: var, name: include_favicon },
+                                else_expr: { type: const, value: null } }]
+      - [include_domains,     { type: if, condition: { type: exists, var: include_domains },
+                                then_expr: { type: var, name: include_domains },
+                                else_expr: { type: const, value: null } }]
+      - [exclude_domains,     { type: if, condition: { type: exists, var: exclude_domains },
+                                then_expr: { type: var, name: exclude_domains },
+                                else_expr: { type: const, value: null } }]
+      - [country,             { type: if, condition: { type: exists, var: country },
+                                then_expr: { type: var, name: country },
+                                else_expr: { type: const, value: null } }]
+      - [auto_parameters,     { type: if, condition: { type: exists, var: auto_parameters },
+                                then_expr: { type: var, name: auto_parameters },
+                                else_expr: { type: const, value: null } }]
+      - [exact_match,         { type: if, condition: { type: exists, var: exact_match },
+                                then_expr: { type: var, name: exact_match },
+                                else_expr: { type: const, value: null } }]
+
+# ── Extract ───────────────────────────────────────────────────────────────────
+
+url_extract:
+  method: POST
+  path:
+    - { type: literal, value: extract }
+  response:
+    items: results
+  body:
+    type: object
+    fields:
+      - [urls,               { type: var, name: urls }]
+      - [query,              { type: if, condition: { type: exists, var: query },
+                               then_expr: { type: var, name: query },
+                               else_expr: { type: const, value: null } }]
+      - [extract_depth,      { type: if, condition: { type: exists, var: extract_depth },
+                               then_expr: { type: var, name: extract_depth },
+                               else_expr: { type: const, value: null } }]
+      - [format,             { type: if, condition: { type: exists, var: format },
+                               then_expr: { type: var, name: format },
+                               else_expr: { type: const, value: null } }]
+      - [chunks_per_source,  { type: if, condition: { type: exists, var: chunks_per_source },
+                               then_expr: { type: var, name: chunks_per_source },
+                               else_expr: { type: const, value: null } }]
+      - [include_images,     { type: if, condition: { type: exists, var: include_images },
+                               then_expr: { type: var, name: include_images },
+                               else_expr: { type: const, value: null } }]
+      - [include_favicon,    { type: if, condition: { type: exists, var: include_favicon },
+                               then_expr: { type: var, name: include_favicon },
+                               else_expr: { type: const, value: null } }]
+
+# ── Crawl ─────────────────────────────────────────────────────────────────────
+
+site_crawl:
+  method: POST
+  path:
+    - { type: literal, value: crawl }
+  response:
+    items: results
+  body:
+    type: object
+    fields:
+      - [url,              { type: var, name: url }]
+      - [instructions,     { type: if, condition: { type: exists, var: instructions },
+                             then_expr: { type: var, name: instructions },
+                             else_expr: { type: const, value: null } }]
+      - [max_depth,        { type: if, condition: { type: exists, var: max_depth },
+                             then_expr: { type: var, name: max_depth },
+                             else_expr: { type: const, value: null } }]
+      - [max_breadth,      { type: if, condition: { type: exists, var: max_breadth },
+                             then_expr: { type: var, name: max_breadth },
+                             else_expr: { type: const, value: null } }]
+      - [limit,            { type: if, condition: { type: exists, var: limit },
+                             then_expr: { type: var, name: limit },
+                             else_expr: { type: const, value: null } }]
+      - [chunks_per_source, { type: if, condition: { type: exists, var: chunks_per_source },
+                              then_expr: { type: var, name: chunks_per_source },
+                              else_expr: { type: const, value: null } }]
+      - [include_images,   { type: if, condition: { type: exists, var: include_images },
+                             then_expr: { type: var, name: include_images },
+                             else_expr: { type: const, value: null } }]
+
+# ── Research ──────────────────────────────────────────────────────────────────
+
+research_create:
+  # POST /research — async, returns {request_id, created_at, status, input, model}
+  # Explicit object body (not body: {type: var, name: input}): execute_create splats each
+  # param key into env, overwriting env["input"] with the scalar question string.
+  method: POST
+  path:
+    - { type: literal, value: research }
+  response: single
+  body:
+    type: object
+    fields:
+      - [input,            { type: var, name: input }]
+      - [model,            { type: if, condition: { type: exists, var: model },
+                             then_expr: { type: var, name: model },
+                             else_expr: { type: const, value: null } }]
+      - [citation_format,  { type: if, condition: { type: exists, var: citation_format },
+                             then_expr: { type: var, name: citation_format },
+                             else_expr: { type: const, value: null } }]
+
+research_get:
+  # GET /research/{request_id} — poll for task status and results
+  # id = request_id value from the ResearchTask entity
+  method: GET
+  path:
+    - { type: literal, value: research }
+    - { type: var, name: id }
+  response: single

package/templates/mcp-radar/agent/channels/mcp-radar.ts

@@ -0,0 +1,85 @@
+import type { IncomingMessage, ServerResponse } from "node:http";
+
+import { waitUntil } from "@vercel/functions";
+import { defineChannel } from "@plasm_lang/vercel-agent";
+
+import { readProofMarkdown } from "../../lib/proof-store.js";
+import { radarStatus, runRadar } from "../../lib/run-radar.js";
+
+function readJsonBody(req: IncomingMessage): Promise<unknown> {
+  return new Promise((resolve, reject) => {
+    let body = "";
+    req.on("data", (chunk) => {
+      body += chunk;
+    });
+    req.on("end", () => {
+      if (!body.trim()) {
+        resolve({});
+        return;
+      }
+      try {
+        resolve(JSON.parse(body));
+      } catch (err) {
+        reject(err);
+      }
+    });
+    req.on("error", reject);
+  });
+}
+
+function sendJson(res: ServerResponse, status: number, payload: unknown): void {
+  res.statusCode = status;
+  res.setHeader("content-type", "application/json; charset=utf-8");
+  res.end(JSON.stringify(payload, null, 2));
+}
+
+export default defineChannel({
+  name: "mcp-radar",
+  routes: [
+    {
+      method: "POST",
+      path: "/channel/mcp-radar/run",
+      handler: async (req, res, ctx) => {
+        const body = (await readJsonBody(req)) as { force?: boolean };
+        const options = { force: body.force === true };
+
+        if (process.env.VERCEL === "1") {
+          waitUntil(
+            runRadar(ctx, options).catch((err: unknown) => {
+              console.error("[mcp-radar] background run failed:", err);
+            }),
+          );
+          sendJson(res, 202, { accepted: true, async: true });
+          return;
+        }
+
+        const result = await runRadar(ctx, options);
+        const status = result.ok ? 200 : 500;
+        sendJson(res, status, result);
+      },
+    },
+    {
+      method: "GET",
+      path: "/channel/mcp-radar/proof",
+      handler: async (req, res, ctx) => {
+        const url = new URL(req.url ?? "/", "http://localhost");
+        const format = url.searchParams.get("format");
+        const markdown = await readProofMarkdown(ctx.agentRoot);
+        if (format === "json") {
+          sendJson(res, 200, { markdown, path: "agent/research/mcp-innovations-proof.md" });
+          return;
+        }
+        res.statusCode = 200;
+        res.setHeader("content-type", "text/markdown; charset=utf-8");
+        res.end(markdown);
+      },
+    },
+    {
+      method: "GET",
+      path: "/channel/mcp-radar/status",
+      handler: async (_req, res, ctx) => {
+        sendJson(res, 200, await radarStatus(ctx.agentRoot));
+      },
+    },
+  ],
+});