fronyboard 0.28.1__tar.gz

fronyboard-0.28.1/.gitignore

@@ -0,0 +1,10 @@
+.venv/
+__pycache__/
+*.pyc
+.pytest_cache/
+backend/dist/
+node_modules/
+*.tsbuildinfo
+# frontend/dist is committed on purpose: the home server deploys by git pull alone (no node).
+# launchers carry FRONY_SERVICE_KEY; commit only the .cmd.example
+*.cmd

fronyboard-0.28.1/PKG-INFO

@@ -0,0 +1,46 @@
+Metadata-Version: 2.5
+Name: fronyboard
+Version: 0.28.1
+Summary: FronyBoard — an MCP server that gives AI agents a first-class project tracker
+Project-URL: Homepage, https://github.com/Cafelatte1/FronyBoard
+Project-URL: Repository, https://github.com/Cafelatte1/FronyBoard
+Project-URL: Issues, https://github.com/Cafelatte1/FronyBoard/issues
+License: MIT
+Keywords: ai-agents,claude-code,mcp,mcp-server,project-tracker
+Classifier: Development Status :: 4 - Beta
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+Classifier: Topic :: Software Development :: Bug Tracking
+Requires-Python: >=3.10
+Requires-Dist: httpx>=0.27
+Requires-Dist: loguru>=0.7
+Requires-Dist: mcp>=1.2.0
+Requires-Dist: pyyaml>=6.0
+Requires-Dist: tzdata>=2024.1
+Description-Content-Type: text/markdown
+
+# FronyBoard
+
+An MCP server that gives AI agents (Claude Code and friends) a first-class project
+tracker: roadmap → quarterly periods → months → tasks in one SQLite file, a schema +
+rule validation gate before every write, retrospectives that close a period, and a
+read-only web dashboard for humans.
+
+<!-- mcp-name: io.github.cafelatte1/fronyboard -->
+
+## Install
+
+Requires [uv](https://docs.astral.sh/uv/).
+
+```
+claude mcp add FronyBoard -- uvx fronyboard
+```
+
+Any MCP client that can launch a stdio command works the same way: the command is
+`uvx fronyboard`. Data is written to `%LOCALAPPDATA%\Frony\FronyBoard\data`
+(`~/.Frony/FronyBoard/data` where `LOCALAPPDATA` is unset); set `AIRA_DATA_DIR` to
+relocate it.
+
+Full documentation, the data model, the 20 tools and the shared-server mode live in
+the repository: https://github.com/Cafelatte1/FronyBoard

fronyboard-0.28.1/README.md

@@ -0,0 +1,24 @@
+# FronyBoard
+
+An MCP server that gives AI agents (Claude Code and friends) a first-class project
+tracker: roadmap → quarterly periods → months → tasks in one SQLite file, a schema +
+rule validation gate before every write, retrospectives that close a period, and a
+read-only web dashboard for humans.
+
+<!-- mcp-name: io.github.cafelatte1/fronyboard -->
+
+## Install
+
+Requires [uv](https://docs.astral.sh/uv/).
+
+```
+claude mcp add FronyBoard -- uvx fronyboard
+```
+
+Any MCP client that can launch a stdio command works the same way: the command is
+`uvx fronyboard`. Data is written to `%LOCALAPPDATA%\Frony\FronyBoard\data`
+(`~/.Frony/FronyBoard/data` where `LOCALAPPDATA` is unset); set `AIRA_DATA_DIR` to
+relocate it.
+
+Full documentation, the data model, the 20 tools and the shared-server mode live in
+the repository: https://github.com/Cafelatte1/FronyBoard

fronyboard-0.28.1/pyproject.toml

@@ -0,0 +1,45 @@
+[project]
+name = "fronyboard"
+version = "0.28.1"
+description = "FronyBoard — an MCP server that gives AI agents a first-class project tracker"
+readme = "README.md"
+license = {text = "MIT"}
+requires-python = ">=3.10"
+keywords = ["mcp", "mcp-server", "project-tracker", "ai-agents", "claude-code"]
+classifiers = [
+    "Development Status :: 4 - Beta",
+    "Intended Audience :: Developers",
+    "License :: OSI Approved :: MIT License",
+    "Programming Language :: Python :: 3",
+    "Topic :: Software Development :: Bug Tracking",
+]
+dependencies = [
+    "httpx>=0.27",
+    "loguru>=0.7",
+    "mcp>=1.2.0",
+    "pyyaml>=6.0",
+    "tzdata>=2024.1",
+]
+
+[project.urls]
+Homepage = "https://github.com/Cafelatte1/FronyBoard"
+Repository = "https://github.com/Cafelatte1/FronyBoard"
+Issues = "https://github.com/Cafelatte1/FronyBoard/issues"
+
+[project.scripts]
+fronyboard = "fronyboard.server:main"
+
+[dependency-groups]
+dev = [
+    "pytest>=8.0",
+]
+
+[build-system]
+requires = ["hatchling"]
+build-backend = "hatchling.build"
+
+[tool.hatch.build.targets.wheel]
+packages = ["src/fronyboard"]
+
+[tool.pytest.ini_options]
+testpaths = ["test"]

fronyboard-0.28.1/scripts/migrate_v020.py

@@ -0,0 +1,51 @@
+"""One-off migration to the v0.2.0 layout: period folders -> single period files.
+
+For every `projects/{KEY}/{YYYYQ#}/` folder: merge objective.yaml (months) and
+tasks.yaml (tasks, minus their `epic` field — epics are gone in v0.2.0) into
+`projects/{KEY}/{YYYYQ#}.yaml`, move result.md into the `result` field, then
+remove the folder. Idempotent: a project with no period folders is left as is.
+
+Run from backend/ against the live data root (stop the server first):
+
+    uv run python scripts/migrate_v020.py [data-root]    # default: ~/.aira
+"""
+
+import shutil
+import sys
+from pathlib import Path
+
+sys.path.insert(0, str(Path(__file__).resolve().parents[1] / "src"))
+from fronyboard import store  # noqa: E402
+
+
+def migrate(root: Path) -> None:
+    projects = root / "projects"
+    if not projects.is_dir():
+        raise SystemExit(f"no projects directory under {root}")
+    for pdir in sorted(projects.iterdir()):
+        if not pdir.is_dir():
+            continue
+        for period_dir in sorted(p for p in pdir.iterdir() if p.is_dir()):
+            objective = period_dir / "objective.yaml"
+            tasks_file = period_dir / "tasks.yaml"
+            if not objective.exists() and not tasks_file.exists():
+                print(f"skip {period_dir} — not a period folder")
+                continue
+            obj = store.load_yaml(objective) or {} if objective.exists() else {}
+            tsk = store.load_yaml(tasks_file) or {} if tasks_file.exists() else {}
+            data = {"months": obj.get("months") or [], "tasks": []}
+            for t in tsk.get("tasks") or []:
+                t.pop("epic", None)
+                data["tasks"].append(t)
+            result_md = period_dir / "result.md"
+            if result_md.exists():
+                data["result"] = result_md.read_text(encoding="utf-8")
+            out = pdir / f"{period_dir.name}.yaml"
+            store.save_yaml(out, data)
+            shutil.rmtree(period_dir)
+            print(f"migrated {period_dir} -> {out.name} "
+                  f"({len(data['months'])} months, {len(data['tasks'])} tasks)")
+
+
+if __name__ == "__main__":
+    migrate(Path(sys.argv[1]).expanduser() if len(sys.argv) > 1 else Path.home() / ".aira")

fronyboard-0.28.1/src/fronyboard/__init__.py

@@ -0,0 +1,3 @@
+"""FronyBoard — an MCP server that gives AI agents a first-class project tracker."""
+
+__version__ = "0.1.0"

fronyboard-0.28.1/src/fronyboard/auth.py

@@ -0,0 +1,121 @@
+"""HTTP bearer auth for the FronyBoard server — delegation to FronyAuth since AIR-056.
+
+API keys and OAuth tokens are issued and judged by FronyAuth (see fauth.py for
+the client and its configuration); FronyBoard no longer reads auth.yaml/oauth.yaml.
+The only credential that stays local is the dashboard session token, which
+lives in this process's memory and never leaves the machine.
+"""
+
+from __future__ import annotations
+
+import json
+import secrets
+
+from starlette.middleware.cors import CORSMiddleware
+
+from . import fauth, log
+
+# Dashboard sessions are held in memory only — a server restart signs everyone out.
+_sessions: dict[str, str] = {}  # token -> username
+
+
+def create_session(username: str = "admin") -> str:
+    token = "fbsession_" + secrets.token_hex(24)
+    _sessions[token] = username
+    return token
+
+
+def session_user(token: str | None) -> str | None:
+    return _sessions.get(token or "")
+
+
+def verify_session(token: str | None) -> bool:
+    return bool(token) and token in _sessions
+
+
+def drop_session(token: str | None) -> None:
+    _sessions.pop(token or "", None)
+
+
+def with_mcp_cors(app):
+    """Answer browser CORS on /mcp only. claude.ai's web app probes a connector
+    from the browser itself, so the preflight must pass without a credential and
+    the 401 must be readable (it carries the WWW-Authenticate pointer)."""
+    cors = CORSMiddleware(app, allow_origins=["*"], allow_methods=["GET", "POST", "DELETE", "OPTIONS"],
+                          allow_headers=["*"], expose_headers=["Mcp-Session-Id", "WWW-Authenticate"])
+
+    async def wrapped(scope, receive, send):
+        if scope["type"] == "http" and scope.get("path", "").startswith("/mcp"):
+            await cors(scope, receive, send)
+        else:
+            await app(scope, receive, send)
+    return wrapped
+
+
+class BearerAuthMiddleware:
+    """Pure ASGI middleware: reject HTTP requests without a valid credential.
+
+    Only paths starting with one of `protected` require a credential (default:
+    all) — the FronyBoard static files stay open while /mcp and /api stay keyed.
+    `open_paths` are exact-match exceptions inside protected space (the login
+    endpoint). A bearer token may be a dashboard session token (checked locally)
+    or an API key / OAuth access token (judged by FronyAuth). When FronyAuth is
+    unreachable the answer is 503, never 401 — a client must not conclude its
+    key was revoked because the auth server blinked.
+
+    `resource_metadata_url` is what a 401 on /mcp advertises via
+    WWW-Authenticate (RFC 9728) so OAuth-capable clients know where to start.
+    """
+
+    def __init__(self, app, protected: tuple[str, ...] = ("/",),
+                 open_paths: tuple[str, ...] = (), resource_metadata_url: str | None = None):
+        self.app = app
+        self.protected = protected
+        self.open_paths = open_paths
+        self.resource_metadata_url = resource_metadata_url
+
+    async def __call__(self, scope, receive, send):
+        path = scope.get("path", "")
+        if scope["type"] != "http" or path in self.open_paths or \
+                not any(path.startswith(p) for p in self.protected):
+            await self.app(scope, receive, send)
+            return
+        auth_header = ""
+        for name, value in scope.get("headers") or []:
+            if name == b"authorization":
+                auth_header = value.decode("latin-1")
+                break
+        token = auth_header[7:] if auth_header.lower().startswith("bearer ") else None
+        client = scope.get("client") or ("?", 0)
+        if verify_session(token):
+            caller = f"session:{session_user(token)}"
+        else:
+            try:
+                caller = await fauth.verify(token)
+            except fauth.Unavailable as e:
+                log.event("ERROR", "auth", "fauth_unavailable", ip=str(client[0]), path=path,
+                          error=str(e))
+                await self._reject(send, 503, "auth service unavailable — try again shortly")
+                return
+        if caller is None:
+            log.event("WARNING", "auth", "key_rejected", ip=str(client[0]), path=path,
+                      prefix=(token or "")[:9] or None)
+            headers = []
+            if self.resource_metadata_url is not None and path.startswith("/mcp"):
+                # RFC 9728 discovery: tells an OAuth-capable client where to start.
+                headers.append((b"www-authenticate",
+                                f'Bearer resource_metadata="{self.resource_metadata_url}"'.encode()))
+            await self._reject(send, 401, "unauthorized — send 'Authorization: Bearer <api key>'",
+                               headers)
+            return
+        # Tag the request so the MCP tool log can name its caller.
+        scope.setdefault("state", {})["caller"] = caller
+        await self.app(scope, receive, send)
+
+    @staticmethod
+    async def _reject(send, status: int, message: str, extra_headers: list | None = None) -> None:
+        body = json.dumps({"error": message}).encode()
+        headers = [(b"content-type", b"application/json"),
+                   (b"content-length", str(len(body)).encode())] + (extra_headers or [])
+        await send({"type": "http.response.start", "status": status, "headers": headers})
+        await send({"type": "http.response.body", "body": body})

fronyboard-0.28.1/src/fronyboard/fauth.py

@@ -0,0 +1,129 @@
+"""Client for FronyAuth — the central auth server every Frony service delegates to.
+
+Since AIR-056 FronyBoard no longer reads auth.yaml/oauth.yaml itself: every bearer
+credential (API key or OAuth access token) is judged by FronyAuth's
+POST /introspect, the dashboard login by POST /admin/verify, and the Settings
+key management by its /keys API. The contract is FronyAuth's
+docs/introspection.md (project-auth repo).
+
+Configuration (set in the launcher next to AIRA_DATA_DIR):
+
+    FRONY_AUTH_URL     FronyAuth base URL   (default http://127.0.0.1:8640)
+    FRONY_SERVICE_KEY  this service's own frony_ API key, used to call FronyAuth
+
+Verdicts are cached in memory by sha256(token) — positives for 60s (or until
+the token's own expiry), negatives for 5s — so a FronyAuth blip does not drop
+every request. When FronyAuth cannot be reached and no cached verdict exists,
+`Unavailable` is raised and the middleware answers 503 (fail closed, never 401:
+a client must not conclude its key was revoked).
+"""
+
+from __future__ import annotations
+
+import asyncio
+import hashlib
+import os
+import time
+
+import httpx
+
+POSITIVE_TTL = 60
+NEGATIVE_TTL = 5
+TIMEOUT = 2.0
+
+_cache: dict[str, tuple[float, str | None]] = {}  # sha256(token) -> (expires, caller|None)
+_http: tuple[asyncio.AbstractEventLoop, httpx.AsyncClient] | None = None
+
+
+class Unavailable(Exception):
+    """FronyAuth could not be reached and no cached verdict exists."""
+
+
+def base_url() -> str:
+    return (os.environ.get("FRONY_AUTH_URL") or "http://127.0.0.1:8640").rstrip("/")
+
+
+def _headers() -> dict:
+    return {"Authorization": f"Bearer {os.environ.get('FRONY_SERVICE_KEY', '')}"}
+
+
+def _client() -> httpx.AsyncClient:
+    """One client per event loop, reused across calls: building an AsyncClient costs
+    ~200 ms on the home server (SSL context + CA bundle) while the request itself takes
+    ~30 ms, and a per-call client made every introspect and /keys round trip pay it (AIR-072).
+    Keyed by loop so tests, which run one loop per test, never reuse a closed one."""
+    global _http
+    loop = asyncio.get_running_loop()
+    if _http is None or _http[0] is not loop:
+        _http = (loop, httpx.AsyncClient(timeout=TIMEOUT))
+    return _http[1]
+
+
+async def _post(path: str, payload: dict) -> httpx.Response:
+    last_error: Exception | None = None
+    for _ in range(2):  # one retry, per the contract
+        try:
+            return await _client().post(base_url() + path, json=payload, headers=_headers())
+        except httpx.HTTPError as e:
+            last_error = e
+    raise Unavailable(str(last_error))
+
+
+async def verify(token: str | None) -> str | None:
+    """The caller label for a bearer token (`key:…` / `oauth:…`), or None."""
+    if not token:
+        return None
+    digest = hashlib.sha256(token.encode()).hexdigest()
+    now = time.time()
+    cached = _cache.get(digest)
+    if cached and cached[0] > now:
+        return cached[1]
+    try:
+        response = await _post("/introspect", {"token": token})
+    except Unavailable:
+        if cached:  # expired entry beats an outage — the contract's cache rule
+            return cached[1]
+        raise
+    if response.status_code != 200:
+        raise Unavailable(f"introspect answered {response.status_code}")
+    result = response.json()
+    if result.get("active"):
+        caller, ttl = str(result.get("caller")), POSITIVE_TTL
+    else:
+        caller, ttl = None, NEGATIVE_TTL
+    _cache[digest] = (now + ttl, caller)
+    return caller
+
+
+async def admin_verify(username: str, password: str, client_addr: str) -> tuple[int, dict]:
+    """Delegate a dashboard login; returns FronyAuth's (status, body) as-is."""
+    response = await _post("/admin/verify",
+                           {"username": username, "password": password, "client_addr": client_addr})
+    return response.status_code, response.json()
+
+
+async def keys() -> list[dict]:
+    try:
+        response = await _client().get(base_url() + "/keys", headers=_headers())
+    except httpx.HTTPError as e:
+        raise Unavailable(str(e))
+    if response.status_code != 200:
+        raise Unavailable(f"/keys answered {response.status_code}")
+    return response.json()["keys"]
+
+
+async def create_key(name: str) -> tuple[int, dict]:
+    response = await _post("/keys", {"name": name})
+    return response.status_code, response.json()
+
+
+async def delete_key(name: str) -> tuple[int, dict]:
+    try:
+        response = await _client().delete(base_url() + f"/keys/{name}", headers=_headers())
+    except httpx.HTTPError as e:
+        raise Unavailable(str(e))
+    return response.status_code, response.json()
+
+
+def clear_cache() -> None:
+    _cache.clear()

fronyboard-0.28.1/src/fronyboard/log.py

@@ -0,0 +1,222 @@
+"""JSON Lines event logs, written for agents rather than people.
+
+Two files under the log root (`FRONYBOARD_LOG_DIR`, default `<data root>/../logs`):
+
+    tools.jsonl   one line per MCP tool call — who called what, on which record,
+                  how long it took, and whether it was accepted (kept 180 days)
+    server.jsonl  boot/shutdown, auth events, HTTP 4xx/5xx, rejected tool calls
+                  and unhandled exceptions with tracebacks (kept 30 days)
+
+Every line is a flat JSON object with a fixed field set (see docs/logging.md).
+Nothing is emitted until `setup()` runs, so importing this module (tests, CLI
+subcommands) stays silent. stdout is never a sink — in stdio mode it carries MCP.
+"""
+
+from __future__ import annotations
+
+import datetime
+import json
+import logging
+import os
+import secrets
+import sys
+import time
+import traceback
+import zoneinfo
+from pathlib import Path
+from typing import Any
+
+from loguru import logger
+
+from . import store
+
+logger.remove()
+
+# Free-text fields are logged as their length only: they are long, and they are
+# the user's planning prose, not telemetry.
+TEXT_FIELDS = {"content", "prd", "goal", "now", "next", "later", "result_markdown", "description"}
+
+_tz: datetime.tzinfo | None = None
+
+
+def log_dir() -> Path:
+    override = os.environ.get("FRONYBOARD_LOG_DIR")
+    return Path(override) if override else store.data_root().parent / "logs"
+
+
+def setup(*, stderr: bool = False) -> Path:
+    """Install the two file sinks (and optionally a WARNING+ stderr echo); returns the log root."""
+    global _tz
+    name = os.environ.get("FRONYBOARD_TZ")
+    try:
+        _tz = zoneinfo.ZoneInfo(name) if name else None
+    except (zoneinfo.ZoneInfoNotFoundError, ValueError):
+        _tz = None
+    root = log_dir()
+    root.mkdir(parents=True, exist_ok=True)
+    logger.remove()
+    common = {"format": "{message}", "level": "INFO", "rotation": "00:00",
+              "compression": "gz", "encoding": "utf-8"}
+    logger.add(root / "server.jsonl", retention="30 days",
+               filter=lambda r: r["extra"].get("stream") != "tools", **common)
+    logger.add(root / "tools.jsonl", retention="180 days",
+               filter=lambda r: r["extra"].get("stream") == "tools", **common)
+    if stderr:
+        logger.add(sys.stderr, format="{message}", level="WARNING",
+                   filter=lambda r: r["extra"].get("stream") != "tools")
+    # Route the stdlib loggers (uvicorn, mcp) through the same sinks.
+    logging.basicConfig(handlers=[InterceptHandler()], level=logging.INFO, force=True)
+    for lg_name in ("uvicorn", "uvicorn.error", "uvicorn.access"):
+        lg = logging.getLogger(lg_name)
+        lg.handlers = [InterceptHandler()]
+        lg.propagate = False
+    return root
+
+
+def shutdown() -> None:
+    logger.remove()
+
+
+def _ts() -> str:
+    """ISO 8601 with offset, in FRONYBOARD_TZ or the process-local zone."""
+    return datetime.datetime.now(_tz).astimezone(_tz).isoformat(timespec="milliseconds")
+
+
+def _dump(payload: dict[str, Any]) -> str:
+    return json.dumps(payload, ensure_ascii=False, default=str)
+
+
+def event(level: str, scope: str, evt: str, **fields: Any) -> None:
+    """One server.jsonl line: {ts, level, scope, event, ...fields}."""
+    payload = {"ts": _ts(), "level": level, "scope": scope, "event": evt, **fields}
+    logger.bind(stream="server").log(level, _dump(payload))
+
+
+def exception(scope: str, evt: str, **fields: Any) -> None:
+    """`event` at ERROR with the current exception's traceback attached."""
+    event("ERROR", scope, evt, trace=traceback.format_exc(), **fields)
+
+
+def tool_call(**fields: Any) -> None:
+    """One tools.jsonl line."""
+    logger.bind(stream="tools").info(_dump({"ts": _ts(), **fields}))
+
+
+def new_req() -> str:
+    """Short correlation id shared by a tools.jsonl line and its server.jsonl follow-ups."""
+    return secrets.token_hex(3)
+
+
+def summarize_args(args: dict[str, Any]) -> dict[str, Any]:
+    out: dict[str, Any] = {}
+    for k, v in args.items():
+        if v is None:
+            continue
+        if k in TEXT_FIELDS:
+            out[f"{k}_len"] = len(str(v))
+        else:
+            out[k] = v
+    return out
+
+
+class InterceptHandler(logging.Handler):
+    """stdlib logging → server.jsonl. Access lines below 400 are dropped (the
+    dashboard polls every minute); everything else keeps its logger name."""
+
+    def emit(self, record: logging.LogRecord) -> None:
+        if record.name == "uvicorn.access":
+            try:
+                addr, method, path, _http, status = record.args  # type: ignore[misc]
+                status = int(status)
+            except (TypeError, ValueError):
+                return
+            if status < 400:
+                return
+            if method == "GET" and path == "/mcp" and status in (404, 405):
+                return  # a client opening the optional SSE listen stream — protocol chatter, not a fault
+            event("WARNING" if status < 500 else "ERROR", "http", "response",
+                  status=status, method=method, path=path, ip=str(addr).rsplit(":", 1)[0])
+            return
+        if record.levelno < logging.WARNING:
+            return  # startup chatter
+        level = "ERROR" if record.levelno >= logging.ERROR else "WARNING"
+        fields: dict[str, Any] = {"logger": record.name, "msg": record.getMessage()}
+        if record.exc_info:
+            fields["trace"] = "".join(traceback.format_exception(*record.exc_info))
+        event(level, "py", "log", **fields)
+
+
+class ToolLogMiddleware:
+    """MCP server middleware: one tools.jsonl line per tools/call.
+
+    The caller comes from `scope["state"]["caller"]`, which the bearer-auth ASGI
+    middleware fills in for HTTP transports; stdio has no request and logs as `stdio`.
+    """
+
+    async def __call__(self, ctx, call_next):
+        if ctx.method != "tools/call":
+            return await call_next(ctx)
+        params = ctx.params or {}
+        name = params.get("name")
+        args = dict(params.get("arguments") or {})
+        req = new_req()
+        caller = "stdio"
+        request = getattr(ctx, "request", None)
+        if request is not None:
+            state = (getattr(request, "scope", None) or {}).get("state") or {}
+            caller = state.get("caller") or "unknown"
+        line: dict[str, Any] = {"req": req, "tool": name, "caller": caller}
+        key = args.pop("key", None)
+        task = args.pop("task_id", None)
+        period = args.pop("period", None)
+        project = key or (task.split("-", 1)[0] if isinstance(task, str) and "-" in task else None)
+        if project:
+            line["project"] = project
+        if period:
+            line["period"] = period
+        if task:
+            line["task"] = task
+        line["args"] = summarize_args(args)
+
+        t0 = time.perf_counter()
+        try:
+            result = await call_next(ctx)
+        except Exception as e:
+            ms = round((time.perf_counter() - t0) * 1000, 1)
+            tool_call(**line, ms=ms, ok=False, error=type(e).__name__, msg=str(e))
+            exception("tool", "exception", req=req, tool=name, error=type(e).__name__, msg=str(e))
+            raise
+        ms = round((time.perf_counter() - t0) * 1000, 1)
+        is_error, content, structured = _result_parts(result)
+        if is_error:
+            # The SDK turns any exception raised by a tool into an is_error result;
+            # for this server that is a validation/argument rejection (FronyBoardError).
+            msg = "; ".join(_text(c) for c in content)
+            msg = msg.removeprefix(f"Error executing tool {name}: ")[:500]  # SDK boilerplate
+            tool_call(**line, ms=ms, ok=False, error="rejected", msg=msg)
+            event("WARNING", "tool", "rejected", req=req, tool=name, msg=msg)
+        else:
+            sc = structured
+            if isinstance(sc, dict) and "warnings" not in sc and isinstance(sc.get("result"), dict):
+                sc = sc["result"]
+            warnings = len(sc.get("warnings") or []) if isinstance(sc, dict) else 0
+            tool_call(**line, ms=ms, ok=True, warnings=warnings)
+        return result
+
+
+def _result_parts(result: Any) -> tuple[bool, list[Any], Any]:
+    """(is_error, content, structured_content) from a CallToolResult, whether the
+    middleware sees the model or its wire-format dict."""
+    if isinstance(result, dict):
+        return (bool(result.get("isError") or result.get("is_error")),
+                list(result.get("content") or []),
+                result.get("structuredContent") or result.get("structured_content") or {})
+    return (bool(getattr(result, "is_error", False)),
+            list(getattr(result, "content", None) or []),
+            getattr(result, "structured_content", None) or {})
+
+
+def _text(part: Any) -> str:
+    if isinstance(part, dict):
+        return str(part.get("text", ""))
+    return str(getattr(part, "text", ""))