Upload 21 files

.env.example

@@ -0,0 +1,4 @@
+# Local vLLM endpoint (no API key needed)
+LLM_BASE_URL=http://localhost:8000/v1
+LLM_MODEL=/model
+APP_PORT=8090

.gitattributes

@@ -1,35 +1,35 @@
-*.7z filter=lfs diff=lfs merge=lfs -text
-*.arrow filter=lfs diff=lfs merge=lfs -text
-*.bin filter=lfs diff=lfs merge=lfs -text
-*.bz2 filter=lfs diff=lfs merge=lfs -text
-*.ckpt filter=lfs diff=lfs merge=lfs -text
-*.ftz filter=lfs diff=lfs merge=lfs -text
-*.gz filter=lfs diff=lfs merge=lfs -text
-*.h5 filter=lfs diff=lfs merge=lfs -text
-*.joblib filter=lfs diff=lfs merge=lfs -text
-*.lfs.* filter=lfs diff=lfs merge=lfs -text
-*.mlmodel filter=lfs diff=lfs merge=lfs -text
-*.model filter=lfs diff=lfs merge=lfs -text
-*.msgpack filter=lfs diff=lfs merge=lfs -text
-*.npy filter=lfs diff=lfs merge=lfs -text
-*.npz filter=lfs diff=lfs merge=lfs -text
-*.onnx filter=lfs diff=lfs merge=lfs -text
-*.ot filter=lfs diff=lfs merge=lfs -text
-*.parquet filter=lfs diff=lfs merge=lfs -text
-*.pb filter=lfs diff=lfs merge=lfs -text
-*.pickle filter=lfs diff=lfs merge=lfs -text
-*.pkl filter=lfs diff=lfs merge=lfs -text
-*.pt filter=lfs diff=lfs merge=lfs -text
-*.pth filter=lfs diff=lfs merge=lfs -text
-*.rar filter=lfs diff=lfs merge=lfs -text
-*.safetensors filter=lfs diff=lfs merge=lfs -text
-saved_model/**/* filter=lfs diff=lfs merge=lfs -text
-*.tar.* filter=lfs diff=lfs merge=lfs -text
-*.tar filter=lfs diff=lfs merge=lfs -text
-*.tflite filter=lfs diff=lfs merge=lfs -text
-*.tgz filter=lfs diff=lfs merge=lfs -text
-*.wasm filter=lfs diff=lfs merge=lfs -text
-*.xz filter=lfs diff=lfs merge=lfs -text
-*.zip filter=lfs diff=lfs merge=lfs -text
-*.zst filter=lfs diff=lfs merge=lfs -text
-*tfevents* filter=lfs diff=lfs merge=lfs -text
+*.7z filter=lfs diff=lfs merge=lfs -text
+*.arrow filter=lfs diff=lfs merge=lfs -text
+*.bin filter=lfs diff=lfs merge=lfs -text
+*.bz2 filter=lfs diff=lfs merge=lfs -text
+*.ckpt filter=lfs diff=lfs merge=lfs -text
+*.ftz filter=lfs diff=lfs merge=lfs -text
+*.gz filter=lfs diff=lfs merge=lfs -text
+*.h5 filter=lfs diff=lfs merge=lfs -text
+*.joblib filter=lfs diff=lfs merge=lfs -text
+*.lfs.* filter=lfs diff=lfs merge=lfs -text
+*.mlmodel filter=lfs diff=lfs merge=lfs -text
+*.model filter=lfs diff=lfs merge=lfs -text
+*.msgpack filter=lfs diff=lfs merge=lfs -text
+*.npy filter=lfs diff=lfs merge=lfs -text
+*.npz filter=lfs diff=lfs merge=lfs -text
+*.onnx filter=lfs diff=lfs merge=lfs -text
+*.ot filter=lfs diff=lfs merge=lfs -text
+*.parquet filter=lfs diff=lfs merge=lfs -text
+*.pb filter=lfs diff=lfs merge=lfs -text
+*.pickle filter=lfs diff=lfs merge=lfs -text
+*.pkl filter=lfs diff=lfs merge=lfs -text
+*.pt filter=lfs diff=lfs merge=lfs -text
+*.pth filter=lfs diff=lfs merge=lfs -text
+*.rar filter=lfs diff=lfs merge=lfs -text
+*.safetensors filter=lfs diff=lfs merge=lfs -text
+saved_model/**/* filter=lfs diff=lfs merge=lfs -text
+*.tar.* filter=lfs diff=lfs merge=lfs -text
+*.tar filter=lfs diff=lfs merge=lfs -text
+*.tflite filter=lfs diff=lfs merge=lfs -text
+*.tgz filter=lfs diff=lfs merge=lfs -text
+*.wasm filter=lfs diff=lfs merge=lfs -text
+*.xz filter=lfs diff=lfs merge=lfs -text
+*.zip filter=lfs diff=lfs merge=lfs -text
+*.zst filter=lfs diff=lfs merge=lfs -text
+*tfevents* filter=lfs diff=lfs merge=lfs -text

.gitignore

@@ -0,0 +1,9 @@
+__pycache__/
+*.pyc
+*.pyo
+.env
+*.egg-info/
+.DS_Store
+model/
+*.safetensors
+*.bin

Dockerfile

@@ -0,0 +1,18 @@
+FROM python:3.12-slim
+
+RUN useradd -m -u 1000 user
+USER user
+ENV PATH="/home/user/.local/bin:$PATH"
+
+WORKDIR /app
+
+COPY --chown=user ./requirements.txt requirements.txt
+RUN pip install --no-cache-dir --upgrade -r requirements.txt
+
+COPY --chown=user . /app
+
+ENV DEMO_MODE=true
+ENV LLM_BASE_URL=http://localhost:8000/v1
+ENV LLM_MODEL=/model
+
+CMD ["uvicorn", "main:app", "--host", "0.0.0.0", "--port", "7860"]

README.md

@@ -1,12 +1,421 @@
+<div align="center">
+
+<img src="https://img.shields.io/badge/AMD_Instinct-MI300X-ED1C24?style=for-the-badge&logo=amd&logoColor=white" />
+<img src="https://img.shields.io/badge/ROCm-Stack-ED1C24?style=for-the-badge&logo=amd&logoColor=white" />
+<img src="https://img.shields.io/badge/vLLM-Inference-6D28D9?style=for-the-badge" />
+<img src="https://img.shields.io/badge/Qwen-Multimodal-0EA5E9?style=for-the-badge" />
+<img src="https://img.shields.io/badge/FastAPI-0.115-009688?style=for-the-badge&logo=fastapi&logoColor=white" />
+<img src="https://img.shields.io/badge/Python-3.12+-3776AB?style=for-the-badge&logo=python&logoColor=white" />
+
+<br /><br />
+
+# 🏥 MediAgent
+
+### Autonomous Multi-Agent Medical Imaging Analysis System
+
+**Five specialized AI agents. One radiological verdict. Running entirely on AMD.**
+
+*AMD Developer Hackathon 2026 · Track: Vision & Multimodal AI*
+
+<br />
+
+> Built by **Ramyar** — Security researcher & full-stack developer, Sulaymaniyah, Iraq
+
+</div>
+
+---
+
+## What Is MediAgent?
+
+MediAgent is a production-grade autonomous AI system that analyzes medical images — X-rays, MRI scans, CT scans — through a five-agent pipeline and generates structured, peer-reviewed clinical radiology reports in real time.
+
+Upload an image. Watch five AI agents execute live. Get a formal radiology report with differential diagnoses, ICD-10 codes, a quality score, and a FHIR R4 export ready for any EMR system.
+
+**No cloud APIs. No OpenAI. No Nvidia.**
+Pure AMD MI300X inference. Local. Private. Fast.
+
+---
+
+## The Pipeline
+
+```
+┌─────────────────────────────────────────────────────────────────────┐
+│                        IMAGE UPLOAD                                 │
+│              PNG / JPG / DICOM (.dcm) — up to 20 MB                │
+└──────────────────────────┬──────────────────────────────────────────┘
+                           │
+          ┌────────────────┴────────────────┐
+          │         PARALLEL STAGE          │
+          ▼                                 ▼
+┌─────────────────┐               ┌─────────────────┐
+│  INTAKE AGENT   │               │  VISION AGENT   │
+│                 │               │                 │
+│ • Validates     │               │ • Multimodal    │
+│   image payload │               │   Qwen analysis │
+│ • Normalizes    │               │ • Anatomical    │
+│   clinical text │               │   findings      │
+│ • Extracts      │               │ • Severity per  │
+│   demographics  │               │   region        │
+│ • Safety triage │               │ • Confidence    │
+│   (16 keywords) │               │   scoring       │
+│ • Modality hint │               │ • Anomaly flags │
+└────────┬────────┘               └────────┬────────┘
+         └──────────────┬──────────────────┘
+                        │
+                        ▼
+            ┌───────────────────────┐
+            │    RESEARCH AGENT     │
+            │                       │
+            │ • KB cross-reference  │
+            │   (15 conditions)     │
+            │ • Demographic weight  │
+            │ • Ranked differentials│
+            │ • ICD-10 codes        │
+            │ • Match probabilities │
+            └───────────┬───────────┘
+                        │
+                        ▼
+            ┌───────────────────────┐
+            │     REPORT AGENT      │
+            │                       │
+            │ • ACR/NICE format     │
+            │ • Clinical history    │
+            │ • Technique section   │
+            │ • Findings narrative  │
+            │ • Impression + top Dx │
+            │ • Recommendations     │
+            └───────────┬───────────┘
+                        │
+                        ▼
+            ┌───────────────────────┐
+            │     CRITIC AGENT      │
+            │                       │
+            │ • Cross-validates     │
+            │   report vs findings  │
+            │ • Quality score 0-100 │
+            │ • Uncertainty flags   │
+            │ • Disclaimer enforce  │
+            └───────────┬───────────┘
+                        │
+                        ▼
+┌─────────────────────────────────────────────────────────────────────┐
+│                      FINAL REPORT                                   │
+│         Structured JSON · PDF Export · FHIR R4 DiagnosticReport    │
+└─────────────────────────────────────────────────────────────────────┘
+```
+
+INTAKE and VISION execute **concurrently** — cutting wall-clock latency by running the two most expensive operations in parallel. Everything downstream sequences after both complete.
+
+---
+
+## AMD Hardware Stack
+
+| Component | Technology |
+|---|---|
+| **GPU** | AMD Instinct MI300X |
+| **GPU Software** | ROCm — AMD's open-source GPU compute platform |
+| **Inference Server** | vLLM (ROCm build) at `localhost:8000/v1` |
+| **Model** | Qwen multimodal — native vision + text |
+| **Backend** | FastAPI 0.115 + Uvicorn |
+| **Frontend** | Vanilla JS + Tailwind CSS + SSE streaming |
+
+This project is a direct proof of concept that AMD's ROCm stack is **production-viable for real-world medical AI**. Every inference call — vision analysis, clinical normalization, report synthesis, peer review, post-report chat — runs on AMD MI300X. Zero CUDA dependency. Zero cloud API calls.
+
+---
+
+## Key Features
+
+### 🔴 Real-Time SSE Streaming
+Watch the pipeline execute live, agent by agent. Every status transition — WAITING → RUNNING → DONE — streams to the dashboard as it happens via Server-Sent Events. Per-agent runtime counters track exactly how long each step takes.
+
+### 👁️ Multimodal Vision Analysis
+Qwen processes the raw medical image natively. It returns structured JSON: detected modality, technical quality assessment, per-region findings with anatomical names, radiological descriptions, severity levels (NORMAL / INCIDENTAL / SIGNIFICANT / CRITICAL), confidence scores (0–100), and anomaly flags.
+
+### 🔬 Medical Knowledge Base + ICD-10 Mapping
+The Research Agent cross-references vision findings against 15 curated clinical conditions spanning pulmonary, neurological, abdominal, musculoskeletal, and vascular pathology. Every differential diagnosis comes with an ICD-10 code, match probability, and a sentence explaining exactly why the condition matches the findings.
+
+### 🛡️ Critic Agent QA
+Every report goes through a peer-review pass before delivery. The Critic checks that all anomalies from the Vision Agent appear in the report, flags low-confidence findings, assigns a quality score (completeness 30% + accuracy 40% + safety 20% + compliance 10%), and hard-caps the score at 40/100 if a core agent failed.
+
+### 🏥 DICOM Support
+Upload real `.dcm` files. MediAgent extracts 20+ metadata fields — patient name, study date, institution, modality, body part, KVP, slice thickness, pixel spacing, image dimensions — and pre-populates the intake form automatically. MONOCHROME1 inversion and multi-frame handling included.
+
+### 📋 FHIR R4 Export
+Every report can be exported as a fully conformant HL7 FHIR R4 DiagnosticReport resource. Includes an inline Patient resource, Observation resources, LOINC and SNOMED CT codes, severity mapping, full report text in `presentedForm`, and custom extensions for AI quality score and pipeline status. Ready to import into Epic, Cerner, or any FHIR-capable EMR.
+
+### 💬 Post-Report Clinical Chat
+After the report is delivered, a ClinicalAdvisorAgent is available for follow-up questions. It answers in 2–4 sentences with direct reference to the report findings. Qwen's thinking/reasoning mode is explicitly disabled — answers are fast, direct, and clinical.
+
+### 🔒 Hard Safety Enforcement
+- **16 deterministic safety keywords** — chest pain, stroke symptoms, acute trauma, hemoptysis, sepsis, spinal trauma, and more — trigger urgent flags regardless of LLM output.
+- **Age-based alerts** — pediatric (<18) and geriatric (>75) cases are automatically flagged for expert review.
+- **Mandatory AI disclaimer** — enforced at two independent layers (Report Agent + Critic Agent) and cannot be bypassed or modified by the LLM.
+- **Graceful degradation** — the pipeline produces a report even if individual agents fail, always marking what succeeded and what didn't.
+
+### 📄 Client-Side PDF Export
+Full radiology report exported as a formatted PDF directly in the browser using jsPDF — severity color banner, all six report sections, DICOM metadata, QA score. No server round-trip needed.
+
+---
+
+## Agent Architecture
+
+### IntakeAgent
+Validates the image payload (minimum size, valid base64), applies deterministic safety triage, and normalizes clinical language. For simple inputs under 120 characters it skips the LLM entirely and uses a built-in layman-to-medical term map (22 entries: "can't breathe" → "dyspnea", "lump" → "mass/nodule", "dizzy" → "dizziness/vertigo", etc.). Only calls the LLM for complex clinical narratives with comorbidities or medical history. Falls back cleanly to raw input preservation if the LLM is unavailable.
+
+### VisionAgent
+Sends the base64 image and clinical context to Qwen at temperature 0.0 with a strict JSON schema enforced via system prompt. Handles malformed enum values from the LLM with safe conversion fallbacks — a single bad field never drops a finding. Tracks token usage and anomaly counts in the output metadata.
+
+### ResearchAgent
+Pre-filters the knowledge base to only conditions compatible with the detected modality before sending to the LLM — reducing prompt size and improving accuracy. Enforces strict output rules: only conditions from the KB, 2–4 differentials maximum, 5% minimum probability, exact ICD-10 codes, and evidence sentences that actually explain the match.
+
+### ReportAgent
+Builds a structured prompt with clearly labeled sections — clinical history, imaging technique, findings block, differentials block — and asks the LLM to synthesize them into a formal ACR/NICE radiology report. The disclaimer is overwritten to the exact regulatory string after LLM generation, unconditionally.
+
+### CriticAgent
+Operates at temperature 0.0 for fully deterministic QA. Receives the draft report and the full pipeline state including raw vision findings. Checks every anomaly is accounted for, flags low-confidence observations, and appends a `[QUALITY ASSESSMENT]` block to the recommendations section with score, issues, and uncertainty warnings.
+
+### ClinicalAdvisorAgent
+Activated only after report delivery, scoped to the specific report's findings. Strips all Qwen thinking output via multi-layer regex before returning the answer — handles `<think>` XML blocks, markdown think fences, and plain-text reasoning preambles.
+
+---
+
+## LLM Client
+
+The `LLMClient` wraps the OpenAI Python SDK pointed at the local vLLM endpoint. It handles:
+
+- Text completions with optional JSON mode enforcement
+- Multimodal completions with base64 image injection
+- Token-level streaming with an `on_token` callback
+- 3-attempt retry loop with 1-second flat backoff
+- 90-second timeout per call
+- Dual-strategy JSON extraction: direct parse first, then character-by-character brace-matching fallback for responses where the LLM adds conversational padding
+
+---
+
+## Medical Knowledge Base
+
+15 conditions covering the most common radiological findings across all supported modalities:
+
+| Condition | ICD-10 | Modalities | Severity |
+|---|---|---|---|
+| Community-Acquired Pneumonia | J18.9 | X-RAY, CT | SIGNIFICANT |
+| Cardiogenic Pulmonary Edema | J81.0 | X-RAY, CT | CRITICAL |
+| Pleural Effusion | J90 | X-RAY, CT, MRI | SIGNIFICANT |
+| Spontaneous Pneumothorax | J93.9 | X-RAY, CT | CRITICAL |
+| Intracerebral Hemorrhage | I61.9 | CT, MRI | CRITICAL |
+| Ischemic Stroke | I63.9 | CT, MRI | CRITICAL |
+| Intracranial Neoplasm | C71.9 | MRI, CT | SIGNIFICANT |
+| Abdominal Aortic Aneurysm | I71.4 | CT, MRI | CRITICAL |
+| Nephrolithiasis | N20.0 | CT, X-RAY | SIGNIFICANT |
+| Small Bowel Obstruction | K56.6 | X-RAY, CT | SIGNIFICANT |
+| Long Bone Fracture | S82.902 | X-RAY, CT | SIGNIFICANT |
+| Degenerative Joint Disease | M19.90 | X-RAY, MRI | INCIDENTAL |
+| Hepatic Steatosis | K76.0 | CT, MRI | INCIDENTAL |
+| Herniated Disc | M51.16 | MRI, CT | SIGNIFICANT |
+| Pulmonary Nodule | R91.1 | X-RAY, CT | SIGNIFICANT |
+
+---
+
+## API Reference
+
+| Method | Endpoint | Description |
+|---|---|---|
+| `GET` | `/` | Clinical dashboard UI |
+| `GET` | `/health` | System health, version, active sessions |
+| `GET` | `/metrics/gpu` | Live AMD GPU metrics (util, VRAM, temp, power) |
+| `POST` | `/analyze` | Synchronous pipeline → full JSON report |
+| `POST` | `/analyze/stream` | Real-time SSE streaming pipeline |
+| `GET` | `/status/{report_id}` | Poll live pipeline state |
+| `POST` | `/chat/{report_id}` | Post-report clinical Q&A |
+| `GET` | `/api/docs` | Swagger UI |
+| `GET` | `/api/redoc` | ReDoc UI |
+
+### `/analyze/stream` — SSE Event Types
+
+```json
+// Agent status update (emitted on every state transition)
+{"agent": "VISION", "status": "RUNNING"}
+{"agent": "VISION", "status": "DONE"}
+
+// Final report (emitted when pipeline completes)
+{"type": "report", "data": {...}, "report_id": "REP-A3F9C2D1B4E7"}
+
+// Error
+{"type": "error", "message": "Pipeline produced no report"}
+```
+
+### Form Fields (`/analyze`, `/analyze/stream`)
+
+| Field | Type | Required | Notes |
+|---|---|---|---|
+| `image` | File | ✅ | PNG, JPG, or DICOM (.dcm), max 20 MB |
+| `symptoms` | string | — | Free-text chief complaint |
+| `age` | integer | — | 0–120 |
+| `sex` | string | — | `M`, `F`, or `O` |
+| `clinical_context` | string | — | Medical history, referral details |
+
+---
+
+## Data Models
+
+```
+PatientInput
+    └── image_base64, symptoms, age, sex, clinical_context
+
+PipelineState
+    ├── agent_statuses: {INTAKE, VISION, RESEARCH, REPORT, CRITIC}
+    ├── intake_output: IntakeOutput
+    ├── vision_output: VisionOutput
+    │       └── findings: [VisionFinding, ...]
+    │               └── anatomical_region, description, severity,
+    │                   confidence, confidence_score, is_anomaly
+    ├── research_output: ResearchOutput
+    │       └── differential_diagnoses: [KnowledgeMatch, ...]
+    │               └── condition_name, match_probability,
+    │                   supporting_evidence, differential_rank, icd10_code
+    ├── report_draft: ReportSection
+    │       └── clinical_history, technique, findings, impression,
+    │           recommendations, disclaimer
+    └── final_report: FinalReport
+            └── report_id, patient_metadata, sections, vision_summary,
+                research_summary, overall_severity, agent_pipeline_status,
+                generation_timestamp
+```
+
+---
+
+## Project Structure
+
+```
+mediagent/
+├── main.py                  ← FastAPI server, all routes, SSE orchestration
+├── core/
+│   ├── llm.py               ← LLM client (retry, vision, streaming, JSON extraction)
+│   ├── models.py            ← All Pydantic v2 data models
+│   ├── pipeline.py          ← Parallel pipeline orchestrator
+│   ├── dicom.py             ← DICOM parser (pydicom + numpy + Pillow)
+│   └── fhir.py              ← FHIR R4 DiagnosticReport builder
+├── agents/
+│   ├── intake.py            ← Input validation, normalization, safety triage
+│   ├── vision.py            ← Multimodal image analysis
+│   ├── research.py          ← KB matching, ICD-10, differential diagnosis
+│   ├── report.py            ← ACR/NICE radiology report synthesis
+│   ├── critic.py            ← QA validation, quality scoring
+│   └── advisor.py           ← Post-report clinical Q&A
+├── static/
+│   └── index.html           ← Full dashboard (Tailwind + Chart.js + SSE)
+├── requirements.txt
+└── .env.example
+```
+
+---
+
+## Getting Started
+
+### Prerequisites
+
+- Python 3.12+
+- vLLM running a Qwen multimodal model on ROCm, accessible at `http://localhost:8000/v1`
+- ROCm-compatible AMD GPU (MI300X recommended)
+
+### Installation
+
+```bash
+# Clone the repository
+git clone https://github.com/Ramyar2007/mediagent
+cd mediagent
+
+# Install Python dependencies
+pip install -r requirements.txt
+
+# Configure environment
+cp .env.example .env
+# Edit .env and set LLM_BASE_URL to your vLLM endpoint
+```
+
+### Environment Variables
+
+```env
+LLM_BASE_URL=http://localhost:8000/v1   # vLLM OpenAI-compatible endpoint
+LLM_MODEL=/model                         # Model path served by vLLM
+APP_PORT=8090                            # Server port
+```
+
+### Run
+
+```bash
+python main.py
+```
+
+Dashboard available at **http://localhost:8090**
+
+Swagger docs at **http://localhost:8090/api/docs**
+
 ---
-title: MediAgent
-emoji: 🏆
-colorFrom: indigo
-colorTo: green
-sdk: docker
-pinned: false
-license: mit
-short_description: Autonomous 5-agent medical imaging pipeline
+
+## Dependencies
+
+| Package | Version | Purpose |
+|---|---|---|
+| `fastapi` | 0.115.6 | Web framework |
+| `uvicorn[standard]` | 0.34.0 | ASGI server |
+| `openai` | 1.58.1 | SDK for vLLM OpenAI-compatible API |
+| `python-multipart` | 0.0.20 | Multipart form / file upload |
+| `pydantic` | 2.10.5 | Data validation and serialization |
+| `Pillow` | 11.1.0 | Image processing for DICOM conversion |
+| `pydicom` | 2.4.4 | DICOM file parsing and metadata extraction |
+| `numpy` | 1.26.4 | Pixel array normalization for DICOM |
+
+Optional: `amdsmi` Python library — used automatically when available for more accurate GPU metrics than the `rocm-smi` CLI fallback.
+
 ---
 
-Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference
+## Clinical Safety
+
+MediAgent is built with clinical safety as a first-class concern, not an afterthought.
+
+**Mandatory disclaimer** — enforced at two independent code layers and cannot be overridden by any LLM output:
+
+> *"This analysis is AI-generated and must be reviewed by a licensed radiologist before any clinical decisions are made."*
+
+**Hard safety rules that run deterministically, without LLM involvement:**
+- 16 urgent clinical keywords trigger immediate flags before any AI processing
+- Pediatric and geriatric age thresholds auto-flag for specialist review
+- Quality score is hard-capped at 40/100 if core agents (Vision, Report) fail
+- Low-confidence findings are always flagged with confirmatory imaging recommendations
+- The disclaimer is re-enforced after every LLM call, unconditionally
+
+**This system is a decision support tool, not a clinical decision maker.** Every output is intended to assist, not replace, a licensed radiologist.
+
+---
+
+## Dashboard Preview
+
+The single-page clinical dashboard provides:
+
+- **Live pipeline panel** — real-time agent status cards with per-step runtime counters
+- **Analytics tab** — severity distribution donut chart, differential diagnosis confidence bar chart, agent timing bar chart — all populated from structured model output
+- **Report panel** — severity banner, safety flags, all six report sections, finding cards color-coded by severity
+- **DICOM metadata card** — study date, institution, modality, body part, technical parameters
+- **PDF export** — full formatted report generated client-side
+- **Clinical chat** — slide-up Q&A panel backed by the ClinicalAdvisorAgent
+- **AMD GPU panel** — live util %, VRAM used/total, temperature, power draw — polling every 3 seconds
+
+---
+
+## Built For
+
+**AMD Developer Hackathon 2026**
+Track: Vision & Multimodal AI
+
+This project demonstrates that AMD's ROCm ecosystem is a complete, production-viable alternative for serious AI workloads. Medical imaging analysis — with real multimodal vision, structured clinical reasoning, and standards-compliant output — running fully on AMD MI300X without a single NVIDIA or cloud dependency.
+
+---
+
+<div align="center">
+
+**Built by Ramyar · Sulaymaniyah, Iraq**
+
+*#AMDDevChallenge · AMD Instinct MI300X · ROCm · vLLM · Qwen*
+
+</div>

agents/advisor.py

@@ -0,0 +1,99 @@
+# mediagent/agents/advisor.py
+"""
+Clinical Advisor Agent for MediAgent.
+Post-report interactive Q&A. Answers follow-up clinical questions
+from radiologists/clinicians in full context of the generated report.
+Acts as a 24/7 senior radiology consultant.
+"""
+
+import logging
+import re
+from typing import Optional
+
+from core.llm import LLMClient
+from core.models import FinalReport
+
+logger = logging.getLogger(__name__)
+
+
+class ClinicalAdvisorAgent:
+    """
+    Interactive clinical consultation agent activated after report generation.
+    Answers follow-up questions with access to all pipeline outputs.
+    Scope is limited to radiological interpretation — no treatment prescriptions.
+    """
+
+    SYSTEM_PROMPT = """You are a senior radiologist consultant. Answer the clinician's question directly and concisely — 2-4 sentences maximum. No preamble, no thinking out loud, no reasoning steps. Just the answer.
+Rules: reference report findings; no fabrication; no medications/dosages; formal radiological tone. If management decision, end with "Clinical correlation recommended." """
+
+    def __init__(self, llm_client: Optional[LLMClient] = None):
+        self.llm = llm_client or LLMClient()
+
+    def answer(self, question: str, report: FinalReport) -> str:
+        """
+        Answer a follow-up clinical question in the context of the generated report.
+
+        Args:
+            question: Free-text clinical question from the user
+            report: The FinalReport from the pipeline
+
+        Returns:
+            str: Clinical answer text
+        """
+        logger.info("💬 Clinical Advisor processing question: %.80s", question)
+
+        sections = report.sections
+        severity = report.overall_severity.value if hasattr(report.overall_severity, "value") else str(report.overall_severity)
+
+        # Send only the most relevant report fields — less tokens = faster response
+        context = (
+            f"Severity: {severity} | Impression: {sections.impression} | "
+            f"Findings: {sections.findings[:600]} | "
+            f"Recommendations: {sections.recommendations[:300]}"
+        )
+
+        prompt = f"Report: {context}\n\nQuestion: {question}\n\nAnswer:"
+
+        result = self.llm.generate_text(
+            prompt=prompt,
+            system_prompt=self.SYSTEM_PROMPT,
+            temperature=0.0,
+            max_tokens=200,
+            # Disable Qwen3 thinking/reasoning mode entirely
+            extra_body={"chat_template_kwargs": {"enable_thinking": False}},
+        )
+
+        if result.get("success") and result.get("content"):
+            answer = self._strip_thinking(result["content"].strip())
+            logger.info("✅ Clinical Advisor answered | tokens=%s", result.get("usage", {}).get("total_tokens", 0))
+            return answer
+
+        logger.warning("⚠️ Clinical Advisor LLM call failed")
+        return "Unable to process this question. Please review the report directly and consult a licensed radiologist."
+
+    @staticmethod
+    def _strip_thinking(text: str) -> str:
+        """
+        Remove all thinking/reasoning output that Qwen and similar models emit.
+        Handles both structured tags and plain-text reasoning patterns.
+        """
+        # Remove <think>...</think> XML blocks
+        text = re.sub(r"<think>.*?</think>", "", text, flags=re.DOTALL)
+        # Remove ```think ... ``` markdown blocks
+        text = re.sub(r"```think.*?```", "", text, flags=re.DOTALL)
+        # Remove plain-text reasoning preambles Qwen3 emits without tags:
+        # "Here's a thinking process: 1. ..." or "Let me think: ..." etc.
+        text = re.sub(
+            r"(?i)^(here'?s?\s+(a\s+)?thinking\s+process:?|let me (think|analyze|consider):?|thinking:?).*?(\n\n|\Z)",
+            "", text, flags=re.DOTALL
+        )
+        # Remove numbered reasoning lists at the start (1. **Title:** ...)
+        text = re.sub(r"^(\s*\d+\.\s+\*\*[^*]+\*\*:.*\n?)+", "", text, flags=re.MULTILINE)
+        # If after stripping we have a clear section break, take only what's after it
+        if "\n\n" in text:
+            parts = [p.strip() for p in text.split("\n\n") if p.strip()]
+            # Take the last substantial chunk (the actual answer)
+            for part in reversed(parts):
+                if len(part) > 20:
+                    return part
+        return text.strip()

agents/critic.py

@@ -0,0 +1,194 @@
+# mediagent/agents/critic.py
+"""
+Critic Agent for MediAgent.
+Final quality control and peer-review layer. Validates report consistency,
+flags low-confidence observations, enforces regulatory disclaimers, assigns
+quality scores, and applies corrective refinements before final delivery.
+"""
+
+import logging
+from typing import Any, Dict, List, Optional
+
+from core.llm import LLMClient
+from core.models import AgentStatus, PipelineState, ReportSection, VisionOutput
+
+logger = logging.getLogger(__name__)
+
+
+class CriticAgent:
+    """
+    Medical QA/QC engine. Cross-validates the synthesized report against
+    upstream agent outputs, detects logical inconsistencies, enforces
+    clinical safety thresholds, and produces a finalized, auditable report.
+    """
+
+    STANDARD_DISCLAIMER = (
+        "This analysis is AI-generated and must be reviewed by a licensed radiologist "
+        "before any clinical decisions are made."
+    )
+
+    SYSTEM_PROMPT = """You are a senior radiology peer-reviewer. Evaluate the draft report against the vision findings and return ONLY valid JSON:
+{"clinical_history":"string","technique":"string","findings":"string","impression":"string","recommendations":"string","disclaimer":"string","quality_score":0-100,"review_issues":["string"],"uncertainty_warnings":["string"]}
+
+Review criteria:
+1. CONSISTENCY: Every vision anomaly must appear in the report. Flag contradictions.
+2. CONFIDENCE: Findings < 50% confidence or LOW → add uncertainty warning, recommend confirmatory imaging.
+3. DISCLAIMER: Must be exactly: "This analysis is AI-generated and must be reviewed by a licensed radiologist before any clinical decisions are made."
+4. TONE: Formal, objective radiological language. No speculative phrasing or definitive claims without imaging evidence.
+5. QUALITY SCORE: completeness 30% + accuracy/consistency 40% + clinical safety 20% + compliance 10%.
+6. Apply corrections directly. No placeholders or TODOs.
+No markdown. Never fabricate findings. Lower score for failed pipeline agents."""
+
+    def __init__(self, llm_client: Optional[LLMClient] = None):
+        self.llm = llm_client or LLMClient()
+        self.last_quality_score: int = 100
+        self.last_review_issues: List[str] = []
+        self.last_uncertainty_warnings: List[str] = []
+
+    def process(self, draft_report: ReportSection, pipeline_state: PipelineState) -> ReportSection:
+        """
+        Execute final peer review and quality enforcement.
+        
+        Args:
+            draft_report: Unreviewed ReportSection from Report Agent
+            pipeline_state: Full execution context including vision findings and agent statuses
+            
+        Returns:
+            ReportSection: Finalized, QA-reviewed clinical report
+        """
+        logger.info("🛡️ Critic Agent initiated final quality review")
+        
+        user_prompt = self._build_review_prompt(draft_report, pipeline_state)
+        
+        result = self.llm.generate_text(
+            prompt=user_prompt,
+            system_prompt=self.SYSTEM_PROMPT,
+            temperature=0.0,
+            force_json=True
+        )
+
+        if not result.get("success"):
+            logger.error(f"❌ Critic LLM call failed: {result.get('error')}")
+            return self._apply_deterministic_qa(draft_report, pipeline_state)
+
+        raw_content = result.get("content", "")
+        parsed = LLMClient.extract_json_from_response(raw_content)
+        if not parsed:
+            logger.warning("⚠️ Failed to parse critic JSON response. Applying deterministic QA.")
+            return self._apply_deterministic_qa(draft_report, pipeline_state)
+
+        try:
+            return self._parse_qa_response(parsed, pipeline_state)
+        except Exception as e:
+            logger.error(f"💥 Critic mapping failed: {e}")
+            return self._apply_deterministic_qa(draft_report, pipeline_state)
+
+    def _build_review_prompt(self, draft: ReportSection, state: PipelineState) -> str:
+        """Format pipeline context and draft report for LLM critique."""
+        # Extract vision findings for cross-reference
+        vision_text = "No vision findings available."
+        if state.vision_output:
+            findings_list = []
+            for f in state.vision_output.findings:
+                findings_list.append(
+                    f"- Region: {f.anatomical_region} | Desc: {f.description} | "
+                    f"Severity: {f.severity.value} | Confidence: {f.confidence.value} ({f.confidence_score}%) | "
+                    f"Anomaly: {f.is_anomaly}"
+                )
+            vision_text = "\n".join(findings_list) if findings_list else "No specific findings."
+
+        # Agent execution status
+        agent_status = ", ".join([f"{k}: {v.value}" for k, v in state.agent_statuses.items()])
+
+        return f"""[PIPELINE EXECUTION STATUS]
+{agent_status}
+
+[VISION AGENT FINDINGS FOR CROSS-REFERENCE]
+{vision_text}
+
+[DRAFT REPORT FOR REVIEW]
+Clinical History: {draft.clinical_history}
+Technique: {draft.technique}
+Findings: {draft.findings}
+Impression: {draft.impression}
+Recommendations: {draft.recommendations}
+Disclaimer: {draft.disclaimer}
+
+Critique the draft against the vision findings and pipeline status. Apply corrections, flag uncertainties, verify compliance, and output the refined JSON report."""
+
+    def _parse_qa_response(self, data: Dict[str, Any], state: PipelineState) -> ReportSection:
+        """Validate, extract, and enforce QA metadata on the report."""
+        # Extract core report fields
+        draft = ReportSection(
+            clinical_history=str(data.get("clinical_history", "Not provided.")),
+            technique=str(data.get("technique", "Imaging technique not specified.")),
+            findings=str(data.get("findings", "No abnormalities detected.")),
+            impression=str(data.get("impression", "Within normal limits.")),
+            recommendations=str(data.get("recommendations", "Routine follow-up as clinically indicated.")),
+            disclaimer=str(data.get("disclaimer", self.STANDARD_DISCLAIMER))
+        )
+
+        # Extract QA metadata
+        self.last_quality_score = int(data.get("quality_score", 85))
+        self.last_review_issues = data.get("review_issues", [])
+        self.last_uncertainty_warnings = data.get("uncertainty_warnings", [])
+
+        # Append QA summary to recommendations for frontend visibility
+        qa_summary = "\n\n[QUALITY ASSESSMENT]\nScore: {score}/100\nIssues: {issues}\nUncertainties: {warnings}".format(
+            score=self.last_quality_score,
+            issues=" | ".join(self.last_review_issues) if self.last_review_issues else "None",
+            warnings=" | ".join(self.last_uncertainty_warnings) if self.last_uncertainty_warnings else "None"
+        )
+        draft.recommendations += qa_summary
+
+        return self._apply_deterministic_qa(draft, state)
+
+    def _apply_deterministic_qa(self, draft: ReportSection, state: PipelineState) -> ReportSection:
+        """Hard-rule safety checks that cannot be overridden by LLM output."""
+        # 1. Enforce exact disclaimer
+        if draft.disclaimer != self.STANDARD_DISCLAIMER:
+            draft.disclaimer = self.STANDARD_DISCLAIMER
+            if self.last_review_issues:
+                self.last_review_issues.append("Disclaimer corrected to regulatory standard.")
+            else:
+                self.last_review_issues = ["Disclaimer corrected to regulatory standard."]
+
+        # 2. Cap quality score if critical pipeline failures occurred
+        critical_failures = [
+            k for k, v in state.agent_statuses.items() 
+            if v == AgentStatus.ERROR and k in ["VISION", "REPORT"]
+        ]
+        if critical_failures:
+            self.last_quality_score = min(self.last_quality_score, 40)
+            self.last_review_issues.append(f"Pipeline degraded: {', '.join(critical_failures)} agents failed.")
+
+        # 3. Flag low-confidence vision findings if not already warned
+        if state.vision_output:
+            low_conf_findings = [
+                f.anatomical_region for f in state.vision_output.findings 
+                if f.confidence.value == "LOW" or f.confidence_score < 50.0
+            ]
+            if low_conf_findings:
+                warning = f"Low confidence observations in: {', '.join(low_conf_findings)}. Confirmatory imaging recommended."
+                if warning not in self.last_uncertainty_warnings:
+                    self.last_uncertainty_warnings.append(warning)
+
+        # 4. Re-append updated QA summary if modified
+        qa_summary = "\n\n[QUALITY ASSESSMENT]\nScore: {score}/100\nIssues: {issues}\nUncertainties: {warnings}".format(
+            score=self.last_quality_score,
+            issues=" | ".join(self.last_review_issues) if self.last_review_issues else "None",
+            warnings=" | ".join(self.last_uncertainty_warnings) if self.last_uncertainty_warnings else "None"
+        )
+        if qa_summary not in draft.recommendations:
+            draft.recommendations += qa_summary
+
+        logger.info(f"✅ Critic Agent completed | QA Score: {self.last_quality_score}/100")
+        return draft
+
+    def _get_fallback_report(self, draft: ReportSection) -> ReportSection:
+        """Safe fallback when critic review cannot be completed."""
+        draft.disclaimer = self.STANDARD_DISCLAIMER
+        self.last_quality_score = 50
+        self.last_review_issues = ["Critic agent unavailable. Report delivered unreviewed."]
+        self.last_uncertainty_warnings = ["Peer review skipped. Manual radiologist verification mandatory."]
+        return self._apply_deterministic_qa(draft, PipelineState())

agents/intake.py

@@ -0,0 +1,216 @@
+# mediagent/agents/intake.py
+"""
+Intake Agent for MediAgent.
+Validates patient submissions, normalizes clinical terminology,
+extracts demographics, detects imaging modality hints, and flags
+urgent safety concerns before routing to downstream agents.
+"""
+
+import logging
+import re
+from typing import Any, Dict, List, Optional
+
+from core.llm import LLMClient
+from core.models import IntakeOutput, ImageModality, PatientInput
+
+logger = logging.getLogger(__name__)
+
+
+class IntakeAgent:
+    """
+    First-stage pipeline agent responsible for input validation,
+    clinical text normalization, demographic extraction, and safety triage.
+    Ensures downstream agents receive structured, standardized input.
+    """
+
+    # Deterministic safety keywords for immediate flagging
+    SAFETY_KEYWORDS = [
+        "acute trauma", "chest pain", "shortness of breath", "dyspnea",
+        "stroke symptoms", "neurological deficit", "hemoptysis", "massive bleed",
+        "pediatric emergency", "pregnant", "anaphylaxis", "sepsis", "fever",
+        "head injury", "spinal trauma", "acute abdomen", "suspected fracture"
+    ]
+
+    MODALITY_KEYWORDS = {
+        "x-ray": ImageModality.XRAY,
+        "xr": ImageModality.XRAY,
+        "radiograph": ImageModality.XRAY,
+        "ct scan": ImageModality.CT,
+        "ct": ImageModality.CT,
+        "computed tomography": ImageModality.CT,
+        "mri": ImageModality.MRI,
+        "magnetic resonance": ImageModality.MRI,
+        "mammogram": ImageModality.XRAY,  # Technically X-ray based
+    }
+
+    def __init__(self, llm_client: Optional[LLMClient] = None):
+        self.llm = llm_client or LLMClient()
+
+    def process(self, patient_input: PatientInput) -> IntakeOutput:
+        """
+        Main intake processing method.
+        
+        Args:
+            patient_input: Raw validated patient submission
+            
+        Returns:
+            IntakeOutput: Structured, normalized, safety-checked data
+        """
+        logger.info("📋 Intake Agent processing initiated")
+        
+        # 1. Validate image payload
+        if not self._validate_image_payload(patient_input.image_base64):
+            logger.warning("⚠️ Image payload validation failed. Proceeding with warnings.")
+            
+        # 2. Apply deterministic safety triage
+        safety_flags = self._check_deterministic_safety(patient_input)
+        
+        # 3. Clinical normalization & demographic extraction via LLM
+        structured_data = self._normalize_with_llm(patient_input, safety_flags)
+        
+        # 4. Enrich modality detection
+        modality = self._infer_modality(patient_input, structured_data)
+        
+        # 5. Assemble & validate output
+        try:
+            output = IntakeOutput(
+                validated=True,
+                standardized_symptoms=structured_data.get("standardized_symptoms", patient_input.symptoms or ""),
+                extracted_demographics=structured_data.get("extracted_demographics", {}),
+                safety_flags=list(set(safety_flags + structured_data.get("safety_flags", []))),
+                recommended_modality=modality,
+                processing_notes=structured_data.get("processing_notes", "")
+            )
+            logger.info("✅ Intake Agent completed successfully")
+            return output
+        except Exception as e:
+            logger.error(f"💥 IntakeOutput validation failed: {e}")
+            return self._get_fallback_output(patient_input, safety_flags)
+
+    def _validate_image_payload(self, base64_data: str) -> bool:
+        """Validate base64 image integrity and size constraints."""
+        if not base64_data or len(base64_data) < 500:
+            return False
+        # Check for valid base64 pattern (ignoring data URI prefix)
+        clean = re.sub(r"^data:image/[a-z]+;base64,", "", base64_data)
+        try:
+            import base64
+            base64.b64decode(clean)
+            return len(clean) < 20 * 1024 * 1024  # < 20MB limit
+        except Exception:
+            return False
+
+    def _check_deterministic_safety(self, inp: PatientInput) -> List[str]:
+        """Scan raw input for high-priority clinical safety terms."""
+        text = f"{inp.symptoms} {inp.clinical_context}".lower()
+        flags = []
+        for kw in self.SAFETY_KEYWORDS:
+            if kw.lower() in text:
+                flags.append(f"URGENT_TERM_DETECTED: {kw}")
+        if inp.age is not None and inp.age < 18:
+            flags.append("PATIENT_AGE: PEDIATRIC_REQUIRES_EXPERT_REVIEW")
+        if inp.age is not None and inp.age > 75:
+            flags.append("PATIENT_AGE: GERIATRIC_CONSIDERATIONS_RECOMMENDED")
+        return flags
+
+    # Layman-to-medical term map for fast deterministic normalization
+    LAYMAN_TERMS = {
+        "can't breathe": "dyspnea", "hard to breathe": "dyspnea", "difficulty breathing": "dyspnea",
+        "stomach pain": "abdominal pain", "belly pain": "abdominal pain", "tummy pain": "abdominal pain",
+        "chest tightness": "chest pain/pressure", "heart racing": "palpitations",
+        "blurry vision": "visual disturbance", "can't see clearly": "visual disturbance",
+        "dizzy": "dizziness/vertigo", "feel faint": "presyncope", "passed out": "syncope",
+        "throwing up": "vomiting", "nausea and vomiting": "nausea/emesis",
+        "back pain": "dorsal pain", "leg pain": "lower extremity pain",
+        "arm pain": "upper extremity pain", "neck pain": "cervicalgia",
+        "headache": "cephalgia", "head pain": "cephalgia",
+        "swollen": "edema", "swelling": "edema", "bruise": "ecchymosis",
+        "lump": "mass/nodule", "bump": "mass/nodule"
+    }
+
+    def _normalize_with_llm(self, inp: PatientInput, existing_flags: List[str]) -> Dict[str, Any]:
+        """
+        Normalize clinical text. Uses fast deterministic mapping for simple inputs;
+        falls back to LLM only for complex or lengthy clinical context.
+        """
+        combined_text = f"{inp.symptoms or ''} {inp.clinical_context or ''}".strip()
+
+        # Skip LLM for short/simple inputs — deterministic normalization is sufficient
+        if len(combined_text) <= 120 and not any(
+            indicator in combined_text.lower()
+            for indicator in ["history of", "diagnosed with", "chronic", "prior", "previous", "medication", "allerg"]
+        ):
+            logger.debug("⚡ Short input detected — using fast deterministic normalization (skipping LLM)")
+            return self._fast_normalize(inp, existing_flags)
+
+        prompt = f"""You are a clinical data standardization expert.
+Convert raw patient input to standardized clinical terminology. Respond ONLY with JSON:
+{{"standardized_symptoms":"string","extracted_demographics":{{"age":int|null,"sex":"M|F|O"|null,"comorbidities":["string"]}},"safety_flags":["string"],"processing_notes":"string"}}
+
+Input:
+- Symptoms: "{inp.symptoms or 'Not provided'}"
+- Age: {inp.age}
+- Sex: {inp.sex}
+- Clinical Context: "{inp.clinical_context or 'Not provided'}"
+- Existing Flags: {existing_flags}
+
+Rules: convert layman terms to medical terminology; extract comorbidities; add safety flags; no markdown."""
+
+        result = self.llm.generate_text(prompt=prompt, force_json=True)
+        if result.get("success") and result.get("content"):
+            parsed = LLMClient.extract_json_from_response(result["content"])
+            if parsed:
+                return parsed
+
+        logger.warning("⚠️ LLM normalization failed. Using deterministic fallback.")
+        return self._build_fallback_dict(inp, existing_flags)
+
+    def _fast_normalize(self, inp: PatientInput, flags: List[str]) -> Dict[str, Any]:
+        """Deterministic normalization using term mapping — zero LLM calls."""
+        text = f"{inp.symptoms or ''} {inp.clinical_context or ''}".lower()
+        normalized = inp.symptoms or "No symptoms provided"
+        for layman, medical in self.LAYMAN_TERMS.items():
+            if layman in text:
+                normalized = normalized.lower().replace(layman, medical)
+        return {
+            "standardized_symptoms": normalized.strip(),
+            "extracted_demographics": {
+                "age": inp.age,
+                "sex": inp.sex,
+                "comorbidities": []
+            },
+            "safety_flags": flags,
+            "processing_notes": "Fast deterministic normalization applied."
+        }
+
+    def _infer_modality(self, inp: PatientInput, llm_data: Dict[str, Any]) -> ImageModality:
+        """Infer imaging modality from text hints or default to UNKNOWN."""
+        text = f"{inp.symptoms} {inp.clinical_context}".lower()
+        for kw, mod in self.MODALITY_KEYWORDS.items():
+            if kw in text:
+                return mod
+        return ImageModality.UNKNOWN
+
+    def _build_fallback_dict(self, inp: PatientInput, flags: List[str]) -> Dict[str, Any]:
+        """Deterministic fallback when LLM is unavailable."""
+        return {
+            "standardized_symptoms": inp.symptoms or "No symptoms provided",
+            "extracted_demographics": {
+                "age": inp.age,
+                "sex": inp.sex,
+                "comorbidities": []
+            },
+            "safety_flags": flags,
+            "processing_notes": "LLM normalization unavailable. Raw input preserved."
+        }
+
+    def _get_fallback_output(self, inp: PatientInput, flags: List[str]) -> IntakeOutput:
+        """Return a safe, minimally structured IntakeOutput on critical failure."""
+        return IntakeOutput(
+            validated=False,
+            standardized_symptoms=inp.symptoms or "",
+            extracted_demographics={"age": inp.age, "sex": inp.sex, "comorbidities": []},
+            safety_flags=flags + ["INTAKE_AGENT_FALLBACK_MODE"],
+            recommended_modality=ImageModality.UNKNOWN,
+            processing_notes="Intake agent encountered critical validation failure. Pipeline continues with degraded state."
+        )

agents/report.py

@@ -0,0 +1,201 @@
+# mediagent/agents/report.py
+"""
+Report Agent for MediAgent.
+Synthesizes outputs from Intake, Vision, and Research agents into a 
+structured, professional clinical radiology report. Follows standard 
+ACR/NICE radiological reporting conventions with strict JSON enforcement.
+"""
+
+import logging
+from typing import Optional, Any
+
+from core.llm import LLMClient
+from core.models import IntakeOutput, ReportSection, ResearchOutput, VisionOutput
+
+logger = logging.getLogger(__name__)
+
+
+class ReportAgent:
+    """
+    Clinical report synthesis engine. Transforms structured agent outputs
+    into a formal radiology report suitable for clinician review.
+    """
+
+    STANDARD_DISCLAIMER = (
+        "This analysis is AI-generated and must be reviewed by a licensed radiologist "
+        "before any clinical decisions are made."
+    )
+
+    SYSTEM_PROMPT = """You are a senior board-certified radiologist. Synthesize the provided findings into a formal radiology report. Return ONLY valid JSON:
+{"clinical_history":"string","technique":"string","findings":"string","impression":"string","recommendations":"string","disclaimer":"string"}
+
+Section rules:
+1. clinical_history: Age, sex, chief complaint, relevant context — formal clinical language.
+2. technique: Modality, planes/sequences, contrast status, image quality.
+3. findings: Anatomical region-by-region description; severity levels (NORMAL/INCIDENTAL/SIGNIFICANT/CRITICAL); size, shape, density, location.
+4. impression: Top 3 differentials with probabilities; clinical significance; end with "Confidence Level: High/Medium/Low — [reason]".
+5. recommendations: Next steps based on severity and confidence (further imaging, referral, urgent eval, follow-up).
+6. disclaimer: MUST be exactly: "This analysis is AI-generated and must be reviewed by a licensed radiologist before any clinical decisions are made."
+No markdown, no preamble, no extra text. Use standard radiological terminology. State "Not provided" for missing data."""
+
+    def __init__(self, llm_client: Optional[LLMClient] = None):
+        self.llm = llm_client or LLMClient()
+
+    def process(
+        self,
+        intake: Optional[IntakeOutput] = None,
+        vision: Optional[VisionOutput] = None,
+        research: Optional[ResearchOutput] = None,
+    ) -> ReportSection:
+        """
+        Synthesize agent outputs into a formal clinical radiology report.
+        
+        Args:
+            intake: Structured patient context and safety flags
+            vision: Imaging analysis findings and technical details
+            research: Ranked differential diagnoses and clinical correlations
+            
+        Returns:
+            ReportSection: Complete, structured radiology report
+        """
+        logger.info("📝 Report Agent initiated report synthesis")
+        
+        user_prompt = self._build_user_prompt(intake, vision, research)
+
+        result = self.llm.generate_text(
+            prompt=user_prompt,
+            system_prompt=self.SYSTEM_PROMPT,
+            temperature=0.1,
+            force_json=True,
+        )
+
+        if not result.get("success"):
+            logger.error(f"❌ Report generation LLM call failed: {result.get('error')}")
+            return self._get_fallback_report(intake, vision, research)
+
+        raw_content = result.get("content", "")
+        parsed = LLMClient.extract_json_from_response(raw_content)
+        if not parsed:
+            logger.warning("⚠️ Failed to parse report LLM JSON response. Using fallback.")
+            return self._get_fallback_report(intake, vision, research)
+
+        try:
+            return self._parse_report_response(parsed)
+        except Exception as e:
+            logger.error(f"💥 Report mapping failed: {e}")
+            return self._get_fallback_report(intake, vision, research)
+
+    def _build_user_prompt(self, intake, vision, research) -> str:
+        """Construct a highly structured prompt for the LLM synthesizer."""
+        # Clinical History Block
+        history = "Patient information not provided."
+        if intake:
+            age = f"{intake.extracted_demographics.get('age', 'Unknown')} years"
+            sex = intake.extracted_demographics.get('sex', 'Unknown')
+            symptoms = intake.standardized_symptoms or "No symptoms reported"
+            context = intake.processing_notes or ""
+            history = f"Age: {age} | Sex: {sex} | Chief Complaint: {symptoms} | Additional Context: {context}"
+
+        # Technique Block
+        technique = "Imaging technique not specified."
+        if vision:
+            modality = vision.modality_detected.value
+            quality = vision.technical_quality
+            technique = f"Modality: {modality} | Technical Assessment: {quality}"
+
+        # Findings Block
+        findings_text = "No imaging findings available."
+        if vision and vision.findings:
+            finding_blocks = []
+            for f in vision.findings:
+                finding_blocks.append(
+                    f"- {f.anatomical_region}: {f.description} (Severity: {f.severity.value}, "
+                    f"Confidence: {f.confidence.value} {f.confidence_score:.0f}%, Anomaly: {'Yes' if f.is_anomaly else 'No'})"
+                )
+            findings_text = "\n".join(finding_blocks)
+
+        # Differentials Block
+        diff_text = "No differential diagnoses generated."
+        if research and research.differential_diagnoses:
+            top_three = research.differential_diagnoses[:3]
+            diff_blocks = []
+            for d in top_three:
+                diff_blocks.append(
+                    f"{d.differential_rank}. {d.condition_name} (ICD-10: {d.icd10_code}) - "
+                    f"Probability: {d.match_probability:.1f}% | Evidence: {d.supporting_evidence}"
+                )
+            diff_text = "\n".join(diff_blocks)
+
+        return f"""Synthesize the following structured medical data into a formal radiology report:
+
+[CLINICAL HISTORY]
+{history}
+
+[IMAGING TECHNIQUE]
+{technique}
+
+[IMAGING FINDINGS]
+{findings_text}
+
+[DIFFERENTIAL DIAGNOSES]
+{diff_text}
+
+Generate the complete report following the exact JSON schema and clinical guidelines provided in the system prompt."""
+
+    def _parse_report_response(self, data: dict) -> ReportSection:
+        """Validate and map LLM output to ReportSection model with safety enforcement."""
+        # Extract fields with safe defaults
+        clinical_history = str(data.get("clinical_history", "Not provided."))
+        technique = str(data.get("technique", "Digital advanced imaging acquisition."))
+        findings = str(data.get("findings", "No abnormalities detected."))
+        impression = str(data.get("impression", "Within normal limits."))
+        recommendations = str(data.get("recommendations", "Routine follow-up as clinically indicated."))
+        
+        # Enforce exact disclaimer for regulatory compliance
+        disclaimer = self.STANDARD_DISCLAIMER
+
+        return ReportSection(
+            clinical_history=clinical_history,
+            technique=technique,
+            findings=findings,
+            impression=impression,
+            recommendations=recommendations,
+            disclaimer=disclaimer
+        )
+
+    def _get_fallback_report(
+        self, 
+        intake: Optional[IntakeOutput], 
+        vision: Optional[VisionOutput], 
+        research: Optional[ResearchOutput]
+    ) -> ReportSection:
+        """Deterministic fallback report when LLM synthesis fails."""
+        logger.warning("⚠️ Generating deterministic fallback radiology report.")
+        
+        # Build minimal clinically safe sections from raw data
+        history = "Patient data available. See raw intake logs for details."
+        if intake:
+            history = f"Symptoms: {intake.standardized_symptoms} | Demographics: {intake.extracted_demographics}"
+            
+        technique = "Imaging modality unspecified due to processing limitation."
+        if vision:
+            technique = f"Modality: {vision.modality_detected.value} | Quality: {vision.technical_quality}"
+            
+        findings = "Imaging analysis incomplete. Manual radiologist review strongly recommended."
+        if vision and vision.findings:
+            findings = "; ".join([f"{f.anatomical_region}: {f.description}" for f in vision.findings])
+            
+        impression = "Diagnostic certainty limited. Top clinical considerations based on available data:"
+        if research and research.differential_diagnoses:
+            impression += " " + ", ".join([d.condition_name for d in research.differential_diagnoses[:3]])
+            
+        recommendations = "Urgent manual review by a licensed radiologist is required. Correlate with clinical presentation."
+        
+        return ReportSection(
+            clinical_history=history,
+            technique=technique,
+            findings=findings,
+            impression=impression,
+            recommendations=recommendations,
+            disclaimer=self.STANDARD_DISCLAIMER
+        )

agents/research.py

@@ -0,0 +1,281 @@
+# mediagent/agents/research.py
+"""
+Research Agent for MediAgent.
+Cross-references vision agent findings against a built-in medical knowledge
+base to generate ranked differential diagnoses, ICD-10 mappings, and clinical
+correlations. Uses LLM reasoning to weigh evidence and account for demographics.
+"""
+
+import logging
+from typing import Any, Dict, List, Optional
+
+from core.llm import LLMClient
+from core.models import KnowledgeMatch, ResearchOutput, VisionFinding
+
+logger = logging.getLogger(__name__)
+
+# ─────────────────────────────────────────────────────────────────────────────
+# BUILT-IN MEDICAL KNOWLEDGE BASE
+# Curated set of common radiological findings mapped to clinical conditions.
+# Designed for deterministic cross-referencing with LLM reasoning overlay.
+# ─────────────────────────────────────────────────────────────────────────────
+
+MEDICAL_KB = [
+    {
+        "condition": "Community-Acquired Pneumonia",
+        "icd10": "J18.9",
+        "key_findings": ["lobar consolidation", "alveolar opacity", "air bronchograms", "focal infiltrate"],
+        "modalities": ["X-RAY", "CT"],
+        "typical_severity": "SIGNIFICANT"
+    },
+    {
+        "condition": "Cardiogenic Pulmonary Edema",
+        "icd10": "J81.0",
+        "key_findings": ["bilateral perihilar opacities", "kerley B lines", "cephalization", "pleural effusion", "cardiomegaly"],
+        "modalities": ["X-RAY", "CT"],
+        "typical_severity": "CRITICAL"
+    },
+    {
+        "condition": "Pleural Effusion",
+        "icd10": "J90",
+        "key_findings": ["blunting of costophrenic angle", "meniscus sign", "layering fluid", "hemothorax"],
+        "modalities": ["X-RAY", "CT", "MRI"],
+        "typical_severity": "SIGNIFICANT"
+    },
+    {
+        "condition": "Spontaneous Pneumothorax",
+        "icd10": "J93.9",
+        "key_findings": ["visceral pleural line", "absence of lung markings", "lung collapse", "hyperlucent hemithorax"],
+        "modalities": ["X-RAY", "CT"],
+        "typical_severity": "CRITICAL"
+    },
+    {
+        "condition": "Intracerebral Hemorrhage",
+        "icd10": "I61.9",
+        "key_findings": ["hyperdense collection", "mass effect", "midline shift", "sulcal effacement", "edema"],
+        "modalities": ["CT", "MRI"],
+        "typical_severity": "CRITICAL"
+    },
+    {
+        "condition": "Ischemic Stroke",
+        "icd10": "I63.9",
+        "key_findings": ["hypodensity", "loss of gray-white differentiation", "hypoenhancement", "restricted diffusion"],
+        "modalities": ["CT", "MRI"],
+        "typical_severity": "CRITICAL"
+    },
+    {
+        "condition": "Intracranial Neoplasm",
+        "icd10": "C71.9",
+        "key_findings": ["space-occupying lesion", "ring enhancement", "vasogenic edema", "midline shift", "mass effect"],
+        "modalities": ["MRI", "CT"],
+        "typical_severity": "SIGNIFICANT"
+    },
+    {
+        "condition": "Abdominal Aortic Aneurysm",
+        "icd10": "I71.4",
+        "key_findings": ["aortic dilation", "circumferential calcification", "thrombus", "rupture signs"],
+        "modalities": ["CT", "MRI"],
+        "typical_severity": "CRITICAL"
+    },
+    {
+        "condition": "Nephrolithiasis",
+        "icd10": "N20.0",
+        "key_findings": ["hyperdense calculus", "hydronephrosis", "ureteral dilation", "perinephric stranding"],
+        "modalities": ["CT", "X-RAY"],
+        "typical_severity": "SIGNIFICANT"
+    },
+    {
+        "condition": "Small Bowel Obstruction",
+        "icd10": "K56.6",
+        "key_findings": ["dilated loops", "air-fluid levels", "transition point", "collapsed distal bowel"],
+        "modalities": ["X-RAY", "CT"],
+        "typical_severity": "SIGNIFICANT"
+    },
+    {
+        "condition": "Long Bone Fracture",
+        "icd10": "S82.902",
+        "key_findings": ["cortical discontinuity", "displacement", "callus formation", "periosteal reaction", "fracture line"],
+        "modalities": ["X-RAY", "CT"],
+        "typical_severity": "SIGNIFICANT"
+    },
+    {
+        "condition": "Degenerative Joint Disease",
+        "icd10": "M19.90",
+        "key_findings": ["joint space narrowing", "osteophytes", "subchondral sclerosis", "subchondral cysts"],
+        "modalities": ["X-RAY", "MRI"],
+        "typical_severity": "INCIDENTAL"
+    },
+    {
+        "condition": "Hepatic Steatosis",
+        "icd10": "K76.0",
+        "key_findings": ["decreased hepatic attenuation", "liver brighter than spleen", "fatty infiltration", "hepatomegaly"],
+        "modalities": ["CT", "MRI", "X-RAY"],
+        "typical_severity": "INCIDENTAL"
+    },
+    {
+        "condition": "Herniated Disc",
+        "icd10": "M51.16",
+        "key_findings": ["disc protrusion", "nerve root compression", "thecal sac indentation", "annular tear"],
+        "modalities": ["MRI", "CT"],
+        "typical_severity": "SIGNIFICANT"
+    },
+    {
+        "condition": "Pulmonary Nodule",
+        "icd10": "R91.1",
+        "key_findings": ["solitary pulmonary nodule", "ground-glass opacity", "spiculated margins", "calcification pattern"],
+        "modalities": ["X-RAY", "CT"],
+        "typical_severity": "SIGNIFICANT"
+    }
+]
+
+
+class ResearchAgent:
+    """
+    Knowledge-driven differential diagnosis engine. Matches imaging findings
+    to a curated clinical knowledge base, applies demographic weighting, and
+    returns ranked diagnostic hypotheses with ICD-10 codes and confidence.
+    """
+
+    SYSTEM_PROMPT = """You are a clinical radiology research specialist. Cross-reference imaging findings against the provided knowledge base and return ONLY valid JSON:
+{"differential_diagnoses":[{"condition_name":"string","match_probability":0-100,"supporting_evidence":"string","differential_rank":1,"icd10_code":"string"}],"matched_conditions":["string"],"relevant_guidelines":["string"],"research_notes":"string"}
+
+Rules:
+1. ONLY use conditions from the provided KB. Do not invent diagnoses.
+2. Match anatomical regions and radiological descriptors to KB key_findings.
+3. Factor in demographics (age, sex, comorbidities) to adjust probabilities.
+4. Output 2-4 differentials maximum, ranked highest to lowest probability.
+5. Use exact ICD-10 codes from the KB.
+6. Skip conditions with no imaging evidence. Never force-fit.
+7. Minimum probability 5%. Never output 0%.
+8. Each supporting_evidence must explain WHY the condition matches (one full sentence minimum).
+9. No markdown, no commentary — JSON only."""
+
+    def __init__(self, llm_client: Optional[LLMClient] = None):
+        self.llm = llm_client or LLMClient()
+
+    def process(self, vision_findings: List[VisionFinding], demographics: Dict[str, Any] = None, detected_modality: str = "UNKNOWN") -> ResearchOutput:
+        """
+        Execute knowledge-base cross-referencing and differential generation.
+        
+        Args:
+            vision_findings: List of structured findings from Vision Agent
+            demographics: Patient metadata from Intake Agent
+            
+        Returns:
+            ResearchOutput: Ranked differentials, matched conditions, and clinical notes
+        """
+        logger.info("🔍 Research Agent initiated differential diagnosis matching")
+
+        demographics = demographics or {}
+        findings_text = self._format_findings_for_prompt(vision_findings)
+        kb_text = self._format_kb_for_prompt(detected_modality)
+
+        user_prompt = f"""Patient Demographics:
+- Age: {demographics.get('age', 'Unknown')}
+- Sex: {demographics.get('sex', 'Unknown')}
+- Comorbidities: {demographics.get('comorbidities', 'None reported')}
+
+Vision Agent Findings:
+{findings_text}
+
+Medical Knowledge Base:
+{kb_text}
+
+Analyze the findings, match them against the knowledge base, factor in demographics, and return the ranked differential diagnosis in the specified JSON format."""
+
+        result = self.llm.generate_text(
+            prompt=user_prompt,
+            system_prompt=self.SYSTEM_PROMPT,
+            temperature=0.1,
+            force_json=True
+        )
+
+        if not result.get("success"):
+            logger.error(f"❌ Research LLM call failed: {result.get('error')}")
+            return self._get_fallback_output()
+
+        raw_content = result.get("content", "")
+        parsed = LLMClient.extract_json_from_response(raw_content)
+        if not parsed:
+            logger.warning("⚠️ Failed to parse research LLM JSON response. Using fallback.")
+            return self._get_fallback_output()
+
+        try:
+            return self._parse_research_response(parsed)
+        except Exception as e:
+            logger.error(f"💥 Research response mapping failed: {e}")
+            return self._get_fallback_output()
+
+    def _format_findings_for_prompt(self, findings: List[VisionFinding]) -> str:
+        """Convert VisionFinding objects into LLM-readable text blocks."""
+        if not findings:
+            return "No specific findings reported by vision agent. Image appears unremarkable."
+        blocks = []
+        for i, f in enumerate(findings, 1):
+            blocks.append(
+                f"[{i}] Region: {f.anatomical_region} | "
+                f"Description: {f.description} | "
+                f"Severity: {f.severity.value} | "
+                f"Confidence: {f.confidence.value} ({f.confidence_score:.1f}%) | "
+                f"Anomaly: {'Yes' if f.is_anomaly else 'No'}"
+            )
+        return "\n".join(blocks)
+
+    def _format_kb_for_prompt(self, modality: str = "UNKNOWN") -> str:
+        """Format the KB into a structured reference block, pre-filtered by modality."""
+        # Filter to only conditions compatible with the detected modality
+        if modality in ("X-RAY", "CT", "MRI"):
+            relevant = [e for e in MEDICAL_KB if modality in e["modalities"]]
+        else:
+            relevant = MEDICAL_KB
+
+        lines = ["[CONDITION REFERENCE TABLE]"]
+        for entry in relevant:
+            lines.append(
+                f"- {entry['condition']} (ICD-10: {entry['icd10']}) | "
+                f"Findings: {', '.join(entry['key_findings'])} | "
+                f"Severity: {entry['typical_severity']}"
+            )
+        return "\n".join(lines)
+
+    def _parse_research_response(self, data: Dict[str, Any]) -> ResearchOutput:
+        """Validate and map LLM output to ResearchOutput model."""
+        raw_diffs = data.get("differential_diagnoses", [])
+        differentials = []
+
+        for rank, item in enumerate(raw_diffs, 1):
+            try:
+                match = KnowledgeMatch(
+                    condition_name=str(item.get("condition_name", "Unknown Condition")),
+                    match_probability=float(item.get("match_probability", 0.0)),
+                    supporting_evidence=str(item.get("supporting_evidence", "Insufficient data for correlation.")),
+                    differential_rank=rank,
+                    icd10_code=str(item.get("icd10_code", "Z00.00"))
+                )
+                differentials.append(match)
+            except Exception as e:
+                logger.warning(f"⚠️ Skipping malformed differential entry: {e}")
+                continue
+
+        matched_conditions = [d.condition_name for d in differentials]
+        guidelines = data.get("relevant_guidelines", ["ACR Appropriateness Criteria", "NICE Imaging Guidelines"])
+        notes = data.get("research_notes", "Standard knowledge-base cross-referencing applied.")
+
+        return ResearchOutput(
+            differential_diagnoses=differentials,
+            matched_conditions=matched_conditions,
+            relevant_guidelines=guidelines,
+            research_notes=notes,
+            sources_used=["internal_knowledge_base", "ac_radiology_standards"]
+        )
+
+    def _get_fallback_output(self) -> ResearchOutput:
+        """Safe fallback when KB matching fails."""
+        logger.warning("⚠️ Returning fallback ResearchOutput.")
+        return ResearchOutput(
+            differential_diagnoses=[],
+            matched_conditions=[],
+            relevant_guidelines=["Manual radiologist review required"],
+            research_notes="Knowledge base matching failed. Clinical correlation strongly recommended.",
+            sources_used=["internal_knowledge_base"]
+        )

agents/vision.py

@@ -0,0 +1,157 @@
+# mediagent/agents/vision.py
+"""
+Vision Agent for MediAgent.
+Multimodal medical image analysis engine that processes base64-encoded
+diagnostic images using local Qwen vision capabilities. Extracts
+anatomical structures, detects pathologies, and structures findings
+into standardized radiological observations with confidence scoring.
+"""
+
+import logging
+from typing import Any, Dict, List, Optional
+
+from core.llm import LLMClient
+from core.models import (
+    ConfidenceLevel,
+    ImageModality,
+    SeverityLevel,
+    VisionFinding,
+    VisionOutput,
+)
+
+logger = logging.getLogger(__name__)
+
+
+class VisionAgent:
+    """
+    Specialized radiological analysis agent. Interprets medical imagery
+    (X-ray, MRI, CT) and outputs structured findings with severity and
+    confidence classifications. Operates with deterministic fallbacks
+    to maintain pipeline continuity on LLM failures.
+    """
+
+    SYSTEM_PROMPT = """You are a board-certified radiologist. Analyze the medical image and return ONLY valid JSON:
+{
+  "modality_detected": "X-RAY"|"MRI"|"CT"|"UNKNOWN",
+  "technical_quality": "brief quality/artifact/positioning note",
+  "findings": [
+    {
+      "anatomical_region": "string",
+      "description": "concise radiological observation using standard terminology",
+      "severity": "NORMAL"|"INCIDENTAL"|"SIGNIFICANT"|"CRITICAL",
+      "confidence": "LOW"|"MEDIUM"|"HIGH",
+      "confidence_score": 0.0-100.0,
+      "is_anomaly": boolean
+    }
+  ],
+  "overall_assessment": "concise clinical summary"
+}
+Rules: precise radiological terms; correct anatomical orientation; distinguish normal variants from pathology; realistic confidence scores; no treatment plans; no markdown; no extra text."""
+
+    def __init__(self, llm_client: Optional[LLMClient] = None):
+        self.llm = llm_client or LLMClient()
+
+    def process(self, image_base64: str, clinical_context: str = "") -> VisionOutput:
+        """
+        Execute multimodal image analysis.
+        
+        Args:
+            image_base64: Base64 encoded medical image
+            clinical_context: Standardized symptoms/demographics from Intake Agent
+            
+        Returns:
+            VisionOutput: Structured radiological findings and metadata
+        """
+        logger.info("👁️ Vision Agent initiated multimodal analysis")
+
+        user_prompt = "Analyze this medical image carefully."
+        if clinical_context:
+            user_prompt += f"\n\nClinical Context: {clinical_context}"
+        user_prompt += "\n\nProvide a structured radiological assessment following the specified JSON schema."
+
+        result = self.llm.generate_vision(
+            base64_image=image_base64,
+            prompt=user_prompt,
+            system_prompt=self.SYSTEM_PROMPT,
+            temperature=0.0,
+            max_tokens=2000
+        )
+
+        if not result.get("success"):
+            logger.error(f"❌ Vision LLM call failed: {result.get('error')}")
+            return self._get_fallback_output()
+
+        raw_content = result.get("content", "")
+        parsed = LLMClient.extract_json_from_response(raw_content)
+        if not parsed:
+            logger.warning("⚠️ Failed to parse vision LLM JSON response. Using fallback.")
+            return self._get_fallback_output()
+
+        try:
+            return self._parse_vision_response(parsed, result.get("usage", {}))
+        except Exception as e:
+            logger.error(f"💥 Vision response mapping failed: {e}")
+            return self._get_fallback_output()
+
+    def _parse_vision_response(self, data: Dict[str, Any], usage: Dict[str, int]) -> VisionOutput:
+        """Map raw LLM JSON to validated Pydantic models with safe enum conversion."""
+        findings = []
+        raw_findings = data.get("findings", [])
+
+        for item in raw_findings:
+            try:
+                finding = VisionFinding(
+                    anatomical_region=item.get("anatomical_region", "Unspecified Region"),
+                    description=item.get("description", "Unable to generate detailed description."),
+                    severity=self._safe_enum(SeverityLevel, item.get("severity"), SeverityLevel.NORMAL),
+                    confidence=self._safe_enum(ConfidenceLevel, item.get("confidence"), ConfidenceLevel.MEDIUM),
+                    confidence_score=float(item.get("confidence_score", 50.0)),
+                    is_anomaly=bool(item.get("is_anomaly", False))
+                )
+                findings.append(finding)
+            except Exception as e:
+                logger.warning(f"⚠️ Skipping malformed finding due to validation error: {e}")
+                continue
+
+        modality_str = data.get("modality_detected", "UNKNOWN").upper()
+        try:
+            modality = ImageModality(modality_str)
+        except ValueError:
+            modality = ImageModality.UNKNOWN
+
+        return VisionOutput(
+            modality_detected=modality,
+            technical_quality=data.get(
+                "technical_quality", 
+                "Image quality acceptable for preliminary assessment."
+            ),
+            findings=findings,
+            overall_assessment=data.get(
+                "overall_assessment", 
+                "Unable to generate overall assessment from provided data."
+            ),
+            metadata={
+                "llm_usage": usage,
+                "findings_count": len(findings),
+                "anomalies_detected": sum(1 for f in findings if f.is_anomaly)
+            }
+        )
+
+    @staticmethod
+    def _safe_enum(enum_cls, value, default):
+        """Safely convert string to enum, falling back gracefully."""
+        try:
+            return enum_cls(str(value).strip().upper())
+        except (ValueError, AttributeError, TypeError):
+            return default
+
+    def _get_fallback_output(self) -> VisionOutput:
+        """Return a safe, non-failure-breaking VisionOutput when processing fails."""
+        logger.warning("⚠️ Returning fallback VisionOutput due to processing failure.")
+        return VisionOutput(
+            modality_detected=ImageModality.UNKNOWN,
+            technical_quality="Analysis unavailable due to system error. Manual review required.",
+            findings=[],
+            overall_assessment="Vision analysis could not be completed. Please verify image quality and system connectivity.",
+            metadata={"error": "VISION_AGENT_FALLBACK", "llm_usage": {"prompt_tokens": 0, "completion_tokens": 0, "total_tokens": 0}}
+        )

core/dicom.py

@@ -0,0 +1,128 @@
+# mediagent/core/dicom.py
+"""
+DICOM file parser for MediAgent.
+Extracts pixel data + clinical metadata from .dcm files,
+converts to base64 PNG for the vision pipeline, and returns
+structured metadata to pre-populate the intake form.
+"""
+
+import base64
+import io
+import logging
+from typing import Any, Dict, Optional, Tuple
+
+logger = logging.getLogger(__name__)
+
+
+def parse_dicom(file_bytes: bytes) -> Tuple[str, Dict[str, Any]]:
+    """
+    Parse a DICOM (.dcm) file.
+
+    Returns:
+        (base64_image_string, metadata_dict)
+        base64_image_string: "data:image/png;base64,..." ready for vision pipeline
+        metadata_dict: extracted clinical metadata for intake pre-population
+    """
+    try:
+        import pydicom
+        import numpy as np
+        from PIL import Image
+    except ImportError as e:
+        raise ImportError(f"DICOM support requires pydicom, numpy, Pillow: {e}")
+
+    ds = pydicom.dcmread(io.BytesIO(file_bytes), force=True)
+
+    # ── Metadata extraction ───────────────────────────────────────────────────
+    metadata: Dict[str, Any] = {}
+
+    _tag_map = {
+        "PatientName":       "patient_name",
+        "PatientID":         "patient_id",
+        "PatientBirthDate":  "birth_date",
+        "PatientSex":        "sex",
+        "PatientAge":        "age_str",
+        "StudyDate":         "study_date",
+        "StudyDescription":  "study_description",
+        "SeriesDescription": "series_description",
+        "Modality":          "modality",
+        "InstitutionName":   "institution",
+        "Manufacturer":      "manufacturer",
+        "ManufacturerModelName": "device_model",
+        "KVP":               "kvp",
+        "ExposureTime":      "exposure_time_ms",
+        "SliceThickness":    "slice_thickness_mm",
+        "BodyPartExamined":  "body_part",
+        "StudyInstanceUID":  "study_uid",
+        "SOPInstanceUID":    "instance_uid",
+        "Rows":              "image_rows",
+        "Columns":           "image_cols",
+        "PixelSpacing":      "pixel_spacing_mm",
+    }
+
+    for dicom_tag, key in _tag_map.items():
+        try:
+            val = getattr(ds, dicom_tag, None)
+            if val is not None:
+                metadata[key] = str(val)
+        except Exception:
+            pass
+
+    # Normalise age: DICOM age strings look like "045Y", "006M", "010D"
+    age: Optional[int] = None
+    age_str = metadata.pop("age_str", None)
+    if age_str:
+        try:
+            if age_str.endswith("Y"):
+                age = int(age_str[:-1])
+            elif age_str.endswith("M"):
+                age = max(0, int(int(age_str[:-1]) / 12))
+        except ValueError:
+            pass
+    if age is not None:
+        metadata["age"] = age
+
+    # Normalise sex: DICOM uses M/F/O
+    sex = metadata.get("sex", "")
+    if sex and sex.upper() in ("M", "F", "O"):
+        metadata["sex"] = sex.upper()
+    else:
+        metadata.pop("sex", None)
+
+    # ── Pixel data → PNG base64 ───────────────────────────────────────────────
+    try:
+        pixel_array = ds.pixel_array.astype(float)
+    except Exception as e:
+        raise ValueError(f"Could not read DICOM pixel data: {e}")
+
+    # MONOCHROME1 means bright = low value → invert
+    photometric = str(getattr(ds, "PhotometricInterpretation", "MONOCHROME2")).strip()
+    if photometric == "MONOCHROME1":
+        pixel_array = pixel_array.max() - pixel_array
+
+    # Normalise to 0–255
+    p_min, p_max = pixel_array.min(), pixel_array.max()
+    if p_max > p_min:
+        pixel_array = ((pixel_array - p_min) / (p_max - p_min) * 255).astype("uint8")
+    else:
+        pixel_array = pixel_array.astype("uint8")
+
+    # Handle grayscale, RGB, multi-frame (take first frame)
+    if pixel_array.ndim == 3 and pixel_array.shape[0] > 3:
+        pixel_array = pixel_array[0]  # first frame of multi-frame
+
+    if pixel_array.ndim == 2:
+        img = Image.fromarray(pixel_array, mode="L").convert("RGB")
+    else:
+        img = Image.fromarray(pixel_array.astype("uint8"))
+
+    buf = io.BytesIO()
+    img.save(buf, format="PNG", optimize=True)
+    b64 = base64.b64encode(buf.getvalue()).decode("utf-8")
+    base64_image = f"data:image/png;base64,{b64}"
+
+    logger.info(
+        f"DICOM parsed | modality={metadata.get('modality','?')} "
+        f"body_part={metadata.get('body_part','?')} "
+        f"size={metadata.get('image_rows','?')}x{metadata.get('image_cols','?')}"
+    )
+    return base64_image, metadata

core/fhir.py

@@ -0,0 +1,210 @@
+# mediagent/core/fhir.py
+"""
+FHIR R4 DiagnosticReport export for MediAgent.
+Converts a FinalReport into a standards-compliant HL7 FHIR R4 resource
+suitable for import into any EMR system (Epic, Cerner, etc.).
+"""
+
+import base64
+import uuid
+from datetime import datetime
+from typing import Any, Dict, List
+
+from core.models import FinalReport
+
+
+def to_fhir_diagnostic_report(report: FinalReport) -> Dict[str, Any]:
+    """
+    Convert a MediAgent FinalReport into a FHIR R4 DiagnosticReport resource.
+
+    Conforms to:
+      http://hl7.org/fhir/R4/diagnosticreport.html
+      LOINC 18748-4 (Diagnostic imaging study)
+    """
+    meta = report.patient_metadata or {}
+    sections = report.sections
+    ts = report.generation_timestamp.strftime("%Y-%m-%dT%H:%M:%SZ")
+    patient_uid = f"patient-{uuid.uuid4().hex[:8]}"
+
+    # ── Contained Patient resource ────────────────────────────────────────────
+    patient: Dict[str, Any] = {
+        "resourceType": "Patient",
+        "id": patient_uid,
+    }
+    if meta.get("sex"):
+        patient["gender"] = _map_sex(str(meta["sex"]))
+    age = meta.get("age")
+    if age:
+        birth_year = datetime.now().year - int(age)
+        patient["birthDate"] = str(birth_year)
+    if meta.get("patient_name"):
+        patient["name"] = [{"text": str(meta["patient_name"])}]
+
+    # ── Imaging study Observations (one per finding section) ─────────────────
+    observations: List[Dict[str, Any]] = []
+    finding_text = sections.findings or ""
+    if finding_text:
+        obs_id = f"obs-{uuid.uuid4().hex[:8]}"
+        observations.append({
+            "resourceType": "Observation",
+            "id": obs_id,
+            "status": "final",
+            "category": [{
+                "coding": [{
+                    "system": "http://terminology.hl7.org/CodeSystem/observation-category",
+                    "code": "imaging",
+                    "display": "Imaging"
+                }]
+            }],
+            "code": {
+                "coding": [{
+                    "system": "http://loinc.org",
+                    "code": "59776-5",
+                    "display": "Findings"
+                }]
+            },
+            "subject": {"reference": f"#{patient_uid}"},
+            "effectiveDateTime": ts,
+            "valueString": finding_text[:2000]  # FHIR string limit safeguard
+        })
+
+    # ── Build contained resources list ───────────────────────────────────────
+    contained: List[Dict] = [patient] + observations
+    obs_refs = [{"reference": f"#{o['id']}"} for o in observations]
+
+    # ── Severity → SNOMED code ────────────────────────────────────────────────
+    severity_val = report.overall_severity.value if hasattr(report.overall_severity, "value") else str(report.overall_severity)
+    conclusion_codes = _severity_to_snomed(severity_val)
+
+    # ── Modality coding from vision summary ──────────────────────────────────
+    modality_code = _extract_modality_code(report.vision_summary)
+
+    # ── Presented form: full plain-text report ────────────────────────────────
+    report_text = (
+        f"CLINICAL HISTORY\n{sections.clinical_history}\n\n"
+        f"TECHNIQUE\n{sections.technique}\n\n"
+        f"FINDINGS\n{sections.findings}\n\n"
+        f"IMPRESSION\n{sections.impression}\n\n"
+        f"RECOMMENDATIONS\n{sections.recommendations}\n\n"
+        f"DISCLAIMER\n{sections.disclaimer}"
+    )
+
+    # ── Agent pipeline extension ──────────────────────────────────────────────
+    pipeline_str = ", ".join(
+        f"{k}:{v.value}" for k, v in report.agent_pipeline_status.items()
+    )
+
+    resource: Dict[str, Any] = {
+        "resourceType": "DiagnosticReport",
+        "id": report.report_id,
+        "meta": {
+            "profile": [
+                "http://hl7.org/fhir/StructureDefinition/DiagnosticReport"
+            ],
+            "lastUpdated": ts,
+            "tag": [{
+                "system": "https://mediagent.ai/tags",
+                "code": "ai-generated",
+                "display": "AI Generated — Requires Radiologist Review"
+            }]
+        },
+        "contained": contained,
+        "status": "final",
+        "category": [{
+            "coding": [{
+                "system": "http://terminology.hl7.org/CodeSystem/v2-0074",
+                "code": "RAD",
+                "display": "Radiology"
+            }]
+        }],
+        "code": {
+            "coding": [
+                {
+                    "system": "http://loinc.org",
+                    "code": "18748-4",
+                    "display": "Diagnostic imaging study"
+                },
+                modality_code
+            ],
+            "text": "Medical Imaging Analysis — AI-Assisted Radiology Report"
+        },
+        "subject": {
+            "reference": f"#{patient_uid}"
+        },
+        "effectiveDateTime": ts,
+        "issued": ts,
+        "performer": [{
+            "display": "MediAgent AI System (AMD Instinct MI300X)"
+        }],
+        "result": obs_refs,
+        "conclusion": sections.impression,
+        "conclusionCode": conclusion_codes,
+        "presentedForm": [{
+            "contentType": "text/plain; charset=utf-8",
+            "data": base64.b64encode(report_text.encode("utf-8")).decode("utf-8"),
+            "title": f"Radiology Report {report.report_id}",
+            "creation": ts
+        }],
+        "extension": [
+            {
+                "url": "https://mediagent.ai/fhir/StructureDefinition/ai-quality-score",
+                "valueInteger": _extract_qa_score(sections.recommendations)
+            },
+            {
+                "url": "https://mediagent.ai/fhir/StructureDefinition/overall-severity",
+                "valueCode": severity_val
+            },
+            {
+                "url": "https://mediagent.ai/fhir/StructureDefinition/pipeline-status",
+                "valueString": pipeline_str
+            },
+            {
+                "url": "https://mediagent.ai/fhir/StructureDefinition/inference-platform",
+                "valueString": "AMD Instinct MI300X / ROCm / vLLM / Qwen"
+            }
+        ]
+    }
+
+    return resource
+
+
+# ── Helpers ───────────────────────────────────────────────────────────────────
+
+def _map_sex(sex: str) -> str:
+    return {"M": "male", "F": "female", "O": "other"}.get(sex.upper(), "unknown")
+
+
+def _severity_to_snomed(severity: str) -> List[Dict]:
+    snomed = {
+        "NORMAL":      ("260313008", "Normal"),
+        "INCIDENTAL":  ("102483000", "Incidental finding"),
+        "SIGNIFICANT": ("404684003", "Clinical finding"),
+        "CRITICAL":    ("399625000", "Critical finding"),
+    }
+    code, display = snomed.get(severity.upper(), ("404684003", "Clinical finding"))
+    return [{
+        "coding": [{
+            "system": "http://snomed.info/sct",
+            "code": code,
+            "display": display
+        }]
+    }]
+
+
+def _extract_modality_code(vision_summary: str) -> Dict:
+    """Map detected modality to DICOM/RadLex LOINC codes."""
+    loinc_map = {
+        "X-RAY": ("24627-2", "Chest X-ray"),
+        "CT":    ("18747-6", "CT study"),
+        "MRI":   ("18755-9", "MRI study"),
+    }
+    for key, (code, display) in loinc_map.items():
+        if key in vision_summary.upper():
+            return {"system": "http://loinc.org", "code": code, "display": display}
+    return {"system": "http://loinc.org", "code": "18748-4", "display": "Diagnostic imaging study"}
+
+
+def _extract_qa_score(recommendations: str) -> int:
+    import re
+    m = re.search(r"Score[:\s]+(\d+)", recommendations or "")
+    return int(m.group(1)) if m else 85

core/llm.py

@@ -0,0 +1,315 @@
+# mediagent/core/llm.py
+"""
+Production-grade LLM client wrapper for MediAgent.
+Handles text and multimodal (vision) completions against local Qwen model.
+Implements retry logic, error handling, response parsing, and OpenAI-compatible API calls.
+"""
+
+import logging
+import time
+import re
+from typing import Any, Dict, List, Optional, Union
+
+import openai
+
+logger = logging.getLogger(__name__)
+
+
+class LLMClient:
+    """
+    Lightweight, framework-agnostic LLM client wrapping OpenAI Python SDK.
+    Designed for local inference endpoints (vLLM, Ollama, TensorRT-LLM) 
+    running at http://localhost:8000/v1 with model path "/model".
+    """
+
+    DEFAULT_BASE_URL = "http://localhost:8000/v1"
+    DEFAULT_MODEL = "/model"
+    DEFAULT_API_KEY = "none"
+
+    def __init__(
+        self,
+        base_url: str = DEFAULT_BASE_URL,
+        model: str = DEFAULT_MODEL,
+        max_retries: int = 3,
+        timeout: float = 90.0,
+        temperature: float = 0.0
+    ):
+        self.model = model
+        self.max_retries = max_retries
+        self.default_temperature = temperature
+        self.timeout = timeout
+
+        self.client = openai.OpenAI(
+            base_url=base_url,
+            api_key=self.DEFAULT_API_KEY,
+            timeout=timeout
+        )
+        logger.info(f"LLMClient initialized | Model: {self.model} | Endpoint: {base_url}")
+
+    # ─────────────────────────────────────────────────────────────────────────
+    # CORE GENERATION METHODS
+    # ─────────────────────────────────────────────────────────────────────────
+
+    def generate_text(
+        self,
+        prompt: str,
+        system_prompt: str = "",
+        temperature: Optional[float] = None,
+        force_json: bool = False,
+        max_tokens: Optional[int] = None,
+        extra_body: Optional[Dict] = None,
+    ) -> Dict[str, Any]:
+        """
+        Send a text-only completion request to the LLM.
+        Returns standardized response dict with content, usage, success flag, and error.
+        """
+        messages = self._build_messages(system_prompt, prompt)
+        response_format = {"type": "json_object"} if force_json else None
+        return self._execute_with_retry(
+            messages=messages,
+            temperature=temperature,
+            response_format=response_format,
+            call_type="TEXT",
+            max_tokens=max_tokens,
+            extra_body=extra_body,
+        )
+
+    def generate_text_streaming(
+        self,
+        prompt: str,
+        system_prompt: str = "",
+        temperature: Optional[float] = None,
+        on_token: Optional[Any] = None,
+    ) -> Dict[str, Any]:
+        """
+        Text completion with optional token-level streaming callback.
+        When on_token is provided, calls on_token(chunk: str) for every token chunk
+        as it arrives from the model. Returns the full response dict at the end.
+        Falls back to standard generate_text if streaming fails.
+        """
+        if on_token is None:
+            return self.generate_text(prompt, system_prompt, temperature)
+
+        messages = self._build_messages(system_prompt, prompt)
+        temp = temperature if temperature is not None else self.default_temperature
+
+        try:
+            stream = self.client.chat.completions.create(
+                model=self.model,
+                messages=messages,
+                temperature=temp,
+                stream=True,
+            )
+            full_content = ""
+            for chunk in stream:
+                delta = (chunk.choices[0].delta.content or "") if chunk.choices else ""
+                if delta:
+                    full_content += delta
+                    try:
+                        on_token(delta)
+                    except Exception:
+                        pass  # callback errors must not break generation
+
+            logger.debug("Streaming TEXT generation completed | chars=%d", len(full_content))
+            return {
+                "success": True,
+                "content": full_content,
+                "usage": {"prompt_tokens": 0, "completion_tokens": 0, "total_tokens": 0},
+                "model": self.model,
+                "error": None,
+            }
+        except Exception as e:
+            logger.warning("Streaming failed (%s), falling back to standard call", e)
+            return self.generate_text(prompt, system_prompt, temperature)
+
+    def generate_vision(
+        self,
+        base64_image: str,
+        prompt: str,
+        system_prompt: str = "",
+        temperature: Optional[float] = None,
+        max_tokens: Optional[int] = None
+    ) -> Dict[str, Any]:
+        """
+        Send a multimodal completion request with a base64 encoded medical image.
+        Automatically detects image MIME type and formats per OpenAI vision spec.
+        """
+        img_url = self._format_image_url(base64_image)
+        user_content = [
+            {"type": "text", "text": prompt},
+            {"type": "image_url", "image_url": {"url": img_url}}
+        ]
+        messages = self._build_messages(system_prompt, user_content)
+        return self._execute_with_retry(
+            messages=messages,
+            temperature=temperature,
+            response_format=None,
+            call_type="VISION",
+            max_tokens=max_tokens
+        )
+
+    # ─────────────────────────────────────────────────────────────────────────
+    # INTERNAL HELPERS
+    # ─────────────────────────────────────────────────────────────────────────
+
+    def _build_messages(
+        self,
+        system_prompt: str,
+        user_content: Union[str, List[Dict]]
+    ) -> List[Dict]:
+        """Construct OpenAI-compatible message array."""
+        messages = []
+        if system_prompt:
+            messages.append({"role": "system", "content": system_prompt})
+        if isinstance(user_content, str):
+            messages.append({"role": "user", "content": user_content})
+        else:
+            messages.append({"role": "user", "content": user_content})
+        return messages
+
+    def _format_image_url(self, base64_data: str) -> str:
+        """Normalize base64 image data into OpenAI vision-compatible URL format."""
+        if base64_data.startswith(("data:image/png;base64,", "data:image/jpeg;base64,", "data:image/jpg;base64,")):
+            return base64_data
+        # Default to JPEG if no MIME prefix is present
+        return f"data:image/jpeg;base64,{base64_data}"
+
+    def _attempt_call(
+        self,
+        messages: List[Dict],
+        temperature: Optional[float],
+        response_format: Optional[Dict],
+        max_tokens: Optional[int] = None,
+        extra_body: Optional[Dict] = None,
+    ) -> Dict[str, Any]:
+        """Execute a single API call with the OpenAI client."""
+        kwargs = {
+            "model": self.model,
+            "messages": messages,
+            "temperature": temperature if temperature is not None else self.default_temperature,
+        }
+        if max_tokens:
+            kwargs["max_tokens"] = max_tokens
+        if response_format:
+            kwargs["response_format"] = response_format
+        if extra_body:
+            kwargs["extra_body"] = extra_body
+
+        response = self.client.chat.completions.create(**kwargs)
+        content = response.choices[0].message.content or ""
+        
+        usage = response.usage
+        return {
+            "success": True,
+            "content": content,
+            "raw_response": response,
+            "usage": {
+                "prompt_tokens": usage.prompt_tokens if usage else 0,
+                "completion_tokens": usage.completion_tokens if usage else 0,
+                "total_tokens": usage.total_tokens if usage else 0,
+            },
+            "model": response.model,
+            "error": None
+        }
+
+    def _execute_with_retry(
+        self,
+        messages: List[Dict],
+        temperature: Optional[float],
+        response_format: Optional[Dict],
+        call_type: str,
+        max_tokens: Optional[int] = None,
+        extra_body: Optional[Dict] = None,
+    ) -> Dict[str, Any]:
+        """Retry wrapper with exponential backoff for robust local inference."""
+        last_error = None
+        for attempt in range(1, self.max_retries + 1):
+            try:
+                result = self._attempt_call(messages, temperature, response_format, max_tokens, extra_body)
+                if result["success"]:
+                    logger.debug(f"{call_type} generation successful on attempt {attempt}")
+                    return result
+            except Exception as e:
+                last_error = str(e)
+                logger.warning(f"{call_type} generation failed on attempt {attempt}/{self.max_retries}: {e}")
+                if attempt < self.max_retries:
+                    # Short fixed backoff for local inference — no need for exponential waits
+                    backoff = 1.0
+                    logger.info(f"Retrying in {backoff}s...")
+                    time.sleep(backoff)
+
+        logger.error(f"{call_type} generation failed permanently after {self.max_retries} attempts.")
+        return {
+            "success": False,
+            "content": "",
+            "usage": {"prompt_tokens": 0, "completion_tokens": 0, "total_tokens": 0},
+            "model": self.model,
+            "error": last_error or f"{call_type} endpoint unreachable or max retries exceeded."
+        }
+
+    # ─────────────────────────────────────────────────────────────────────────
+    # RESPONSE PARSING UTILITIES
+    # ─────────────────────────────────────────────────────────────────────────
+
+    @staticmethod
+    def extract_json_from_response(content: str) -> Optional[Dict[str, Any]]:
+        """
+        Safely extract JSON from LLM output, stripping markdown formatting
+        and handling partial/comma-separated JSON arrays if necessary.
+        """
+        if not content:
+            return None
+        try:
+            # Strip markdown code fences if present
+            cleaned = re.sub(r"^```(?:json)?\s*|\s*```$", "", content.strip(), flags=re.MULTILINE)
+            # First try direct JSON decode
+            return LLMClient._safe_json_decode(cleaned)
+        except Exception:
+            logger.debug("Direct JSON extraction failed. Attempting fallback parsing...")
+            return LLMClient._fallback_json_parse(cleaned)
+
+    @staticmethod
+    def _safe_json_decode(text: str):
+        """Import json lazily and decode, raising cleanly on failure."""
+        import json
+        return json.loads(text)
+
+    @staticmethod
+    def _fallback_json_parse(text: str) -> Optional[Dict[str, Any]]:
+        """
+        Fallback: scan for first valid JSON object or array in the text.
+        Handles cases where the LLM adds conversational padding.
+        """
+        import json
+        brace_depth = 0
+        start_idx = None
+        for i, char in enumerate(text):
+            if char == "{":
+                if brace_depth == 0:
+                    start_idx = i
+                brace_depth += 1
+            elif char == "}":
+                brace_depth -= 1
+                if brace_depth == 0 and start_idx is not None:
+                    candidate = text[start_idx:i+1]
+                    try:
+                        return json.loads(candidate)
+                    except json.JSONDecodeError:
+                        continue
+        # Try array fallback
+        bracket_depth = 0
+        start_idx = None
+        for i, char in enumerate(text):
+            if char == "[":
+                if bracket_depth == 0:
+                    start_idx = i
+                bracket_depth += 1
+            elif char == "]":
+                bracket_depth -= 1
+                if bracket_depth == 0 and start_idx is not None:
+                    candidate = text[start_idx:i+1]
+                    try:
+                        return json.loads(candidate)
+                    except json.JSONDecodeError:
+                        continue
+        return None

core/models.py

@@ -0,0 +1,215 @@
+# mediagent/core/models.py
+"""
+Pydantic data models for MediAgent multi-agent medical imaging pipeline.
+Defines input, agent outputs, report structure, and pipeline state tracking.
+"""
+
+import enum
+import uuid
+from datetime import datetime
+from typing import Any, Dict, List, Optional
+
+from pydantic import BaseModel, Field, field_validator
+
+
+# ─────────────────────────────────────────────────────────────────────────────
+# ENUMERATIONS
+# ─────────────────────────────────────────────────────────────────────────────
+
+class SeverityLevel(str, enum.Enum):
+    """Clinical severity classification for findings."""
+    NORMAL = "NORMAL"
+    INCIDENTAL = "INCIDENTAL"
+    SIGNIFICANT = "SIGNIFICANT"
+    CRITICAL = "CRITICAL"
+
+
+class ConfidenceLevel(str, enum.Enum):
+    """AI confidence classification for model outputs."""
+    LOW = "LOW"
+    MEDIUM = "MEDIUM"
+    HIGH = "HIGH"
+
+
+class AgentStatus(str, enum.Enum):
+    """Real-time pipeline agent execution states."""
+    WAITING = "WAITING"
+    RUNNING = "RUNNING"
+    DONE = "DONE"
+    ERROR = "ERROR"
+
+
+class ImageModality(str, enum.Enum):
+    """Supported medical imaging modalities."""
+    XRAY = "X-RAY"
+    MRI = "MRI"
+    CT = "CT"
+    UNKNOWN = "UNKNOWN"
+
+
+# ─────────────────────────────────────────────────────────────────────────────
+# INPUT MODELS
+# ─────────────────────────────────────────────────────────────────────────────
+
+class PatientInput(BaseModel):
+    """Initial client submission containing image and clinical context."""
+    image_base64: str = Field(
+        ...,
+        description="Base64 encoded medical image (PNG/JPG format)"
+    )
+    symptoms: str = Field(
+        default="",
+        description="Patient reported symptoms or chief complaint"
+    )
+    age: Optional[int] = Field(
+        default=None, ge=0, le=120, description="Patient age in years"
+    )
+    sex: Optional[str] = Field(
+        default=None, pattern="^(M|F|O)$", description="Patient biological sex"
+    )
+    clinical_context: Optional[str] = Field(
+        default=None, description="Relevant medical history or referral details"
+    )
+
+    @field_validator("image_base64")
+    @classmethod
+    def validate_image_data(cls, v: str) -> str:
+        if not v or len(v) < 10:
+            raise ValueError("Invalid or empty base64 image data provided.")
+        return v
+
+
+# ─────────────────────────────────────────────────────────────────────────────
+# AGENT OUTPUT MODELS
+# ─────────────────────────────────────────────────────────────────────────────
+
+class IntakeOutput(BaseModel):
+    """Structured data produced by the Intake Agent."""
+    validated: bool = Field(default=True, description="Whether input passed validation checks")
+    standardized_symptoms: str = Field(default="", description="Clinically normalized symptom description")
+    extracted_demographics: Dict[str, Any] = Field(default_factory=dict)
+    safety_flags: List[str] = Field(default_factory=list, description="Pre-analysis safety/alert flags")
+    recommended_modality: ImageModality = Field(default=ImageModality.UNKNOWN)
+    processing_notes: str = Field(default="")
+
+
+class VisionFinding(BaseModel):
+    """Individual anatomical observation from the Vision Agent."""
+    anatomical_region: str = Field(..., description="e.g., Left Lung Field, Medial Patella")
+    description: str = Field(..., description="Detailed radiological description")
+    severity: SeverityLevel = Field(default=SeverityLevel.NORMAL)
+    confidence: ConfidenceLevel = Field(default=ConfidenceLevel.LOW)
+    confidence_score: float = Field(default=0.0, ge=0.0, le=100.0)
+    is_anomaly: bool = Field(default=False)
+
+
+class VisionOutput(BaseModel):
+    """Complete visual analysis result from the Vision Agent."""
+    modality_detected: ImageModality = Field(default=ImageModality.UNKNOWN)
+    technical_quality: str = Field(default="Acceptable", description="Image quality/artifact assessment")
+    findings: List[VisionFinding] = Field(default_factory=list)
+    overall_assessment: str = Field(default="No obvious abnormalities detected.")
+    metadata: Dict[str, Any] = Field(default_factory=dict)
+
+
+class KnowledgeMatch(BaseModel):
+    """Differential diagnosis entry from the Research Agent."""
+    condition_name: str = Field(..., description="Medical condition or diagnosis")
+    match_probability: float = Field(..., ge=0.0, le=100.0, description="Confidence percentage")
+    supporting_evidence: str = Field(..., description="Pathophysiological/clinical correlation")
+    differential_rank: int = Field(default=0, ge=1)
+    icd10_code: Optional[str] = Field(default=None)
+
+
+class ResearchOutput(BaseModel):
+    """Knowledge base search and differential diagnosis result."""
+    differential_diagnoses: List[KnowledgeMatch] = Field(default_factory=list)
+    matched_conditions: List[str] = Field(default_factory=list)
+    relevant_guidelines: List[str] = Field(default_factory=list)
+    research_notes: str = Field(default="")
+    sources_used: List[str] = Field(default=["internal_knowledge_base"])
+
+
+# ─────────────────────────────────────────────────────────────────────────────
+# REPORT MODELS
+# ─────────────────────────────────────────────────────────────────────────────
+
+class ReportSection(BaseModel):
+    """Standard radiology report structure."""
+    clinical_history: str = Field(default="Not provided.")
+    technique: str = Field(default="Digital advanced imaging acquisition.")
+    findings: str = Field(default="No abnormalities detected.")
+    impression: str = Field(default="Within normal limits.")
+    recommendations: str = Field(default="Routine follow-up as clinically indicated.")
+    disclaimer: str = Field(
+        default="This analysis is AI-generated and must be reviewed by a licensed radiologist before any clinical decisions are made."
+    )
+
+
+class FinalReport(BaseModel):
+    """Complete synthesized clinical report ready for delivery."""
+    report_id: str = Field(default_factory=lambda: f"REP-{uuid.uuid4().hex[:12].upper()}")
+    patient_metadata: Dict[str, Any] = Field(default_factory=dict)
+    sections: ReportSection = Field(default_factory=ReportSection)
+    vision_summary: str = Field(default="")
+    research_summary: str = Field(default="")
+    overall_severity: SeverityLevel = Field(default=SeverityLevel.NORMAL)
+    generation_timestamp: datetime = Field(default_factory=datetime.now)
+    agent_pipeline_status: Dict[str, AgentStatus] = Field(default_factory=dict)
+
+
+# ─────────────────────────────────────────────────────────────────────────────
+# CHAT / ADVISOR MODELS
+# ─────────────────────────────────────────────────────────────────────────────
+
+class ChatMessage(BaseModel):
+    """Single turn in the post-report clinical advisor chat."""
+    role: str = Field(..., description="'user' or 'assistant'")
+    content: str = Field(..., description="Message text")
+    timestamp: datetime = Field(default_factory=datetime.now)
+
+
+class ChatRequest(BaseModel):
+    """Incoming question for the ClinicalAdvisorAgent."""
+    question: str = Field(..., min_length=3, max_length=1000)
+
+
+class ChatResponse(BaseModel):
+    """Response from the ClinicalAdvisorAgent."""
+    answer: str
+    report_id: str
+    timestamp: datetime = Field(default_factory=datetime.now)
+
+
+# ─────────────────────────────────────────────────────────────────────────────
+# PIPELINE STATE MODEL
+# ─────────────────────────────────────────────────────────────────────────────
+
+class PipelineState(BaseModel):
+    """Tracks real-time execution state across all agents."""
+    current_step: str = Field(default="INIT")
+    agent_statuses: Dict[str, AgentStatus] = Field(
+        default_factory=lambda: {
+            "INTAKE": AgentStatus.WAITING,
+            "VISION": AgentStatus.WAITING,
+            "RESEARCH": AgentStatus.WAITING,
+            "REPORT": AgentStatus.WAITING,
+            "CRITIC": AgentStatus.WAITING
+        }
+    )
+    intake_output: Optional[IntakeOutput] = None
+    vision_output: Optional[VisionOutput] = None
+    research_output: Optional[ResearchOutput] = None
+    report_draft: Optional[ReportSection] = None
+    final_report: Optional[FinalReport] = None
+    error_log: List[str] = Field(default_factory=list)
+
+    def mark_running(self, agent_name: str) -> None:
+        self.agent_statuses[agent_name] = AgentStatus.RUNNING
+
+    def mark_done(self, agent_name: str) -> None:
+        self.agent_statuses[agent_name] = AgentStatus.DONE
+
+    def mark_error(self, agent_name: str, error_msg: str) -> None:
+        self.agent_statuses[agent_name] = AgentStatus.ERROR
+        self.error_log.append(f"[{agent_name}] {error_msg}")

core/pipeline.py

@@ -0,0 +1,238 @@
+# mediagent/core/pipeline.py
+"""
+Pipeline Orchestrator for MediAgent.
+Manages execution of all medical imaging analysis agents with parallel
+scheduling where possible, tracks real-time state, handles graceful error
+recovery, and coordinates data flow between specialized AI components.
+
+Parallelism strategy:
+  - INTAKE + VISION run concurrently (vision only needs the raw image)
+  - RESEARCH runs after VISION completes (needs findings)
+  - REPORT runs after all three complete
+  - CRITIC runs after REPORT
+"""
+
+import logging
+import time
+from concurrent.futures import ThreadPoolExecutor, wait as futures_wait
+from datetime import datetime
+from typing import Any, Callable, Dict, Optional
+
+from core.models import (
+    AgentStatus,
+    FinalReport,
+    IntakeOutput,
+    PipelineState,
+    PatientInput,
+    ResearchOutput,
+    ReportSection,
+    VisionOutput,
+)
+
+logger = logging.getLogger(__name__)
+
+
+class PipelineOrchestrator:
+    """
+    Central execution engine that routes patient data through the 5-agent
+    medical analysis pipeline. Runs INTAKE and VISION in parallel to cut
+    wall-clock latency, then sequences RESEARCH → REPORT → CRITIC.
+    """
+
+    AGENT_ORDER = ["INTAKE", "VISION", "RESEARCH", "REPORT", "CRITIC"]
+
+    def __init__(
+        self,
+        intake_agent: Any,
+        vision_agent: Any,
+        research_agent: Any,
+        report_agent: Any,
+        critic_agent: Any,
+        on_status_update: Optional[Callable[[PipelineState], None]] = None,
+    ):
+        self.agents = {
+            "INTAKE": intake_agent,
+            "VISION": vision_agent,
+            "RESEARCH": research_agent,
+            "REPORT": report_agent,
+            "CRITIC": critic_agent,
+        }
+        self.on_status_update = on_status_update
+
+    def run(self, patient_input: PatientInput) -> PipelineState:
+        """
+        Execute the full diagnostic pipeline with parallel INTAKE+VISION stage.
+
+        Returns:
+            PipelineState: Complete execution state containing all outputs,
+                          agent statuses, and final report.
+        """
+        logger.info("🚀 Pipeline execution started | Input ID: %s", id(patient_input))
+        state = PipelineState()
+
+        try:
+            # ─────────────────────────────────────────────────────────────
+            # STAGE 1: INTAKE + VISION in parallel
+            # Vision uses raw symptoms as clinical context so it doesn't
+            # have to wait for intake normalization to complete.
+            # ─────────────────────────────────────────────────────────────
+            raw_context = patient_input.symptoms or ""
+            with ThreadPoolExecutor(max_workers=2) as pool:
+                intake_fut = pool.submit(
+                    self._execute_step, state, "INTAKE",
+                    patient_input=patient_input
+                )
+                vision_fut = pool.submit(
+                    self._execute_step, state, "VISION",
+                    image_base64=patient_input.image_base64,
+                    clinical_context=raw_context
+                )
+                futures_wait([intake_fut, vision_fut])
+
+            if state.agent_statuses["INTAKE"] == AgentStatus.ERROR:
+                logger.warning("⚠️ Intake failed. Halting pipeline for safety.")
+                return state
+            if state.agent_statuses["VISION"] == AgentStatus.ERROR:
+                logger.warning("⚠️ Vision analysis failed. Continuing with degraded pipeline.")
+
+            # ─────────────────────────────────────────────────────────────
+            # STAGE 2: RESEARCH (needs vision findings + intake demographics)
+            # ─────────────────────────────────────────────────────────────
+            self._execute_step(
+                state, "RESEARCH",
+                vision_findings=state.vision_output.findings if state.vision_output else [],
+                demographics=state.intake_output.extracted_demographics,
+                detected_modality=state.vision_output.modality_detected.value if state.vision_output else "UNKNOWN"
+            )
+            if state.agent_statuses["RESEARCH"] == AgentStatus.ERROR:
+                logger.warning("⚠️ Research failed. Generating report without differential augmentation.")
+
+            # ─────────────────────────────────────────────────────────────
+            # STAGE 3: REPORT (synthesizes all three upstream outputs)
+            # ─────────────────────────────────────────────────────────────
+            self._execute_step(
+                state, "REPORT",
+                intake=state.intake_output,
+                vision=state.vision_output,
+                research=state.research_output,
+            )
+            if state.agent_statuses["REPORT"] == AgentStatus.ERROR:
+                logger.error("❌ Report generation failed. Pipeline cannot complete safely.")
+                return state
+
+            # ─────────────────────────────────────────────────────────────
+            # STAGE 4: CRITIC (QA review of final draft)
+            # ─────────────────────────────────────────────────────────────
+            self._execute_step(
+                state, "CRITIC",
+                draft_report=state.report_draft,
+                pipeline_state=state
+            )
+
+            state.final_report = self._assemble_final_report(state)
+            state.current_step = "COMPLETE"
+            logger.info("✅ Pipeline execution completed successfully.")
+
+        except Exception as e:
+            logger.exception("💥 Unhandled pipeline failure: %s", str(e))
+            state.current_step = "FAILED"
+            state.error_log.append(f"SYSTEM_FAILURE: {str(e)}")
+
+        return state
+
+    def _execute_step(
+        self,
+        state: PipelineState,
+        agent_name: str,
+        **kwargs
+    ) -> None:
+        """
+        Generic step executor with state management, timing, and error isolation.
+        Thread-safe: each agent writes to its own dedicated state field.
+        """
+        logger.info(f"▶️ Executing agent: {agent_name}")
+        state.current_step = agent_name
+        state.mark_running(agent_name)
+        self._notify(state)
+
+        start_time = time.perf_counter()
+        try:
+            agent = self.agents[agent_name]
+            output = agent.process(**kwargs)
+            elapsed = time.perf_counter() - start_time
+
+            if output is not None:
+                if agent_name == "INTAKE":
+                    state.intake_output = output
+                elif agent_name == "VISION":
+                    state.vision_output = output
+                elif agent_name == "RESEARCH":
+                    state.research_output = output
+                elif agent_name == "REPORT":
+                    state.report_draft = output
+
+            state.mark_done(agent_name)
+            logger.info(f"✅ {agent_name} completed in {elapsed:.3f}s")
+
+        except Exception as e:
+            elapsed = time.perf_counter() - start_time
+            error_msg = f"{agent_name} execution failed after {elapsed:.3f}s: {str(e)}"
+            logger.error("❌ %s", error_msg, exc_info=True)
+            state.mark_error(agent_name, str(e))
+
+        finally:
+            self._notify(state)
+
+    def _assemble_final_report(self, state: PipelineState) -> FinalReport:
+        """
+        Synthesize all agent outputs into the final deliverable report structure.
+        Applies critic modifications and standardizes formatting.
+        """
+        report_draft = state.report_draft or ReportSection()
+        
+        # Determine overall severity from vision findings
+        overall_severity = "NORMAL"
+        if state.vision_output and state.vision_output.findings:
+            severity_hierarchy = {"CRITICAL": 4, "SIGNIFICANT": 3, "INCIDENTAL": 2, "NORMAL": 1}
+            highest = max(
+                (severity_hierarchy.get(f.severity.value, 1) for f in state.vision_output.findings),
+                default=1
+            )
+            severity_map = {4: "CRITICAL", 3: "SIGNIFICANT", 2: "INCIDENTAL", 1: "NORMAL"}
+            overall_severity = severity_map.get(highest, "NORMAL")
+
+        # Build vision summary
+        vision_summary = "No imaging analysis performed."
+        if state.vision_output:
+            anomalies = [f.description for f in state.vision_output.findings if f.is_anomaly]
+            vision_summary = (
+                f"Modality: {state.vision_output.modality_detected.value} | "
+                f"Quality: {state.vision_output.technical_quality} | "
+                f"Anomalies Detected: {len(anomalies)} | "
+                f"Overall: {state.vision_output.overall_assessment}"
+            )
+
+        # Build research summary
+        research_summary = "No differential diagnosis generated."
+        if state.research_output and state.research_output.differential_diagnoses:
+            top_dx = state.research_output.differential_diagnoses[:3]
+            dx_list = " | ".join([d.condition_name for d in top_dx])
+            research_summary = f"Top Differentials: {dx_list} | Confidence: {'/'.join([f'{d.match_probability:.0f}%' for d in top_dx])}"
+
+        return FinalReport(
+            patient_metadata=state.intake_output.extracted_demographics if state.intake_output else {},
+            sections=report_draft,
+            vision_summary=vision_summary,
+            research_summary=research_summary,
+            overall_severity=overall_severity,
+            agent_pipeline_status=state.agent_statuses,
+            generation_timestamp=datetime.now()
+        )
+
+    def _notify(self, state: PipelineState) -> None:
+        """Invoke status callback if registered (used for SSE/UI polling)."""
+        if self.on_status_update:
+            try:
+                self.on_status_update(state)
+            except Exception as e:
+                logger.warning("⚠️ Status callback failed: %s", str(e))

main.py

@@ -0,0 +1,521 @@
+# mediagent/main.py
+"""
+MediAgent - Autonomous Multi-Agent Medical Imaging Analysis System
+Production FastAPI Server & Orchestrator Entry Point
+
+New in v2.0:
+  - DICOM (.dcm) file support with automatic metadata extraction
+  - Real-time token-level streaming during report generation
+  - AMD GPU metrics endpoint (/metrics/gpu)
+  - Post-report clinical advisor chat (/chat/{report_id})
+  - FHIR R4 DiagnosticReport export (/export/fhir/{report_id})
+"""
+
+import json
+import logging
+import base64
+import uuid
+import asyncio
+import subprocess
+import uvicorn
+import os
+from datetime import datetime
+from typing import Dict, Optional, Any, AsyncGenerator
+from concurrent.futures import ThreadPoolExecutor
+
+from fastapi import FastAPI, UploadFile, File, Form, HTTPException
+from fastapi.middleware.cors import CORSMiddleware
+from fastapi.responses import HTMLResponse, JSONResponse, FileResponse, StreamingResponse
+from fastapi.staticfiles import StaticFiles
+
+from core.llm import LLMClient
+from core.models import PatientInput, PipelineState, ChatRequest, ChatResponse
+from core.pipeline import PipelineOrchestrator
+from agents.intake import IntakeAgent
+from agents.vision import VisionAgent
+from agents.research import ResearchAgent
+from agents.report import ReportAgent
+from agents.critic import CriticAgent
+from agents.advisor import ClinicalAdvisorAgent
+
+# ─────────────────────────────────────────────────────────────────────────────
+# LOGGING
+# ─────────────────────────────────────────────────────────────────────────────
+logging.basicConfig(
+    level=logging.INFO,
+    format="%(asctime)s | %(levelname)-8s | %(name)s | %(message)s",
+    datefmt="%Y-%m-%d %H:%M:%S",
+    force=True
+)
+logger = logging.getLogger("mediagent.server")
+
+# ─────────────────────────────────────────────────────────────────────────────
+# CONFIG
+# ─────────────────────────────────────────────────────────────────────────────
+LLM_BASE_URL = os.getenv("LLM_BASE_URL", "http://localhost:8000/v1")
+DEMO_MODE = os.getenv("DEMO_MODE", "false").lower() == "true"
+
+# ─────────────────────────────────────────────────────────────────────────────
+# APP
+# ─────────────────────────────────────────────────────────────────────────────
+app = FastAPI(
+    title="MediAgent API",
+    version="2.0.0",
+    description="Autonomous Multi-Agent Medical Imaging Analysis System — AMD MI300X",
+    docs_url="/api/docs",
+    redoc_url="/api/redoc"
+)
+
+app.add_middleware(
+    CORSMiddleware,
+    allow_origins=["*"],
+    allow_credentials=True,
+    allow_methods=["*"],
+    allow_headers=["*"],
+)
+
+# Registry: report_id → PipelineState (capped at 200 entries)
+pipeline_registry: Dict[str, PipelineState] = {}
+REGISTRY_MAX_SIZE = 200
+
+
+# ─────────────────────────────────────────────────────────────────────────────
+# STARTUP
+# ─────────────────────────────────────────────────────────────────────────────
+@app.on_event("startup")
+async def startup_event():
+    logger.info("🚀 MediAgent v2.0 — System Startup")
+    if DEMO_MODE:
+        logger.info("⚠️  DEMO MODE ACTIVE — no real inference will be performed")
+    try:
+        llm_client = LLMClient()
+        app.state.llm_client      = llm_client
+        app.state.intake_agent    = IntakeAgent(llm_client=llm_client)
+        app.state.vision_agent    = VisionAgent(llm_client=llm_client)
+        app.state.research_agent  = ResearchAgent(llm_client=llm_client)
+        app.state.report_agent    = ReportAgent(llm_client=llm_client)
+        app.state.critic_agent    = CriticAgent(llm_client=llm_client)
+        app.state.advisor_agent   = ClinicalAdvisorAgent(llm_client=llm_client)
+
+        def _default_cb(state: PipelineState):
+            pass
+
+        app.state.orchestrator = PipelineOrchestrator(
+            intake_agent=app.state.intake_agent,
+            vision_agent=app.state.vision_agent,
+            research_agent=app.state.research_agent,
+            report_agent=app.state.report_agent,
+            critic_agent=app.state.critic_agent,
+            on_status_update=_default_cb,
+        )
+        logger.info("✅ All agents initialised. MediAgent v2.0 online.")
+    except Exception as e:
+        logger.critical("💥 Startup failure: %s", e)
+        raise SystemExit(str(e))
+
+
+# ─────────────────────────────────────────────────────────────────────────────
+# HELPERS
+# ─────────────────────────────────────────────────────────────────────────────
+
+def _evict_registry():
+    if len(pipeline_registry) >= REGISTRY_MAX_SIZE:
+        del pipeline_registry[next(iter(pipeline_registry))]
+
+
+async def _read_and_encode_image(image: UploadFile):
+    image_bytes = await image.read()
+    if len(image_bytes) > 20 * 1024 * 1024:
+        raise HTTPException(status_code=413, detail="Image exceeds 20 MB size limit.")
+
+    filename = (image.filename or "").lower()
+    content_type = image.content_type or ""
+
+    is_dicom = (
+        filename.endswith(".dcm")
+        or "dicom" in content_type
+        or image_bytes[:4] == b"\x00\x00\x00\x00"
+        or image_bytes[128:132] == b"DICM"
+    )
+
+    if is_dicom:
+        try:
+            from core.dicom import parse_dicom
+            b64_image, dicom_meta = parse_dicom(image_bytes)
+            logger.info("DICOM parsed | meta keys: %s", list(dicom_meta.keys()))
+            return b64_image, dicom_meta
+        except Exception as e:
+            logger.warning("DICOM parse failed (%s), treating as regular image", e)
+
+    b64_data = base64.b64encode(image_bytes).decode("utf-8")
+    mime = content_type if content_type.startswith("image/") else "image/jpeg"
+    return f"data:{mime};base64,{b64_data}", None
+
+
+# ─────────────────────────────────────────────────────────────────────────────
+# ROUTES — STATIC / HEALTH
+# ─────────────────────────────────────────────────────────────────────────────
+
+@app.get("/", response_class=HTMLResponse)
+async def serve_frontend():
+    return FileResponse("static/index.html")
+
+
+@app.get("/health")
+async def health_check():
+    return {
+        "status": "healthy",
+        "version": "2.0.0",
+        "timestamp": datetime.utcnow().isoformat() + "Z",
+        "system": "MediAgent",
+        "infrastructure": "AMD Instinct MI300X / ROCm / vLLM",
+        "agents_loaded": hasattr(app.state, "orchestrator"),
+        "active_sessions": len(pipeline_registry),
+        "demo_mode": DEMO_MODE,
+        "features": ["dicom", "clinical_chat", "gpu_metrics"],
+    }
+
+
+# ─────────────────────────────────────────────────────────────────────────────
+# ROUTES — AMD GPU METRICS
+# ─────────────────────────────────────────────────────────────────────────────
+
+@app.get("/metrics/gpu")
+async def get_gpu_metrics():
+    metrics: Dict[str, Any] = {
+        "available": False,
+        "timestamp": datetime.utcnow().isoformat() + "Z",
+    }
+
+    try:
+        import amdsmi
+        amdsmi.amdsmi_init()
+        devices = amdsmi.amdsmi_get_processor_handles()
+        cards = []
+        for i, dev in enumerate(devices):
+            try:
+                usage   = amdsmi.amdsmi_get_gpu_activity(dev)
+                vram    = amdsmi.amdsmi_get_gpu_memory_usage(dev, amdsmi.AmdSmiMemoryType.VRAM)
+                vtotal  = amdsmi.amdsmi_get_gpu_memory_total(dev, amdsmi.AmdSmiMemoryType.VRAM)
+                temp    = amdsmi.amdsmi_get_temp_metric(dev, amdsmi.AmdSmiTemperatureType.JUNCTION,
+                                                         amdsmi.AmdSmiTemperatureMetric.CURRENT)
+                power   = amdsmi.amdsmi_get_power_info(dev)
+                clk     = amdsmi.amdsmi_get_clk_freq(dev, amdsmi.AmdSmiClkType.GFX)
+                cards.append({
+                    "card":          f"GPU {i}",
+                    "gpu_use_pct":   usage.get("gfx_activity", 0),
+                    "vram_used_mb":  round(vram / 1024 / 1024, 1),
+                    "vram_total_mb": round(vtotal / 1024 / 1024, 1),
+                    "temp_c":        temp,
+                    "power_w":       round(power.get("current_socket_power", 0), 1),
+                    "clk_mhz":       clk.get("cur_clk", 0),
+                })
+            except Exception:
+                pass
+        amdsmi.amdsmi_shut_down()
+        if cards:
+            metrics["available"] = True
+            metrics["source"] = "amdsmi"
+            metrics["cards"] = cards
+            return metrics
+    except Exception:
+        pass
+
+    try:
+        result = subprocess.run(
+            ["rocm-smi", "--showuse", "--showmeminfo", "vram", "--showtemp", "--showpower", "--json"],
+            capture_output=True, text=True, timeout=5
+        )
+        if result.returncode == 0 and result.stdout.strip():
+            raw = json.loads(result.stdout)
+            cards = []
+            for key, val in raw.items():
+                if not isinstance(val, dict):
+                    continue
+
+                def _pick(d, *keys, default=0):
+                    for k in keys:
+                        v = d.get(k)
+                        if v is not None:
+                            try: return float(str(v).replace("%","").strip())
+                            except ValueError: pass
+                    return default
+
+                vram_used  = _pick(val,
+                    "VRAM Total Used Memory (B)", "Used VRAM (B)", "vram_used",
+                    "VRAM Total Used Memory (MiB)", "Used VRAM (MiB)", "VRAM Total Memory Used (MiB)")
+                vram_total = _pick(val,
+                    "VRAM Total Memory (B)", "Total VRAM (B)", "vram_total",
+                    "VRAM Total Memory (MiB)", "Total VRAM (MiB)", "VRAM Total Memory Size (MiB)")
+                if vram_used  > 1_000_000: vram_used  = round(vram_used  / 1024 / 1024, 1)
+                if vram_total > 1_000_000: vram_total = round(vram_total / 1024 / 1024, 1)
+
+                cards.append({
+                    "card":          key,
+                    "gpu_use_pct":   _pick(val, "GPU use (%)", "GPU Use (%)", "GFX Activity (%)", "GPU activity (%)"),
+                    "vram_used_mb":  vram_used,
+                    "vram_total_mb": vram_total,
+                    "temp_c":        _pick(val, "Temperature (Sensor junction) (C)",
+                                        "Temperature (Sensor HBM 0) (C)", "Junction Temperature (C)"),
+                    "power_w":       _pick(val, "Current Socket Graphics Package Power (W)",
+                                        "Average Graphics Package Power (W)", "Socket Power (W)"),
+                })
+
+            if cards:
+                metrics["available"] = True
+                metrics["source"] = "rocm-smi"
+                metrics["cards"] = cards
+                return metrics
+    except FileNotFoundError:
+        pass
+    except Exception as e:
+        logger.debug("rocm-smi JSON failed: %s", e)
+
+    metrics["note"] = "AMD GPU metrics unavailable — is ROCm installed?"
+    return metrics
+
+
+# ─────────────────────────────────────────────────────────────────────────────
+# ROUTES — ANALYSIS
+# ─────────────────────────────────────────────────────────────────────────────
+
+@app.post("/analyze")
+async def analyze_image(
+    image: UploadFile = File(...),
+    symptoms: str = Form(default=""),
+    age: Optional[int] = Form(default=None, ge=0, le=120),
+    sex: Optional[str] = Form(default=None),
+    clinical_context: str = Form(default=""),
+):
+    logger.info("[SYNC] New analysis request | file=%s", image.filename)
+    report_id = f"REP-{uuid.uuid4().hex[:12].upper()}"
+
+    try:
+        b64_image, dicom_meta = await _read_and_encode_image(image)
+    except HTTPException:
+        raise
+    except Exception as e:
+        raise HTTPException(status_code=400, detail=f"Image processing failed: {e}")
+
+    if dicom_meta:
+        if age is None and dicom_meta.get("age"):
+            try: age = int(dicom_meta["age"])
+            except (ValueError, TypeError): pass
+        if not sex and dicom_meta.get("sex"):
+            sex = dicom_meta["sex"]
+        if not clinical_context and dicom_meta.get("study_description"):
+            clinical_context = f"DICOM: {dicom_meta.get('study_description','')} | {dicom_meta.get('body_part','')}"
+
+    patient_input = PatientInput(
+        image_base64=b64_image, symptoms=symptoms, age=age,
+        sex=sex, clinical_context=clinical_context
+    )
+
+    _evict_registry()
+    pipeline_registry[report_id] = PipelineState()
+
+    try:
+        state = app.state.orchestrator.run(patient_input)
+        pipeline_registry[report_id] = state
+        if not state.final_report:
+            raise HTTPException(status_code=500, detail="Pipeline completed without final report.")
+        report_dict = state.final_report.model_dump()
+        if dicom_meta:
+            report_dict["dicom_metadata"] = dicom_meta
+        logger.info("[SYNC] Complete | report_id=%s", report_id)
+        return JSONResponse(content=report_dict)
+    except HTTPException:
+        raise
+    except Exception as e:
+        logger.exception("Pipeline failure: %s", e)
+        raise HTTPException(status_code=500, detail=str(e))
+
+
+@app.post("/analyze/stream")
+async def analyze_stream(
+    image: UploadFile = File(...),
+    symptoms: str = Form(default=""),
+    age: Optional[int] = Form(default=None, ge=0, le=120),
+    sex: Optional[str] = Form(default=None),
+    clinical_context: str = Form(default=""),
+):
+    logger.info("[STREAM] New streaming analysis request | file=%s", image.filename)
+
+    try:
+        b64_image, dicom_meta = await _read_and_encode_image(image)
+    except HTTPException:
+        raise
+    except Exception as e:
+        raise HTTPException(status_code=400, detail=str(e))
+
+    if dicom_meta:
+        if age is None and dicom_meta.get("age"):
+            try: age = int(dicom_meta["age"])
+            except (ValueError, TypeError): pass
+        if not sex and dicom_meta.get("sex"):
+            sex = dicom_meta["sex"]
+        if not clinical_context and dicom_meta.get("study_description"):
+            clinical_context = f"DICOM: {dicom_meta.get('study_description','')} | {dicom_meta.get('body_part','')}"
+
+    patient_input = PatientInput(
+        image_base64=b64_image, symptoms=symptoms, age=age,
+        sex=sex, clinical_context=clinical_context
+    )
+
+    async def event_generator() -> AsyncGenerator[str, None]:
+        queue: asyncio.Queue = asyncio.Queue()
+        executor = ThreadPoolExecutor(max_workers=1)
+
+        _last_statuses: dict = {}
+
+        def _status_cb(state: PipelineState):
+            for agent_name, status in state.agent_statuses.items():
+                if _last_statuses.get(agent_name) != status:
+                    _last_statuses[agent_name] = status
+                    payload = {"agent": agent_name, "status": status.value}
+                    queue.put_nowait(f"data: {json.dumps(payload)}\n\n")
+
+        def _run_pipeline():
+            # ── DEMO MODE ──────────────────────────────────────────────────────
+            if DEMO_MODE:
+                import time
+                for agent in ["INTAKE", "VISION", "RESEARCH", "REPORT", "CRITIC"]:
+                    queue.put_nowait(f'data: {json.dumps({"agent": agent, "status": "RUNNING"})}\n\n')
+                    time.sleep(1.2)
+                    queue.put_nowait(f'data: {json.dumps({"agent": agent, "status": "DONE"})}\n\n')
+                demo_report = {
+                    "type": "report",
+                    "report_id": "REP-DEMO0000001",
+                    "data": {
+                        "report_id": "REP-DEMO0000001",
+                        "overall_severity": "SIGNIFICANT",
+                        "vision_summary": "Demo mode active — live inference runs on AMD Instinct MI300X via ROCm + vLLM.",
+                        "research_summary": "This is a demonstration deployment. Real analysis requires the AMD MI300X inference backend.",
+                        "agent_pipeline_status": "DEMO",
+                        "sections": {
+                            "clinical_history": "Demo submission — AMD Developer Hackathon 2026.",
+                            "technique": "Demo mode active. No live GPU inference on this host.",
+                            "findings": "This Space demonstrates the full MediAgent UI and pipeline architecture. Live multimodal analysis runs on AMD Instinct MI300X via ROCm + vLLM. See the video demo for live inference on real medical images.",
+                            "impression": "1. Demo mode active — no real image analysis performed (85%)\n\nConfidence Level: N/A — Demo deployment",
+                            "recommendations": "Deploy with LLM_BASE_URL pointed at a live vLLM ROCm endpoint to enable full analysis.\n\n[QUALITY ASSESSMENT]\nScore: N/A | Demo mode",
+                            "disclaimer": "This analysis is AI-generated and must be reviewed by a licensed radiologist before any clinical decisions are made."
+                        },
+                        "vision_findings": [
+                            {"severity": "SIGNIFICANT", "confidence_score": 85, "description": "Demo mode — live analysis requires AMD MI300X backend"},
+                            {"severity": "NORMAL", "confidence_score": 95, "description": "Demo mode — system operational"}
+                        ],
+                        "differential_diagnoses": [
+                            {"condition_name": "Demo Mode Active", "match_probability": 100},
+                            {"condition_name": "Requires AMD MI300X", "match_probability": 85}
+                        ]
+                    }
+                }
+                queue.put_nowait(f'data: {json.dumps(demo_report)}\n\n')
+                queue.put_nowait(None)
+                return
+            # ── LIVE MODE ──────────────────────────────────────────────────────
+            try:
+                report_id = f"REP-{uuid.uuid4().hex[:12].upper()}"
+                orchestrator = PipelineOrchestrator(
+                    intake_agent=app.state.intake_agent,
+                    vision_agent=app.state.vision_agent,
+                    research_agent=app.state.research_agent,
+                    report_agent=app.state.report_agent,
+                    critic_agent=app.state.critic_agent,
+                    on_status_update=_status_cb,
+                )
+                state = orchestrator.run(patient_input)
+                _evict_registry()
+                pipeline_registry[report_id] = state
+
+                if state.final_report:
+                    report_dict = state.final_report.model_dump()
+                    if dicom_meta:
+                        report_dict["dicom_metadata"] = dicom_meta
+                    if state.vision_output:
+                        report_dict["vision_findings"] = [
+                            {"severity": f.severity.value, "confidence_score": f.confidence_score, "description": f.description}
+                            for f in state.vision_output.findings
+                        ]
+                    if state.research_output:
+                        report_dict["differential_diagnoses"] = [
+                            {"condition_name": d.condition_name, "match_probability": d.match_probability}
+                            for d in state.research_output.differential_diagnoses[:5]
+                        ]
+                    payload = {"type": "report", "data": report_dict, "report_id": report_id}
+                    queue.put_nowait(f"data: {json.dumps(payload, default=str)}\n\n")
+                else:
+                    queue.put_nowait(f"data: {json.dumps({'type':'error','message':'Pipeline produced no report'})}\n\n")
+            except Exception as e:
+                logger.exception("Stream pipeline crashed: %s", e)
+                queue.put_nowait(f"data: {json.dumps({'type':'error','message':str(e)})}\n\n")
+            finally:
+                queue.put_nowait(None)
+
+        asyncio.get_running_loop().run_in_executor(executor, _run_pipeline)
+
+        while True:
+            event = await queue.get()
+            if event is None:
+                break
+            yield event
+
+    return StreamingResponse(event_generator(), media_type="text/event-stream")
+
+
+# ─────────────────────────────────────────────────────────────────────────────
+# ROUTES — CLINICAL ADVISOR CHAT
+# ─────────────────────────────────────────────────────────────────────────────
+
+@app.post("/chat/{report_id}", response_model=ChatResponse)
+async def clinical_chat(report_id: str, request: ChatRequest):
+    if DEMO_MODE:
+        return ChatResponse(
+            answer="This is a demo deployment. Clinical Q&A is available when running on AMD Instinct MI300X with live inference. See the video demo for full functionality.",
+            report_id=report_id
+        )
+
+    if report_id not in pipeline_registry:
+        raise HTTPException(status_code=404, detail="Report not found. Run analysis first.")
+
+    state = pipeline_registry[report_id]
+    if not state.final_report:
+        raise HTTPException(status_code=400, detail="Report not yet complete.")
+
+    loop = asyncio.get_running_loop()
+    answer = await loop.run_in_executor(
+        None,
+        app.state.advisor_agent.answer,
+        request.question,
+        state.final_report,
+    )
+
+    return ChatResponse(answer=answer, report_id=report_id)
+
+
+# ─────────────────────────────────────────────────────────────────────────────
+# ROUTES — STATUS
+# ─────────────────────────────────────────────────────────────────────────────
+
+@app.get("/status/{report_id}")
+async def get_pipeline_status(report_id: str):
+    if report_id not in pipeline_registry:
+        raise HTTPException(status_code=404, detail="Report ID not found.")
+    state = pipeline_registry[report_id]
+    return {
+        "report_id": report_id,
+        "current_step": state.current_step,
+        "agent_statuses": {k: v.value for k, v in state.agent_statuses.items()},
+        "error_log": state.error_log,
+        "completed": state.current_step == "COMPLETE",
+    }
+
+
+# ─────────────────────────────────────────────────────────────────────────────
+# STATIC + ENTRY
+# ─────────────────────────────────────────────────────────────────────────────
+app.mount("/static", StaticFiles(directory="static"), name="static")
+
+if __name__ == "__main__":
+    logger.info("🏥 Starting MediAgent v2.0 on port 8090")
+    uvicorn.run("main:app", host="0.0.0.0", port=8090, log_level="info", reload=False)

requirements.txt

@@ -0,0 +1,12 @@
+# MediAgent Core Dependencies
+# Compatible with Python 3.12+
+# Optimized for AMD MI300X local inference stack
+
+fastapi==0.115.6
+uvicorn[standard]==0.34.0
+openai==1.58.1
+python-multipart==0.0.20
+pydantic==2.10.5
+Pillow==11.1.0
+pydicom==2.4.4
+numpy==1.26.4

static/index.html

@@ -0,0 +1,833 @@
+<!DOCTYPE html>
+<html lang="en">
+<head>
+    <meta charset="UTF-8">
+    <meta name="viewport" content="width=device-width, initial-scale=1.0">
+    <title>MediAgent v2 | AMD MI300X Radiology AI</title>
+    <script src="https://cdn.tailwindcss.com"></script>
+    <script src="https://cdnjs.cloudflare.com/ajax/libs/jspdf/2.5.1/jspdf.umd.min.js"></script>
+    <script src="https://cdn.jsdelivr.net/npm/chart.js@4.4.0/dist/chart.umd.min.js"></script>
+    <link href="https://fonts.googleapis.com/css2?family=Inter:wght@300;400;500;600;700&family=JetBrains+Mono:wght@400;500&display=swap" rel="stylesheet">
+    <script>
+        tailwind.config = {
+            theme: {
+                extend: {
+                    fontFamily: { sans: ['Inter','sans-serif'], mono: ['JetBrains Mono','monospace'] },
+                    colors: {
+                        med: { 50:'#eff6ff',100:'#dbeafe',200:'#bfdbfe',500:'#3b82f6',600:'#2563eb',700:'#1d4ed8',800:'#1e40af',900:'#1e3a8a' },
+                        amd: { 400:'#f97316',500:'#ea580c',600:'#c2410c' }
+                    }
+                }
+            }
+        }
+    </script>
+    <style>
+        * { box-sizing: border-box; }
+        body { height:100vh; overflow:hidden; background:#f1f5f9; }
+        ::-webkit-scrollbar { width:5px; height:5px; }
+        ::-webkit-scrollbar-track { background:transparent; }
+        ::-webkit-scrollbar-thumb { background:#cbd5e1; border-radius:3px; }
+        @keyframes fadeIn { from{opacity:0;transform:translateY(4px)} to{opacity:1;transform:translateY(0)} }
+        @keyframes typing { from{opacity:0} to{opacity:1} }
+        .animate-fade-in { animation:fadeIn 0.3s ease-out forwards; }
+        .drop-zone.drag-over { border-color:#2563eb !important; background:#eff6ff !important; transform:scale(1.01); }
+        .finding-NORMAL    { border-left-color:#10b981; }
+        .finding-INCIDENTAL{ border-left-color:#f59e0b; }
+        .finding-SIGNIFICANT{border-left-color:#f97316; }
+        .finding-CRITICAL  { border-left-color:#ef4444; }
+        .chat-bubble-user { background:#1e40af; color:#fff; border-radius:12px 12px 2px 12px; }
+        .chat-bubble-ai   { background:#f1f5f9; color:#1e293b; border-radius:12px 12px 12px 2px; }
+        .token-stream { white-space:pre-wrap; }
+        .gpu-bar { transition: width 0.8s ease; }
+        .panel-tab.active { border-bottom:2px solid #2563eb; color:#1d4ed8; font-weight:600; }
+        .dicom-badge { background:linear-gradient(135deg,#1e40af,#7c3aed); }
+    </style>
+</head>
+<body class="flex flex-col text-slate-800 font-sans">
+
+<!-- ═══════════════════════════════════════════════════════════════════ HEADER -->
+<header class="h-14 bg-slate-900 text-white flex items-center justify-between px-5 shrink-0 z-20 shadow-lg">
+    <div class="flex items-center gap-3">
+        <div class="w-8 h-8 bg-med-600 rounded-lg flex items-center justify-center font-black text-white text-sm">M</div>
+        <div>
+            <div class="flex items-center gap-2">
+                <h1 class="font-bold text-base tracking-tight leading-none">MediAgent <span class="text-med-400">v2</span></h1>
+                <span class="text-[9px] bg-amd-500 text-white px-1.5 py-0.5 rounded font-bold uppercase tracking-wider">AMD MI300X</span>
+            </div>
+            <div class="flex items-center gap-1.5 mt-0.5">
+                <span class="w-1.5 h-1.5 rounded-full bg-green-400 animate-pulse"></span>
+                <span class="text-[9px] uppercase tracking-widest text-slate-400">System Online</span>
+            </div>
+        </div>
+    </div>
+    <div class="flex items-center gap-3">
+        <div id="gpu-header-badge" class="hidden items-center gap-2 bg-slate-800 border border-orange-500/30 px-3 py-1 rounded-full">
+            <span class="w-1.5 h-1.5 rounded-full bg-orange-400 animate-pulse"></span>
+            <span class="text-[10px] font-mono text-orange-300" id="gpu-header-text">GPU: --</span>
+        </div>
+        <span id="clock" class="text-xs font-mono text-slate-400"></span>
+    </div>
+</header>
+
+<!-- ═══════════════════════════════════════════════════════════════════ MAIN -->
+<main class="flex-1 grid grid-cols-12 overflow-hidden" style="height:calc(100vh - 56px)">
+
+    <!-- ══ LEFT: INPUT ══════════════════════════════════════════════════════ -->
+    <section class="col-span-3 bg-slate-50 border-r border-slate-200 flex flex-col overflow-y-auto">
+        <div class="p-4 flex flex-col gap-4">
+
+            <!-- Upload zone -->
+            <div>
+                <p class="text-[10px] font-bold text-slate-500 uppercase tracking-widest mb-2">Medical Image</p>
+                <div id="drop-zone" class="drop-zone border-2 border-dashed border-slate-300 rounded-xl p-5 text-center cursor-pointer bg-white hover:border-med-500 transition-all relative group">
+                    <input type="file" id="file-input" class="hidden" accept="image/png,image/jpeg,.dcm,application/dicom">
+                    <div id="upload-placeholder">
+                        <svg class="w-9 h-9 text-slate-300 mx-auto mb-2 group-hover:text-med-500 transition-colors" fill="none" stroke="currentColor" viewBox="0 0 24 24"><path stroke-linecap="round" stroke-linejoin="round" stroke-width="1.5" d="M4 16l4.586-4.586a2 2 0 012.828 0L16 16m-2-2l1.586-1.586a2 2 0 012.828 0L20 14m-6-6h.01M6 20h12a2 2 0 002-2V6a2 2 0 00-2-2H6a2 2 0 00-2 2v12a2 2 0 002 2z"></path></svg>
+                        <p class="text-xs font-semibold text-slate-500">Drop image or click to upload</p>
+                        <p class="text-[10px] text-slate-400 mt-1">PNG · JPG · <span class="text-purple-600 font-semibold">DICOM (.dcm)</span></p>
+                    </div>
+                    <img id="image-preview" class="hidden w-full h-36 object-contain rounded-lg bg-slate-100" alt="Preview">
+                    <div id="dicom-info" class="hidden mt-2 p-2 dicom-badge rounded-lg text-white text-[10px] font-mono leading-relaxed"></div>
+                </div>
+            </div>
+
+            <!-- Form -->
+            <form id="analysis-form" class="space-y-3">
+                <div>
+                    <label class="block text-[10px] font-bold text-slate-600 uppercase tracking-wider mb-1">Chief Complaint</label>
+                    <textarea id="symptoms" rows="2" class="w-full text-xs border border-slate-300 rounded-lg p-2.5 focus:ring-2 focus:ring-med-500 focus:border-med-500 outline-none resize-none" placeholder="e.g. Chest pain, shortness of breath..."></textarea>
+                </div>
+                <div class="grid grid-cols-2 gap-2">
+                    <div>
+                        <label class="block text-[10px] font-bold text-slate-600 uppercase tracking-wider mb-1">Age</label>
+                        <input type="number" id="age" min="0" max="120" class="w-full text-xs border border-slate-300 rounded-lg p-2.5 focus:ring-2 focus:ring-med-500 outline-none" placeholder="Yrs">
+                    </div>
+                    <div>
+                        <label class="block text-[10px] font-bold text-slate-600 uppercase tracking-wider mb-1">Sex</label>
+                        <select id="sex" class="w-full text-xs border border-slate-300 rounded-lg p-2.5 focus:ring-2 focus:ring-med-500 outline-none bg-white">
+                            <option value="">Select</option>
+                            <option value="M">Male</option>
+                            <option value="F">Female</option>
+                            <option value="O">Other</option>
+                        </select>
+                    </div>
+                </div>
+                <div>
+                    <label class="block text-[10px] font-bold text-slate-600 uppercase tracking-wider mb-1">Clinical History</label>
+                    <textarea id="clinical_context" rows="2" class="w-full text-xs border border-slate-300 rounded-lg p-2.5 focus:ring-2 focus:ring-med-500 outline-none resize-none" placeholder="Relevant history, medications..."></textarea>
+                </div>
+                <button type="submit" id="submit-btn" class="w-full bg-med-800 hover:bg-med-900 text-white font-bold py-2.5 rounded-lg shadow transition-all flex items-center justify-center gap-2 disabled:opacity-40 disabled:cursor-not-allowed text-sm">
+                    <span id="btn-text">Run Analysis</span>
+                    <svg id="btn-spinner" class="hidden w-4 h-4 animate-spin" fill="none" viewBox="0 0 24 24"><circle class="opacity-25" cx="12" cy="12" r="10" stroke="currentColor" stroke-width="4"></circle><path class="opacity-75" fill="currentColor" d="M4 12a8 8 0 018-8V0C5.373 0 0 5.373 0 12h4z"></path></svg>
+                </button>
+            </form>
+
+            <!-- AMD GPU Panel -->
+            <div style="background: var(--color-background-primary); border-radius: var(--border-radius-lg); border: 0.5px solid var(--color-border-tertiary); padding: 14px 16px;">
+                <div style="display: flex; align-items: center; justify-content: space-between; margin-bottom: 14px;">
+                    <div style="display: flex; align-items: center; gap: 8px;">
+                        <svg width="14" height="14" viewBox="0 0 24 24" fill="none" stroke="#f97316" stroke-width="2" stroke-linecap="round" stroke-linejoin="round"><rect x="2" y="6" width="20" height="12" rx="2" /><path d="M6 6V4M10 6V4M14 6V4M18 6V4M6 20v-2M10 20v-2M14 20v-2M18 20v-2" /></svg>
+                        <span style="font-size: 11px; font-weight: 500; color: #f97316; letter-spacing: 0.06em; text-transform: uppercase;">AMD GPU Metrics</span>
+                    </div>
+                    <span id="gpu-status-dot" style="width: 8px; height: 8px; border-radius: 50%; background: var(--color-border-secondary); display: inline-block;"></span>
+                </div>
+                <div id="gpu-panel-content">
+                    <p style="font-size: 11px; color: var(--color-text-tertiary); font-family: var(--font-mono); text-align: center; padding: 8px 0; margin: 0;">Polling GPU...</p>
+                </div>
+            </div>
+
+        </div>
+    </section>
+
+    <!-- ══ CENTER: PIPELINE + CHARTS ════════════════════════════════════════ -->
+    <section class="col-span-3 bg-white border-r border-slate-200 flex flex-col overflow-hidden">
+        <!-- Tabs -->
+        <div class="flex border-b border-slate-200 px-4 pt-3 gap-4 shrink-0">
+            <button class="panel-tab active text-[11px] pb-2 px-1 text-slate-500 transition-colors" onclick="switchTab('pipeline',this)">Pipeline</button>
+            <button class="panel-tab text-[11px] pb-2 px-1 text-slate-500 transition-colors" onclick="switchTab('charts',this)">Analytics</button>
+        </div>
+
+        <!-- Pipeline tab -->
+        <div id="tab-pipeline" class="flex-1 overflow-y-auto p-4 space-y-3">
+            <div id="pipeline-tracker"></div>
+            <div class="p-3 bg-slate-50 rounded-lg border border-slate-200 mt-2">
+                <p class="text-[9px] font-bold text-slate-400 uppercase tracking-widest mb-1">System Log</p>
+                <div id="pipeline-log" class="text-[11px] font-mono text-slate-600 leading-relaxed">Waiting for input...</div>
+                <div id="pipeline-timer" class="text-[11px] font-mono text-med-600 mt-1 hidden"></div>
+            </div>
+        </div>
+
+        <!-- Analytics tab -->
+        <div id="tab-charts" class="hidden flex-1 overflow-y-auto p-4 space-y-4">
+            <div>
+                <p class="text-[10px] font-bold text-slate-500 uppercase tracking-widest mb-2">Severity Distribution</p>
+                <div class="flex justify-center"><canvas id="severityChart" width="160" height="160"></canvas></div>
+            </div>
+            <div>
+                <p class="text-[10px] font-bold text-slate-500 uppercase tracking-widest mb-2">Finding Confidence</p>
+                <canvas id="confidenceChart" height="160"></canvas>
+            </div>
+            <div>
+                <p class="text-[10px] font-bold text-slate-500 uppercase tracking-widest mb-2">Agent Timing (s)</p>
+                <canvas id="timingChart" height="120"></canvas>
+            </div>
+        </div>
+    </section>
+
+    <!-- ══ RIGHT: REPORT + CHAT ════════════════════════════════════════════ -->
+    <section class="col-span-6 flex flex-col overflow-hidden bg-white">
+
+        <!-- Report area -->
+        <div id="report-scroll" class="flex-1 overflow-y-auto px-6 py-5">
+            <!-- Empty state -->
+            <div id="empty-state" class="h-full flex flex-col items-center justify-center text-slate-300">
+                <svg class="w-16 h-16 mb-4" fill="none" stroke="currentColor" viewBox="0 0 24 24"><path stroke-linecap="round" stroke-linejoin="round" stroke-width="1" d="M9 12h6m-6 4h6m2 5H7a2 2 0 01-2-2V5a2 2 0 012-2h5.586a1 1 0 01.707.293l5.414 5.414a1 1 0 01.293.707V19a2 2 0 01-2 2z"></path></svg>
+                <p class="text-sm font-medium text-slate-400">Upload an image and run analysis</p>
+                <p class="text-xs text-slate-300 mt-1">Supports PNG, JPG, DICOM</p>
+            </div>
+
+            <!-- Final report -->
+            <div id="report-content" class="hidden space-y-5 animate-fade-in">
+
+                <!-- Severity banner -->
+                <div id="severity-banner" class="px-4 py-3 rounded-xl flex items-center justify-between">
+                    <div class="flex items-center gap-3">
+                        <span id="banner-icon" class="w-8 h-8 rounded-full flex items-center justify-center bg-white/50"></span>
+                        <span id="severity-text" class="font-bold text-sm uppercase tracking-wide">Severity: NORMAL</span>
+                    </div>
+                    <div class="text-[10px] font-mono opacity-75 flex items-center gap-3">
+                        <span id="meta-id">---</span>
+                        <span>|</span>
+                        <span id="meta-time">---</span>
+                        <span>|</span>
+                        <span id="meta-qa" class="font-bold">QA ---</span>
+                    </div>
+                </div>
+
+                <!-- DICOM metadata card -->
+                <div id="dicom-meta-card" class="hidden p-3 rounded-xl border border-purple-200 bg-purple-50">
+                    <p class="text-[10px] font-bold text-purple-700 uppercase tracking-widest mb-2">DICOM Metadata</p>
+                    <div id="dicom-meta-content" class="grid grid-cols-2 gap-x-4 gap-y-1 text-[11px] font-mono text-purple-800"></div>
+                </div>
+
+                <!-- Report sections -->
+                <div class="space-y-4">
+                    <div><h3 class="text-xs font-bold text-slate-700 border-b border-slate-100 pb-1 mb-2 uppercase tracking-wide">Clinical History</h3><p id="sec-history" class="text-sm text-slate-600 leading-relaxed"></p></div>
+                    <div><h3 class="text-xs font-bold text-slate-700 border-b border-slate-100 pb-1 mb-2 uppercase tracking-wide">Technique</h3><p id="sec-technique" class="text-sm text-slate-600 leading-relaxed"></p></div>
+                    <div><h3 class="text-xs font-bold text-slate-700 border-b border-slate-100 pb-1 mb-2 uppercase tracking-wide">Findings</h3><div id="sec-findings" class="space-y-2"></div></div>
+                    <div><h3 class="text-xs font-bold text-slate-700 border-b border-slate-100 pb-1 mb-2 uppercase tracking-wide">Impression</h3><p id="sec-impression" class="text-sm text-slate-700 leading-relaxed font-medium"></p></div>
+                    <div><h3 class="text-xs font-bold text-slate-700 border-b border-slate-100 pb-1 mb-2 uppercase tracking-wide">Recommendations</h3><p id="sec-recommendations" class="text-sm text-slate-600 leading-relaxed"></p></div>
+                    <div class="bg-red-50 border border-red-100 rounded-xl p-4"><p class="text-[11px] text-red-800 italic font-medium" id="sec-disclaimer"></p></div>
+                </div>
+
+            </div>
+        </div>
+
+        <!-- Bottom bar: actions + chat -->
+        <div class="border-t border-slate-200 bg-white shrink-0">
+
+            <!-- Action buttons -->
+            <div class="flex items-center gap-2 px-4 py-2 border-b border-slate-100">
+                <button id="export-pdf-btn" disabled class="flex items-center gap-1.5 bg-slate-800 hover:bg-slate-700 text-white text-xs font-semibold px-4 py-1.5 rounded-lg shadow disabled:opacity-30 disabled:cursor-not-allowed transition-all">
+                    <svg class="w-3.5 h-3.5" fill="none" stroke="currentColor" viewBox="0 0 24 24"><path stroke-linecap="round" stroke-linejoin="round" stroke-width="2" d="M12 10v6m0 0l-3-3m3 3l3-3m2 8H7a2 2 0 01-2-2V5a2 2 0 012-2h5.586a1 1 0 01.707.293l5.414 5.414a1 1 0 01.293.707V19a2 2 0 01-2 2z"></path></svg>
+                    Export PDF
+                </button>
+                <button id="toggle-chat-btn" disabled class="ml-auto flex items-center gap-1.5 bg-blue-600 hover:bg-blue-700 text-white text-xs font-semibold px-4 py-1.5 rounded-lg shadow disabled:opacity-30 disabled:cursor-not-allowed transition-all">
+                    <svg class="w-3.5 h-3.5" fill="none" stroke="currentColor" viewBox="0 0 24 24"><path stroke-linecap="round" stroke-linejoin="round" stroke-width="2" d="M8 12h.01M12 12h.01M16 12h.01M21 12c0 4.418-4.03 8-9 8a9.863 9.863 0 01-4.255-.949L3 20l1.395-3.72C3.512 15.042 3 13.574 3 12c0-4.418 4.03-8 9-8s9 3.582 9 8z"></path></svg>
+                    Ask AI Consultant
+                </button>
+            </div>
+
+            <!-- Clinical chat -->
+            <div id="chat-panel" class="hidden flex flex-col" style="height:240px">
+                <div id="chat-messages" class="flex-1 overflow-y-auto px-4 py-3 space-y-2 bg-slate-50"></div>
+                <div class="flex gap-2 px-4 py-2 bg-white border-t border-slate-100">
+                    <input id="chat-input" type="text" placeholder="Ask a follow-up question about the report..." class="flex-1 text-xs border border-slate-300 rounded-lg px-3 py-2 focus:ring-2 focus:ring-blue-400 outline-none">
+                    <button id="chat-send-btn" class="bg-blue-600 hover:bg-blue-700 text-white text-xs font-bold px-4 py-2 rounded-lg transition-all">Send</button>
+                </div>
+            </div>
+        </div>
+    </section>
+
+</main>
+
+<!-- Toast -->
+<div id="toast" class="fixed bottom-5 right-5 translate-y-16 opacity-0 transition-all duration-300 z-50 pointer-events-none">
+    <div id="toast-inner" class="bg-slate-800 text-white px-4 py-2.5 rounded-lg shadow-xl text-xs font-medium flex items-center gap-2">
+        <span id="toast-message">Message</span>
+    </div>
+</div>
+
+<script>
+// ═══════════════════════════════════════════════════════ GLOBALS
+const AGENTS = ['INTAKE','VISION','RESEARCH','REPORT','CRITIC'];
+let lastReportData = null;
+let currentReportId = null;
+let startTime = 0;
+let timerInterval = null;
+let agentTimings = {};
+let agentStartTimes = {};
+let severityChart = null;
+let confidenceChart = null;
+let timingChart = null;
+let gpuPollInterval = null;
+
+// ═══════════════════════════════════════════════════════ INIT
+function init() {
+    renderAgents();
+    setInterval(() => {
+        document.getElementById('clock').textContent = new Date().toLocaleTimeString([],{hour:'2-digit',minute:'2-digit',second:'2-digit'});
+    }, 1000);
+    startGpuPolling();
+}
+
+// ═══════════════════════════════════════════════════════ TAB SWITCHING
+function switchTab(name, btn) {
+    document.querySelectorAll('.panel-tab').forEach(b => b.classList.remove('active'));
+    btn.classList.add('active');
+    document.getElementById('tab-pipeline').classList.toggle('hidden', name !== 'pipeline');
+    document.getElementById('tab-charts').classList.toggle('hidden', name !== 'charts');
+}
+
+// ═══════════════════════════════════════════════════════ FILE UPLOAD
+const dropZone = document.getElementById('drop-zone');
+const fileInput = document.getElementById('file-input');
+dropZone.addEventListener('click', () => fileInput.click());
+dropZone.addEventListener('dragover', e => { e.preventDefault(); dropZone.classList.add('drag-over'); });
+dropZone.addEventListener('dragleave', () => dropZone.classList.remove('drag-over'));
+dropZone.addEventListener('drop', e => { e.preventDefault(); dropZone.classList.remove('drag-over'); if (e.dataTransfer.files.length) handleFile(e.dataTransfer.files[0]); });
+fileInput.addEventListener('change', e => { if (e.target.files.length) handleFile(e.target.files[0]); });
+
+function handleFile(file) {
+    const isDicom = file.name.toLowerCase().endsWith('.dcm') || file.type === 'application/dicom';
+    if (!isDicom && !file.type.startsWith('image/')) { showToast('Unsupported file type.', 'error'); return; }
+
+    const reader = new FileReader();
+    reader.onload = e => {
+        const preview = document.getElementById('image-preview');
+        const placeholder = document.getElementById('upload-placeholder');
+        const dicomInfo = document.getElementById('dicom-info');
+
+        if (isDicom) {
+            preview.classList.add('hidden');
+            placeholder.classList.add('hidden');
+            dicomInfo.classList.remove('hidden');
+            dicomInfo.innerHTML = `📂 DICOM File Detected<br><span class="opacity-75">${file.name}</span><br><span class="opacity-60">${(file.size/1024).toFixed(1)} KB</span>`;
+            showToast('DICOM file loaded — metadata will be auto-extracted', 'success');
+        } else {
+            preview.src = e.target.result;
+            preview.classList.remove('hidden');
+            placeholder.classList.add('hidden');
+            dicomInfo.classList.add('hidden');
+            showToast('Image loaded.', 'success');
+        }
+    };
+    if (isDicom) {
+        reader.readAsArrayBuffer(file);
+    } else {
+        reader.readAsDataURL(file);
+    }
+}
+
+// ═══════════════════════════════════════════════════════ AGENT PIPELINE UI
+function renderAgents() {
+    document.getElementById('pipeline-tracker').innerHTML = AGENTS.map(a => `
+        <div id="card-${a}" class="rounded-xl border border-slate-200 bg-white p-3 flex items-center gap-3 transition-all duration-300">
+            <div id="icon-${a}" class="w-8 h-8 rounded-full bg-slate-100 flex items-center justify-center shrink-0 transition-all">
+                <svg class="w-4 h-4 text-slate-400" fill="none" stroke="currentColor" viewBox="0 0 24 24"><circle cx="12" cy="12" r="9" stroke-width="2"/></svg>
+            </div>
+            <div class="flex-1 min-w-0">
+                <div class="flex justify-between items-center">
+                    <span class="text-[11px] font-bold text-slate-700 uppercase tracking-wider">${a}</span>
+                    <span id="badge-${a}" class="text-[9px] font-mono font-bold px-1.5 py-0.5 rounded bg-slate-100 text-slate-500">WAITING</span>
+                </div>
+                <span id="timing-${a}" class="text-[9px] font-mono text-slate-400"></span>
+            </div>
+        </div>
+    `).join('');
+}
+
+function updateAgent(name, status, elapsed) {
+    const card = document.getElementById(`card-${name}`);
+    const badge = document.getElementById(`badge-${name}`);
+    const icon  = document.getElementById(`icon-${name}`);
+    const timEl = document.getElementById(`timing-${name}`);
+    if (!card) return;
+
+    const cfg = {
+        WAITING:  { card:'border-slate-200 bg-white',         badge:'bg-slate-100 text-slate-500',   icon:'bg-slate-100',   iconHtml:'<svg class="w-4 h-4 text-slate-400" fill="none" stroke="currentColor" viewBox="0 0 24 24"><circle cx="12" cy="12" r="9" stroke-width="2"/></svg>' },
+        RUNNING:  { card:'border-blue-400 bg-blue-50',         badge:'bg-blue-100 text-blue-700',     icon:'bg-blue-100',    iconHtml:'<svg class="w-4 h-4 text-blue-600 animate-spin" fill="none" viewBox="0 0 24 24"><circle class="opacity-25" cx="12" cy="12" r="10" stroke="currentColor" stroke-width="4"></circle><path class="opacity-75" fill="currentColor" d="M4 12a8 8 0 018-8V0C5.373 0 0 5.373 0 12h4z"></path></svg>' },
+        DONE:     { card:'border-green-400 bg-green-50',       badge:'bg-green-100 text-green-700',   icon:'bg-green-100',   iconHtml:'<svg class="w-4 h-4 text-green-600" fill="none" stroke="currentColor" viewBox="0 0 24 24"><path stroke-linecap="round" stroke-linejoin="round" stroke-width="2.5" d="M5 13l4 4L19 7"/></svg>' },
+        ERROR:    { card:'border-red-400 bg-red-50',           badge:'bg-red-100 text-red-700',       icon:'bg-red-100',     iconHtml:'<svg class="w-4 h-4 text-red-600" fill="none" stroke="currentColor" viewBox="0 0 24 24"><path stroke-linecap="round" stroke-linejoin="round" stroke-width="2.5" d="M6 18L18 6M6 6l12 12"/></svg>' },
+    };
+    const c = cfg[status] || cfg.WAITING;
+    card.className = `rounded-xl border p-3 flex items-center gap-3 transition-all duration-300 ${c.card}`;
+    badge.className = `text-[9px] font-mono font-bold px-1.5 py-0.5 rounded ${c.badge}`;
+    badge.textContent = status;
+    icon.className = `w-8 h-8 rounded-full flex items-center justify-center shrink-0 transition-all ${c.icon}`;
+    icon.innerHTML = c.iconHtml;
+    if (elapsed !== undefined) timEl.textContent = `${elapsed.toFixed(2)}s`;
+}
+
+// ═══════════════════════════════════════════════════════ SUBMIT
+document.getElementById('analysis-form').addEventListener('submit', async e => {
+    e.preventDefault();
+    const files = fileInput.files;
+    if (!files.length) { showToast('Upload an image first.', 'error'); return; }
+
+    setLoading(true);
+    renderAgents();
+    resetReport();
+    agentTimings = {};
+    agentStartTimes = {};
+    startTimer();
+    log('Sending to AMD MI300X pipeline...');
+
+    const fd = new FormData();
+    fd.append('image', files[0]);
+    fd.append('symptoms', document.getElementById('symptoms').value);
+    fd.append('age', document.getElementById('age').value || '');
+    fd.append('sex', document.getElementById('sex').value);
+    fd.append('clinical_context', document.getElementById('clinical_context').value);
+
+    try {
+        const res = await fetch('/analyze/stream', { method:'POST', body:fd });
+        if (!res.ok) throw new Error(`HTTP ${res.status}`);
+
+        const reader = res.body.getReader();
+        const dec = new TextDecoder();
+        let buf = '';
+
+        while (true) {
+            const { done, value } = await reader.read();
+            if (done) break;
+            buf += dec.decode(value, { stream:true });
+            const parts = buf.split('\n\n');
+            buf = parts.pop();
+            for (const part of parts) {
+                if (part.startsWith('data: ')) {
+                    try { handleSSE(JSON.parse(part.slice(6))); } catch {}
+                }
+            }
+        }
+    } catch (err) {
+        stopTimer();
+        showToast(`Error: ${err.message}`, 'error');
+        log(`ERROR: ${err.message}`);
+    } finally {
+        setLoading(false);
+    }
+});
+
+function handleSSE(data) {
+    if (data.agent && data.status) {
+        const now = performance.now();
+        if (data.status === 'RUNNING') {
+            agentStartTimes[data.agent] = now;
+        } else if (data.status === 'DONE' || data.status === 'ERROR') {
+            const elapsed = agentStartTimes[data.agent] ? (now - agentStartTimes[data.agent]) / 1000 : 0;
+            agentTimings[data.agent] = elapsed;
+            updateAgent(data.agent, data.status, elapsed);
+        }
+        if (data.status === 'RUNNING') updateAgent(data.agent, 'RUNNING');
+        log(`${data.agent} → ${data.status}`);
+        return;
+    }
+
+    if (data.type === 'report') {
+        stopTimer();
+        lastReportData = data.data;
+        currentReportId = data.report_id || data.data?.report_id;
+        renderReport(data.data);
+        updateCharts(data.data);
+        document.getElementById('export-pdf-btn').disabled = false;
+        document.getElementById('toggle-chat-btn').disabled = false;
+        showToast('Analysis complete.', 'success');
+        return;
+    }
+
+    if (data.type === 'error') {
+        stopTimer();
+        showToast(`Pipeline error: ${data.message}`, 'error');
+        log(`ERROR: ${data.message}`);
+    }
+}
+
+// ═══════════════════════════════════════════════════════ REPORT RENDER
+function resetReport() {
+    document.getElementById('empty-state').classList.remove('hidden');
+    document.getElementById('report-content').classList.add('hidden');
+    document.getElementById('dicom-meta-card').classList.add('hidden');
+    document.getElementById('export-pdf-btn').disabled = true;
+    document.getElementById('toggle-chat-btn').disabled = true;
+    document.getElementById('chat-panel').classList.add('hidden');
+    document.getElementById('chat-messages').innerHTML = '';
+}
+
+function renderReport(data) {
+    const s = data.sections;
+    document.getElementById('empty-state').classList.add('hidden');
+    document.getElementById('report-content').classList.remove('hidden');
+
+    // Severity banner
+    const sev = data.overall_severity || 'NORMAL';
+    const bannerCfg = {
+        NORMAL:      'bg-emerald-50 text-emerald-800 border border-emerald-200',
+        INCIDENTAL:  'bg-amber-50 text-amber-800 border border-amber-200',
+        SIGNIFICANT: 'bg-orange-50 text-orange-800 border border-orange-200',
+        CRITICAL:    'bg-red-50 text-red-800 border border-red-200 animate-pulse',
+    };
+    const banner = document.getElementById('severity-banner');
+    banner.className = `px-4 py-3 rounded-xl flex items-center justify-between ${bannerCfg[sev] || bannerCfg.NORMAL}`;
+    document.getElementById('severity-text').textContent = `Severity: ${sev}`;
+
+    const iconCfg = { NORMAL:'✅', INCIDENTAL:'⚠️', SIGNIFICANT:'🔶', CRITICAL:'🚨' };
+    document.getElementById('banner-icon').textContent = iconCfg[sev] || '✅';
+
+    // Meta
+    document.getElementById('meta-id').textContent = data.report_id || '---';
+    document.getElementById('meta-time').textContent = data.generation_timestamp
+        ? new Date(data.generation_timestamp).toLocaleTimeString() : '---';
+    const qaM = (s.recommendations || '').match(/Score[:\s]+(\d+)/);
+    document.getElementById('meta-qa').textContent = `QA ${qaM ? qaM[1] : '85'}/100`;
+
+    // DICOM metadata
+    if (data.dicom_metadata && Object.keys(data.dicom_metadata).length) {
+        const card = document.getElementById('dicom-meta-card');
+        const content = document.getElementById('dicom-meta-content');
+        card.classList.remove('hidden');
+        const show = ['modality','body_part','study_date','institution','kvp','slice_thickness_mm','image_rows','image_cols'];
+        content.innerHTML = show
+            .filter(k => data.dicom_metadata[k])
+            .map(k => `<div><span class="opacity-60">${k.replace(/_/g,' ')}:</span> <span class="font-semibold">${data.dicom_metadata[k]}</span></div>`)
+            .join('');
+    }
+
+    // Sections
+    document.getElementById('sec-history').textContent      = s.clinical_history   || 'Not provided.';
+    document.getElementById('sec-technique').textContent    = s.technique           || 'Not provided.';
+    document.getElementById('sec-impression').textContent   = s.impression          || 'Not provided.';
+    document.getElementById('sec-recommendations').textContent = s.recommendations  || 'None.';
+    document.getElementById('sec-disclaimer').textContent   = s.disclaimer;
+    document.getElementById('sec-findings').innerHTML       = renderFindings(s.findings);
+
+    document.getElementById('report-scroll').scrollTop = 0;
+}
+
+function renderFindings(text) {
+    if (!text) return '<p class="text-xs text-slate-400 italic">No findings.</p>';
+    const sevOrder = { CRITICAL:4, SIGNIFICANT:3, INCIDENTAL:2, NORMAL:1 };
+    const sevColors = {
+        NORMAL:      { border:'finding-NORMAL',      badge:'bg-emerald-100 text-emerald-800', bar:'bg-emerald-500' },
+        INCIDENTAL:  { border:'finding-INCIDENTAL',  badge:'bg-amber-100 text-amber-800',    bar:'bg-amber-500' },
+        SIGNIFICANT: { border:'finding-SIGNIFICANT', badge:'bg-orange-100 text-orange-800',  bar:'bg-orange-500' },
+        CRITICAL:    { border:'finding-CRITICAL',    badge:'bg-red-100 text-red-800',        bar:'bg-red-500' },
+    };
+
+    // Find highest severity in text
+    let topSev = 'NORMAL';
+    for (const sev of ['CRITICAL','SIGNIFICANT','INCIDENTAL','NORMAL']) {
+        if (text.toUpperCase().includes(sev)) { topSev = sev; break; }
+    }
+
+    // Extract confidence scores
+    const confMatches = [...text.matchAll(/(\d+(?:\.\d+)?)%/g)];
+    const avgConf = confMatches.length
+        ? Math.round(confMatches.reduce((a,m) => a + parseFloat(m[1]), 0) / confMatches.length)
+        : 75;
+
+    const c = sevColors[topSev] || sevColors.NORMAL;
+    const confColor = avgConf >= 75 ? 'bg-emerald-500' : avgConf >= 50 ? 'bg-amber-500' : 'bg-red-500';
+
+    return `
+        <div class="pl-4 pr-4 py-4 rounded-lg border-l-4 ${c.border} bg-white shadow-sm">
+            <div class="flex justify-between items-start mb-3">
+                <span class="text-[10px] font-bold px-2 py-0.5 rounded ${c.badge} uppercase">${topSev}</span>
+                <span class="text-[10px] font-mono text-slate-500">${avgConf}% avg confidence</span>
+            </div>
+            <p class="text-sm text-slate-700 leading-relaxed whitespace-pre-wrap mb-3">${text}</p>
+            <div class="flex items-center gap-2">
+                <span class="text-[9px] font-mono text-slate-400 uppercase w-16">Confidence</span>
+                <div class="flex-1 h-1.5 bg-slate-100 rounded-full overflow-hidden">
+                    <div class="h-full rounded-full ${confColor} transition-all duration-1000" style="width:${avgConf}%"></div>
+                </div>
+                <span class="text-[10px] font-bold font-mono text-slate-600">${avgConf}%</span>
+            </div>
+        </div>`;
+}
+
+// ═══════════════════════════════════════════════════════ CHARTS
+function updateCharts(data) {
+        // Severity donut — read directly from structured vision findings
+        const sevCounts = { NORMAL: 0, INCIDENTAL: 0, SIGNIFICANT: 0, CRITICAL: 0 };
+        const visionFindings = data.vision_findings || [];
+        if (visionFindings.length > 0) {
+            for (const f of visionFindings) {
+                const sev = (f.severity || 'NORMAL').toUpperCase();
+                if (sev in sevCounts) sevCounts[sev]++;
+            }
+        }
+        if (Object.values(sevCounts).every(v => v === 0)) sevCounts[data.overall_severity || 'NORMAL'] = 1;
+
+        if (severityChart) severityChart.destroy();
+        severityChart = new Chart(document.getElementById('severityChart'), {
+            type: 'doughnut',
+            data: {
+                labels: Object.keys(sevCounts),
+                datasets: [{ data: Object.values(sevCounts), backgroundColor: ['#10b981', '#f59e0b', '#f97316', '#ef4444'], borderWidth: 2, borderColor: '#fff' }]
+            },
+            options: { responsive: false, plugins: { legend: { position: 'bottom', labels: { font: { size: 9 }, padding: 8 } } }, cutout: '65%' }
+        });
+
+        // Confidence bar — read directly from structured differential diagnoses
+        const differentials = data.differential_diagnoses || [];
+        const labels = differentials.length > 0
+            ? differentials.map(d => (d.condition_name || 'Unknown').slice(0, 22))
+            : ['Dx 1', 'Dx 2', 'Dx 3'];
+        const probs = differentials.length > 0
+            ? differentials.map(d => Math.round(parseFloat(d.match_probability) || 0))
+            : [0, 0, 0];
+
+        if (confidenceChart) confidenceChart.destroy();
+        confidenceChart = new Chart(document.getElementById('confidenceChart'), {
+            type: 'bar',
+            data: {
+                labels: labels,
+                datasets: [{ label: 'Probability %', data: probs, backgroundColor: ['#3b82f6', '#8b5cf6', '#06b6d4', '#10b981', '#f97316'], borderRadius: 4 }]
+            },
+            options: { responsive: true, indexAxis: 'y', scales: { x: { max: 100, ticks: { font: { size: 9 } } }, y: { ticks: { font: { size: 9 } } } }, plugins: { legend: { display: false } } }
+        });
+
+    // Agent timing
+    const agentLabels = Object.keys(agentTimings);
+    const agentValues = agentLabels.map(k => parseFloat(agentTimings[k].toFixed(2)));
+    if (timingChart) timingChart.destroy();
+    if (agentLabels.length) {
+        timingChart = new Chart(document.getElementById('timingChart'), {
+            type: 'bar',
+            data: {
+                labels: agentLabels,
+                datasets: [{ label:'Seconds', data:agentValues, backgroundColor:'#f97316', borderRadius:4 }]
+            },
+            options: { responsive:true, scales:{ y:{ ticks:{font:{size:9}} }, x:{ ticks:{font:{size:9}} } }, plugins:{ legend:{display:false} } }
+        });
+    }
+}
+
+// ═══════════════════════════════════════════════════════ CLINICAL CHAT
+document.getElementById('toggle-chat-btn').addEventListener('click', () => {
+    const panel = document.getElementById('chat-panel');
+    const isHidden = panel.classList.contains('hidden');
+    panel.classList.toggle('hidden', !isHidden);
+    if (isHidden && document.getElementById('chat-messages').children.length === 0) {
+        appendChat('assistant', "Report loaded. Ask me anything about the findings, differentials, or recommendations.");
+    }
+});
+
+document.getElementById('chat-send-btn').addEventListener('click', sendChat);
+document.getElementById('chat-input').addEventListener('keydown', e => { if (e.key === 'Enter' && !e.shiftKey) { e.preventDefault(); sendChat(); } });
+
+async function sendChat() {
+    const input = document.getElementById('chat-input');
+    const q = input.value.trim();
+    if (!q || !currentReportId) return;
+    input.value = '';
+    appendChat('user', q);
+    const thinking = appendChat('assistant', '⏳ Consulting AI...');
+
+    try {
+        const res = await fetch(`/chat/${currentReportId}`, {
+            method: 'POST',
+            headers: { 'Content-Type': 'application/json' },
+            body: JSON.stringify({ question: q })
+        });
+        const data = await res.json();
+        thinking.textContent = data.answer || 'No response.';
+    } catch (e) {
+        thinking.textContent = 'Failed to get response. Please try again.';
+    }
+}
+
+function appendChat(role, text) {
+    const container = document.getElementById('chat-messages');
+    const div = document.createElement('div');
+    div.className = `text-xs leading-relaxed p-2.5 max-w-[90%] animate-fade-in ${role === 'user' ? 'chat-bubble-user ml-auto' : 'chat-bubble-ai'}`;
+    div.textContent = text;
+    container.appendChild(div);
+    container.scrollTop = container.scrollHeight;
+    return div;
+}
+
+// ══════════════════════════════════════��════════════════ PDF EXPORT
+document.getElementById('export-pdf-btn').addEventListener('click', () => {
+    if (!lastReportData) return;
+    try {
+        const { jsPDF } = window.jspdf;
+        const doc = new jsPDF();
+        const d = lastReportData;
+        const s = d.sections;
+        const W=210, LM=14, CW=182, TM=32, FY=285;
+        let y = TM;
+        const NAVY=[30,58,138], BLUE=[30,64,175], GRAY=[60,60,60], DARK=[20,20,20];
+        const sevRGB = {NORMAL:[16,185,129],INCIDENTAL:[245,158,11],SIGNIFICANT:[249,115,22],CRITICAL:[239,68,68]}[d.overall_severity]||[16,185,129];
+
+        doc.setFillColor(...NAVY); doc.rect(0,0,W,26,'F');
+        doc.setFillColor(59,130,246); doc.roundedRect(LM,6,10,14,2,2,'F');
+        doc.setTextColor(255,255,255); doc.setFont('helvetica','bold'); doc.setFontSize(10); doc.text('M',LM+3.5,14.5);
+        doc.setFontSize(16); doc.text('MediAgent Clinical Report',28,14);
+        doc.setFontSize(8); doc.setFont('helvetica','normal'); doc.text('AMD Instinct MI300X | ROCm | vLLM | Qwen',28,20);
+        const now=new Date(); doc.text(`${d.report_id} | ${now.toLocaleString()}`,196,12,{align:'right'});
+        doc.text(`Overall: ${d.overall_severity||'NORMAL'}`,196,18,{align:'right'});
+        doc.setFillColor(...sevRGB); doc.rect(0,26,W,4,'F');
+
+        const footer=pg=>{ doc.setDrawColor(200); doc.line(LM,FY-5,196,FY-5); doc.setFont('helvetica','normal'); doc.setFontSize(7); doc.setTextColor(150,150,150); doc.text('MediAgent v2.0 | AMD MI300X | AI-generated — requires licensed radiologist review',LM,FY); doc.text(`${pg}`,196,FY,{align:'right'}); };
+        const brk=(h=10)=>{ if(y+h>FY-8){ footer(doc.internal.getNumberOfPages()); doc.addPage(); y=TM; } };
+        const txt=(t,{sz=10,bold=false,col=GRAY,gap=5}={})=>{ if(!t)t='Not provided.'; doc.setFont('helvetica',bold?'bold':'normal'); doc.setFontSize(sz); doc.setTextColor(...col); const lines=doc.splitTextToSize(t,CW); for(const l of lines){ brk(gap); doc.text(l,LM,y); y+=gap; } y+=1; };
+        const sec=t=>{ brk(12); doc.setDrawColor(...BLUE); doc.setLineWidth(0.4); doc.line(LM,y,196,y); y+=4; doc.setFont('helvetica','bold'); doc.setFontSize(11); doc.setTextColor(...NAVY); doc.text(t,LM,y); y+=6; };
+
+        brk(22); doc.setFillColor(241,245,249); doc.rect(LM,y,CW,18,'F');
+        doc.setFont('helvetica','normal'); doc.setFontSize(9); doc.setTextColor(...GRAY);
+        doc.text(`Report ID: ${d.report_id}`,LM+3,y+6); doc.text(`Generated: ${now.toLocaleString()}`,LM+3,y+11);
+        doc.text(`Severity: ${d.overall_severity||'NORMAL'}`,LM+3,y+16);
+        const qa=((s.recommendations||'').match(/Score[:\s]+(\d+)/)||[])[1]||'85';
+        doc.text(`QA Score: ${qa}/100`,LM+100,y+6);
+        y+=24;
+
+        if(d.dicom_metadata && Object.keys(d.dicom_metadata).length>0) {
+            sec('DICOM Metadata');
+            const dm=d.dicom_metadata;
+            const pairs=[['Modality',dm.modality],['Body Part',dm.body_part],['Study Date',dm.study_date],['Institution',dm.institution]].filter(p=>p[1]);
+            txt(pairs.map(p=>`${p[0]}: ${p[1]}`).join('  |  '),{sz:9});
+        }
+        sec('Clinical History'); txt(s.clinical_history);
+        sec('Technique'); txt(s.technique);
+        sec('Findings'); brk(20); doc.setFillColor(249,250,251); const fl=doc.splitTextToSize(s.findings||'None.',CW-4); const fh=Math.max(18,fl.length*5+8); doc.rect(LM,y,CW,fh,'F'); txt(s.findings||'None.');
+        sec('Impression'); txt(s.impression,{sz:11,bold:true,col:DARK,gap:6});
+        sec('Recommendations'); txt(s.recommendations);
+        sec('Disclaimer'); brk(18); doc.setFillColor(254,226,226); doc.rect(LM,y,CW,16,'F'); doc.setFont('helvetica','bold'); doc.setFontSize(8); doc.setTextColor(127,29,29); doc.splitTextToSize('DISCLAIMER: '+(s.disclaimer||''),CW-6).forEach((l,i)=>doc.text(l,LM+3,y+5+i*4.5));
+        footer(doc.internal.getNumberOfPages());
+        doc.save(`MediAgent_${d.report_id}_${now.toISOString().split('T')[0]}.pdf`);
+        showToast('PDF exported.', 'success');
+    } catch(e) { console.error(e); showToast('PDF export failed.', 'error'); }
+});
+
+// ═══════════════════════════════════════════════════════ AMD GPU POLLING
+function startGpuPolling() {
+    pollGpu();
+    gpuPollInterval = setInterval(pollGpu, 3000);
+}
+
+async function pollGpu() {
+    try {
+        const res = await fetch('/metrics/gpu');
+        const data = await res.json();
+        renderGpuPanel(data);
+    } catch(e) {
+        // silently ignore
+    }
+}
+
+function renderGpuPanel(data) {
+    const panel = document.getElementById('gpu-panel-content');
+    const dot = document.getElementById('gpu-status-dot');
+    const headerBadge = document.getElementById('gpu-header-badge');
+    const headerText = document.getElementById('gpu-header-text');
+
+    if (!data.available || !data.cards || !data.cards.length) {
+        dot.className = 'w-1.5 h-1.5 rounded-full bg-slate-600';
+        panel.innerHTML = `<p class="text-[10px] text-slate-500 font-mono text-center py-1">${data.note || 'No GPU detected'}</p>`;
+        return;
+    }
+
+    dot.className = 'w-1.5 h-1.5 rounded-full bg-orange-400 animate-pulse';
+    const card = data.cards[0];
+    const gpuPct = Math.round(parseFloat(card.gpu_use_pct) || 0);
+    const vramUsed = Math.round(parseFloat(card.vram_used_mb) || 0);
+    const vramTotal = Math.round(parseFloat(card.vram_total_mb) || 1);
+    const vramPct = vramTotal > 0 ? Math.round((vramUsed / vramTotal) * 100) : 0;
+    const temp = Math.round(parseFloat(card.temp_c) || 0);
+    const power = Math.round(parseFloat(card.power_w) || 0);
+
+    // Header badge
+    headerBadge.classList.remove('hidden');
+    headerBadge.classList.add('flex');
+    headerText.textContent = `GPU ${gpuPct}% | ${temp}°C`;
+
+    const bar = (pct, color) => `
+        <div class="h-1.5 bg-slate-700 rounded-full overflow-hidden">
+            <div class="h-full rounded-full ${color} gpu-bar" style="width:${pct}%"></div>
+        </div>`;
+
+    const gpuColor = gpuPct > 80 ? 'bg-red-500' : gpuPct > 50 ? 'bg-orange-400' : 'bg-green-400';
+    const vramColor = vramPct > 85 ? 'bg-red-500' : vramPct > 60 ? 'bg-orange-400' : 'bg-blue-400';
+
+    panel.innerHTML = `
+        <div class="space-y-2">
+            <div>
+                <div class="flex justify-between items-center mb-0.5">
+                    <span class="text-[9px] font-mono text-slate-400">GPU UTIL</span>
+                    <span class="text-[10px] font-bold font-mono text-orange-300">${gpuPct}%</span>
+                </div>
+                ${bar(gpuPct, gpuColor)}
+            </div>
+            <div>
+                <div class="flex justify-between items-center mb-0.5">
+                    <span class="text-[9px] font-mono text-slate-400">VRAM</span>
+                    <span class="text-[10px] font-bold font-mono text-blue-300">${vramUsed}/${vramTotal} MiB</span>
+                </div>
+                ${bar(vramPct, vramColor)}
+            </div>
+            <div class="grid grid-cols-2 gap-2 pt-1 border-t border-slate-700">
+                <div class="text-center">
+                    <div class="text-[9px] text-slate-500 font-mono">TEMP</div>
+                    <div class="text-[11px] font-bold font-mono ${temp>80?'text-red-400':temp>65?'text-orange-400':'text-green-400'}">${temp}°C</div>
+                </div>
+                <div class="text-center">
+                    <div class="text-[9px] text-slate-500 font-mono">POWER</div>
+                    <div class="text-[11px] font-bold font-mono text-slate-300">${power}W</div>
+                </div>
+            </div>
+            ${data.note ? `<p class="text-[9px] text-slate-600 font-mono text-center">${data.note}</p>` : ''}
+        </div>`;
+}
+
+// ═══════════════════════════════════════════════════════ UTILITIES
+function setLoading(v) {
+    document.getElementById('submit-btn').disabled = v;
+    document.getElementById('btn-text').textContent = v ? 'Processing...' : 'Run Analysis';
+    document.getElementById('btn-spinner').classList.toggle('hidden', !v);
+}
+
+function log(msg) {
+    document.getElementById('pipeline-log').innerHTML = `<span class="text-slate-700">&gt; ${msg}</span>`;
+}
+
+function startTimer() {
+    startTime = performance.now();
+    const timerEl = document.getElementById('pipeline-timer');
+    timerEl.classList.remove('hidden');
+    timerInterval = setInterval(() => {
+        timerEl.textContent = `⏱ ${((performance.now()-startTime)/1000).toFixed(1)}s elapsed`;
+    }, 100);
+}
+
+function stopTimer() {
+    clearInterval(timerInterval);
+    const elapsed = ((performance.now()-startTime)/1000).toFixed(1);
+    document.getElementById('pipeline-log').innerHTML = `<span class="text-green-600 font-bold">✅ Complete in ${elapsed}s</span>`;
+    document.getElementById('pipeline-timer').classList.add('hidden');
+}
+
+function showToast(msg, type='success') {
+    const toast = document.getElementById('toast');
+    const inner = document.getElementById('toast-inner');
+    document.getElementById('toast-message').textContent = msg;
+    inner.className = `${type==='error'?'bg-red-600':'bg-slate-800'} text-white px-4 py-2.5 rounded-lg shadow-xl text-xs font-medium flex items-center gap-2`;
+    toast.classList.remove('translate-y-16','opacity-0');
+    setTimeout(() => toast.classList.add('translate-y-16','opacity-0'), 3500);
+}
+
+init();
+</script>
+</body>
+</html>