flowforge-map 0.1.0__py3-none-any.whl

flowforge/api/checks.py

@@ -0,0 +1,255 @@
+"""Check now (D24): a health check of every dependency on the map, run by the scheduler, kept over time.
+
+GET  /checks/plan           what a check run would do, the MCP servers it would start, and whether you said yes
+POST /checks {ids?, confirm?}   start a check run (201, `run_id`); 409 until starting MCP servers is confirmed
+GET  /checks                the latest verdict per dependency, in map order, with a summary
+GET  /checks/{dep_id}       one dependency's checks, newest first
+
+Progress streams over GET /runs/{run_id}/events, like any run (D16).
+"""
+
+from __future__ import annotations
+
+import asyncio
+import json
+import math
+import re
+from pathlib import Path
+from typing import Any
+
+from fastapi import APIRouter, HTTPException
+from pydantic import BaseModel, ConfigDict
+
+from flowforge.api.runs import start_run
+from flowforge.api.scan import repo_path
+from flowforge.checks import CheckTarget, probes, starts_process
+from flowforge.nodes.check_node import MCP_AT_ONCE
+from flowforge.scan.models import Dependency, EnvName, ScanResult
+from flowforge.scan.urls import clean_url
+from flowforge.schema import Step, Workflow
+from flowforge.state import AppState, app_state
+
+router = APIRouter()
+
+CHECKABLE = ("llm", "api", "mcp", "local")
+CONFIRMED_SETTING = "checks_confirmed"   # the MCP commands the user agreed to start, one by one (JSON list)
+LAST_RUN_SETTING = "checks_last_run"
+HISTORY = 12                             # checks shown per dependency
+COUNTS = ("up", "warn", "down", "skipped", "unchecked", "unconfirmed")
+# rough check times by kind, so the scheduler starts the slow MCP servers first (D1 weights, D24)
+ESTIMATE_MS = {"mcp": 3000.0, "llm": 300.0, "api": 300.0, "local": 10.0}
+STEP_SLACK_S = 5.0   # on top of a probe's own timeout
+
+
+class CheckRequest(BaseModel):
+    model_config = ConfigDict(extra="forbid")
+
+    ids: list[str] | None = None   # None = every dependency on the map
+    confirm: bool = False          # yes, start the MCP servers listed in /checks/plan
+
+
+def _reads_env(dep: Dependency, scan: ScanResult) -> list[EnvName]:
+    """Env names an MCP server's own script reads, and where, from the scan (for a likely fix when it won't start)."""
+    if dep.kind != "mcp" or not dep.command or len(dep.command) < 2:
+        return []
+    script = dep.command[1]
+    return [e for e in scan.env_names if e.ref.rsplit(":", 1)[0] == script]
+
+
+def _address(what: str | None) -> str | None:
+    """A block you added: its text is an address only if it looks like one (no query kept, D24)."""
+    if not what or " " in what.strip():
+        return None
+    what = what.strip()
+    return clean_url(what) if "://" in what else (what if "." in what or ":" in what else None)
+
+
+def target_for(dep: Dependency, scan: ScanResult, name: str | None = None) -> CheckTarget:
+    """What a check of a scanned dependency reaches (D24); shared by Check now and the MCP server (D29)."""
+    return CheckTarget(id=dep.id, kind=dep.kind, name=name or dep.name, target=dep.target, command=dep.command,
+                       model=dep.model, catalog=dep.catalog, env_names=dep.env_names, reads_env=_reads_env(dep, scan))
+
+
+def confirmed_commands(storage: Any) -> set[str]:
+    """The MCP commands the user said yes to starting (D24)."""
+    return set(json.loads(storage.setting(CONFIRMED_SETTING) or "[]"))
+
+
+def _target(node: dict[str, Any], dep: Dependency | None, scan: ScanResult | None) -> CheckTarget:
+    if dep is not None and scan is not None:
+        return target_for(dep, scan, node["title"])
+    what = (node.get("what") or "").strip()   # a dependency the user added on the map: its address or command
+    address = _address(what)
+    if node["kind"] in ("mcp", "local") and what and "://" not in what:
+        command = what.split()
+    else:
+        command = [address] if node["kind"] == "mcp" and address else None
+    return CheckTarget(id=node["id"], kind=node["kind"], name=node["title"], catalog=node.get("catalog"),
+                       target=address, command=command, model=(node.get("op") or {}).get("model"))
+
+
+def _map(s: AppState) -> tuple[list[dict[str, Any]], dict[str, CheckTarget], dict[str, Dependency]]:
+    """The checkable blocks of the dependency map with your edits (hidden ones are gone), and their targets."""
+    view = s.flows["deps"].current("mine")
+    if not view.get("available"):
+        return [], {}, {}
+    analysis = s.flows["deps"].analysis() or {}
+    scan = ScanResult.model_validate(analysis["scan"]) if analysis.get("scan") else None
+    deps = {d.id: d for d in scan.dependencies} if scan else {}
+    nodes = [n for n in view["nodes"] if n["kind"] in CHECKABLE]
+    targets = {n["id"]: _target(n, deps.get(n["id"]), scan) for n in nodes if n["status"] != "unconfirmed"}
+    return nodes, targets, deps
+
+
+def _origin(command: list[str], root: Path | None) -> str:
+    """Where the code that starts comes from, in plain words."""
+    program = Path(command[0]).name
+    package = next((a for a in command[1:] if not a.startswith("-")), "")
+    if program in ("npx", "bunx", "pnpx"):
+        return "downloads from npm" + ("" if package.rfind("@") > 0 else ", any version")
+    if program in ("uvx", "pipx"):
+        return "downloads from PyPI" + ("" if "@" in package or "==" in package else ", any version")
+    if root is not None and package and (root / package).is_file():
+        return "runs a script in this repo"
+    return f"runs {program} from your PATH"
+
+
+def command_text(t: CheckTarget) -> str:
+    return " ".join(t.command or [])
+
+
+def _confirmed(s: AppState) -> set[str]:
+    return confirmed_commands(s.storage)
+
+
+def _unconfirmed(s: AppState, targets: list[CheckTarget]) -> list[CheckTarget]:
+    """The servers this check would start that the user hasn't said yes to. Each yes covers the command shown, so
+    a re-scan or an edit that changes a command asks again (D24). Example mode starts nothing."""
+    if s.example:
+        return []
+    yes = _confirmed(s)
+    return [t for t in targets if starts_process(t) and command_text(t) not in yes]
+
+
+def check_workflow(targets: list[CheckTarget], root: str) -> Workflow:
+    """One check step per dependency, no edges, no retries, no cache (D24). Only MCP_AT_ONCE servers start
+    together (CheckNode), so a server's timeout includes its wait for a turn: every round may take the full
+    MCP_TIMEOUT_S."""
+    rounds = math.ceil(sum(t.kind == "mcp" for t in targets) / MCP_AT_ONCE) or 1
+    timeout = {"mcp": probes.MCP_TIMEOUT_S * rounds, "llm": probes.HTTP_TIMEOUT_S, "api": probes.HTTP_TIMEOUT_S,
+               "local": 1.0}
+    steps = [Step(id="c_" + re.sub(r"\W", "_", t.id), type="check", retries=0, cache=False,
+                  description=f"Check {t.name}", estimated_ms=ESTIMATE_MS[t.kind],
+                  timeout_s=timeout[t.kind] + STEP_SLACK_S,
+                  params={"target": t.model_dump(mode="json"), "root": root}) for t in targets]
+    return Workflow(id="health-check", name="Health check", max_concurrency=8, type_concurrency={"check": 8},
+                    steps=steps)
+
+
+@router.get("/checks/plan")
+def check_plan() -> dict[str, Any]:
+    s = app_state()
+    _, targets, deps = _map(s)
+    root = repo_path(s)
+    starts = []
+    for t in targets.values():
+        if starts_process(t):
+            dep = deps.get(t.id)
+            source = dep.evidence[0].ref if dep and dep.evidence else None
+            starts.append({"id": t.id, "name": t.name, "command": " ".join(t.command or []),
+                           "origin": _origin(t.command or [], root), "source": source})
+    confirmed = not _unconfirmed(s, list(targets.values()))
+    kinds = {k: sum(t.kind == k for t in targets.values()) for k in CHECKABLE}
+    return {"checks": len(targets), "kinds": kinds, "starts": starts, "confirmed": confirmed, "example": s.example}
+
+
+async def _record(s: AppState, run_id: str, workflow: Workflow) -> None:
+    """When the run ends, keep a verdict for every check that finished (D24), from the run's events, so a run you
+    stopped still keeps what it found. A check that broke says so (skipped), never blaming the dependency; a
+    check that never ran records nothing."""
+    run = s.runs[run_id]
+    if run.task is not None:
+        await asyncio.wait([run.task])
+    targets = {step.id: step.params["target"] for step in workflow.steps}
+    rows = []
+    for event in run.events:
+        if event.get("type") != "step" or event.get("step_id") not in targets:
+            continue
+        out = event.get("output")
+        if event.get("state") == "succeeded" and isinstance(out, dict) and out.get("status"):
+            rows.append(out)
+        elif event.get("state") == "failed":
+            target = targets[event["step_id"]]
+            rows.append({"id": target["id"], "kind": target["kind"], "status": "skipped",
+                         "summary": "The check couldn't run", "reason": event.get("error")})
+    if rows:
+        s.storage.add_checks(run_id, rows)
+    s.storage.set_setting(LAST_RUN_SETTING, run_id)
+
+
+@router.post("/checks", status_code=201)
+async def start_checks(req: CheckRequest) -> dict[str, Any]:
+    s = app_state()
+    _, targets, _ = _map(s)
+    root = repo_path(s)
+    if not targets or root is None:
+        raise HTTPException(409, "There is nothing to check yet. Scan a folder first.")
+    chosen = list(targets.values())
+    if req.ids is not None:
+        unknown = sorted(set(req.ids) - set(targets))
+        if unknown:
+            raise HTTPException(422, f"not on the map, or unconfirmed: {', '.join(unknown)}")
+        chosen = [targets[i] for i in req.ids]
+    asking = _unconfirmed(s, chosen)
+    if asking:
+        if not req.confirm:
+            n = len(asking)
+            raise HTTPException(409, f"Checking would start {n} MCP server{'s' if n != 1 else ''} on this computer. "
+                                     "See what starts in GET /checks/plan, then send confirm: true.")
+        # the yes covers exactly the servers this check starts, nothing else on the map
+        s.storage.set_setting(CONFIRMED_SETTING, json.dumps(sorted(_confirmed(s) | {command_text(t) for t in asking})))
+    workflow = check_workflow(chosen, str(root))
+    run_id = start_run(workflow, use_cache=False)
+    task = asyncio.create_task(_record(s, run_id, workflow))
+    s.tasks.add(task)
+    task.add_done_callback(s.tasks.discard)
+    return {"run_id": run_id, "checks": len(workflow.steps)}
+
+
+def _item(node: dict[str, Any], history: list[dict[str, Any]]) -> dict[str, Any]:
+    item = {"id": node["id"], "name": node["title"], "kind": node["kind"], "catalog": node.get("catalog"),
+            "history": [h["status"] for h in reversed(history)]}   # oldest first, as the squares read
+    if node["status"] == "unconfirmed":
+        return {**item, "status": "unconfirmed", "summary": "Not checked: unconfirmed", "history": []}
+    if not history:
+        return {**item, "status": "unchecked", "summary": "Not checked yet"}
+    last = history[0]
+    return {**item, **{k: last.get(k) for k in ("status", "latency_ms", "summary", "reason", "fix", "at")}}
+
+
+@router.get("/checks")
+def latest_checks() -> dict[str, Any]:
+    s = app_state()
+    nodes, _, _ = _map(s)
+    by_dep: dict[str, list[dict[str, Any]]] = {}
+    for row in s.storage.check_history(limit=HISTORY):
+        by_dep.setdefault(row["dep_id"], []).append(row)
+    items = [_item(n, by_dep.get(n["id"], [])) for n in nodes]
+    summary = {k: sum(i["status"] == k for i in items) for k in COUNTS}
+    checked = [i["at"] for i in items if i.get("at")]
+    run_id = s.storage.setting(LAST_RUN_SETTING)
+    last = s.storage.get_run(run_id) if run_id else None
+    return {"run_id": run_id, "checked_at": max(checked) if checked else None,
+            "took_ms": last.get("makespan_ms") if last else None,
+            "summary": summary, "items": items, "example": s.example}
+
+
+@router.get("/checks/{dep_id}")
+def dependency_checks(dep_id: str, limit: int = 50) -> list[dict[str, Any]]:
+    s = app_state()
+    nodes, _, _ = _map(s)
+    history = s.storage.check_history(dep_id, limit=limit)
+    if not history and dep_id not in {n["id"] for n in nodes}:
+        raise HTTPException(404, f"'{dep_id}' isn't on the map")
+    return [{k: h.get(k) for k in ("run_id", "status", "latency_ms", "summary", "reason", "fix", "at")}
+            for h in history]

flowforge/api/connectors.py

@@ -0,0 +1,289 @@
+"""Connectors: list, read, create, edit, delete, logo, test, activity, presets (D10, D12, D16).
+
+Keys are references only: responses carry `secret: {"ref", "status": "set" | "missing"}`, never
+a value. Bodies are validated by hand so a rejected body is never echoed back (it might hold a
+pasted key). Connectors from connectors.json are read-only here (D16).
+"""
+
+from __future__ import annotations
+
+import asyncio
+import json
+import os
+from datetime import datetime, timedelta
+from typing import Annotated, Any
+
+from fastapi import APIRouter, Body, HTTPException, Response, UploadFile
+from fastapi.responses import FileResponse
+from pydantic import ValidationError
+
+from flowforge.checks import CheckTarget
+from flowforge.connectors.models import Connector, parse_connector
+from flowforge.connectors.presets import CUSTOM, DEFAULT_CONNECTORS, PRESETS
+from flowforge.connectors.registry import ConnectorFileError, _describe, check_references
+from flowforge.connectors.runtime import build_node
+from flowforge.home import flowforge_home
+from flowforge.nodes.base import NodeError
+from flowforge.nodes.local_node import LocalNode
+from flowforge.nodes.mcp_node import MCPNode
+from flowforge.security.logfilter import secret_values_for
+from flowforge.state import AppState, app_state
+
+MCP_TIMEOUT_S = 15
+MAX_LOGO_BYTES = 1024 * 1024
+LOGO_TYPES = {"png": "image/png", "jpg": "image/jpeg", "webp": "image/webp"}
+
+router = APIRouter()
+
+
+# --- helpers ------------------------------------------------------------------------------------------
+
+def secret_status(connector: Connector, example: bool = False) -> dict[str, str] | None:
+    """"set" or "missing", never the value. In example mode a missing key reads "example"."""
+    ref = connector.secret_ref
+    if ref is None:
+        return None
+    name = ref.split(":", 1)[1]
+    if ref.startswith("env:") and os.environ.get(name):
+        return {"ref": ref, "status": "set"}
+    return {"ref": ref, "status": "example" if example else "missing"}
+
+
+def view(connector: Connector, s: AppState) -> dict[str, Any]:
+    data = connector.model_dump(mode="json")
+    data["secret"] = secret_status(connector, s.example)
+    data["managed_by"] = "file" if connector.id in s.file_managed else "app"
+    data["deletable"] = connector.id not in DEFAULT_CONNECTORS and connector.id not in s.file_managed
+    data["is_default"] = connector.id in DEFAULT_CONNECTORS
+    if connector.style.logo.type == "upload":
+        data["logo_url"] = f"/connectors/{connector.id}/logo"
+    return data
+
+
+def get_connector(connector_id: str) -> Connector:
+    connector = app_state().registry.get(connector_id)
+    if connector is None:
+        raise HTTPException(404, "unknown connector")
+    return connector
+
+
+def editable(connector_id: str) -> Connector:
+    connector = get_connector(connector_id)
+    if connector_id in app_state().file_managed:
+        raise HTTPException(409, f"'{connector_id}' is managed by connectors.json; edit that file instead")
+    return connector
+
+
+def parse_body(body: Any) -> Connector:
+    try:
+        connector = parse_connector(body)
+    except ValidationError as exc:
+        raise HTTPException(422, _describe(exc)) from None  # field paths and messages only, no values
+    if connector.secret_ref and connector.secret_ref.startswith("vault:"):
+        raise HTTPException(422, "vault: references need the vault, which arrives in Phase 4; use env:NAME")
+    return connector
+
+
+def install(connector: Connector, s: AppState) -> None:
+    """Save, then swap in a fresh node and bucket. Running runs keep their snapshot (D16)."""
+    others = [c for c in s.registry.all() if c.id != connector.id]
+    try:
+        check_references([*others, connector])
+    except ConnectorFileError as exc:
+        raise HTTPException(422, str(exc)) from None
+    s.registry.save(connector)
+    node, bucket = build_node(connector)
+    old = s.nodes.get(connector.id)
+    if old is not None:
+        s.retired_nodes.append(old)
+    s.nodes[connector.id] = node
+    if connector.id == "nim":
+        s.nodes["llm"] = node
+    if bucket is not None and node.rate_limit_key:
+        s.rate_limits[node.rate_limit_key] = bucket
+    else:
+        s.rate_limits.pop(connector.id, None)
+    refresh_redaction(s)
+
+
+def refresh_redaction(s: AppState) -> None:
+    s.redactor.set_values(secret_values_for(s.registry.all()))
+
+
+# --- routes -------------------------------------------------------------------------------------------
+
+@router.get("/connectors")
+def list_connectors() -> list[dict[str, Any]]:
+    s = app_state()
+    return [view(c, s) for c in s.registry.all()]
+
+
+@router.get("/connectors/{connector_id}")
+def read_connector(connector_id: str) -> dict[str, Any]:
+    return view(get_connector(connector_id), app_state())
+
+
+@router.post("/connectors", status_code=201)
+def create_connector(body: Annotated[Any, Body()]) -> dict[str, Any]:
+    s = app_state()
+    connector = parse_body(body)
+    if s.registry.get(connector.id) is not None:
+        raise HTTPException(409, f"a connector called '{connector.id}' already exists")
+    install(connector, s)
+    return view(connector, s)
+
+
+@router.put("/connectors/{connector_id}")
+def update_connector(connector_id: str, body: Annotated[Any, Body()]) -> dict[str, Any]:
+    s = app_state()
+    current = editable(connector_id)
+    connector = parse_body(body)
+    if connector.id != connector_id:
+        raise HTTPException(422, "the id in the body must match the URL; ids can't be renamed")
+    if connector.style.logo.type == "upload" and current.style.logo != connector.style.logo:
+        raise HTTPException(422, "upload a logo through /connectors/{id}/logo")
+    install(connector.model_copy(update={"created_at": current.created_at}), s)
+    return view(connector, s)
+
+
+@router.delete("/connectors/{connector_id}", status_code=204)
+def delete_connector(connector_id: str) -> Response:
+    s = app_state()
+    editable(connector_id)
+    if connector_id in DEFAULT_CONNECTORS:
+        raise HTTPException(409, f"'{connector_id}' is a default connector and can't be deleted")
+    users = [c.id for c in s.registry.all() if c.fallback == connector_id]
+    if users:
+        raise HTTPException(409, f"'{connector_id}' is the fallback for {', '.join(users)}; change those first")
+    s.registry.delete(connector_id)
+    node = s.nodes.pop(connector_id, None)
+    if node is not None:
+        s.retired_nodes.append(node)
+    s.rate_limits.pop(connector_id, None)
+    refresh_redaction(s)
+    return Response(status_code=204)
+
+
+@router.post("/connectors/{connector_id}/logo")
+async def upload_logo(connector_id: str, file: UploadFile) -> dict[str, Any]:
+    """PNG, JPEG or WebP, at most 1 MB, checked by content (CLAUDE.md §6.5). No SVG."""
+    s = app_state()
+    connector = editable(connector_id)
+    data = await file.read(MAX_LOGO_BYTES + 1)
+    if len(data) > MAX_LOGO_BYTES:
+        raise HTTPException(413, "logos must be 1 MB or smaller")
+    if data.startswith(b"\x89PNG\r\n\x1a\n"):
+        ext = "png"
+    elif data.startswith(b"\xff\xd8\xff"):
+        ext = "jpg"
+    elif data[:4] == b"RIFF" and data[8:12] == b"WEBP":
+        ext = "webp"
+    else:
+        raise HTTPException(415, "logos must be PNG, JPEG or WebP images")
+    folder = flowforge_home() / "logos"
+    folder.mkdir(parents=True, exist_ok=True)
+    for old in LOGO_TYPES:
+        (folder / f"{connector_id}.{old}").unlink(missing_ok=True)
+    (folder / f"{connector_id}.{ext}").write_bytes(data)
+    data = connector.model_dump(mode="json")
+    data["style"]["logo"] = {"type": "upload", "file": f"{connector_id}.{ext}"}
+    updated = parse_connector(data)
+    s.registry.save(updated)
+    return view(updated, s)
+
+
+@router.get("/connectors/{connector_id}/logo")
+def get_logo(connector_id: str) -> FileResponse:
+    logo = get_connector(connector_id).style.logo
+    if logo.type != "upload":
+        raise HTTPException(404, "this connector has no uploaded logo")
+    name, _, ext = logo.file.rpartition(".")
+    path = flowforge_home() / "logos" / f"{connector_id}.{ext}"
+    if name != connector_id or ext not in LOGO_TYPES or not path.is_file():
+        raise HTTPException(404, "logo file missing")
+    return FileResponse(path, media_type=LOGO_TYPES[ext],
+                        headers={"X-Content-Type-Options": "nosniff", "Cache-Control": "no-cache"})
+
+
+@router.post("/connectors/{connector_id}/test")
+async def test_connector(connector_id: str) -> dict[str, Any]:
+    """One harmless check. MCP: list its tools. Local: the program and folder exist. LLM and HTTP: the health
+    check's one request, with no key (D24)."""
+    s = app_state()
+    connector = get_connector(connector_id)
+    node = s.nodes.get(connector_id)
+    if connector.type in ("llm", "http"):   # the health check's one request, without the key (D24)
+        target = CheckTarget(id=connector.id, kind="llm" if connector.type == "llm" else "api", name=connector.name,
+                             target=connector.connection.base_url, model=getattr(connector.connection, "model", None))
+        out = await s.nodes["check"].run({"target": target.model_dump(mode="json"), "root": "."})
+        result = {"ok": out["status"] in ("up", "warn"), "message": out["summary"]}
+        s.connector_tests[connector_id] = {**result, "at": datetime.now().astimezone().isoformat(timespec="seconds")}
+        return result
+    try:
+        if isinstance(node, MCPNode):
+            tools = await asyncio.wait_for(node.list_tools(), MCP_TIMEOUT_S)
+            message = f"Connected. {len(tools)} tool{'s' if len(tools) != 1 else ''} found."
+        elif isinstance(node, LocalNode):
+            node._program(node._env())
+            node._workdir(None)
+            message = "Ready. The program and its folder were found."
+        else:
+            raise HTTPException(409, "this connector has no node; restart FlowForge")
+        result = {"ok": True, "message": message}
+    except (NodeError, TimeoutError) as exc:
+        result = {"ok": False, "message": s.redactor.redact_text(str(exc) or "timed out")}
+    s.connector_tests[connector_id] = {**result, "at": datetime.now().astimezone().isoformat(timespec="seconds")}
+    return result
+
+
+def connector_steps(s: AppState, recent_runs: int = 50) -> dict[str, list[dict[str, Any]]]:
+    """Steps from recent stored runs, grouped by the connector that answered them, newest first."""
+    by_connector: dict[str, list[dict[str, Any]]] = {}
+    for summary, result in s.storage.recent_results(limit=recent_runs):
+        started = datetime.fromisoformat(summary["started_at"])
+        titles = {o["id"]: o["title"] for o in json.loads(summary.get("steps_json") or "[]")}
+        for step in result["steps"].values():
+            connector_id = step.get("answered_by")
+            if connector_id is None or step.get("started_at") is None:
+                continue
+            offset = step.get("finished_at") or step["started_at"]
+            duration = None
+            if step.get("finished_at") is not None:
+                duration = (step["finished_at"] - step["started_at"]) * 1000
+            by_connector.setdefault(connector_id, []).append({
+                "run_id": summary["id"], "plan": summary["workflow_name"] or summary["workflow_id"],
+                "step_id": step["step_id"], "title": titles.get(step["step_id"], step["step_id"]),
+                "state": step["state"], "error": step.get("error"),
+                "cache_hit": step.get("cache_hit"), "attempts": step.get("attempts", 0), "duration_ms": duration,
+                "at": (started + timedelta(seconds=offset)).isoformat(timespec="milliseconds")})
+    for items in by_connector.values():
+        items.sort(key=lambda i: i["at"], reverse=True)
+    return by_connector
+
+
+@router.get("/connectors/{connector_id}/activity")
+def connector_activity(connector_id: str, limit: int = 20) -> list[dict[str, Any]]:
+    """This connector's most recent steps, newest first (from stored results, D16)."""
+    get_connector(connector_id)
+    return connector_steps(app_state()).get(connector_id, [])[:limit]
+
+
+@router.get("/connectors/{connector_id}/tools")
+async def connector_tools(connector_id: str) -> list[dict[str, Any]]:
+    node = app_state().nodes.get(connector_id)
+    if node is None:
+        raise HTTPException(404, "unknown connector")
+    if not isinstance(node, MCPNode):
+        raise HTTPException(422, f"'{connector_id}' is not an MCP connector")
+    try:
+        return await asyncio.wait_for(node.list_tools(), MCP_TIMEOUT_S)
+    except (NodeError, TimeoutError) as exc:
+        raise HTTPException(502, f"could not list tools: {str(exc) or type(exc).__name__}") from exc
+
+
+@router.get("/presets")
+def list_presets() -> list[dict[str, Any]]:
+    """Ready-made connectors and one Custom template per type, for "Add an app"."""
+    presets = [{**c.model_dump(mode="json"), "preset": c.id} for c in PRESETS.values()]
+    custom = [{"preset": f"custom-{t}", "name": f"Custom {t}", **template} for t, template in CUSTOM.items()]
+    return presets + custom