Version renderer and continue research in chat

Dockerfile

@@ -6,8 +6,9 @@ RUN apt-get update && \
 
 WORKDIR /app
 RUN uv pip install --system --no-cache \
-    fast-agent-mcp==0.9.7 \
-    'fastmcp[apps]' \
+    fast-agent-mcp==0.9.17 \
+    'fastmcp[apps]==3.4.4' \
+    prefab-ui==0.20.2 \
     huggingface_hub
 
 COPY --link ./ /app

research/app_artifacts.py

@@ -72,6 +72,32 @@ def finalize_bucket_html(
         return _artifact_urls(username, job.id)
 
 
+def read_bucket_markdown(
+    job: ResearchJob,
+    auth: AgentAuth | None,
+    *,
+    api: HfApi | None = None,
+) -> str:
+    """Read the completed Markdown report with the caller's token."""
+    if auth is None or not auth.token:
+        raise RuntimeError("Caller authentication is required to read the report")
+
+    api = api or HfApi()
+    username = api.whoami(token=auth.token)["name"]
+    bucket_id = f"{username}/research-agent"
+    report_path = f"{job.id}/output/report.md"
+
+    with tempfile.TemporaryDirectory() as directory:
+        local = Path(directory) / "report.md"
+        api.download_bucket_files(
+            bucket_id,
+            [(report_path, local)],
+            raise_on_missing_files=True,
+            token=auth.token,
+        )
+        return local.read_text()
+
+
 def _download_first(
     api: Any,
     bucket_id: str,

research/app_renderer.py

@@ -0,0 +1,70 @@
+"""Versioned Prefab renderer resource for reliable host cache invalidation."""
+
+from __future__ import annotations
+
+import hashlib
+from collections.abc import Sequence
+from pathlib import Path
+from fastmcp import FastMCP
+from fastmcp.apps.config import UI_MIME_TYPE, AppConfig, ResourceCSP
+from fastmcp.server.providers.addressing import hash_tool
+from fastmcp.server.transforms import Transform
+from fastmcp.tools.base import Tool
+from prefab_ui.renderer import get_renderer_csp, get_renderer_html
+
+
+class RendererUriTransform(Transform):
+    """Point one UI tool at a content-addressed renderer resource."""
+
+    def __init__(self, tool_name: str, resource_uri: str) -> None:
+        self.tool_name = tool_name
+        self.resource_uri = resource_uri
+
+    async def list_tools(self, tools: Sequence[Tool]) -> Sequence[Tool]:
+        return [
+            self._with_renderer(tool) if tool.name == self.tool_name else tool
+            for tool in tools
+        ]
+
+    def _with_renderer(self, tool: Tool) -> Tool:
+        meta = dict(tool.meta or {})
+        ui = dict(meta.get("ui") or {})
+        ui["resourceUri"] = self.resource_uri
+        meta["ui"] = ui
+        return tool.model_copy(update={"meta": meta})
+
+
+def install_versioned_renderer(
+    mcp: FastMCP,
+    *,
+    app_name: str,
+    tool_name: str,
+) -> str:
+    """Register the Prefab renderer at a URI derived from its exact content."""
+    html = get_renderer_html()
+    digest = hashlib.sha256(html.encode()).hexdigest()[:12]
+    tool_digest = hash_tool(app_name, tool_name)
+    resource_uri = f"ui://prefab/tool/{tool_digest}/renderer-{digest}.html"
+    csp = ResourceCSP(**(get_renderer_csp() or {}))
+
+    @mcp.resource(
+        resource_uri,
+        name="Versioned Prefab Renderer",
+        mime_type=UI_MIME_TYPE,
+        app=AppConfig(csp=csp),
+    )
+    def prefab_renderer() -> str:
+        return html
+
+    mcp.add_transform(RendererUriTransform(tool_name, resource_uri))
+    return digest
+
+
+def app_build_id(home: Path) -> str:
+    """Hash the app code and prompts that shape a rendered research view."""
+    digest = hashlib.sha256()
+    paths = sorted(home.glob("*.py")) + sorted((home / "agent-cards").glob("*.md"))
+    for path in paths:
+        digest.update(path.relative_to(home).as_posix().encode())
+        digest.update(path.read_bytes())
+    return digest.hexdigest()[:8]

research/app_ui.py

@@ -4,11 +4,12 @@ from __future__ import annotations
 
 from typing import Any
 
-from prefab_ui.actions import SetInterval, SetState
-from prefab_ui.actions.mcp import CallTool
+from prefab_ui.actions import SetInterval, SetState, ShowToast
+from prefab_ui.actions.mcp import CallTool, SendMessage, UpdateContext
 from prefab_ui.app import PrefabApp
 from prefab_ui.components import (
     Badge,
+    Button,
     Card,
     CardContent,
     CardDescription,
@@ -33,13 +34,20 @@ from prefab_ui.components.control_flow import Else, ForEach
 from prefab_ui.rx import RESULT, STATE
 
 
-def build_research_ui(topic: str, snapshot: dict[str, Any]) -> PrefabApp:
+def build_research_ui(
+    topic: str,
+    snapshot: dict[str, Any],
+    *,
+    build_id: str,
+) -> PrefabApp:
     with PrefabApp(
         state={
             "job": snapshot,
             "topic": topic,
             "job_id": snapshot["job_id"],
             "poll_ms": "1500",
+            "chat_sent": False,
+            "app_version": f"build {build_id}",
         }
     ) as ui:
         with Column(
@@ -72,8 +80,9 @@ def build_research_ui(topic: str, snapshot: dict[str, Any]) -> PrefabApp:
                     with Row(justify="between", align="center", gap=4):
                         with Column(gap=1):
                             Heading("🤗 Research Agent")
-                            Muted(STATE.topic)
+                            Muted(STATE.topic, css_class="text-xs leading-4")
                         with Row(gap=2, align="center"):
+                            Badge(STATE.app_version, variant="outline")
                             with If("{{ !job.done }}"):
                                 Loader(variant="dots", size="sm")
                             Badge(STATE.job.status, variant="info")
@@ -171,5 +180,36 @@ def build_research_ui(topic: str, snapshot: dict[str, Any]) -> PrefabApp:
                             STATE.job.result,
                             css_class="whitespace-pre-wrap",
                         )
+                        with If("{{ !chat_sent }}"):
+                            Button(
+                                "Continue in chat",
+                                variant="outline",
+                                size="sm",
+                                css_class="mt-4",
+                                on_click=CallTool(
+                                    "research_chat_context",
+                                    arguments={"job_id": STATE.job_id},
+                                    on_success=[
+                                        UpdateContext(content=RESULT.markdown),
+                                        SendMessage(
+                                            RESULT.message,
+                                            on_success=SetState("chat_sent", True),
+                                            on_error=ShowToast(
+                                                "This host could not send the chat message.",
+                                                variant="error",
+                                            ),
+                                        ),
+                                    ],
+                                    on_error=ShowToast(
+                                        "Could not load the Markdown report.",
+                                        variant="error",
+                                    ),
+                                ),
+                            )
+                        with If(STATE.chat_sent):
+                            Muted(
+                                "Report added to model context and sent to chat.",
+                                css_class="mt-3 text-xs",
+                            )
 
     return ui

research/fastmcp_server.py

@@ -15,7 +15,9 @@ from pydantic import Field
 from prefab_ui.app import PrefabApp
 
 from .app_auth import auth_provider, http_middleware, request_auth
+from .app_artifacts import read_bucket_markdown
 from .app_jobs import ResearchJobStore, owner_id, unavailable_snapshot
+from .app_renderer import app_build_id, install_versioned_renderer
 from .app_ui import build_research_ui
 from .research_runner import ResearchRunner
 
@@ -46,8 +48,9 @@ def register_research_app(
     app: FastMCPApp,
     jobs: ResearchJobStore,
     runner: ResearchRunner,
+    build_id: str,
 ) -> None:
-    """Register one UI entry point and its two app-only backend tools."""
+    """Register one UI entry point and its app-only backend tools."""
 
     @app.ui(
         name="research",
@@ -66,7 +69,7 @@ def register_research_app(
             else "local development user"
         )
         job.add_event(f"Authenticated as {identity}", kind="auth")
-        return build_research_ui(topic, job.snapshot())
+        return build_research_ui(topic, job.snapshot(), build_id=build_id)
 
     @app.tool()
     async def start_research(
@@ -90,6 +93,25 @@ def register_research_app(
         job = await jobs.get(job_id, owner_id(auth, ctx.session_id))
         return job.snapshot() if job else unavailable_snapshot(job_id)
 
+    @app.tool()
+    async def research_chat_context(
+        job_id: str,
+        ctx: MCPContext,
+    ) -> dict[str, str]:
+        auth = request_auth()
+        job = await jobs.get(job_id, owner_id(auth, ctx.session_id))
+        if job is None or not job.snapshot()["done"]:
+            raise RuntimeError("Research job is not available or complete")
+        markdown = await asyncio.to_thread(read_bucket_markdown, job, auth)
+        return {
+            "markdown": markdown,
+            "message": (
+                "The research report is complete and has been added to context. "
+                "Please summarize the main findings and include links to the "
+                "source artifacts and generated Markdown and HTML reports."
+            ),
+        }
+
 
 async def main() -> None:
     args = parse_args()
@@ -107,6 +129,7 @@ async def main() -> None:
             app,
             jobs=ResearchJobStore(),
             runner=ResearchRunner(harness, RESEARCH_HOME),
+            build_id=app_build_id(RESEARCH_HOME),
         )
 
         mcp = FastMCP(
@@ -115,6 +138,11 @@ async def main() -> None:
             instructions="Call `research` to open the live research app.",
         )
         mcp.add_provider(app)
+        install_versioned_renderer(
+            mcp,
+            app_name="Research Agent",
+            tool_name="research",
+        )
         await mcp.run_http_async(
             transport=args.transport,
             host=args.host,