feat: SRP refactor, streaming UX fix, and semantic disease detection (#12)

* feat: SRP refactor, streaming UX fix, and semantic disease detection

- Split 652-line clinical_trials_guru.py monolith into focused modules:
config, models, tools, prompts, trials_api, _console, agents/intake,
agents/research. clinical_trials_guru.py now ~60 lines of re-exports.
- Move tool schemas and disease benchmark profiles to JSON files under
data/; adding a new disease requires only a new JSON file, no code change.
- Fix Gradio 6.x input-locking bug by switching all intake/research turns
to Anthropic streaming API — inputs unblock after milliseconds, not 30s.
- Replace brittle substring match_disease() with identify_disease tool:
the intake agent calls identify_disease(standardized_name=...) when it
semantically identifies the disease; system does reliable registry lookup
via lookup_disease_profile(). Handles all languages, synonyms, and symptom
descriptions that keyword matching could not.
- Pin Gradio to >=6.14.0,<7.0.0 to prevent unexpected major-version breaks.

Co-Authored-By: Claude Sonnet 4.6 <noreply@anthropic.com>

* refactor: move all business logic out of app.py — pure UI wiring

- Add INTAKE_TOOLS / RESEARCH_TOOLS grouping constants to tools.py
- Add intake_greeting() (blocking) and stream_intake_turn() (event
generator) to agents/intake.py; handles identify_disease tool and
PatientProfile construction internally
- Add stream_research_agent() (event generator) to agents/research.py;
handles search_clinical_trials tool internally; uses profile.lang for
LANGUAGE_DIRECTIVE so app.py never touches system prompts
- Update agents/__init__.py exports
- Update clinical_trials_guru.py re-exports
- Rewrite app.py: imports only intake_greeting, stream_intake_turn,
stream_research_agent, PatientProfile, LANGUAGES, UI — no tool
objects, no tool names, no profile construction, no system prompts

app.py now maps agent events ("token"/"text"/"profile"/"done") to
Gradio state updates and nothing more.

Co-authored-by: KevinIsInCoding <KevinIsInCoding@users.noreply.github.com>

---------

Co-authored-by: Claude Sonnet 4.6 <noreply@anthropic.com>
Co-authored-by: claude[bot] <41898282+claude[bot]@users.noreply.github.com>
Co-authored-by: KevinIsInCoding <KevinIsInCoding@users.noreply.github.com>

_console.py

@@ -0,0 +1,3 @@
+from rich.console import Console
+
+console = Console()

agents/__init__.py

@@ -0,0 +1,10 @@
+from .intake import run_intake_agent, intake_greeting, stream_intake_turn
+from .research import run_research_agent, stream_research_agent
+
+__all__ = [
+    "run_intake_agent",
+    "intake_greeting",
+    "stream_intake_turn",
+    "run_research_agent",
+    "stream_research_agent",
+]

agents/intake.py

@@ -0,0 +1,219 @@
+from __future__ import annotations
+
+import datetime
+import json
+from dataclasses import asdict
+from typing import Generator
+
+import anthropic
+from rich.panel import Panel
+from rich.text import Text
+
+from beacon_logging import get_logger
+from config import INTAKE_MODEL
+from models import PatientProfile, geocode_zip
+from prompts import INTAKE_SYSTEM, lookup_disease_profile
+from tools import INTAKE_TOOLS
+from translations import LANGUAGE_DIRECTIVE
+from _console import console
+
+_logger = get_logger("agents.intake")
+
+
+def run_intake_agent(client: anthropic.Anthropic) -> PatientProfile:
+    today = datetime.date.today().strftime("%B %d, %Y")
+
+    console.print()
+    console.print(Panel(
+        Text("Beacon — Rare Disease Clinical Trial Finder", justify="center", style="bold cyan"),
+        border_style="cyan",
+        padding=(1, 4),
+    ))
+
+    messages: list[anthropic.types.MessageParam] = [
+        {"role": "user", "content": "Please begin."}
+    ]
+
+    while True:
+        response = client.messages.create(
+            model=INTAKE_MODEL,
+            max_tokens=1024,
+            system=f"Today's date is {today}.\n\n" + INTAKE_SYSTEM,
+            tools=INTAKE_TOOLS,
+            messages=messages,
+        )
+
+        text = next((b.text for b in response.content if b.type == "text"), "")
+        if text:
+            console.print(f"\n[bold cyan]Beacon:[/bold cyan] {text}")
+
+        identify_block = next(
+            (b for b in response.content if b.type == "tool_use" and b.name == "identify_disease"),
+            None,
+        )
+        submit_block = next(
+            (b for b in response.content if b.type == "tool_use" and b.name == "submit_profile"),
+            None,
+        )
+
+        if identify_block:
+            disease = lookup_disease_profile(identify_block.input["standardized_name"])
+            tool_result = json.dumps({
+                "benchmarks_to_collect": disease["benchmarks"] if disease else [],
+                "message": (
+                    f"Collect these benchmarks for {disease['full_name']}"
+                    if disease else "Disease not in registry — skip benchmark questions."
+                ),
+            })
+            messages.append({"role": "assistant", "content": response.content})
+            messages.append({"role": "user", "content": [{
+                "type": "tool_result",
+                "tool_use_id": identify_block.id,
+                "content": tool_result,
+            }]})
+            continue
+
+        if submit_block:
+            data = submit_block.input
+            try:
+                with console.status("[cyan]Geocoding location…[/cyan]", spinner="dots"):
+                    lat, lon = geocode_zip(data["zip_code"], data.get("country_code", "US"))
+            except Exception as exc:
+                console.print(f"[yellow]Warning:[/yellow] Geocoding failed ({exc}) — coordinates set to 0,0.")
+                lat, lon = 0.0, 0.0
+            profile = PatientProfile(
+                disease=data["disease"],
+                age=data["age"],
+                onset_months=data["onset_months"],
+                diagnosis_months=data.get("diagnosis_months", 0),
+                benchmarks=data.get("benchmarks") or {},
+                zip_code=data["zip_code"],
+                country_code=data.get("country_code", "US"),
+                lat=lat,
+                lon=lon,
+                radius_miles=data.get("radius_miles", 100),
+                phases=data.get("phases") or [],
+                include_eap=data.get("include_eap", False),
+                include_observational=data.get("include_observational", False),
+            )
+            _logger.info(
+                "Patient intake complete (CLI)",
+                extra={"data": {"intake_summary": asdict(profile)}},
+            )
+            return profile
+
+        messages.append({"role": "assistant", "content": response.content})
+        user_input = input("\nYou: ").strip() or "(no response)"
+        messages.append({"role": "user", "content": user_input})
+
+
+def intake_greeting(client: anthropic.Anthropic, lang: str = "en") -> tuple[str, list]:
+    """Run the opening intake turn (blocking). Returns (greeting_text, initial_messages)."""
+    today = datetime.date.today().strftime("%B %d, %Y")
+    system = f"Today's date is {today}.\n\n" + LANGUAGE_DIRECTIVE[lang] + INTAKE_SYSTEM
+    messages: list[anthropic.types.MessageParam] = [{"role": "user", "content": "Please begin."}]
+    response = client.messages.create(
+        model=INTAKE_MODEL,
+        max_tokens=1024,
+        system=system,
+        tools=INTAKE_TOOLS,
+        messages=messages,
+    )
+    text = next((b.text for b in response.content if b.type == "text"), "")
+    return text, messages + [{"role": "assistant", "content": response.content}]
+
+
+def stream_intake_turn(
+    client: anthropic.Anthropic,
+    messages: list[anthropic.types.MessageParam],
+    lang: str = "en",
+) -> Generator[tuple, None, None]:
+    """
+    Stream one user turn of the intake conversation.
+
+    Yields:
+      ("token", str)                              — partial text chunk
+      ("reset_stream",)                           — identify_disease handled; clear token buffer
+      ("text", str, list)                         — model responded with text; updated messages
+      ("profile", PatientProfile, list)           — profile submitted; updated messages
+    """
+    today = datetime.date.today().strftime("%B %d, %Y")
+    system = f"Today's date is {today}.\n\n" + LANGUAGE_DIRECTIVE[lang] + INTAKE_SYSTEM
+    new_msgs = list(messages)
+
+    while True:
+        intake_text = ""
+        with client.messages.stream(
+            model=INTAKE_MODEL,
+            max_tokens=1024,
+            system=system,
+            tools=INTAKE_TOOLS,
+            messages=new_msgs,
+        ) as stream:
+            for chunk in stream.text_stream:
+                intake_text += chunk
+                yield ("token", chunk)
+            response = stream.get_final_message()
+
+        intake_text = intake_text or next(
+            (b.text for b in response.content if b.type == "text"), ""
+        )
+
+        identify_block = next(
+            (b for b in response.content if b.type == "tool_use" and b.name == "identify_disease"),
+            None,
+        )
+        submit_block = next(
+            (b for b in response.content if b.type == "tool_use" and b.name == "submit_profile"),
+            None,
+        )
+
+        if identify_block:
+            disease = lookup_disease_profile(identify_block.input["standardized_name"])
+            tool_result = json.dumps({
+                "benchmarks_to_collect": disease["benchmarks"] if disease else [],
+                "message": (
+                    f"Collect these benchmarks for {disease['full_name']}"
+                    if disease else "Disease not in registry — skip benchmark questions."
+                ),
+            })
+            new_msgs = new_msgs + [
+                {"role": "assistant", "content": response.content},
+                {"role": "user", "content": [{
+                    "type": "tool_result",
+                    "tool_use_id": identify_block.id,
+                    "content": tool_result,
+                }]},
+            ]
+            yield ("reset_stream",)
+            continue
+
+        new_msgs = new_msgs + [{"role": "assistant", "content": response.content}]
+
+        if submit_block:
+            data = submit_block.input
+            try:
+                lat, lon = geocode_zip(data["zip_code"], data.get("country_code", "US"))
+            except Exception:
+                lat, lon = 0.0, 0.0
+            profile = PatientProfile(
+                disease=data["disease"],
+                age=data["age"],
+                onset_months=data["onset_months"],
+                diagnosis_months=data.get("diagnosis_months", 0),
+                benchmarks=data.get("benchmarks") or {},
+                zip_code=data["zip_code"],
+                country_code=data.get("country_code", "US"),
+                lat=lat,
+                lon=lon,
+                radius_miles=data.get("radius_miles", 100),
+                phases=data.get("phases") or [],
+                include_eap=data.get("include_eap", False),
+                include_observational=data.get("include_observational", False),
+                lang=lang,
+            )
+            yield ("profile", profile, new_msgs)
+            return
+
+        yield ("text", intake_text, new_msgs)
+        return

agents/research.py

@@ -0,0 +1,155 @@
+from __future__ import annotations
+
+import json
+from typing import Generator
+
+import anthropic
+
+from beacon_logging import get_logger
+from config import RESEARCH_MODEL
+from models import PatientProfile
+from prompts import RESEARCH_SYSTEM
+from tools import RESEARCH_TOOLS
+from translations import LANGUAGE_DIRECTIVE
+from trials_api import search_trials_api, _flatten_and_rank
+from _console import console
+
+_logger = get_logger("agents.research")
+
+
+def run_research_agent(client: anthropic.Anthropic, profile: PatientProfile) -> str:
+    messages: list[anthropic.types.MessageParam] = [
+        {
+            "role": "user",
+            "content": (
+                f"Find clinical trials for this patient:\n\n{profile.summary()}\n\n"
+                "Search within the specified radius and rank results by distance."
+            ),
+        }
+    ]
+
+    while True:
+        response = client.messages.create(
+            model=RESEARCH_MODEL,
+            max_tokens=8096,
+            system=RESEARCH_SYSTEM,
+            tools=RESEARCH_TOOLS,
+            messages=messages,
+        )
+
+        messages.append({"role": "assistant", "content": response.content})
+
+        if response.stop_reason == "end_turn":
+            return next(
+                (b.text for b in response.content if b.type == "text"),
+                "No analysis produced.",
+            )
+
+        tool_results: list[anthropic.types.ToolResultBlockParam] = []
+        for block in response.content:
+            if block.type != "tool_use" or block.name != "search_clinical_trials":
+                continue
+            args = block.input
+            radius = args.get("radius_miles", profile.radius_miles)
+            phases = args.get("phases") or None
+            study_type = args.get("study_type", "INTERVENTIONAL")
+            status_msg = (
+                f"[cyan]Searching:[/cyan] '[bold]{args['condition']}[/bold]' | "
+                f"radius=[bold]{radius}[/bold] mi | "
+                f"type=[bold]{study_type}[/bold] | "
+                f"phases=[bold]{phases or 'all'}[/bold]"
+            )
+            try:
+                with console.status(status_msg, spinner="dots"):
+                    studies = search_trials_api(
+                        condition=args["condition"],
+                        lat=args["lat"],
+                        lon=args["lon"],
+                        radius_miles=radius,
+                        phases=phases,
+                        study_type=study_type,
+                    )
+                    ranked = _flatten_and_rank(studies, profile.lat, profile.lon)
+                console.print(f"  [green]✓[/green] {len(ranked)} trial(s) found.")
+                content = json.dumps(ranked)
+                is_error = False
+            except Exception as exc:
+                console.print(f"[red bold]API error:[/red bold] {exc}")
+                content = f"API request failed: {exc}. The ClinicalTrials.gov endpoint may be temporarily unavailable."
+                is_error = True
+            tool_results.append({
+                "type": "tool_result",
+                "tool_use_id": block.id,
+                "content": content,
+                "is_error": is_error,
+            })
+
+        messages.append({"role": "user", "content": tool_results})
+
+
+def stream_research_agent(
+    client: anthropic.Anthropic,
+    profile: PatientProfile,
+) -> Generator[tuple, None, None]:
+    """
+    Stream the research agent for a given patient profile.
+
+    Yields:
+      ("token", str)   — partial text chunk
+      ("done", str)    — research complete; the full analysis text (may be empty)
+    """
+    messages: list[anthropic.types.MessageParam] = [{
+        "role": "user",
+        "content": (
+            f"Find clinical trials for this patient:\n\n{profile.summary()}\n\n"
+            "Search within the specified radius and rank results by distance."
+        ),
+    }]
+
+    while True:
+        stream_text = ""
+        with client.messages.stream(
+            model=RESEARCH_MODEL,
+            max_tokens=8096,
+            system=LANGUAGE_DIRECTIVE[profile.lang] + RESEARCH_SYSTEM,
+            tools=RESEARCH_TOOLS,
+            messages=messages,
+        ) as stream:
+            for chunk in stream.text_stream:
+                stream_text += chunk
+                yield ("token", chunk)
+            rresponse = stream.get_final_message()
+
+        messages.append({"role": "assistant", "content": rresponse.content})
+
+        if rresponse.stop_reason == "end_turn":
+            yield ("done", stream_text)
+            return
+
+        tool_results: list[anthropic.types.ToolResultBlockParam] = []
+        for block in rresponse.content:
+            if block.type != "tool_use" or block.name != "search_clinical_trials":
+                continue
+            args = block.input
+            try:
+                studies = search_trials_api(
+                    condition=args["condition"],
+                    lat=args["lat"],
+                    lon=args["lon"],
+                    radius_miles=args.get("radius_miles", profile.radius_miles),
+                    phases=args.get("phases") or None,
+                    study_type=args.get("study_type", "INTERVENTIONAL"),
+                )
+                ranked = _flatten_and_rank(studies, profile.lat, profile.lon)
+                content = json.dumps(ranked)
+                is_error = False
+            except Exception as exc:
+                content = f"API request failed: {exc}. The ClinicalTrials.gov endpoint may be temporarily unavailable."
+                is_error = True
+            tool_results.append({
+                "type": "tool_result",
+                "tool_use_id": block.id,
+                "content": content,
+                "is_error": is_error,
+            })
+        messages.append({"role": "user", "content": tool_results})

app.py

@@ -1,8 +1,6 @@
 from __future__ import annotations
 
 import dataclasses
-import datetime
-import json
 from typing import Generator
 
 import anthropic
@@ -10,136 +8,19 @@ import gradio as gr
 from beacon_logging import get_logger
 from dotenv import load_dotenv
 
-from clinical_trials_guru import (
-    INTAKE_MODEL,
-    INTAKE_SYSTEM,
-    RESEARCH_MODEL,
-    RESEARCH_SYSTEM,
-    SEARCH_TRIALS_TOOL,
-    SUBMIT_PROFILE_TOOL,
-    PatientProfile,
-    _flatten_and_rank,
-    geocode_zip,
-    search_trials_api,
-)
-from translations import LANGUAGE_DIRECTIVE, LANGUAGES, UI
+from agents.intake import intake_greeting, stream_intake_turn
+from agents.research import stream_research_agent
+from models import PatientProfile
+from translations import LANGUAGES, UI
 
 load_dotenv()
 
 _logger = get_logger("app")
 
 
-def _intake_turn(
-    user_text: str, messages: list, lang: str = "en"
-) -> tuple[str, list, PatientProfile | None]:
-    today = datetime.date.today().strftime("%B %d, %Y")
-    messages = messages + [{"role": "user", "content": user_text}]
-    client = anthropic.Anthropic()
-    system = f"Today's date is {today}.\n\n" + LANGUAGE_DIRECTIVE[lang] + INTAKE_SYSTEM
-    response = client.messages.create(
-        model=INTAKE_MODEL,
-        max_tokens=1024,
-        system=system,
-        tools=[SUBMIT_PROFILE_TOOL],
-        messages=messages,
-    )
-    text = next((b.text for b in response.content if b.type == "text"), "")
-    tool_block = next(
-        (b for b in response.content if b.type == "tool_use" and b.name == "submit_profile"),
-        None,
-    )
-    messages = messages + [{"role": "assistant", "content": response.content}]
-
-    if tool_block:
-        data = tool_block.input
-        try:
-            lat, lon = geocode_zip(data["zip_code"], data.get("country_code", "US"))
-        except Exception:
-            lat, lon = 0.0, 0.0
-        profile = PatientProfile(
-            disease=data["disease"],
-            age=data["age"],
-            onset_months=data["onset_months"],
-            diagnosis_months=data.get("diagnosis_months", 0),
-            benchmarks=data.get("benchmarks") or {},
-            zip_code=data["zip_code"],
-            country_code=data.get("country_code", "US"),
-            lat=lat,
-            lon=lon,
-            radius_miles=data.get("radius_miles", 100),
-            phases=data.get("phases") or [],
-            include_eap=data.get("include_eap", False),
-            include_observational=data.get("include_observational", False),
-            lang=lang,
-        )
-        _logger.info(
-            "Patient intake complete (web)",
-            extra={"data": {"intake_summary": dataclasses.asdict(profile)}},
-        )
-        return text or UI[lang]["got_it"], messages, profile
-
-    return text, messages, None
-
-
-def _run_research(profile: PatientProfile) -> str:
-    lang = profile.lang
-    client = anthropic.Anthropic()
-    messages: list[anthropic.types.MessageParam] = [
-        {
-            "role": "user",
-            "content": (
-                f"Find clinical trials for this patient:\n\n{profile.summary()}\n\n"
-                "Search within the specified radius and rank results by distance."
-            ),
-        }
-    ]
-    while True:
-        response = client.messages.create(
-            model=RESEARCH_MODEL,
-            max_tokens=8096,
-            system=LANGUAGE_DIRECTIVE[lang] + RESEARCH_SYSTEM,
-            tools=[SEARCH_TRIALS_TOOL],
-            messages=messages,
-        )
-        messages.append({"role": "assistant", "content": response.content})
-        if response.stop_reason == "end_turn":
-            return next(
-                (b.text for b in response.content if b.type == "text"),
-                UI[lang]["no_analysis"],
-            )
-        tool_results: list[anthropic.types.ToolResultBlockParam] = []
-        for block in response.content:
-            if block.type != "tool_use" or block.name != "search_clinical_trials":
-                continue
-            args = block.input
-            try:
-                studies = search_trials_api(
-                    condition=args["condition"],
-                    lat=args["lat"],
-                    lon=args["lon"],
-                    radius_miles=args.get("radius_miles", profile.radius_miles),
-                    phases=args.get("phases") or None,
-                    study_type=args.get("study_type", "INTERVENTIONAL"),
-                )
-                ranked = _flatten_and_rank(studies, profile.lat, profile.lon)
-                content = json.dumps(ranked)
-                is_error = False
-            except Exception as exc:
-                content = UI[lang]["api_error"].format(exc=exc)
-                is_error = True
-            tool_results.append(
-                {
-                    "type": "tool_result",
-                    "tool_use_id": block.id,
-                    "content": content,
-                    "is_error": is_error,
-                }
-            )
-        messages.append({"role": "user", "content": tool_results})
-
-
 def initialize(lang: str = "en"):
-    text, msgs, _ = _intake_turn("Please begin.", [], lang=lang)
+    client = anthropic.Anthropic()
+    text, msgs = intake_greeting(client, lang)
     chat = [{"role": "assistant", "content": text}]
     return chat, msgs, None, "intake"
 
@@ -148,7 +29,7 @@ def respond(
     user_msg: str,
     chat_history: list,
     intake_msgs: list,
-    profile,
+    profile: PatientProfile | None,
     phase: str,
     lang: str,
 ) -> Generator:
@@ -157,43 +38,64 @@ def respond(
         return
 
     t = UI[lang]
+    client = anthropic.Anthropic()
+
     chat_history = chat_history + [{"role": "user", "content": user_msg}]
+    new_intake_msgs = intake_msgs + [{"role": "user", "content": user_msg}]
     yield chat_history, intake_msgs, profile, phase, gr.update(value=""), gr.update()
 
-    assistant_text, updated_msgs, new_profile = _intake_turn(user_msg, intake_msgs, lang=lang)
-
-    if new_profile:
-        status = (assistant_text + "\n\n" if assistant_text else "") + t["status_searching"]
-        chat_history = chat_history + [{"role": "assistant", "content": status}]
-        yield (
-            chat_history,
-            updated_msgs,
-            new_profile,
-            "researching",
-            gr.update(interactive=False, placeholder=t["searching"]),
-            gr.update(visible=False),
-        )
+    intake_text = ""
+    for event in stream_intake_turn(client, new_intake_msgs, lang):
+        if event[0] == "token":
+            intake_text += event[1]
+            yield (
+                chat_history + [{"role": "assistant", "content": intake_text}],
+                intake_msgs, profile, phase, gr.update(), gr.update(),
+            )
+        elif event[0] == "reset_stream":
+            intake_text = ""
+        elif event[0] == "text":
+            _, full_text, updated_msgs = event
+            chat_history = chat_history + [{"role": "assistant", "content": full_text}]
+            yield (
+                chat_history, updated_msgs, profile, "intake",
+                gr.update(interactive=True), gr.update(),
+            )
+            return
+        elif event[0] == "profile":
+            _, new_profile, updated_msgs = event
+            _logger.info(
+                "Patient intake complete (web)",
+                extra={"data": {"intake_summary": dataclasses.asdict(new_profile)}},
+            )
+            if intake_text:
+                chat_history = chat_history + [{"role": "assistant", "content": intake_text}]
+            chat_history = chat_history + [{"role": "assistant", "content": t["status_searching"]}]
+            yield (
+                chat_history, updated_msgs, new_profile, "researching",
+                gr.update(interactive=False, placeholder=t["searching"]),
+                gr.update(visible=False),
+            )
 
-        analysis = _run_research(new_profile)
-        chat_history = chat_history + [{"role": "assistant", "content": analysis}]
-        yield (
-            chat_history,
-            updated_msgs,
-            new_profile,
-            "done",
-            gr.update(interactive=False, placeholder=t["search_complete"]),
-            gr.update(visible=True),
-        )
-    else:
-        chat_history = chat_history + [{"role": "assistant", "content": assistant_text}]
-        yield (
-            chat_history,
-            updated_msgs,
-            profile,
-            "intake",
-            gr.update(),
-            gr.update(),
-        )
+            stream_text = ""
+            for rev in stream_research_agent(client, new_profile):
+                if rev[0] == "token":
+                    stream_text += rev[1]
+                    yield (
+                        chat_history + [{"role": "assistant", "content": stream_text}],
+                        updated_msgs, new_profile, "researching",
+                        gr.update(interactive=False, placeholder=t["searching"]),
+                        gr.update(visible=False),
+                    )
+                elif rev[0] == "done":
+                    analysis = rev[1] or t["no_analysis"]
+                    chat_history = chat_history + [{"role": "assistant", "content": analysis}]
+                    yield (
+                        chat_history, updated_msgs, new_profile, "done",
+                        gr.update(interactive=False, placeholder=t["search_complete"]),
+                        gr.update(visible=True),
+                    )
+            return
 
 
 def change_language(lang: str):

clinical_trials_guru.py

@@ -1,614 +1,22 @@
 from __future__ import annotations
 
-import json
-import math
-import time
-from dataclasses import asdict, dataclass, field
 from typing import Optional, TypedDict
 
-from beacon_logging import get_logger
-from translations import LANGUAGE_DIRECTIVE
-
 import anthropic
-import httpx
 from rich import box
-from rich.console import Console
 from rich.markdown import Markdown
 from rich.panel import Panel
-from rich.text import Text
 from langgraph.graph import StateGraph, START, END
 
-_logger = get_logger("clinical_trials_guru")
-
-CTGOV_BASE = "https://clinicaltrials.gov/api/v2/studies"
-INTAKE_MODEL = "claude-sonnet-4-6"
-RESEARCH_MODEL = "claude-opus-4-7"
-
-console = Console()
-
-# ── Tool schemas ──────────────────────────────────────────────────────────────
-
-SUBMIT_PROFILE_TOOL: anthropic.types.ToolParam = {
-    "name": "submit_profile",
-    "description": (
-        "Call this when you have collected all required information. "
-        "Standardize the disease name to its full medical term."
-    ),
-    "input_schema": {
-        "type": "object",
-        "properties": {
-            "disease": {
-                "type": "string",
-                "description": "Full medical name (e.g. 'Amyotrophic Lateral Sclerosis')",
-            },
-            "age": {"type": "integer"},
-            "onset_months": {
-                "type": "integer",
-                "description": "Months since first symptom onset",
-            },
-            "diagnosis_months": {
-                "type": "integer",
-                "description": "Months since formal/official diagnosis",
-            },
-            "benchmarks": {
-                "type": "object",
-                "description": "Disease-specific scores, e.g. {\"ALSFRS-R\": \"38\"}",
-                "additionalProperties": {"type": "string"},
-            },
-            "zip_code": {"type": "string", "description": "Patient ZIP / postal code"},
-            "country_code": {
-                "type": "string",
-                "description": "ISO 2-letter country code (default US)",
-            },
-            "radius_miles": {
-                "type": "integer",
-                "description": "Search radius in miles from patient location (default 100)",
-            },
-            "phases": {
-                "type": "array",
-                "items": {"type": "string", "enum": ["0", "1", "2", "3", "4", "na"]},
-                "description": "Desired trial phases (0=Early Phase 1, 1=Phase 1, 2=Phase 2, 3=Phase 3, 4=Phase 4, na=Not Applicable). Empty = all phases.",
-            },
-            "include_eap": {
-                "type": "boolean",
-                "description": "Whether patient is interested in Expanded Access Programs (compassionate use)",
-            },
-            "include_observational": {
-                "type": "boolean",
-                "description": "Whether patient is interested in observational studies (no experimental treatment; researchers observe and measure outcomes)",
-            },
-        },
-        "required": ["disease", "age", "onset_months", "diagnosis_months", "zip_code"],
-    },
-}
-
-SEARCH_TRIALS_TOOL: anthropic.types.ToolParam = {
-    "name": "search_clinical_trials",
-    "description": (
-        "Search ClinicalTrials.gov for studies within a geographic radius. "
-        "Results are pre-ranked by distance from the patient's location. "
-        "Call multiple times with different parameters (synonyms, broader radius, "
-        "different phases) if initial results are sparse. "
-        "Use study_type='EXPANDED_ACCESS' to search for Expanded Access Programs (EAP / compassionate use). "
-        "Use study_type='OBSERVATIONAL' to search for observational studies (no experimental treatment assigned)."
-    ),
-    "input_schema": {
-        "type": "object",
-        "properties": {
-            "condition": {
-                "type": "string",
-                "description": "Disease / condition to search (medical name and/or abbreviation)",
-            },
-            "lat": {"type": "number", "description": "Patient latitude"},
-            "lon": {"type": "number", "description": "Patient longitude"},
-            "radius_miles": {"type": "integer", "description": "Search radius in miles"},
-            "phases": {
-                "type": "array",
-                "items": {"type": "string"},
-                "description": (
-                    "Phase numbers to filter e.g. ['1','2','3']. "
-                    "IMPORTANT: Never enumerate all phases to mean 'all phases' — "
-                    "pass an empty array [] instead. NA-phase trials (device feasibility, "
-                    "unphased studies) only appear when phases=[] (no filter). "
-                    "Ignored for EAP."
-                ),
-            },
-            "study_type": {
-                "type": "string",
-                "enum": ["INTERVENTIONAL", "EXPANDED_ACCESS", "OBSERVATIONAL"],
-                "description": "INTERVENTIONAL (default) for clinical trials; EXPANDED_ACCESS for EAP/compassionate use; OBSERVATIONAL for observational studies.",
-            },
-        },
-        "required": ["condition", "lat", "lon", "radius_miles"],
-    },
-}
-
-# ── System prompts ────────────────────────────────────────────────────────────
-
-INTAKE_SYSTEM = """\
-You are Beacon's patient intake specialist for rare disease clinical trials.
-Collect the following through a warm, conversational interview — do NOT present a form.
-
-REQUIRED:
-  • Disease/condition (standardize: "Lou Gehrig's" → "Amyotrophic Lateral Sclerosis")
-  • Patient age
-  • Months since first symptom onset (convert dates/years as needed)
-  • Months since formal/official diagnosis (convert dates/years as needed; may differ from onset)
-  • ZIP/postal code and country for geographic search
-
-OPTIONAL (ask based on disease):
-  • Disease-specific benchmark scores:
-      ALS → ALSFRS-R (0-48) + FVC % predicted (0-100%) + ALS subtype;
-              FVC (Forced Vital Capacity) measures how much air a person can forcibly exhale —
-              it reflects respiratory muscle strength. In ALS it is expressed as a percentage
-              of the value expected for someone of the same age/height/sex (e.g. "72%").
-              Many trials require FVC ≥ 50% or ≥ 60% for enrollment. If the patient has had
-              recent pulmonary function testing, ask for their FVC % predicted.
-              ALS subtype: ask whether the patient has sporadic ALS (no family history, ~90–95%
-              of cases) or familial/genetic ALS (inherited; ~5–10% of cases). If familial, ask
-              which gene mutation is involved if they know it (common ones: SOD1, C9orf72, FUS,
-              TDP-43). This affects trial eligibility — many gene-targeted trials require a
-              confirmed mutation. The patient may skip if unknown. Store as e.g.
-              {"ALS subtype": "sporadic"} or {"ALS subtype": "familial", "ALS gene": "SOD1"}.
-          MS → EDSS (0-10); Parkinson's → MDS-UPDRS III;
-      Huntington's → TFC (0-13) + CAG repeats; SMA → HFMS + SMA type;
-      Duchenne/Pompe → 6-Minute Walk Test; Friedreich's → SARA score
-  • Preferred search radius in miles (default 100)
-  • Study types of interest — ask whether the patient wants:
-      - Clinical trials. Briefly explain the phases so the patient can choose:
-          Early Phase 1 — First-in-human safety testing; tiny doses, very small group (~10–15 people);
-                          no efficacy data yet; highest uncertainty.
-          Phase 1       — Establishes safe dosage range and identifies side effects;
-                          small group (20–80 people); primary goal is safety, not treatment.
-          Phase 2       — Tests whether the treatment works and further evaluates safety;
-                          larger group (100–300 people); patients more likely to receive active drug.
-          Phase 3       — Compares treatment against current standard of care in a large group
-                          (1,000–3,000 people); required for regulatory approval; best efficacy evidence.
-          Phase 4       — Post-approval surveillance; treatment is already FDA-approved;
-                          studies long-term safety, rare side effects, and new uses.
-          Not Applicable — Studies that do not fall into the standard phase framework
-                          (e.g., device feasibility studies, behavioral/observational trials,
-                          or studies where phase designation is not required by FDA).
-      - Observational studies — studies where researchers observe participants and collect
-        data without assigning treatments. No experimental drug or intervention is given.
-        Patients may contribute valuable data to disease understanding, registries, or
-        natural history studies. Often have broader eligibility than interventional trials.
-      - Expanded Access Programs (EAP / compassionate use) — a pathway for patients who
-        do not qualify for or cannot access a clinical trial to receive an investigational
-        drug, biologic, or device outside of a trial. Also called "compassionate use."
-        The treatment is not yet FDA-approved; a physician must submit the EAP request
-        to the drug sponsor and obtain FDA authorization. EAP does not guarantee efficacy
-        but may be an option when no approved treatments remain.
-      - Or any combination; or all types (default if no preference)
-
-Ask naturally. You may infer disease synonyms and convert dates to months, but never infer or skip the ZIP/postal code — always ask the patient for it directly. Once you have every required field confirmed by the patient, call submit_profile.\
-"""
-
-RESEARCH_SYSTEM = """\
-You are Beacon, an expert rare-disease clinical trial navigator.
-You have a search_clinical_trials tool that queries ClinicalTrials.gov in real time.
-Results are already ranked by geographic distance from the patient.
-
-Workflow:
-1. Search for the patient's disease. Use both the full medical name and common abbreviation.
-   - If the patient wants clinical trials, search with study_type="INTERVENTIONAL".
-   - If the patient wants observational studies, also search with study_type="OBSERVATIONAL".
-   - If the patient wants Expanded Access Programs (EAP), also search with study_type="EXPANDED_ACCESS".
-   - Run a separate search for each study_type the patient is interested in.
-2. IMPORTANT — phase filtering: Never pass phases=["1","2","3","4"] to mean "all phases."
-   Always pass phases=[] (omit the field) when the patient has no phase preference.
-   NA-phase trials (device feasibility studies, unphased interventions) only appear
-   when no phase filter is applied. Passing explicit phase numbers silently excludes them.
-   Phase filters do not apply to OBSERVATIONAL or EXPANDED_ACCESS searches.
-3. If fewer than 3 results are found, retry with: a wider radius, a disease synonym,
-   or drop phase filters entirely (phases=[]).
-4. Produce a final report. Use separate sections for Clinical Trials, Observational Studies, and Expanded Access as applicable.
-   List the top 10 results per section ranked by site proximity.
-   For EACH entry use exactly this format (repeat the block per entry):
-
-   📍 **[Closest hospital/facility name]** — [City, State] ([X] mi)
-   **Trial:** [Full title] ([Phase] — or "Observational" / "Expanded Access" as applicable)
-   **Sponsor:** [Lead sponsor]
-   **Principal Investigator:** [Name — or "Not listed" if absent]
-   **Contact:** [Phone number] | [Email address] (use "Not listed" for any missing field)
-   **Summary:** [2–3 sentence plain-language description of what the trial/program is testing
-               and why it may matter for this patient]
-   **Qualification criteria:** [Key inclusion AND exclusion criteria relevant to this patient,
-                               including age range, functional score thresholds, FVC cutoffs,
-                               and any red flags. Be specific — use exact numbers from the data.]
-   **Link:** https://clinicaltrials.gov/study/[NCT_ID]
-
-   ---
-
-5. After the results add a short "Next steps" section (bullet points).
-   For observational studies, note that participation typically involves check-ins, surveys, or sample collection with no experimental treatment.
-   For EAP results, note that patients typically need a physician to submit the EAP request.
-
-IMPORTANT: Only report trials returned by the search_clinical_trials tool. Do NOT suggest,
-list, or recommend any hospitals, centers, or trials that were not in the tool results —
-even well-known institutions. If no results are found, say so clearly and suggest the patient
-ask their neurologist or contact the ALS Association for a referral.
-
-Be accurate. Do not fabricate details. If data is missing, say so.\
-"""
-
-# ── Data model ────────────────────────────────────────────────────────────────
-
-@dataclass
-class PatientProfile:
-    disease: str
-    age: int
-    onset_months: int
-    diagnosis_months: int = 0
-    benchmarks: dict[str, str] = field(default_factory=dict)
-    zip_code: str = ""
-    country_code: str = "US"
-    lat: float = 0.0
-    lon: float = 0.0
-    radius_miles: int = 100
-    phases: list[str] = field(default_factory=list)
-    include_eap: bool = False
-    include_observational: bool = False
-    lang: str = "en"
-
-    def summary(self) -> str:
-        lines = [
-            f"Disease: {self.disease}",
-            f"Age: {self.age}",
-            f"Symptom onset: {self.onset_months} months ago",
-            f"Formal diagnosis: {self.diagnosis_months} months ago",
-        ]
-        if self.benchmarks:
-            lines.append("Benchmarks: " + ", ".join(f"{k}={v}" for k, v in self.benchmarks.items()))
-        lines.append(
-            f"Location: ZIP {self.zip_code}, {self.country_code} "
-            f"(lat={self.lat:.4f}, lon={self.lon:.4f})"
-        )
-        lines.append(f"Search radius: {self.radius_miles} miles")
-        if self.phases:
-            def _phase_label(p: str) -> str:
-                if p == "0":
-                    return "Early Phase 1"
-                if p == "na":
-                    return "Not Applicable"
-                return f"Phase {p}"
-            labels = [_phase_label(p) for p in self.phases]
-            lines.append(f"Phases: {', '.join(labels)}")
-        interests = ["Clinical trials"]
-        if self.include_observational:
-            interests.append("Observational studies")
-        if self.include_eap:
-            interests.append("Expanded Access Programs (EAP)")
-        lines.append(f"Study type interest: {', '.join(interests)}")
-        return "\n".join(lines)
-
-
-# ��─ Geocoding ─────────────────────────────────────────────────────────────────
-
-def geocode_zip(zip_code: str, country_code: str = "US") -> tuple[float, float]:
-    resp = httpx.get(
-        "https://nominatim.openstreetmap.org/search",
-        params={"postalcode": zip_code, "country": country_code, "format": "json", "limit": 1},
-        headers={"User-Agent": "Beacon-ClinicalTrialFinder/1.0"},
-        timeout=10,
-    )
-    resp.raise_for_status()
-    results = resp.json()
-    if not results:
-        raise ValueError(f"Cannot geocode ZIP {zip_code!r} in {country_code!r}")
-    return float(results[0]["lat"]), float(results[0]["lon"])
-
-
-# ── Distance ──────────────────────────────────────────────────────────────────
-
-def haversine_miles(lat1: float, lon1: float, lat2: float, lon2: float) -> float:
-    R = 3958.8
-    φ1, φ2 = math.radians(lat1), math.radians(lat2)
-    dφ, dλ = math.radians(lat2 - lat1), math.radians(lon2 - lon1)
-    a = math.sin(dφ / 2) ** 2 + math.cos(φ1) * math.cos(φ2) * math.sin(dλ / 2) ** 2
-    return R * 2 * math.atan2(math.sqrt(a), math.sqrt(1 - a))
-
-
-# ── ClinicalTrials.gov ────────────────────────────────────────────────────────
-
-def search_trials_api(
-    condition: str,
-    lat: float,
-    lon: float,
-    radius_miles: int = 100,
-    phases: list[str] | None = None,
-    study_type: str = "INTERVENTIONAL",
-) -> list[dict]:
-    is_eap = study_type == "EXPANDED_ACCESS"
-    is_observational = study_type == "OBSERVATIONAL"
-    params: dict[str, str | int] = {
-        "query.cond": condition,
-        "filter.overallStatus": "AVAILABLE" if is_eap else "RECRUITING",
-        "filter.geo": f"distance({lat},{lon},{radius_miles}mi)",
-        "pageSize": 200,  # max page size; we paginate until exhausted
-        "format": "json",
-    }
-    # aggFilters supports comma-separated keys (e.g. "studyType:exp,phase:3 4").
-    # RECRUITING status already excludes EAPs, so studyType:int is only needed
-    # when no phase filter is applied. studyType:int returns all phases including N/A.
-    # Observational studies use studyType:obs; phases don't apply to them.
-    #
-    # Case matrix:
-    #   EAP only                  → studyType:exp
-    #   EAP + specific phases     → studyType:exp,phase:X Y  (combine both filters)
-    #   EAP + all phases          → studyType:exp  (no phase filter needed)
-    #   Interventional, specific  → phase:X Y
-    #   Interventional, all/NA    → studyType:int  (returns NA trials too)
-    if is_eap:
-        numbered = [p for p in (phases or []) if p != "na"]
-        if numbered:
-            # EAP + specific phases: combine studyType:exp with phase filter
-            params["aggFilters"] = "studyType:exp,phase:" + " ".join(numbered)
-        else:
-            # EAP only or EAP + all phases (no phase restriction)
-            params["aggFilters"] = "studyType:exp"
-    elif is_observational:
-        params["aggFilters"] = "studyType:obs"
-    elif phases:
-        # Exclude "na" from the phase filter — N/A trials have no phase value to match on;
-        # they appear naturally when no phase filter is applied (studyType:int branch).
-        numbered = [p for p in phases if p != "na"]
-        if numbered:
-            params["aggFilters"] = "phase:" + " ".join(numbered)
-        else:
-            # Only "na" was requested — use studyType:int (all phases including N/A appear)
-            params["aggFilters"] = "studyType:int"
-    else:
-        # No phase preference — return all interventional studies including N/A phase
-        params["aggFilters"] = "studyType:int"
-
-    _logger.info(
-        "ClinicalTrials.gov API request",
-        extra={"data": {"endpoint": CTGOV_BASE, "params": dict(params)}},
-    )
-
-    all_studies: list[dict] = []
-    while True:
-        for attempt in range(3):
-            try:
-                resp = httpx.get(CTGOV_BASE, params=params, timeout=30)
-                resp.raise_for_status()
-                body = resp.json()
-                break
-            except httpx.HTTPError as exc:
-                if attempt == 2:
-                    raise
-                wait = 2 ** attempt
-                console.print(f"[yellow]API warning:[/yellow] {exc} — retrying in {wait}s (attempt {attempt + 1}/3)…")
-                time.sleep(wait)
-        page_studies = body.get("studies", [])
-        all_studies.extend(page_studies)
-        next_token = body.get("nextPageToken")
-        _logger.debug(
-            "ClinicalTrials.gov API page received",
-            extra={"data": {"page_count": len(page_studies), "has_next_page": bool(next_token)}},
-        )
-        if not next_token:
-            break
-        params["pageToken"] = next_token
-
-    _logger.info(
-        "ClinicalTrials.gov API response complete",
-        extra={"data": {"total_studies": len(all_studies)}},
-    )
-    return all_studies
-
-
-def _flatten_and_rank(studies: list[dict], patient_lat: float, patient_lon: float) -> list[dict]:
-    result = []
-    for study in studies:
-        proto = study.get("protocolSection", {})
-        id_mod = proto.get("identificationModule", {})
-        desc_mod = proto.get("descriptionModule", {})
-        elig_mod = proto.get("eligibilityModule", {})
-        contacts_mod = proto.get("contactsLocationsModule", {})
-        sponsor_mod = proto.get("sponsorCollaboratorsModule", {})
-        design_mod = proto.get("designModule", {})
-
-        # Central (overall) contacts
-        central_contacts = contacts_mod.get("centralContacts", [])
-        central_phone = next((c.get("phone", "") for c in central_contacts if c.get("phone")), "")
-        central_email = next((c.get("email", "") for c in central_contacts if c.get("email")), "")
-
-        # Principal investigator from overallOfficials
-        officials = contacts_mod.get("overallOfficials", [])
-        pi = next(
-            (o.get("name", "") for o in officials if o.get("role") == "PRINCIPAL_INVESTIGATOR"),
-            officials[0].get("name", "") if officials else "",
-        )
-
-        sites_with_dist: list[tuple[float, dict]] = []
-        for loc in contacts_mod.get("locations", []):
-            geo = loc.get("geoPoint", {})
-            if geo.get("lat") and geo.get("lon"):
-                d = haversine_miles(patient_lat, patient_lon, geo["lat"], geo["lon"])
-                loc_contacts = loc.get("contacts", [])
-                loc_phone = next((c.get("phone", "") for c in loc_contacts if c.get("phone")), "")
-                loc_email = next((c.get("email", "") for c in loc_contacts if c.get("email")), "")
-                sites_with_dist.append((d, {
-                    "label": (
-                        f"{loc.get('facility', '').strip()} — "
-                        f"{loc.get('city', '')}, "
-                        f"{loc.get('state', loc.get('country', ''))} "
-                        f"({d:.0f} mi)"
-                    ),
-                    "facility": loc.get("facility", "").strip(),
-                    "city": loc.get("city", ""),
-                    "state": loc.get("state", loc.get("country", "")),
-                    "distance_miles": round(d, 1),
-                    "phone": loc_phone or central_phone,
-                    "email": loc_email or central_email,
-                }))
-        sites_with_dist.sort(key=lambda x: x[0])
-
-        closest_dist = sites_with_dist[0][0] if sites_with_dist else None
-        result.append({
-            "nct_id": id_mod.get("nctId", ""),
-            "title": id_mod.get("briefTitle", ""),
-            "phase": ", ".join(design_mod.get("phases", [])) or "N/A",
-            "sponsor": sponsor_mod.get("leadSponsor", {}).get("name", ""),
-            "principal_investigator": pi,
-            "contact_phone": central_phone,
-            "contact_email": central_email,
-            "summary": desc_mod.get("briefSummary", "")[:500],
-            "eligibility": elig_mod.get("eligibilityCriteria", "")[:1000],
-            "min_age": elig_mod.get("minimumAge", ""),
-            "max_age": elig_mod.get("maximumAge", ""),
-            "closest_site_miles": round(closest_dist, 1) if closest_dist is not None else None,
-            "nearest_sites": [info for _, info in sites_with_dist[:5]],
-        })
-
-    result.sort(key=lambda x: x["closest_site_miles"] if x["closest_site_miles"] is not None else float("inf"))
-    return result
-
-
-# ── Intake agent ──────────────────────────────────────────────────────────────
-
-def run_intake_agent(client: anthropic.Anthropic) -> PatientProfile:
-    import datetime
-    today = datetime.date.today().strftime("%B %d, %Y")
-
-    console.print()
-    console.print(Panel(
-        Text("Beacon — Rare Disease Clinical Trial Finder", justify="center", style="bold cyan"),
-        border_style="cyan",
-        padding=(1, 4),
-    ))
-
-    messages: list[anthropic.types.MessageParam] = [
-        {"role": "user", "content": "Please begin."}
-    ]
-
-    while True:
-        response = client.messages.create(
-            model=INTAKE_MODEL,
-            max_tokens=1024,
-            system=f"Today's date is {today}.\n\n" + INTAKE_SYSTEM,
-            tools=[SUBMIT_PROFILE_TOOL],
-            messages=messages,
-        )
-
-        text = next((b.text for b in response.content if b.type == "text"), "")
-        if text:
-            console.print(f"\n[bold cyan]Beacon:[/bold cyan] {text}")
-
-        tool_block = next(
-            (b for b in response.content if b.type == "tool_use" and b.name == "submit_profile"),
-            None,
-        )
-        if tool_block:
-            data = tool_block.input
-            try:
-                with console.status("[cyan]Geocoding location…[/cyan]", spinner="dots"):
-                    lat, lon = geocode_zip(data["zip_code"], data.get("country_code", "US"))
-            except Exception as exc:
-                console.print(f"[yellow]Warning:[/yellow] Geocoding failed ({exc}) — coordinates set to 0,0.")
-                lat, lon = 0.0, 0.0
-            profile = PatientProfile(
-                disease=data["disease"],
-                age=data["age"],
-                onset_months=data["onset_months"],
-                diagnosis_months=data.get("diagnosis_months", 0),
-                benchmarks=data.get("benchmarks") or {},
-                zip_code=data["zip_code"],
-                country_code=data.get("country_code", "US"),
-                lat=lat,
-                lon=lon,
-                radius_miles=data.get("radius_miles", 100),
-                phases=data.get("phases") or [],
-                include_eap=data.get("include_eap", False),
-                include_observational=data.get("include_observational", False),
-            )
-            _logger.info(
-                "Patient intake complete (CLI)",
-                extra={"data": {"intake_summary": asdict(profile)}},
-            )
-            return profile
-
-        messages.append({"role": "assistant", "content": response.content})
-        user_input = input("\nYou: ").strip() or "(no response)"
-        messages.append({"role": "user", "content": user_input})
-
-
-# ── Research agent ────────────────────────────────────────────────────────────
-
-def run_research_agent(client: anthropic.Anthropic, profile: PatientProfile) -> str:
-    messages: list[anthropic.types.MessageParam] = [
-        {
-            "role": "user",
-            "content": (
-                f"Find clinical trials for this patient:\n\n{profile.summary()}\n\n"
-                "Search within the specified radius and rank results by distance."
-            ),
-        }
-    ]
-
-    while True:
-        response = client.messages.create(
-            model=RESEARCH_MODEL,
-            max_tokens=8096,
-            system=RESEARCH_SYSTEM,
-            tools=[SEARCH_TRIALS_TOOL],
-            messages=messages,
-        )
-
-        messages.append({"role": "assistant", "content": response.content})
-
-        if response.stop_reason == "end_turn":
-            return next(
-                (b.text for b in response.content if b.type == "text"),
-                "No analysis produced.",
-            )
-
-        tool_results: list[anthropic.types.ToolResultBlockParam] = []
-        for block in response.content:
-            if block.type != "tool_use" or block.name != "search_clinical_trials":
-                continue
-            args = block.input
-            radius = args.get("radius_miles", profile.radius_miles)
-            phases = args.get("phases") or None
-            study_type = args.get("study_type", "INTERVENTIONAL")
-            status_msg = (
-                f"[cyan]Searching:[/cyan] '[bold]{args['condition']}[/bold]' | "
-                f"radius=[bold]{radius}[/bold] mi | "
-                f"type=[bold]{study_type}[/bold] | "
-                f"phases=[bold]{phases or 'all'}[/bold]"
-            )
-            try:
-                with console.status(status_msg, spinner="dots"):
-                    studies = search_trials_api(
-                        condition=args["condition"],
-                        lat=args["lat"],
-                        lon=args["lon"],
-                        radius_miles=radius,
-                        phases=phases,
-                        study_type=study_type,
-                        max_results=args.get("max_results", 20),
-                    )
-                    ranked = _flatten_and_rank(studies, profile.lat, profile.lon)
-                console.print(f"  [green]✓[/green] {len(ranked)} trial(s) found.")
-                content = json.dumps(ranked)
-                is_error = False
-            except Exception as exc:
-                console.print(f"[red bold]API error:[/red bold] {exc}")
-                content = f"API request failed: {exc}. The ClinicalTrials.gov endpoint may be temporarily unavailable."
-                is_error = True
-            tool_results.append({
-                "type": "tool_result",
-                "tool_use_id": block.id,
-                "content": content,
-                "is_error": is_error,
-            })
-
-        messages.append({"role": "user", "content": tool_results})
-
+# Re-exports — backward compat for app.py and any external callers
+from config import CTGOV_BASE, INTAKE_MODEL, RESEARCH_MODEL  # noqa: F401
+from models import PatientProfile, geocode_zip, haversine_miles  # noqa: F401
+from prompts import INTAKE_SYSTEM, RESEARCH_SYSTEM, build_intake_system, lookup_disease_profile  # noqa: F401
+from tools import SUBMIT_PROFILE_TOOL, SEARCH_TRIALS_TOOL, IDENTIFY_DISEASE_TOOL, INTAKE_TOOLS, RESEARCH_TOOLS  # noqa: F401
+from trials_api import search_trials_api, _flatten_and_rank  # noqa: F401
+from agents import run_intake_agent, run_research_agent, intake_greeting, stream_intake_turn, stream_research_agent  # noqa: F401
+from _console import console
 
-# ── LangGraph ─────────────────────────────────────────────────────────────────
 
 class BeaconState(TypedDict):
     profile: Optional[PatientProfile]

config.py

@@ -0,0 +1,3 @@
+CTGOV_BASE = "https://clinicaltrials.gov/api/v2/studies"
+INTAKE_MODEL = "claude-sonnet-4-6"
+RESEARCH_MODEL = "claude-opus-4-7"

data/diseases/als.json

@@ -0,0 +1,25 @@
+{
+  "id": "als",
+  "full_name": "Amyotrophic Lateral Sclerosis",
+  "synonyms": ["ALS", "Lou Gehrig's disease", "Lou Gehrig's", "motor neuron disease", "MND"],
+  "benchmarks": [
+    {
+      "key": "ALSFRS-R",
+      "label": "ALSFRS-R",
+      "range": "0-48",
+      "guidance": "ALSFRS-R (ALS Functional Rating Scale-Revised) measures functional status across 12 domains (speech, swallowing, handwriting, walking, breathing, etc.). 48 = fully functional, 0 = total loss of function. Ask the patient for their most recent score."
+    },
+    {
+      "key": "FVC %",
+      "label": "FVC % predicted",
+      "range": "0-100%",
+      "guidance": "FVC (Forced Vital Capacity) measures how much air a person can forcibly exhale — it reflects respiratory muscle strength. In ALS it is expressed as a percentage of the value expected for someone of the same age/height/sex (e.g. '72%'). Many trials require FVC ≥ 50% or ≥ 60% for enrollment. If the patient has had recent pulmonary function testing, ask for their FVC % predicted."
+    },
+    {
+      "key": "ALS subtype",
+      "label": "ALS subtype",
+      "range": null,
+      "guidance": "Ask whether the patient has sporadic ALS (no family history, ~90–95% of cases) or familial/genetic ALS (inherited; ~5–10% of cases). If familial, ask which gene mutation is involved if they know it (common ones: SOD1, C9orf72, FUS, TDP-43). This affects trial eligibility — many gene-targeted trials require a confirmed mutation. The patient may skip if unknown. Store as e.g. {\"ALS subtype\": \"sporadic\"} or {\"ALS subtype\": \"familial\", \"ALS gene\": \"SOD1\"}."
+    }
+  ]
+}

data/diseases/duchenne.json

@@ -0,0 +1,13 @@
+{
+  "id": "duchenne",
+  "full_name": "Duchenne Muscular Dystrophy",
+  "synonyms": ["DMD", "Duchenne", "Duchenne muscular dystrophy"],
+  "benchmarks": [
+    {
+      "key": "6MWT",
+      "label": "6-Minute Walk Test",
+      "range": null,
+      "guidance": "The 6-Minute Walk Test (6MWT) measures how far a patient can walk in 6 minutes (in meters). It is the primary endpoint in many DMD trials. Ask the patient for their most recent result if they know it."
+    }
+  ]
+}

data/diseases/friedreichs.json

@@ -0,0 +1,13 @@
+{
+  "id": "friedreichs",
+  "full_name": "Friedreich's Ataxia",
+  "synonyms": ["FA", "Friedreich's ataxia", "Friedreich ataxia", "FRDA"],
+  "benchmarks": [
+    {
+      "key": "SARA",
+      "label": "SARA score",
+      "range": "0-40",
+      "guidance": "SARA (Scale for the Assessment and Rating of Ataxia) scores ataxia severity across gait, stance, sitting, speech, finger chase, nose-finger test, fast alternating movements, and heel-shin test. 0 = no ataxia, 40 = most severe. Ask the patient for their most recent score if they know it."
+    }
+  ]
+}

data/diseases/huntingtons.json

@@ -0,0 +1,19 @@
+{
+  "id": "huntingtons",
+  "full_name": "Huntington's Disease",
+  "synonyms": ["Huntington's", "Huntington's disease", "HD", "Huntington disease"],
+  "benchmarks": [
+    {
+      "key": "TFC",
+      "label": "TFC",
+      "range": "0-13",
+      "guidance": "TFC (Total Functional Capacity) measures ability to engage in work, finances, domestic chores, activities of daily living, and care level. 13 = fully functional, 0 = total dependence. Ask the patient for their most recent score if they know it."
+    },
+    {
+      "key": "CAG repeats",
+      "label": "CAG repeats",
+      "range": null,
+      "guidance": "The number of CAG trinucleotide repeats in the HTT gene. ≥36 repeats is associated with Huntington's; ≥40 is fully penetrant. Many trials stratify by CAG repeat length. Ask the patient if they know their CAG repeat count from genetic testing."
+    }
+  ]
+}

data/diseases/ms.json

@@ -0,0 +1,13 @@
+{
+  "id": "ms",
+  "full_name": "Multiple Sclerosis",
+  "synonyms": ["MS", "multiple sclerosis", "relapsing-remitting MS", "RRMS", "PPMS", "SPMS"],
+  "benchmarks": [
+    {
+      "key": "EDSS",
+      "label": "EDSS",
+      "range": "0-10",
+      "guidance": "EDSS (Expanded Disability Status Scale) measures neurological disability. 0 = normal neurological exam, 10 = death due to MS. Ask the patient for their most recent EDSS score if they know it."
+    }
+  ]
+}

data/diseases/parkinsons.json

@@ -0,0 +1,13 @@
+{
+  "id": "parkinsons",
+  "full_name": "Parkinson's Disease",
+  "synonyms": ["Parkinson's", "Parkinson's disease", "PD", "Parkinsonism"],
+  "benchmarks": [
+    {
+      "key": "MDS-UPDRS III",
+      "label": "MDS-UPDRS III",
+      "range": "0-132",
+      "guidance": "MDS-UPDRS Part III (Movement Disorder Society Unified Parkinson's Disease Rating Scale, motor examination) assesses motor symptoms. Lower is better. Ask the patient for their most recent score if they know it."
+    }
+  ]
+}

data/diseases/pompe.json

@@ -0,0 +1,13 @@
+{
+  "id": "pompe",
+  "full_name": "Pompe Disease",
+  "synonyms": ["Pompe", "Pompe disease", "glycogen storage disease type II", "acid maltase deficiency", "GSDII"],
+  "benchmarks": [
+    {
+      "key": "6MWT",
+      "label": "6-Minute Walk Test",
+      "range": null,
+      "guidance": "The 6-Minute Walk Test (6MWT) measures how far a patient can walk in 6 minutes (in meters). It is used as a key functional endpoint in Pompe disease trials. Ask the patient for their most recent result if they know it."
+    }
+  ]
+}

data/diseases/sma.json

@@ -0,0 +1,19 @@
+{
+  "id": "sma",
+  "full_name": "Spinal Muscular Atrophy",
+  "synonyms": ["SMA", "spinal muscular atrophy", "SMA type 1", "SMA type 2", "SMA type 3"],
+  "benchmarks": [
+    {
+      "key": "HFMS",
+      "label": "HFMS",
+      "range": "0-40",
+      "guidance": "HFMS (Hammersmith Functional Motor Scale) assesses motor function. Ask the patient for their most recent score if they know it."
+    },
+    {
+      "key": "SMA type",
+      "label": "SMA type",
+      "range": null,
+      "guidance": "SMA type affects trial eligibility. Type 1 (never sat), Type 2 (sits but never walked), Type 3 (walked independently, onset after 18 months). Ask the patient which type they have."
+    }
+  ]
+}

data/tools/identify_disease.json

@@ -0,0 +1,10 @@
+{
+  "type": "object",
+  "properties": {
+    "standardized_name": {
+      "type": "string",
+      "description": "Full standardized medical name of the patient's disease (e.g. 'Amyotrophic Lateral Sclerosis')"
+    }
+  },
+  "required": ["standardized_name"]
+}

data/tools/search_trials.json

@@ -0,0 +1,23 @@
+{
+  "type": "object",
+  "properties": {
+    "condition": {
+      "type": "string",
+      "description": "Disease / condition to search (medical name and/or abbreviation)"
+    },
+    "lat": { "type": "number", "description": "Patient latitude" },
+    "lon": { "type": "number", "description": "Patient longitude" },
+    "radius_miles": { "type": "integer", "description": "Search radius in miles" },
+    "phases": {
+      "type": "array",
+      "items": { "type": "string" },
+      "description": "Phase numbers to filter e.g. ['1','2','3']. IMPORTANT: Never enumerate all phases to mean 'all phases' — pass an empty array [] instead. NA-phase trials (device feasibility, unphased studies) only appear when phases=[] (no filter). Ignored for EAP."
+    },
+    "study_type": {
+      "type": "string",
+      "enum": ["INTERVENTIONAL", "EXPANDED_ACCESS", "OBSERVATIONAL"],
+      "description": "INTERVENTIONAL (default) for clinical trials; EXPANDED_ACCESS for EAP/compassionate use; OBSERVATIONAL for observational studies."
+    }
+  },
+  "required": ["condition", "lat", "lon", "radius_miles"]
+}

data/tools/submit_profile.json

@@ -0,0 +1,46 @@
+{
+  "type": "object",
+  "properties": {
+    "disease": {
+      "type": "string",
+      "description": "Full medical name (e.g. 'Amyotrophic Lateral Sclerosis')"
+    },
+    "age": { "type": "integer" },
+    "onset_months": {
+      "type": "integer",
+      "description": "Months since first symptom onset"
+    },
+    "diagnosis_months": {
+      "type": "integer",
+      "description": "Months since formal/official diagnosis"
+    },
+    "benchmarks": {
+      "type": "object",
+      "description": "Disease-specific scores, e.g. {\"ALSFRS-R\": \"38\"}",
+      "additionalProperties": { "type": "string" }
+    },
+    "zip_code": { "type": "string", "description": "Patient ZIP / postal code" },
+    "country_code": {
+      "type": "string",
+      "description": "ISO 2-letter country code (default US)"
+    },
+    "radius_miles": {
+      "type": "integer",
+      "description": "Search radius in miles from patient location (default 100)"
+    },
+    "phases": {
+      "type": "array",
+      "items": { "type": "string", "enum": ["0", "1", "2", "3", "4", "na"] },
+      "description": "Desired trial phases (0=Early Phase 1, 1=Phase 1, 2=Phase 2, 3=Phase 3, 4=Phase 4, na=Not Applicable). Empty = all phases."
+    },
+    "include_eap": {
+      "type": "boolean",
+      "description": "Whether patient is interested in Expanded Access Programs (compassionate use)"
+    },
+    "include_observational": {
+      "type": "boolean",
+      "description": "Whether patient is interested in observational studies (no experimental treatment; researchers observe and measure outcomes)"
+    }
+  },
+  "required": ["disease", "age", "onset_months", "diagnosis_months", "zip_code"]
+}

models.py

@@ -0,0 +1,77 @@
+from __future__ import annotations
+
+import math
+from dataclasses import dataclass, field
+
+import httpx
+
+
+@dataclass
+class PatientProfile:
+    disease: str
+    age: int
+    onset_months: int
+    diagnosis_months: int = 0
+    benchmarks: dict[str, str] = field(default_factory=dict)
+    zip_code: str = ""
+    country_code: str = "US"
+    lat: float = 0.0
+    lon: float = 0.0
+    radius_miles: int = 100
+    phases: list[str] = field(default_factory=list)
+    include_eap: bool = False
+    include_observational: bool = False
+    lang: str = "en"
+
+    def summary(self) -> str:
+        lines = [
+            f"Disease: {self.disease}",
+            f"Age: {self.age}",
+            f"Symptom onset: {self.onset_months} months ago",
+            f"Formal diagnosis: {self.diagnosis_months} months ago",
+        ]
+        if self.benchmarks:
+            lines.append("Benchmarks: " + ", ".join(f"{k}={v}" for k, v in self.benchmarks.items()))
+        lines.append(
+            f"Location: ZIP {self.zip_code}, {self.country_code} "
+            f"(lat={self.lat:.4f}, lon={self.lon:.4f})"
+        )
+        lines.append(f"Search radius: {self.radius_miles} miles")
+        if self.phases:
+            def _phase_label(p: str) -> str:
+                if p == "0":
+                    return "Early Phase 1"
+                if p == "na":
+                    return "Not Applicable"
+                return f"Phase {p}"
+            labels = [_phase_label(p) for p in self.phases]
+            lines.append(f"Phases: {', '.join(labels)}")
+        interests = ["Clinical trials"]
+        if self.include_observational:
+            interests.append("Observational studies")
+        if self.include_eap:
+            interests.append("Expanded Access Programs (EAP)")
+        lines.append(f"Study type interest: {', '.join(interests)}")
+        return "\n".join(lines)
+
+
+def geocode_zip(zip_code: str, country_code: str = "US") -> tuple[float, float]:
+    resp = httpx.get(
+        "https://nominatim.openstreetmap.org/search",
+        params={"postalcode": zip_code, "country": country_code, "format": "json", "limit": 1},
+        headers={"User-Agent": "Beacon-ClinicalTrialFinder/1.0"},
+        timeout=10,
+    )
+    resp.raise_for_status()
+    results = resp.json()
+    if not results:
+        raise ValueError(f"Cannot geocode ZIP {zip_code!r} in {country_code!r}")
+    return float(results[0]["lat"]), float(results[0]["lon"])
+
+
+def haversine_miles(lat1: float, lon1: float, lat2: float, lon2: float) -> float:
+    R = 3958.8
+    φ1, φ2 = math.radians(lat1), math.radians(lat2)
+    dφ, dλ = math.radians(lat2 - lat1), math.radians(lon2 - lon1)
+    a = math.sin(dφ / 2) ** 2 + math.cos(φ1) * math.cos(φ2) * math.sin(dλ / 2) ** 2
+    return R * 2 * math.atan2(math.sqrt(a), math.sqrt(1 - a))

prompts.py

@@ -0,0 +1,130 @@
+from __future__ import annotations
+
+import json
+from pathlib import Path
+
+_DISEASES_DIR = Path(__file__).parent / "data" / "diseases"
+
+_ALL_DISEASES: list[dict] = [
+    json.loads(p.read_text())
+    for p in sorted(_DISEASES_DIR.glob("*.json"))
+]
+
+
+def lookup_disease_profile(standardized_name: str) -> dict | None:
+    """Match an LLM-normalized disease name to a registry profile."""
+    lower = standardized_name.lower().strip()
+    for disease in _ALL_DISEASES:
+        if disease["full_name"].lower() == lower:
+            return disease
+        for synonym in disease.get("synonyms", []):
+            if synonym.lower() == lower:
+                return disease
+    # Partial containment fallback (e.g. "ALS (Amyotrophic Lateral Sclerosis)")
+    for disease in _ALL_DISEASES:
+        if disease["full_name"].lower() in lower or lower in disease["full_name"].lower():
+            return disease
+    return None
+
+
+
+INTAKE_SYSTEM = """\
+You are Beacon's patient intake specialist for rare disease clinical trials.
+Collect the following through a warm, conversational interview — do NOT present a form.
+
+REQUIRED:
+  • Disease/condition (standardize: "Lou Gehrig's" → "Amyotrophic Lateral Sclerosis")
+  • Patient age
+  • Months since first symptom onset (convert dates/years as needed)
+  • Months since formal/official diagnosis (convert dates/years as needed; may differ from onset)
+  • ZIP/postal code and country for geographic search
+
+OPTIONAL (disease-specific benchmarks):
+  As soon as you know the patient's disease, call identify_disease(standardized_name=...).
+  The tool response will list the benchmark scores to collect for that specific disease.
+  If the disease is not recognized, skip benchmarks and proceed with required fields only.
+  If the patient describes symptoms without naming a disease, ask clarifying questions first.
+
+  • Preferred search radius in miles (default 100)
+  • Study types of interest — ask whether the patient wants:
+      - Clinical trials. Briefly explain the phases so the patient can choose:
+          Early Phase 1 — First-in-human safety testing; tiny doses, very small group (~10–15 people);
+                          no efficacy data yet; highest uncertainty.
+          Phase 1       — Establishes safe dosage range and identifies side effects;
+                          small group (20–80 people); primary goal is safety, not treatment.
+          Phase 2       — Tests whether the treatment works and further evaluates safety;
+                          larger group (100–300 people); patients more likely to receive active drug.
+          Phase 3       — Compares treatment against current standard of care in a large group
+                          (1,000–3,000 people); required for regulatory approval; best efficacy evidence.
+          Phase 4       — Post-approval surveillance; treatment is already FDA-approved;
+                          studies long-term safety, rare side effects, and new uses.
+          Not Applicable — Studies that do not fall into the standard phase framework
+                          (e.g., device feasibility studies, behavioral/observational trials,
+                          or studies where phase designation is not required by FDA).
+      - Observational studies — studies where researchers observe participants and collect
+        data without assigning treatments. No experimental drug or intervention is given.
+        Patients may contribute valuable data to disease understanding, registries, or
+        natural history studies. Often have broader eligibility than interventional trials.
+      - Expanded Access Programs (EAP / compassionate use) — a pathway for patients who
+        do not qualify for or cannot access a clinical trial to receive an investigational
+        drug, biologic, or device outside of a trial. Also called "compassionate use."
+        The treatment is not yet FDA-approved; a physician must submit the EAP request
+        to the drug sponsor and obtain FDA authorization. EAP does not guarantee efficacy
+        but may be an option when no approved treatments remain.
+      - Or any combination; or all types (default if no preference)
+
+Ask naturally. You may infer disease synonyms and convert dates to months, but never infer or skip the ZIP/postal code — always ask the patient for it directly. Once you have every required field confirmed by the patient, call submit_profile.\
+"""
+
+
+def build_intake_system() -> str:
+    """Kept for backward compatibility. Returns INTAKE_SYSTEM unchanged."""
+    return INTAKE_SYSTEM
+
+RESEARCH_SYSTEM = """\
+You are Beacon, an expert rare-disease clinical trial navigator.
+You have a search_clinical_trials tool that queries ClinicalTrials.gov in real time.
+Results are already ranked by geographic distance from the patient.
+
+Workflow:
+1. Search for the patient's disease. Use both the full medical name and common abbreviation.
+   - If the patient wants clinical trials, search with study_type="INTERVENTIONAL".
+   - If the patient wants observational studies, also search with study_type="OBSERVATIONAL".
+   - If the patient wants Expanded Access Programs (EAP), also search with study_type="EXPANDED_ACCESS".
+   - Run a separate search for each study_type the patient is interested in.
+2. IMPORTANT — phase filtering: Never pass phases=["1","2","3","4"] to mean "all phases."
+   Always pass phases=[] (omit the field) when the patient has no phase preference.
+   NA-phase trials (device feasibility studies, unphased interventions) only appear
+   when no phase filter is applied. Passing explicit phase numbers silently excludes them.
+   Phase filters do not apply to OBSERVATIONAL or EXPANDED_ACCESS searches.
+3. If fewer than 3 results are found, retry with: a wider radius, a disease synonym,
+   or drop phase filters entirely (phases=[]).
+4. Produce a final report. Use separate sections for Clinical Trials, Observational Studies, and Expanded Access as applicable.
+   List the top 10 results per section ranked by site proximity.
+   For EACH entry use exactly this format (repeat the block per entry):
+
+   📍 **[Closest hospital/facility name]** — [City, State] ([X] mi)
+   **Trial:** [Full title] ([Phase] — or "Observational" / "Expanded Access" as applicable)
+   **Sponsor:** [Lead sponsor]
+   **Principal Investigator:** [Name — or "Not listed" if absent]
+   **Contact:** [Phone number] | [Email address] (use "Not listed" for any missing field)
+   **Summary:** [2–3 sentence plain-language description of what the trial/program is testing
+               and why it may matter for this patient]
+   **Qualification criteria:** [Key inclusion AND exclusion criteria relevant to this patient,
+                               including age range, functional score thresholds, FVC cutoffs,
+                               and any red flags. Be specific — use exact numbers from the data.]
+   **Link:** https://clinicaltrials.gov/study/[NCT_ID]
+
+   ---
+
+5. After the results add a short "Next steps" section (bullet points).
+   For observational studies, note that participation typically involves check-ins, surveys, or sample collection with no experimental treatment.
+   For EAP results, note that patients typically need a physician to submit the EAP request.
+
+IMPORTANT: Only report trials returned by the search_clinical_trials tool. Do NOT suggest,
+list, or recommend any hospitals, centers, or trials that were not in the tool results —
+even well-known institutions. If no results are found, say so clearly and suggest the patient
+ask their neurologist or contact the ALS Association for a referral.
+
+Be accurate. Do not fabricate details. If data is missing, say so.\
+"""

pyproject.toml

@@ -10,5 +10,5 @@ dependencies = [
     "openai>=1.0.0",
     "python-dotenv>=1.2.2",
     "rich>=13.0.0",
-    "gradio>=4.0.0",
+    "gradio>=6.14.0,<7.0.0",
 ]

tools.py

@@ -0,0 +1,49 @@
+from __future__ import annotations
+
+import json
+from pathlib import Path
+
+import anthropic
+
+_DATA = Path(__file__).parent / "data" / "tools"
+
+
+def _load(name: str) -> dict:
+    return json.loads((_DATA / f"{name}.json").read_text())
+
+
+SUBMIT_PROFILE_TOOL: anthropic.types.ToolParam = {
+    "name": "submit_profile",
+    "description": (
+        "Call this when you have collected all required information. "
+        "Standardize the disease name to its full medical term."
+    ),
+    "input_schema": _load("submit_profile"),
+}
+
+IDENTIFY_DISEASE_TOOL: anthropic.types.ToolParam = {
+    "name": "identify_disease",
+    "description": (
+        "Call this as soon as you have identified the patient's disease — "
+        "either from a direct statement or from symptom description. "
+        "The response tells you which benchmark scores to collect for that disease. "
+        "Call this before asking any disease-specific questions."
+    ),
+    "input_schema": _load("identify_disease"),
+}
+
+SEARCH_TRIALS_TOOL: anthropic.types.ToolParam = {
+    "name": "search_clinical_trials",
+    "description": (
+        "Search ClinicalTrials.gov for studies within a geographic radius. "
+        "Results are pre-ranked by distance from the patient's location. "
+        "Call multiple times with different parameters (synonyms, broader radius, "
+        "different phases) if initial results are sparse. "
+        "Use study_type='EXPANDED_ACCESS' to search for Expanded Access Programs (EAP / compassionate use). "
+        "Use study_type='OBSERVATIONAL' to search for observational studies (no experimental treatment assigned)."
+    ),
+    "input_schema": _load("search_trials"),
+}
+
+INTAKE_TOOLS: list[anthropic.types.ToolParam] = [SUBMIT_PROFILE_TOOL, IDENTIFY_DISEASE_TOOL]
+RESEARCH_TOOLS: list[anthropic.types.ToolParam] = [SEARCH_TRIALS_TOOL]

trials_api.py

@@ -0,0 +1,162 @@
+from __future__ import annotations
+
+import time
+
+import httpx
+
+from beacon_logging import get_logger
+from config import CTGOV_BASE
+from models import haversine_miles
+from _console import console
+
+_logger = get_logger("trials_api")
+
+
+def search_trials_api(
+    condition: str,
+    lat: float,
+    lon: float,
+    radius_miles: int = 100,
+    phases: list[str] | None = None,
+    study_type: str = "INTERVENTIONAL",
+) -> list[dict]:
+    is_eap = study_type == "EXPANDED_ACCESS"
+    is_observational = study_type == "OBSERVATIONAL"
+    params: dict[str, str | int] = {
+        "query.cond": condition,
+        "filter.overallStatus": "AVAILABLE" if is_eap else "RECRUITING",
+        "filter.geo": f"distance({lat},{lon},{radius_miles}mi)",
+        "pageSize": 200,
+        "format": "json",
+    }
+    # aggFilters supports comma-separated keys (e.g. "studyType:exp,phase:3 4").
+    # RECRUITING status already excludes EAPs, so studyType:int is only needed
+    # when no phase filter is applied. studyType:int returns all phases including N/A.
+    # Observational studies use studyType:obs; phases don't apply to them.
+    #
+    # Case matrix:
+    #   EAP only                  → studyType:exp
+    #   EAP + specific phases     → studyType:exp,phase:X Y  (combine both filters)
+    #   EAP + all phases          → studyType:exp  (no phase filter needed)
+    #   Interventional, specific  → phase:X Y
+    #   Interventional, all/NA    → studyType:int  (returns NA trials too)
+    if is_eap:
+        numbered = [p for p in (phases or []) if p != "na"]
+        if numbered:
+            params["aggFilters"] = "studyType:exp,phase:" + " ".join(numbered)
+        else:
+            params["aggFilters"] = "studyType:exp"
+    elif is_observational:
+        params["aggFilters"] = "studyType:obs"
+    elif phases:
+        # Exclude "na" from the phase filter — N/A trials have no phase value to match on;
+        # they appear naturally when no phase filter is applied (studyType:int branch).
+        numbered = [p for p in phases if p != "na"]
+        if numbered:
+            params["aggFilters"] = "phase:" + " ".join(numbered)
+        else:
+            params["aggFilters"] = "studyType:int"
+    else:
+        params["aggFilters"] = "studyType:int"
+
+    _logger.info(
+        "ClinicalTrials.gov API request",
+        extra={"data": {"endpoint": CTGOV_BASE, "params": dict(params)}},
+    )
+
+    all_studies: list[dict] = []
+    while True:
+        for attempt in range(3):
+            try:
+                resp = httpx.get(CTGOV_BASE, params=params, timeout=30)
+                resp.raise_for_status()
+                body = resp.json()
+                break
+            except httpx.HTTPError as exc:
+                if attempt == 2:
+                    raise
+                wait = 2 ** attempt
+                console.print(f"[yellow]API warning:[/yellow] {exc} — retrying in {wait}s (attempt {attempt + 1}/3)…")
+                time.sleep(wait)
+        page_studies = body.get("studies", [])
+        all_studies.extend(page_studies)
+        next_token = body.get("nextPageToken")
+        _logger.debug(
+            "ClinicalTrials.gov API page received",
+            extra={"data": {"page_count": len(page_studies), "has_next_page": bool(next_token)}},
+        )
+        if not next_token:
+            break
+        params["pageToken"] = next_token
+
+    _logger.info(
+        "ClinicalTrials.gov API response complete",
+        extra={"data": {"total_studies": len(all_studies)}},
+    )
+    return all_studies
+
+
+def _flatten_and_rank(studies: list[dict], patient_lat: float, patient_lon: float) -> list[dict]:
+    result = []
+    for study in studies:
+        proto = study.get("protocolSection", {})
+        id_mod = proto.get("identificationModule", {})
+        desc_mod = proto.get("descriptionModule", {})
+        elig_mod = proto.get("eligibilityModule", {})
+        contacts_mod = proto.get("contactsLocationsModule", {})
+        sponsor_mod = proto.get("sponsorCollaboratorsModule", {})
+        design_mod = proto.get("designModule", {})
+
+        central_contacts = contacts_mod.get("centralContacts", [])
+        central_phone = next((c.get("phone", "") for c in central_contacts if c.get("phone")), "")
+        central_email = next((c.get("email", "") for c in central_contacts if c.get("email")), "")
+
+        officials = contacts_mod.get("overallOfficials", [])
+        pi = next(
+            (o.get("name", "") for o in officials if o.get("role") == "PRINCIPAL_INVESTIGATOR"),
+            officials[0].get("name", "") if officials else "",
+        )
+
+        sites_with_dist: list[tuple[float, dict]] = []
+        for loc in contacts_mod.get("locations", []):
+            geo = loc.get("geoPoint", {})
+            if geo.get("lat") and geo.get("lon"):
+                d = haversine_miles(patient_lat, patient_lon, geo["lat"], geo["lon"])
+                loc_contacts = loc.get("contacts", [])
+                loc_phone = next((c.get("phone", "") for c in loc_contacts if c.get("phone")), "")
+                loc_email = next((c.get("email", "") for c in loc_contacts if c.get("email")), "")
+                sites_with_dist.append((d, {
+                    "label": (
+                        f"{loc.get('facility', '').strip()} — "
+                        f"{loc.get('city', '')}, "
+                        f"{loc.get('state', loc.get('country', ''))} "
+                        f"({d:.0f} mi)"
+                    ),
+                    "facility": loc.get("facility", "").strip(),
+                    "city": loc.get("city", ""),
+                    "state": loc.get("state", loc.get("country", "")),
+                    "distance_miles": round(d, 1),
+                    "phone": loc_phone or central_phone,
+                    "email": loc_email or central_email,
+                }))
+        sites_with_dist.sort(key=lambda x: x[0])
+
+        closest_dist = sites_with_dist[0][0] if sites_with_dist else None
+        result.append({
+            "nct_id": id_mod.get("nctId", ""),
+            "title": id_mod.get("briefTitle", ""),
+            "phase": ", ".join(design_mod.get("phases", [])) or "N/A",
+            "sponsor": sponsor_mod.get("leadSponsor", {}).get("name", ""),
+            "principal_investigator": pi,
+            "contact_phone": central_phone,
+            "contact_email": central_email,
+            "summary": desc_mod.get("briefSummary", "")[:500],
+            "eligibility": elig_mod.get("eligibilityCriteria", "")[:1000],
+            "min_age": elig_mod.get("minimumAge", ""),
+            "max_age": elig_mod.get("maximumAge", ""),
+            "closest_site_miles": round(closest_dist, 1) if closest_dist is not None else None,
+            "nearest_sites": [info for _, info in sites_with_dist[:5]],
+        })
+
+    result.sort(key=lambda x: x["closest_site_miles"] if x["closest_site_miles"] is not None else float("inf"))
+    return result

uv.lock

@@ -135,7 +135,7 @@ dependencies = [
 [package.metadata]
 requires-dist = [
     { name = "anthropic", specifier = ">=0.50.0" },
-    { name = "gradio", specifier = ">=4.0.0" },
+    { name = "gradio", specifier = ">=6.14.0,<7.0.0" },
     { name = "langgraph", specifier = ">=1.2.0" },
     { name = "openai", specifier = ">=1.0.0" },
     { name = "python-dotenv", specifier = ">=1.2.2" },