nexo-brain 7.20.11 → 7.20.13

package/src/plugins/recover.py

@@ -41,7 +41,8 @@ from db_guard import (
     db_row_counts,
     diff_row_counts,
     find_latest_hourly_backup,
-    kill_nexo_mcp_servers,
+    quiesce_nexo_db_writers,
+    resume_nexo_launchagents,
     safe_sqlite_backup,
     validate_backup_matches_source,
 )
@@ -257,15 +258,20 @@ def recover(
         result["steps"].append("dry-run: stopping before any write")
         return result
 
-    # Step 3: kill live MCP servers
+    stopped_launchagents: list[str] = []
+
+    # Step 3: quiesce live DB writers
     if not skip_kill:
-        kill_report = kill_nexo_mcp_servers(dry_run=False)
-        result["steps"].append(f"kill_mcp: terminated={kill_report['terminated']} scanned={kill_report['scanned']}")
-        if kill_report.get("errors"):
-            result["warnings"].extend(kill_report["errors"])
-        # Tiny settle so the ex-server releases file locks.
-        if kill_report["terminated"]:
-            time.sleep(0.5)
+        quiesce_report = quiesce_nexo_db_writers(dry_run=False)
+        result["quiesce"] = quiesce_report
+        stopped_launchagents = list((quiesce_report.get("launchagents") or {}).get("stopped") or [])
+        result["steps"].append(
+            "quiesce_db_writers: "
+            f"terminated={quiesce_report.get('terminated', 0)} "
+            f"launchagents={len(stopped_launchagents)}"
+        )
+        if quiesce_report.get("errors"):
+            result["warnings"].extend(quiesce_report["errors"])
 
     # Step 4: snapshot current state to pre-recover/
     pre_recover_dir = _backup_base() / f"pre-recover-{time.strftime('%Y-%m-%d-%H%M%S')}"
@@ -297,17 +303,24 @@ def recover(
     ok, copy_err = safe_sqlite_backup(chosen, target_path)
     if not ok:
         result["errors"].append(f"restore copy failed: {copy_err}")
+        if stopped_launchagents:
+            result["resume"] = resume_nexo_launchagents(stopped_launchagents)
         return result
     result["steps"].append(f"restored {chosen.name} -> {target_path}")
 
     valid, valid_err = validate_backup_matches_source(chosen, target_path)
     if not valid:
         result["errors"].append(f"post-restore validation failed: {valid_err}")
+        if stopped_launchagents:
+            result["resume"] = resume_nexo_launchagents(stopped_launchagents)
         return result
     result["steps"].append("validated post-restore row counts")
 
     final_counts = db_row_counts(target_path)
     result["final_row_counts"] = {k: v for k, v in final_counts.items() if v is not None}
+    if stopped_launchagents:
+        result["resume"] = resume_nexo_launchagents(stopped_launchagents)
+        result["steps"].append(f"resumed {len((result['resume'] or {}).get('started') or [])} launchagent(s)")
     result["ok"] = True
     return result
 

package/src/server.py

@@ -104,6 +104,7 @@ from plugins.workflow import (
 )
 from plugin_loader import load_all_plugins, load_plugin, remove_plugin, list_plugins
 from tools_guardian import handle_guardian_rule_override
+from tools_api_call import handle_api_call, handle_create_app_token
 from runtime_versioning import (
     RestartRequiredMiddleware,
     build_mcp_status,
@@ -682,14 +683,45 @@ def nexo_local_index_exclusions(action: str = "list", path: str = "", reason: st
 
 
 @mcp.tool
-def nexo_local_context(query: str, intent: str = "answer", limit: int = 12, evidence_required: bool = True, current_context: str = "") -> str:
-    """Retrieve local evidence before answering or acting."""
+def nexo_local_context(
+    query: str,
+    intent: str = "answer",
+    limit: int = 8,
+    evidence_required: bool = True,
+    current_context: str = "",
+    mode: str = "compact",
+    max_chars: int = 20000,
+    include_entities: bool = False,
+    include_relations: bool = False,
+) -> str:
+    """Retrieve local evidence before answering or acting.
+
+    Use mode='compact' for normal answers. Use mode='full' only for deep
+    debugging, ideally with a higher max_chars and a specific query.
+    """
     result = local_context_api.context_query(
         query,
         intent=intent,
         limit=limit,
         evidence_required=evidence_required,
         current_context=current_context,
+        mode=mode,
+        max_chars=max_chars,
+        include_entities=include_entities,
+        include_relations=include_relations,
+    )
+    return json.dumps(result, ensure_ascii=False)
+
+
+@mcp.tool
+def nexo_context_router(query: str, intent: str = "answer", limit: int = 4, current_context: str = "", max_chars: int = 6000) -> str:
+    """Return compact local context evidence suitable for injection before a reply."""
+    result = local_context_api.context_router(
+        query,
+        intent=intent,
+        limit=limit,
+        current_context=current_context,
+        max_chars=max_chars,
     )
     return json.dumps(result, ensure_ascii=False)
 
@@ -2058,6 +2090,62 @@ def nexo_session_log_close(
     return _json.dumps(result, ensure_ascii=False)
 
 
+@mcp.tool
+def nexo_api_call(
+    method: str,
+    path: str,
+    body_json: str = "",
+    idempotency_key: str = "",
+    headers_json: str = "",
+    base_url: str = "",
+) -> str:
+    """Make an authenticated HTTP request to the NEXO Desktop backend (nexo-desktop.com).
+
+    The session bearer is auto-loaded from the OS keychain — the agent never
+    sees or handles tokens. Use this for any /api/* endpoint the user has
+    permission for: provider-proxy/*, credits/*, cards/*, auth/app-tokens, etc.
+
+    Args:
+        method: HTTP method (GET / POST / PUT / DELETE / PATCH).
+        path: path starting with '/' (e.g. '/api/provider-proxy/call').
+        body_json: JSON string of the request body. Empty for GET.
+        idempotency_key: UUID v4 to dedupe POST/PUT retries (avoids double-charge).
+        headers_json: optional extra headers as a JSON object. Authorization is ignored.
+        base_url: override default base (default: https://nexo-desktop.com).
+
+    Returns formatted text with HTTP status + parsed JSON body. Bearer is never echoed.
+    """
+    return handle_api_call(method, path, body_json, idempotency_key, headers_json, base_url)
+
+
+@mcp.tool
+def nexo_create_app_token(
+    name: str,
+    abilities: str = "",
+    allowed_platforms: str = "",
+    expires_at: str = "",
+) -> str:
+    """Create a persistent AppToken for the current user via POST /api/auth/app-tokens.
+
+    Use this when a card needs to mint a token that will live inside a snippet
+    the user pastes on their own website (chatbot widget, embed, public API
+    autoresponder). The plain-text token is returned ONCE — embed it in the
+    generated snippet and never store it elsewhere.
+
+    Args:
+        name: human label for the token (e.g. 'chatbot-mitienda-com').
+        abilities: comma-separated abilities. Allowed:
+                   provider-proxy:call, provider-proxy:estimate, credits:read.
+                   Defaults to 'provider-proxy:call' if empty.
+        allowed_platforms: comma-separated platform keys (openai, anthropic, gemini, ...).
+                           Empty = all platforms the user has access to.
+        expires_at: ISO 8601 future date, empty for non-expiring token.
+
+    Returns the created token summary + plain_text_token (one-time disclosure).
+    """
+    return handle_create_app_token(name, abilities, allowed_platforms, expires_at)
+
+
 if __name__ == "__main__":
     _server_init()
     mcp.run(**_run_kwargs_from_env())

package/src/tools_api_call.py

@@ -0,0 +1,196 @@
+"""HTTP API calls to the nexo-desktop-web backend using the user's session bearer.
+
+Exposes two MCP tools registered in server.py:
+  - nexo_api_call(method, path, body_json, idempotency_key, headers_json, base_url)
+  - nexo_create_app_token(name, abilities, allowed_platforms, expires_at)
+
+The session bearer (Sanctum personal access token) is stored by NEXO Desktop in
+the OS keychain at:
+  service = "com.nexo.shared-auth"
+  account = "sanctum-token"
+
+Cross-platform via the `keyring` library (macOS Keychain, Windows Credential
+Manager, secret-service on Linux). The bearer is never echoed back to the
+agent — it only flows in the Authorization header to the backend.
+
+These tools let the agent (Nero) call any /api/* endpoint on the user's behalf
+without the agent having to manage tokens. Use them from fichas that need
+backend-driven NEXO Credits flows, or to mint persistent AppTokens for
+embeddable resources (chatbot snippets, widgets) that the user pastes on
+their own website.
+"""
+
+from __future__ import annotations
+
+import json
+from typing import Any
+
+import keyring
+import requests
+
+KEYCHAIN_SERVICE = "com.nexo.shared-auth"
+KEYCHAIN_ACCOUNT = "sanctum-token"
+DEFAULT_BASE_URL = "https://nexo-desktop.com"
+ALLOWED_METHODS = {"GET", "POST", "PUT", "DELETE", "PATCH"}
+REQUEST_TIMEOUT_SECONDS = 60
+MAX_BODY_PREVIEW_CHARS = 6000
+
+# Allowed abilities for AppToken creation. Keep in sync with
+# AppTokenService::ABILITY_* constants in the Laravel backend.
+ALLOWED_ABILITIES = {
+    "provider-proxy:call",
+    "provider-proxy:estimate",
+    "credits:read",
+}
+
+
+def _read_session_bearer() -> str | None:
+    try:
+        return keyring.get_password(KEYCHAIN_SERVICE, KEYCHAIN_ACCOUNT)
+    except Exception:
+        return None
+
+
+def _parse_json_arg(raw: str, label: str) -> tuple[Any, str | None]:
+    text = (raw or "").strip()
+    if not text:
+        return None, None
+    try:
+        return json.loads(text), None
+    except json.JSONDecodeError as exc:
+        return None, f"ERROR: {label} is not valid JSON: {exc}"
+
+
+def _format_response(method: str, path: str, status: int, body_text: str) -> str:
+    return f"HTTP {status} {method} {path}\n{body_text}"
+
+
+def handle_api_call(
+    method: str,
+    path: str,
+    body_json: str = "",
+    idempotency_key: str = "",
+    headers_json: str = "",
+    base_url: str = "",
+) -> str:
+    """Make an authenticated request to the NEXO Desktop backend.
+
+    The session bearer is auto-loaded from the OS keychain. It is never
+    returned to the caller. Use this for any /api/* endpoint the user has
+    permission for (provider-proxy/*, credits/*, cards/*, etc).
+    """
+    bearer = _read_session_bearer()
+    if not bearer:
+        return (
+            "ERROR: no NEXO Desktop session token found in the system keychain. "
+            "The user must be logged in to NEXO Desktop before this tool can be used."
+        )
+
+    method_upper = (method or "").strip().upper()
+    if method_upper not in ALLOWED_METHODS:
+        return f"ERROR: method '{method}' is not allowed. Use one of {sorted(ALLOWED_METHODS)}."
+
+    cleaned_path = (path or "").strip()
+    if not cleaned_path.startswith("/"):
+        return "ERROR: path must start with '/' (e.g. /api/provider-proxy/call)."
+
+    base = (base_url or "").strip() or DEFAULT_BASE_URL
+    url = base.rstrip("/") + cleaned_path
+
+    headers = {
+        "Authorization": f"Bearer {bearer}",
+        "Accept": "application/json",
+    }
+
+    extra_headers, err = _parse_json_arg(headers_json, "headers_json")
+    if err:
+        return err
+    if extra_headers is not None:
+        if not isinstance(extra_headers, dict):
+            return "ERROR: headers_json must be a JSON object."
+        for k, v in extra_headers.items():
+            # Never let caller override Authorization.
+            if str(k).lower() == "authorization":
+                continue
+            headers[str(k)] = str(v)
+
+    if idempotency_key.strip():
+        headers["Idempotency-Key"] = idempotency_key.strip()
+
+    body, err = _parse_json_arg(body_json, "body_json")
+    if err:
+        return err
+    if body is not None:
+        headers["Content-Type"] = "application/json"
+
+    try:
+        resp = requests.request(
+            method_upper,
+            url,
+            headers=headers,
+            json=body,
+            timeout=REQUEST_TIMEOUT_SECONDS,
+        )
+    except requests.exceptions.Timeout:
+        return f"ERROR: request to {cleaned_path} timed out after {REQUEST_TIMEOUT_SECONDS}s."
+    except requests.exceptions.RequestException as exc:
+        return f"ERROR: network error calling {cleaned_path}: {exc}"
+
+    try:
+        parsed = resp.json()
+        body_text = json.dumps(parsed, indent=2, ensure_ascii=False)
+    except ValueError:
+        body_text = (resp.text or "")[:MAX_BODY_PREVIEW_CHARS]
+
+    if len(body_text) > MAX_BODY_PREVIEW_CHARS:
+        body_text = body_text[:MAX_BODY_PREVIEW_CHARS] + "\n... [truncated]"
+
+    return _format_response(method_upper, cleaned_path, resp.status_code, body_text)
+
+
+def handle_create_app_token(
+    name: str,
+    abilities: str = "",
+    allowed_platforms: str = "",
+    expires_at: str = "",
+) -> str:
+    """Create a persistent AppToken for the current user via POST /api/auth/app-tokens.
+
+    Use this when a card needs to mint a token that will live inside a snippet
+    the user pastes on their own website (chatbot widget, embed, public API
+    autoresponder). The plain-text token is returned ONCE — the agent must
+    embed it in the snippet immediately and never store it elsewhere.
+    """
+    label = (name or "").strip()
+    if not label:
+        return "ERROR: name is required (human label for the token, e.g. 'chatbot-mitienda-com')."
+
+    requested_abilities = [a.strip() for a in (abilities or "").split(",") if a.strip()]
+    if not requested_abilities:
+        requested_abilities = ["provider-proxy:call"]
+
+    invalid = [a for a in requested_abilities if a not in ALLOWED_ABILITIES]
+    if invalid:
+        return (
+            f"ERROR: invalid abilities {invalid}. "
+            f"Allowed: {sorted(ALLOWED_ABILITIES)}."
+        )
+
+    payload: dict[str, Any] = {
+        "name": label,
+        "abilities": requested_abilities,
+    }
+
+    platforms = [p.strip() for p in (allowed_platforms or "").split(",") if p.strip()]
+    if platforms:
+        payload["allowed_platforms"] = platforms
+
+    expires_clean = (expires_at or "").strip()
+    if expires_clean:
+        payload["expires_at"] = expires_clean
+
+    return handle_api_call(
+        method="POST",
+        path="/api/auth/app-tokens",
+        body_json=json.dumps(payload),
+    )

package/src/tools_credentials.py

@@ -1,8 +1,31 @@
-"""Credentials CRUD tools: get, create, update, delete, list."""
+"""Credentials CRUD tools: get, create, update, delete, list.
+
+Two storage backends live behind these handlers:
+
+  1) The default SQLite credentials table (DB). Used by the agent for any
+     internally-managed secret (Anthropic platform key, Stripe keys, etc.).
+
+  2) The BYOK filesystem store at ``~/.nexo/credentials/byok/{slug}.json``.
+     Used for the user's own API keys connected from NEXO Desktop's
+     "Connections" settings tab. Keys NEVER cross to the NEXO backend and
+     never go through the DB — they live only on the user's machine.
+
+When ``service='byok'`` the handlers transparently route to the filesystem
+backend (get / list / delete). Create is intentionally NOT routed: BYOK
+keys are written through Desktop's UI, which performs remote validation
+before persisting. The agent should never mint a BYOK entry on its own.
+"""
+
+import json
+import os
+from pathlib import Path
 
 from db import create_credential, update_credential, delete_credential, get_credential, list_credentials, get_db
 
 
+BYOK_SERVICE = "byok"
+
+
 def _credential_exists(service: str, key: str) -> bool:
     """Fase 2 R02 helper — exact (service, key) match against active credentials.
 
@@ -20,9 +43,116 @@ def _credential_exists(service: str, key: str) -> bool:
     return row is not None
 
 
+def _byok_base_dir() -> Path:
+    home = os.environ.get("NEXO_HOME") or str(Path.home() / ".nexo")
+    return Path(home) / "credentials" / "byok"
+
+
+def _safe_byok_slug(raw: str) -> str:
+    cleaned = (raw or "").strip().lower()
+    return "".join(ch for ch in cleaned if ch.isalnum() or ch in "-_")
+
+
+def _byok_file_for(key: str) -> Path | None:
+    safe = _safe_byok_slug(key)
+    if not safe:
+        return None
+    return _byok_base_dir() / f"{safe}.json"
+
+
+def _byok_read_file(path: Path) -> dict | None:
+    try:
+        return json.loads(path.read_text(encoding="utf-8"))
+    except Exception:
+        return None
+
+
+def _byok_entry_from_file(slug: str, data: dict) -> dict:
+    """Shape a BYOK file into the {service, key, value, notes} schema the
+    handlers expect — same as DB rows. ``value`` carries the actual API key.
+    """
+    provider = data.get("provider") or slug
+    label = data.get("label") or ""
+    validation = data.get("validation_status") or "unknown"
+    connected_at = data.get("connected_at") or ""
+    last_validated = data.get("last_validated_at") or ""
+    note_parts = [
+        f"provider={provider}",
+        f"label={label}" if label else "",
+        f"validation={validation}",
+        f"connected_at={connected_at}" if connected_at else "",
+        f"last_validated_at={last_validated}" if last_validated else "",
+    ]
+    notes = " | ".join(p for p in note_parts if p)
+    return {
+        "service": BYOK_SERVICE,
+        "key": slug,
+        "value": str(data.get("api_key") or ""),
+        "notes": notes,
+    }
+
+
+def _byok_get(key: str = "") -> list[dict]:
+    """Filesystem-backed lookup for BYOK keys. Returns list of dicts in the
+    same shape as get_credential() so the handler can render them uniformly.
+    """
+    base = _byok_base_dir()
+    if not base.is_dir():
+        return []
+
+    if key:
+        path = _byok_file_for(key)
+        if not path or not path.is_file():
+            return []
+        data = _byok_read_file(path)
+        if data is None:
+            return []
+        return [_byok_entry_from_file(_safe_byok_slug(key), data)]
+
+    out: list[dict] = []
+    for path in sorted(base.glob("*.json")):
+        data = _byok_read_file(path)
+        if data is None:
+            continue
+        out.append(_byok_entry_from_file(path.stem, data))
+    return out
+
+
+def _byok_delete(key: str = "") -> int:
+    """Filesystem-backed delete. Returns the number of files removed."""
+    base = _byok_base_dir()
+    if not base.is_dir():
+        return 0
+    if key:
+        path = _byok_file_for(key)
+        if not path or not path.is_file():
+            return 0
+        try:
+            path.unlink()
+            return 1
+        except Exception:
+            return 0
+    removed = 0
+    for path in base.glob("*.json"):
+        try:
+            path.unlink()
+            removed += 1
+        except Exception:
+            continue
+    return removed
+
+
 def handle_credential_get(service: str, key: str = '') -> str:
-    """Retrieve credential(s) including their values. Use for reading secrets."""
-    results = get_credential(service, key if key else None)
+    """Retrieve credential(s) including their values. Use for reading secrets.
+
+    When ``service='byok'`` the values are read from the local filesystem
+    store written by NEXO Desktop's Settings > Connections UI (the user's
+    own provider API keys, e.g. OpenAI/Anthropic/Gemini/ElevenLabs).
+    """
+    if service == BYOK_SERVICE:
+        results = _byok_get(key)
+    else:
+        results = get_credential(service, key if key else None)
     if not results:
         target = f"{service}/{key}" if key else service
         return f"ERROR: No credentials found for '{target}'."
@@ -50,7 +180,19 @@ def handle_credential_create(service: str, key: str, value: str, notes: str = ''
         force: Set to '1'/'true' to OVERWRITE an existing (service, key) pair.
                Without force, Fase 2 R02 rejects duplicates and points at
                nexo_credential_update as the canonical edit path.
+
+    BYOK keys (service='byok') are intentionally NOT mintable through this
+    tool: they must be added via NEXO Desktop's Settings > Connections, which
+    validates the key against the provider before saving. The agent should
+    not silently inject BYOK credentials.
     """
+    if service == BYOK_SERVICE:
+        return (
+            "ERROR: BYOK credentials cannot be created through this tool. "
+            "Ask the user to open NEXO Desktop > Settings > Connections and "
+            "connect the provider there (the UI validates the key with the "
+            "provider before saving)."
+        )
     # ── R02 (Fase 2 Protocol Enforcer): reject exact (service, key) duplicates ──
     force_flag = str(force or "").strip().lower() in {"1", "true", "yes", "on"}
     if not force_flag and _credential_exists(service, key):
@@ -71,7 +213,16 @@ def handle_credential_create(service: str, key: str, value: str, notes: str = ''
 
 
 def handle_credential_update(service: str, key: str, value: str = '', notes: str = '') -> str:
-    """Update the value and/or notes of an existing credential."""
+    """Update the value and/or notes of an existing credential.
+
+    BYOK entries are not editable from the agent side; users update them by
+    re-connecting the provider from Settings > Connections in Desktop.
+    """
+    if service == BYOK_SERVICE:
+        return (
+            "ERROR: BYOK credentials are not editable from the agent. "
+            "Ask the user to update the connection in NEXO Desktop > Settings > Connections."
+        )
     result = update_credential(
         service,
         key,
@@ -84,7 +235,20 @@ def handle_credential_update(service: str, key: str, value: str = '', notes: str
 
 
 def handle_credential_delete(service: str, key: str = '') -> str:
-    """Delete a credential or all credentials for a service."""
+    """Delete a credential or all credentials for a service.
+
+    For ``service='byok'`` the delete reaches the filesystem store; the file
+    is removed but the provider account on the user's side is untouched.
+    """
+    if service == BYOK_SERVICE:
+        removed = _byok_delete(key if key else None)
+        if removed == 0:
+            target = f"{service}/{key}" if key else service
+            return f"ERROR: No credentials found for '{target}'."
+        if key:
+            return f"Credential deleted."
+        return f"All BYOK credentials deleted ({removed} files)."
+
     deleted = delete_credential(service, key if key else None)
     if not deleted:
         target = f"{service}/{key}" if key else service
@@ -95,9 +259,17 @@ def handle_credential_delete(service: str, key: str = '') -> str:
 
 
 def handle_credential_list(service: str = '') -> str:
-    """List credential service/key names and notes — values are never shown."""
-    results = list_credentials(service if service else None)
-    label = service if service else "ALL"
+    """List credential service/key names and notes — values are never shown.
+
+    Listing without ``service`` only returns DB entries (the historical
+    behaviour). Pass ``service='byok'`` to list the BYOK filesystem store.
+    """
+    if service == BYOK_SERVICE:
+        results = _byok_get("")
+        label = "BYOK"
+    else:
+        results = list_credentials(service if service else None)
+        label = service if service else "ALL"
     if not results:
         return f"CREDENTIALS {label.upper()}: No entries."
     lines = [f"CREDENTIALS {label.upper()} ({len(results)}):"]

package/src/tools_hot_context.py

@@ -27,45 +27,17 @@ def _format_local_context_evidence(query: str, *, limit: int = 4) -> str:
     try:
         from local_context import api as local_context_api
 
-        result = local_context_api.context_query(
+        routed = local_context_api.context_router(
             clean_query,
             intent="pre_action",
             limit=max(1, min(int(limit or 4), 8)),
-            evidence_required=False,
+            max_chars=6000,
         )
     except Exception:
         return ""
-    assets = result.get("assets") or []
-    if not assets:
+    if not routed.get("should_inject"):
         return ""
-    lines = ["", "LOCAL CONTEXT EVIDENCE:"]
-    for asset in assets[:limit]:
-        display_path = str(asset.get("display_path") or asset.get("path") or "")
-        score = asset.get("score")
-        summary = str(asset.get("summary") or "").strip()
-        suffix = f" — {summary[:180]}" if summary else ""
-        lines.append(f"- {display_path} ({asset.get('file_type', 'file')}, score={score}){suffix}")
-    chunks = result.get("chunks") or []
-    if chunks:
-        lines.append("Relevant excerpts:")
-        for chunk in chunks[:limit]:
-            text = " ".join(str(chunk.get("text") or "").split())
-            if not text:
-                continue
-            lines.append(f"- {text[:360]}")
-    refs = result.get("evidence_refs") or []
-    if refs:
-        lines.append(f"Evidence refs: {', '.join(str(ref) for ref in refs[:limit])}")
-    relations = result.get("relations") or []
-    if relations:
-        lines.append("Local relations:")
-        for relation in relations[:limit]:
-            relation_type = str(relation.get("relation_type") or "related")
-            target = str(relation.get("target_ref") or relation.get("target_asset_id") or "").strip()
-            evidence = str(relation.get("evidence") or "").strip()
-            suffix = f" — {evidence[:120]}" if evidence else ""
-            lines.append(f"- {relation_type}: {target}{suffix}")
-    return "\n".join(lines)
+    return str(routed.get("rendered") or "")
 
 
 def _parse_metadata(metadata: str = "") -> dict: