Initial public commit

.dockerignore

@@ -0,0 +1,6 @@
+frontend/build
+frontend/node_modules
+env.list
+__pycache__
+**/__pycache__
+.*

.gitattributes

@@ -0,0 +1,38 @@
+*.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
+frontend/public/assets/jordan.mp4 filter=lfs diff=lfs merge=lfs -text
+frontend/public/assets/sacha.mp4 filter=lfs diff=lfs merge=lfs -text
+frontend/public/assets/alex.mp4 filter=lfs diff=lfs merge=lfs -text

.gitignore

@@ -0,0 +1,6 @@
+env.list
+__pycache__
+**/__pycache__
+frontend/node_modules
+frontend/build
+.git

Dockerfile

@@ -0,0 +1,58 @@
+# Copyright 2025 Google LLC
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+# Build React app
+FROM node:24-slim AS frontend-build
+WORKDIR /app/frontend
+# Upgrade npm to the desired version
+RUN npm install -g npm@11.4.x
+COPY frontend/ ./
+RUN npm install
+RUN npm run build
+
+# Python backend
+FROM python:3.10-slim
+WORKDIR /app
+
+# Install ffmpeg for audio conversion
+RUN apt-get update && apt-get install -y ffmpeg && rm -rf /var/lib/apt/lists/*
+
+# Copy requirements.txt first for better caching
+COPY requirements.txt ./
+RUN pip install --no-cache-dir -r requirements.txt
+
+# Copy Flask app
+COPY *.py ./
+COPY symptoms.json ./
+COPY report_template.txt ./
+
+# Copy built React app
+COPY --from=frontend-build /app/frontend/build ./frontend/build
+ENV FRONTEND_BUILD=/app/frontend/build
+
+# Create cache directory and set permissions, then assign the env variable
+RUN mkdir -p /cache && chmod 777 /cache
+ENV CACHE_DIR=/cache
+
+# If cache.zip exists, extract it into /cache
+COPY cache* /tmp/
+RUN if [ -f /tmp/cache_archive.zip ]; then \
+      apt-get update && apt-get install -y unzip && \
+      unzip /tmp/cache_archive.zip -d /cache && \
+      rm /tmp/cache_archive.zip && \
+      chmod -R 777 /cache; \
+    fi
+
+EXPOSE 7860
+CMD ["gunicorn", "-b", "0.0.0.0:7860", "app:app", "--threads", "4", "--timeout", "300"]

README.md

@@ -0,0 +1,159 @@
+---
+title: Appoint Ready - MedGemma Demo
+emoji: 📋
+colorFrom: blue
+colorTo: gray
+sdk: docker
+models:
+  - google/medgemma-27b-text-it
+pinned: false
+license: apache-2.0
+short_description: 'Simulated Pre-visit Intake Demo built using MedGemma Demo'
+---
+
+## Table of Contents
+- [Demo Description](#demo-description)
+- [Technical Architecture](#technical-architecture)
+- [Running the Demo Locally](#running-the-demo-locally)
+- [Models used](#models-used)
+- [Caching](#caching)
+- [Disclaimer](#disclaimer)
+- [Other Models and Demos](#other-models-and-demos)
+
+# AppointReady: Simulated Pre-visit Intake Demo built using MedGemma
+
+Healthcare providers often seek efficient ways to gather comprehensive patient information before appointments. This demo illustrates how MedGemma could be used in an application to streamline pre-visit information collection and utilization. 
+
+The demonstration first asks questions to gather pre-visit information.
+After it has identified and collected relevant information, the demo application generates a pre-visit report using both collected and health record information (stored as FHIR resources for this demonstration). This type of intelligent pre-visit report can help providers be more efficient and effective while also providing an improved experience for patients compared to traditional intake forms.
+
+At the conclusion of the demo, you can view an evaluation of the pre-visit report which provides additional insights into the quality of the demonstrated capabilities. For this evaluation, MedGemma is provided the patient's reference diagnosis, allowing MedGemma to create a self-evaluation report highlighting strengths as well as areas for improvement.
+
+## Technical Architecture
+This application is composed of several key components:
+
+*   **Frontend**: A web interface built with React that provides the user interface for the chat and report visualization.
+*   **Backend**: A Python server built with Gunicorn/Flask that handles the application logic. It communicates with the LLMs, manages the conversation flow, and generates the final pre-visit report.
+*   **API called**:
+    *   **MedGemma**: Acts as the clinical assistant, asking relevant questions and summarizing information.
+    *   **Gemini**: Role-plays as the patient, providing responses based on a predefined scenario.
+    *   **Gemini TTS**: Generative text-to-speech model.
+*   **Deployment**: The entire application is containerized using Docker for easy deployment and scalability.
+
+A high-level overview of the architecture:
+
+[![](https://mermaid.ink/img/pako:eNqFk81u00AQx19ltVIlkJzIdpM69i1NShpEpQqnHMAcFnvTrGqvrfW6DUS5cUTiS-IKByRegQPileARmN1N7DgE4Yt3_vObnfHMeIXjPKE4wNeCFAs0G0ccwXN0hMZ0zjhFE5FXRWnUsnphsAhflVSgKZdUkFiynEfYIOpRvmcR_v35_Vd9jvDzxvlA5BDFEw28eVfb6N6pyO-Avl_joEb8r8ynJL5RfEjFLYtpuZt5csVZnAsOl2-P7eQpKW_Aqd9oWBQpi4kpf4fSn3XL6F3IsirVfl3tty-NCzW-VuyIxAuq6Q8_0SUVJSvh66TRW-TZ-eMxkUSzH18rEym7xYQSMsTDsqSy1OCnH7--v0UXNGHEQuezi0cWehj-p2FnS6iZkxQNpweb9oQKSZfDKSQwRwVCignNsnY5oDDOhpcKNWcExgFkNgsbBIwWtlNls2ajnHOqN2mza3rBOp1OvSBGrtdFueoZ893hmyg14U2IHrYSDwx2H9lMZV_eHYTxHbhLk2bQvN4FLW5bvKd3mo7-wwO9wxb8myzBgRQVtXBGRUaUiVcqJsJyQTPYrACOCZ2TKpVquGsIKwh_mufZNhJ-5OsFDuYkLcGqioRIOmYE1iSrVQGtpWKUV1zioNf39SU4WOElDhzH7_quNzhxB57XcwZuz8IvQe47XdexvZ5r9zzH953-2sKvdF67Ozju2_aJ43gD1_aOfW_9ByuAZrY?type=png)](https://mermaid.live/edit#pako:eNqFk81u00AQx19ltVIlkJzIdpM69i1NShpEpQqnHMAcFnvTrGqvrfW6DUS5cUTiS-IKByRegQPileARmN1N7DgE4Yt3_vObnfHMeIXjPKE4wNeCFAs0G0ccwXN0hMZ0zjhFE5FXRWnUsnphsAhflVSgKZdUkFiynEfYIOpRvmcR_v35_Vd9jvDzxvlA5BDFEw28eVfb6N6pyO-Avl_joEb8r8ynJL5RfEjFLYtpuZt5csVZnAsOl2-P7eQpKW_Aqd9oWBQpi4kpf4fSn3XL6F3IsirVfl3tty-NCzW-VuyIxAuq6Q8_0SUVJSvh66TRW-TZ-eMxkUSzH18rEym7xYQSMsTDsqSy1OCnH7--v0UXNGHEQuezi0cWehj-p2FnS6iZkxQNpweb9oQKSZfDKSQwRwVCignNsnY5oDDOhpcKNWcExgFkNgsbBIwWtlNls2ajnHOqN2mza3rBOp1OvSBGrtdFueoZ893hmyg14U2IHrYSDwx2H9lMZV_eHYTxHbhLk2bQvN4FLW5bvKd3mo7-wwO9wxb8myzBgRQVtXBGRUaUiVcqJsJyQTPYrACOCZ2TKpVquGsIKwh_mufZNhJ-5OsFDuYkLcGqioRIOmYE1iSrVQGtpWKUV1zioNf39SU4WOElDhzH7_quNzhxB57XcwZuz8IvQe47XdexvZ5r9zzH953-2sKvdF67Ozju2_aJ43gD1_aOfW_9ByuAZrY)
+
+<!--```mermaid
+graph TD
+    %% Define Groups
+    subgraph "User Interaction"
+        User["👤 User"]
+        Frontend["🌐 Frontend (Browser)"]
+    end
+
+    subgraph "Backend Services"
+        GUnicorn["GUnicorn"]
+        Flask["Flask Application"]
+        InterviewSimulation["🧠 Interview Simulation"]
+        Cache["💾 Persistent Cache"]
+        EHRData["📄 EHR Data"]
+        StaticAssets["🖼️ Media, HTML, JS"]
+    end
+
+    subgraph "External AI Services"
+        VertexAI["Vertex AI MedGemma"]
+        GeminiAPI["Gemini API"]
+        GeminiTTS["Gemini TTS API"]
+    end
+
+    %% Define Connections
+    User --- Frontend
+    Frontend --- GUnicorn
+    GUnicorn --- Flask
+    Flask --- InterviewSimulation
+    Flask --- EHRData
+    Flask --- StaticAssets
+    InterviewSimulation --- Cache
+    Cache --- VertexAI
+    Cache --- GeminiAPI
+    Cache --- GeminiTTS
+```-->
+
+## Running the Demo Locally
+
+To run this demo on your own machine, you'll need to have Docker installed.
+
+### Prerequisites
+*   Docker
+*   Git
+*   A Google Cloud project with the Vertex AI API enabled.
+
+### Setup & Configuration
+1.  **Clone the repository:**
+    ```bash
+    git clone https://huggingface.co/spaces/google/appoint-ready
+    cd appoint-ready
+    ```
+
+2.  **Configure environment variables:**
+    This project uses an `env.list` file for configuration, which is passed to Docker. Create this file in the root directory.
+    ```ini
+    # env.list
+    GEMINI_API_KEY="your-gemini-token"
+    GENERATE_SPEECH=false or true
+    GCP_MEDGEMMA_ENDPOINT=medgemma vertex ai endpoint 
+    GCP_MEDGEMMA_SERVICE_ACCOUNT_KEY="service-account-key json"  
+    ```
+
+    GEMINI_API_KEY: Key can be generated via [aistudio](https://aistudio.google.com/apikey).
+    GENERATE_SPEECH: Should the demo generate speech not found in cache. Default is false.
+    GCP_MEDGEMMA_ENDPOINT: Deploy MedGemma via [Model Garden](https://console.cloud.google.com/vertex-ai/publishers/google/model-garden/medgemma).
+
+### Execution
+1.  **Build and run the Docker containers:**
+    ```bash
+    run_local.sh
+    ```
+
+2.  **Access the application:**
+    Once the containers are running, you can access the demo in your web browser at `http://localhost:[PORT]`. (e.g., `http://localhost:7860`).
+
+# Models used
+This demo uses four models:
+
+* MedGemma 27b-text-it: https://huggingface.co/google/medgemma-27b-text-it \
+  For this demo MedGemma-27b was deployed via Model Garden (https://console.cloud.google.com/vertex-ai/publishers/google/model-garden/medgemma).
+* Gemini: https://cloud.google.com/vertex-ai/generative-ai/docs/models/gemini/2-5-flash \
+  We use Gemini to role play the patient while MedGemma plays the clinical assistant.
+* Gemini TTS: https://ai.google.dev/gemini-api/docs/models#gemini-2.5-flash-preview-tts \
+  As an alternative consider using Clould Text-to-Speech: https://cloud.google.com/text-to-speech
+* Veo 3: Was used to generate patient avatar animation https://gemini.google/overview/video-generation
+
+ 
+
+## Caching
+This demo is functional, and results are persistently cached to reduce environmental impact.
+
+## Disclaimer
+This demonstration is for illustrative purposes only and does not represent a finished or approved
+product. It is not representative of compliance to any regulations or standards for
+quality, safety or efficacy. Any real-world application would require additional development,
+training, and adaptation. The experience highlighted in this demo shows MedGemma's baseline
+capability for the displayed task and is intended to help developers and users explore possible
+applications and inspire further development.
+
+This is not an officially supported Google product. This project is not
+eligible for the [Google Open Source Software Vulnerability Rewards
+Program](https://bughunters.google.com/open-source-security).
+
+# Other Models and Demos
+See other demos here: https://huggingface.co/collections/google/hai-def-concept-apps-6837acfccce400abe6ec26c1
+
+MedGemma is finetunable - see colab here: https://github.com/Google-Health/medgemma/blob/main/notebooks/fine_tune_with_hugging_face.ipynb 
+
+# Contacts
+
+* This demo is part of Google's [Health AI Developer Foundations (HAI-DEF)](https://developers.google.com/health-ai-developer-foundations?referral=appoint-ready)
+* Technical info - contact [@lirony](https://huggingface.co/lirony)
+* Press only: press@google.com

__init__.py

@@ -0,0 +1,14 @@
+# Copyright 2025 Google LLC
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+

app.py

@@ -0,0 +1,86 @@
+# Copyright 2025 Google LLC
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+from evaluation import evaluate_report, evaluation_prompt
+from flask import Flask, send_from_directory, request, jsonify, Response, stream_with_context, send_file
+from flask_cors import CORS
+import os, time, json, re
+from gemini import gemini_get_text_response
+from interview_simulator import stream_interview
+from cache import create_cache_zip
+from medgemma import medgemma_get_text_response
+
+app = Flask(__name__, static_folder=os.environ.get("FRONTEND_BUILD", "frontend/build"), static_url_path="/")
+CORS(app, resources={r"/api/*": {"origins": "http://localhost:3000"}})
+
+@app.route("/")
+def serve():
+    """Serves the main index.html file."""
+    return send_from_directory(app.static_folder, "index.html")
+
+
+@app.route("/api/stream_conversation", methods=["GET"])
+def stream_conversation():
+    """Streams the conversation with the interview simulator."""
+    patient = request.args.get("patient", "Patient")
+    condition = request.args.get("condition", "unknown condition")
+    
+    def generate():
+        try:
+            for message in stream_interview(patient, condition):
+                yield f"data: {message}\n\n"
+        except Exception as e:
+            yield f"data: Error: {str(e)}\n\n"
+            raise e
+            
+    return Response(stream_with_context(generate()), mimetype="text/event-stream")
+
+@app.route("/api/evaluate_report", methods=["POST"])
+def evaluate_report_call():
+    """Evaluates the provided medical report."""
+    data = request.get_json()
+    report = data.get("report", "")
+    if not report:
+        return jsonify({"error": "Report is required"}), 400
+    condition = data.get("condition", "")
+    if not condition:
+        return jsonify({"error": "Condition is required"}), 400    
+    
+    evaluation_text = evaluate_report(report, condition)
+    
+    return jsonify({"evaluation": evaluation_text})
+
+
+@app.route("/api/download_cache")
+def download_cache_zip():
+    """Creates a zip file of the cache and returns it for download."""
+    zip_filepath, error = create_cache_zip()
+    if error:
+        return jsonify({"error": error}), 500
+    if not os.path.isfile(zip_filepath):
+        return jsonify({"error": f"File not found: {zip_filepath}"}), 404
+    return send_file(zip_filepath, as_attachment=True)
+
+
+@app.route("/<path:path>")
+def static_proxy(path):
+    """Serves static files and defaults to index.html for unknown paths."""
+    file_path = os.path.join(app.static_folder, path)
+    if os.path.isfile(file_path):
+        return send_from_directory(app.static_folder, path)
+    else:
+        return send_from_directory(app.static_folder, "index.html")
+        
+if __name__ == "__main__":
+    app.run(host="0.0.0.0", port=7860, threaded=True)

auth.py

@@ -0,0 +1,77 @@
+# Copyright 2025 Google LLC
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+import json
+import datetime
+from google.oauth2 import service_account
+import google.auth.transport.requests
+
+def create_credentials(secret_key_json) -> service_account.Credentials:
+  """Creates Google Cloud credentials from the provided service account key.
+
+  Returns:
+      service_account.Credentials: The created credentials object.
+
+  Raises:
+      ValueError: If the environment variable is not set or is empty, or if the
+          JSON format is invalid.
+  """
+
+  if not secret_key_json:
+    raise ValueError("Userdata variable 'GCP_MEDGEMMA_SERVICE_ACCOUNT_KEY' is not set or is empty.")
+  try:
+    service_account_info = json.loads(secret_key_json)
+  except (SyntaxError, ValueError) as e:
+    raise ValueError("Invalid service account key JSON format.") from e
+  return service_account.Credentials.from_service_account_info(
+    service_account_info,
+    scopes=['https://www.googleapis.com/auth/cloud-platform']
+  )
+
+def refresh_credentials(credentials: service_account.Credentials) -> service_account.Credentials:
+  """Refreshes the provided Google Cloud credentials if they are about to expire
+    (within 5 minutes) or if they don't have an expiry time set.
+
+  Args:
+      credentials: The credentials object to refresh.
+
+  Returns:
+      service_account.Credentials: The refreshed credentials object.
+  """
+  if credentials.expiry:
+    expiry_time = credentials.expiry.replace(tzinfo=datetime.timezone.utc)
+    # Calculate the time remaining until expiration
+    time_remaining = expiry_time - datetime.datetime.now(datetime.timezone.utc)
+    # Check if the token is about to expire (e.g., within 5 minutes)
+    if time_remaining < datetime.timedelta(minutes=5):
+        request = google.auth.transport.requests.Request()
+        credentials.refresh(request)
+  else:
+    # If no expiry is set, always attempt to refresh (e.g., for certain credential types)
+    request = google.auth.transport.requests.Request()
+    credentials.refresh(request)
+  return credentials
+
+def get_access_token_refresh_if_needed(credentials: service_account.Credentials) -> str:
+  """Gets the access token from the credentials, refreshing them if needed.
+
+  Args:
+      credentials: The credentials object.
+
+  Returns:
+      str: The access token.
+  """
+  credentials = refresh_credentials(credentials)
+  return credentials.token
+

cache.py

@@ -0,0 +1,67 @@
+# Copyright 2025 Google LLC
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+from diskcache import Cache
+import os
+import shutil
+import tempfile
+import zipfile
+import logging
+
+cache = Cache(os.environ.get("CACHE_DIR", "/cache"))
+# Print cache statistics after loading
+try:
+    item_count = len(cache)
+    size_bytes = cache.volume()
+    print(f"Cache loaded: {item_count} items, approx {size_bytes} bytes")
+except Exception as e:
+    print(f"Could not retrieve cache statistics: {e}")
+
+def create_cache_zip():
+    temp_dir = tempfile.gettempdir()
+    base_name = os.path.join(temp_dir, "cache_archive") # A more descriptive name
+    archive_path = base_name + ".zip"
+    cache_directory = os.environ.get("CACHE_DIR", "/cache")
+    
+    if not os.path.isdir(cache_directory):
+        logging.error(f"Cache directory not found at {cache_directory}")
+        return None, f"Cache directory not found on server: {cache_directory}"
+    
+    logging.info("Forcing a cache checkpoint for safe backup...")
+    try:
+        # Open and immediately close a connection.
+        # This forces SQLite to perform a checkpoint, merging the .wal file
+        # into the main .db file, ensuring the on-disk files are consistent.
+        with Cache(cache_directory) as temp_cache:
+            temp_cache.close()
+        
+        # Clean up temporary files before archiving.
+        tmp_path = os.path.join(cache_directory, 'tmp')
+        if os.path.isdir(tmp_path):
+            logging.info(f"Removing temporary cache directory: {tmp_path}")
+            shutil.rmtree(tmp_path)
+
+        logging.info(f"Checkpoint complete. Creating zip archive of {cache_directory} to {archive_path}")
+        with zipfile.ZipFile(archive_path, 'w', zipfile.ZIP_DEFLATED, compresslevel=9) as zipf:
+            for root, _, files in os.walk(cache_directory):
+                for file in files:
+                    file_path = os.path.join(root, file)
+                    arcname = os.path.relpath(file_path, cache_directory)
+                    zipf.write(file_path, arcname)
+        logging.info("Zip archive created successfully.")
+        return archive_path, None
+        
+    except Exception as e:
+        logging.error(f"Error creating zip archive of cache directory: {e}", exc_info=True)
+        return None, f"Error creating zip archive: {e}"

cache_archive.zip

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:7c4735cc77e6df31539abaa76ef2389252ab6057d875bba8a30b09fdaa5f84e0
+size 6150757

evaluation.py

@@ -0,0 +1,69 @@
+# Copyright 2025 Google LLC
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+import re
+from medgemma import medgemma_get_text_response
+
+
+def evaluation_prompt(defacto_condition):
+    # Returns a detailed prompt for the LLM to evaluate a pre-visit report for a specific condition
+    return f"""
+Your role is to evaluate the helpfulness of a pre-visit report, which is based on a pre-visit patient interview and existing health records.
+The patient was de facto diagnosed condition: "{defacto_condition}" which was not known at the time of the interview.
+
+List the specific elements in the previsit report text that are helpful or necessary for the PCP to diagnose the de facto diagnosed condition: "{defacto_condition}". 
+
+This include pertinet positives or negatives. 
+List critical elements that are MISSING from the previsit report text that would have been helpful for the PCP to diagnose the de facto diagnosed condition. 
+This include pertinet positives or negatives that were missing from the report. 
+(keep in mind that the condition "{defacto_condition}" was not known at the time)
+
+The evaluation output should be in HTML format.
+
+REPORT TEMPLATE START
+
+<h3 class="helpful">Helpful Facts:</h3>
+
+<h3 class="missing">What wasn't covered but would be helpful:</h3>
+
+REPORT TEMPLATE END
+"""
+
+def evaluate_report(report, condition):
+    """Evaluate the pre-visit report based on the condition using MedGemma LLM."""
+    evaluation_text = medgemma_get_text_response([
+        {
+            "role": "system",
+            "content": [
+                {
+                    "type": "text",
+                    "text": f"{evaluation_prompt(condition)}"
+                }
+            ]
+        },
+        {
+            "role": "user",
+            "content": [
+                {
+                    "type": "text",
+                    "text": f"Here is the report text:\n{report}"
+                }
+            ]
+        },        
+    ])
+
+    # Remove any LLM "thinking" blocks (special tokens sometimes present in output)
+    evaluation_text = re.sub(r'<unused94>.*?<unused95>', '', evaluation_text, flags=re.DOTALL)
+
+    return evaluation_text

frontend/package.json

@@ -0,0 +1,31 @@
+{
+  "name": "frontend",
+  "version": "0.1.0",
+  "private": true,
+  "dependencies": {
+    "diff": "^8.0.2",
+    "html-react-parser": "^5.2.5",
+    "marked": "^15.0.12",
+    "react": "^18.2.0",
+    "react-dom": "^18.2.0",
+    "react-scripts": "^5.0.1",    
+    "@textea/json-viewer": "^3.2.1",
+    "@mui/material": "^5.15.20"
+  },
+  "scripts": {
+    "start": "cross-env NODE_OPTIONS=--openssl-legacy-provider react-scripts start",
+    "build": "react-scripts build"
+  },
+  "browserslist": {
+    "production": [
+      ">0.2%",
+      "not dead",
+      "not op_mini all"
+    ],
+    "development": [
+      "last 1 chrome version",
+      "last 1 firefox version",
+      "last 1 safari version"
+    ]
+  }
+}

frontend/public/assets/alex.mp4

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:ae46c52980e7d7a176245a8f42e90c7386af502e2efed87721937a0e3c9e53ae
+size 1122871

frontend/public/assets/alex_fhir.json

@@ -0,0 +1,246 @@
+[
+  {
+    "resourceType": "Patient",
+    "id": "alex-sharma-63-female",
+    "meta": {
+      "profile": [
+        "http://hl7.org/fhir/R4/StructureDefinition/Patient"
+      ]
+    },
+    "text": {
+      "status": "generated",
+      "div": "<div xmlns=\"http://www.w3.org/1999/xhtml\"><p><b>Alex Sharma</b> (Female, 63)</p><p>Known Conditions: Diabetes</p></div>"
+    },
+    "identifier": [
+      {
+        "use": "usual",
+        "type": {
+          "coding": [
+            {
+              "system": "http://terminology.hl7.org/CodeSystem/v2-0203",
+              "code": "MR",
+              "display": "Medical record number"
+            }
+          ]
+        },
+        "system": "http://example.org/patients",
+        "value": "PAT-2023-001"
+      }
+    ],
+    "name": [
+      {
+        "use": "official",
+        "family": "Sharma",
+        "given": [
+          "Alex"
+        ]
+      }
+    ],
+    "gender": "female",
+    "birthDate": "1962-01-15",
+    "deceasedBoolean": false
+  },
+  {
+    "resourceType": "Encounter",
+    "id": "encounter-diabetes-followup",
+    "meta": {
+      "profile": [
+        "http://hl7.org/fhir/R4/StructureDefinition/Encounter"
+      ]
+    },
+    "text": {
+      "status": "generated",
+      "div": "<div xmlns=\"http://www.w3.org/1999/xhtml\"><p><b>Diabetes Follow-up Visit</b> for Alex Sharma on 2024-03-10</p></div>"
+    },
+    "status": "finished",
+    "class": {
+      "system": "http://terminology.hl7.org/CodeSystem/v3-ActCode",
+      "code": "AMB",
+      "display": "Ambulatory"
+    },
+    "type": [
+      {
+        "coding": [
+          {
+            "system": "http://terminology.hl7.org/CodeSystem/v3-ActCode",
+            "code": "FLD",
+            "display": "Field"
+          }
+        ],
+        "text": "Follow-up visit for Diabetes"
+      }
+    ],
+    "subject": {
+      "reference": "Patient/alex-sharma-63-female",
+      "display": "Alex Sharma"
+    },
+    "period": {
+      "start": "2024-03-10T10:00:00Z",
+      "end": "2024-03-10T10:45:00Z"
+    },
+    "serviceProvider": {
+      "reference": "Organization/example-org",
+      "display": "Example Medical Center"
+    }
+  },
+  {
+    "resourceType": "Condition",
+    "id": "condition-diabetes-mellitus",
+    "meta": {
+      "profile": [
+        "http://hl7.org/fhir/R4/StructureDefinition/Condition"
+      ]
+    },
+    "text": {
+      "status": "generated",
+      "div": "<div xmlns=\"http://www.w3.org/1999/xhtml\"><p><b>Diabetes Mellitus, Type 2</b> for Alex Sharma, diagnosed 2020-05-20</p></div>"
+    },
+    "clinicalStatus": {
+      "coding": [
+        {
+          "system": "http://terminology.hl7.org/CodeSystem/condition-clinical",
+          "code": "active",
+          "display": "Active"
+        }
+      ]
+    },
+    "verificationStatus": {
+      "coding": [
+        {
+          "system": "http://terminology.hl7.org/CodeSystem/condition-ver-status",
+          "code": "confirmed",
+          "display": "Confirmed"
+        }
+      ]
+    },
+    "category": [
+      {
+        "coding": [
+          {
+            "system": "http://terminology.hl7.org/CodeSystem/condition-category",
+            "code": "problem-list-item",
+            "display": "Problem List Item"
+          }
+        ]
+      }
+    ],
+    "severity": {
+      "coding": [
+        {
+          "system": "http://terminology.hl7.org/CodeSystem/condition-severity",
+          "code": "24484000",
+          "display": "Moderate"
+        }
+      ]
+    },
+    "code": {
+      "coding": [
+        {
+          "system": "http://snomed.info/sct",
+          "code": "44054006",
+          "display": "Diabetes mellitus"
+        }
+      ],
+      "text": "Diabetes Mellitus, Type 2"
+    },
+    "subject": {
+      "reference": "Patient/alex-sharma-63-female",
+      "display": "Alex Sharma"
+    },
+    "onsetDateTime": "2020-05-20"
+  },
+  {
+    "resourceType": "MedicationRequest",
+    "id": "medicationrequest-metformin",
+    "meta": {
+      "profile": [
+        "http://hl7.org/fhir/R4/StructureDefinition/MedicationRequest"
+      ]
+    },
+    "text": {
+      "status": "generated",
+      "div": "<div xmlns=\"http://www.w3.org/1999/xhtml\"><p><b>Metformin 500mg</b> for Alex Sharma, 1 tablet by mouth twice daily, ongoing</p></div>"
+    },
+    "status": "active",
+    "intent": "order",
+    "medicationCodeableConcept": {
+      "coding": [
+        {
+          "system": "http://www.nlm.nih.gov/research/umls/rxnorm",
+          "code": "6809",
+          "display": "Metformin"
+        }
+      ],
+      "text": "Metformin 500mg Tablet"
+    },
+    "subject": {
+      "reference": "Patient/alex-sharma-63-female",
+      "display": "Alex Sharma"
+    },
+    "encounter": {
+      "reference": "Encounter/encounter-diabetes-followup",
+      "display": "Diabetes Follow-up Visit"
+    },
+    "authoredOn": "2024-03-10T10:30:00Z",
+    "requester": {
+      "reference": "Practitioner/dr-smith",
+      "display": "Dr. Jane Smith"
+    },
+    "dosageInstruction": [
+      {
+        "sequence": 1,
+        "text": "One tablet by mouth twice daily",
+        "timing": {
+          "repeat": {
+            "frequency": 2,
+            "period": 1,
+            "periodUnit": "d"
+          }
+        },
+        "route": {
+          "coding": [
+            {
+              "system": "http://terminology.hl7.org/CodeSystem/v3-RouteOfAdministration",
+              "code": "PO",
+              "display": "Oral"
+            }
+          ]
+        },
+        "doseAndRate": [
+          {
+            "type": {
+              "coding": [
+                {
+                  "system": "http://terminology.hl7.org/CodeSystem/dose-rate-type",
+                  "code": "ordered",
+                  "display": "Ordered"
+                }
+              ]
+            },
+            "doseQuantity": {
+              "value": 1,
+              "unit": "tablet",
+              "system": "http://unitsofmeasure.org",
+              "code": "{tablet}"
+            }
+          }
+        ]
+      }
+    ],
+    "dispenseRequest": {
+      "numberOfRepeatsAllowed": 3,
+      "quantity": {
+        "value": 60,
+        "unit": "tablet",
+        "system": "http://unitsofmeasure.org",
+        "code": "{tablet}"
+      },
+      "expectedSupplyDuration": {
+        "value": 30,
+        "unit": "days",
+        "system": "http://unitsofmeasure.org",
+        "code": "d"
+      }
+    }
+  }
+]

frontend/public/assets/jason_fhir.json

@@ -0,0 +1,167 @@
+{
+  "resourceType": "Bundle",
+  "id": "Jordon-Dubois-Depression-Prozac-Encounter",
+  "type": "collection",
+  "entry": [
+    {
+      "fullUrl": "urn:uuid:patient-jordon-dubois",
+      "resource": {
+        "resourceType": "Patient",
+        "id": "jordon-dubois",
+        "name": [
+          {
+            "given": ["Jordon"],
+            "family": "Dubois"
+          }
+        ],
+        "gender": "male",
+        "birthDate": "1990-06-11"
+      }
+    },
+    {
+      "fullUrl": "urn:uuid:condition-depression",
+      "resource": {
+        "resourceType": "Condition",
+        "id": "depression-jordon-dubois",
+        "subject": {
+          "reference": "urn:uuid:patient-jordon-dubois"
+        },
+        "code": {
+          "coding": [
+            {
+              "system": "http://snomed.info/sct",
+              "code": "366053000",
+              "display": "Depressive disorder"
+            }
+          ],
+          "text": "Depression"
+        },
+        "clinicalStatus": {
+          "coding": [
+            {
+              "system": "http://terminology.hl7.org/CodeSystem/condition-clinical",
+              "code": "active",
+              "display": "Active"
+            }
+          ]
+        },
+        "verificationStatus": {
+          "coding": [
+            {
+              "system": "http://terminology.hl7.org/CodeSystem/condition-ver-status",
+              "code": "confirmed",
+              "display": "Confirmed"
+            }
+          ]
+        },
+        "recordedDate": "2024-01-15T10:00:00Z"
+      }
+    },
+    {
+      "fullUrl": "urn:uuid:medication-prozac",
+      "resource": {
+        "resourceType": "Medication",
+        "id": "prozac",
+        "code": {
+          "coding": [
+            {
+              "system": "http://www.nlm.nih.gov/research/umls/rxnorm",
+              "code": "100371",
+              "display": "Fluoxetine"
+            }
+          ],
+          "text": "Prozac"
+        }
+      }
+    },
+    {
+      "fullUrl": "urn:uuid:medicationrequest-prozac",
+      "resource": {
+        "resourceType": "MedicationRequest",
+        "id": "prozac-request-jordon-dubois",
+        "subject": {
+          "reference": "urn:uuid:patient-jordon-dubois"
+        },
+        "medicationReference": {
+          "reference": "urn:uuid:medication-prozac"
+        },
+        "requester": {
+          "display": "Dr. Smith"
+        },
+        "authoredOn": "2024-01-15T11:00:00Z",
+        "status": "active",
+        "intent": "order",
+        "dosageInstruction": [
+          {
+            "text": "20mg daily",
+            "timing": {
+              "repeat": {
+                "frequency": 1,
+                "period": 1,
+                "periodUnit": "d"
+              }
+            },
+            "route": {
+              "coding": [
+                {
+                  "system": "http://terminology.hl7.org/CodeSystem/v3-RouteOfAdministration",
+                  "code": "PO",
+                  "display": "Oral"
+                }
+              ]
+            },
+            "doseAndRate": [
+              {
+                "type": {
+                  "coding": [
+                    {
+                      "system": "http://terminology.hl7.org/CodeSystem/dose-rate-type",
+                      "code": "ordered",
+                      "display": "Ordered"
+                    }
+                  ]
+                },
+                "doseQuantity": {
+                  "value": 20,
+                  "unit": "mg",
+                  "system": "http://unitsofmeasure.org",
+                  "code": "mg"
+                }
+              }
+            ]
+          }
+        ],
+        "reasonReference": [
+          {
+            "reference": "urn:uuid:condition-depression"
+          }
+        ]
+      }
+    },
+    {
+      "fullUrl": "urn:uuid:encounter-depression",
+      "resource": {
+        "resourceType": "Encounter",
+        "id": "encounter-jordon-dubois-depression",
+        "status": "finished",
+        "class": {
+          "system": "http://terminology.hl7.org/CodeSystem/v3-ActCode",
+          "code": "AMB",
+          "display": "Ambulatory"
+        },
+        "subject": {
+          "reference": "urn:uuid:patient-jordon-dubois"
+        },
+        "period": {
+          "start": "2024-01-15T09:30:00Z",
+          "end": "2024-01-15T10:30:00Z"
+        },
+        "reasonReference": [
+          {
+            "reference": "urn:uuid:condition-depression"
+          }
+        ]
+      }
+    }
+  ]
+}

frontend/public/assets/jordan.mp4

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:a9774a57078508dbcd1626463b1deb84bd468d7b81111b568a966ef3baa56051
+size 1248841

frontend/public/assets/patients_and_conditions.json

@@ -0,0 +1,46 @@
+{
+    "patients": [
+        {
+            "id": 1,
+            "name": "Jordon Dubois",
+            "gender": "Male",
+            "age": 35,
+            "existing_condition": "Depression",
+            "img": "/assets/jordan.avif",
+            "video": "/assets/jordan.mp4",
+            "headshot": "/assets/jordan_300.avif",
+            "fhirFile": "/assets/jason_fhir.json",
+            "voice": "Algenib"
+        },
+        {
+            "id": 2,
+            "name": "Alex Sharma",
+            "gender": "Female",
+            "age": 63,
+            "existing_condition": "Diabetes",
+            "img": "/assets/alex.avif",
+            "video": "/assets/alex.mp4",
+            "headshot": "/assets/alex_300.avif",
+            "fhirFile": "/assets/alex_fhir.json",
+            "voice": "Gacrux"
+        },
+        {
+            "id": 3,
+            "name": "Sacha Silva",
+            "gender": "Female",
+            "age": 24,
+            "existing_condition": "Asthma",
+            "img": "/assets/sacha.avif",
+            "video": "/assets/sacha.mp4",
+            "headshot": "/assets/sacha_150.avif",
+            "fhirFile": "/assets/sacha_fhir.json",
+            "voice": "Callirrhoe"
+        }
+    ],
+    "conditions": [
+        { "name": "Flu", "description": "A common and contagious respiratory illness caused by a virus that can lead to fever, body aches, and fatigue." },
+        { "name": "Malaria", "description": "A serious disease spread by mosquitoes that causes recurring fevers and chills due to a parasite infecting red blood cells." },
+        { "name": "Migraine", "description": "A type of severe headache often accompanied by throbbing pain, sensitivity to light and sound, and sometimes nausea." },
+        { "name": "Serotonin Syndrome", "description": "A potentially dangerous reaction caused by too much serotonin in the brain, often due to certain medications, leading to symptoms like agitation, rapid heart rate, and confusion." }
+    ]
+}

frontend/public/assets/sacha.mp4

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:c722df889fafc7646d27e8fc9d15c279df43a0be68991f122ed17e096745a867
+size 751974

frontend/public/assets/sacha_fhir.json

@@ -0,0 +1,266 @@
+{
+  "resourceType": "Bundle",
+  "type": "collection",
+  "entry": [
+    {
+      "resource": {
+        "resourceType": "Patient",
+        "id": "sacha-silva-patient",
+        "identifier": [
+          {
+            "system": "http://example.org/mrn",
+            "value": "1234567"
+          },
+          {
+            "system": "http://hl7.org/fhir/sid/us-ssn",
+            "value": "999-88-7777"
+          }
+        ],
+        "name": [
+          {
+            "family": "Silva",
+            "given": [
+              "Sacha"
+            ]
+          }
+        ],
+        "gender": "female",
+        "birthDate": "1993-10-27",
+        "address": [
+          {
+            "line": [
+              "123 Main Street"
+            ],
+            "city": "Anytown",
+            "state": "CA",
+            "postalCode": "91234",
+            "country": "US"
+          }
+        ],
+        "telecom": [
+          {
+            "system": "phone",
+            "value": "555-123-4567",
+            "use": "home"
+          },
+          {
+            "system": "email",
+            "value": "sacha.silva@example.com",
+            "use": "home"
+          }
+        ]
+      },
+      "request": {
+        "method": "PUT",
+        "url": "Patient/sacha-silva-patient"
+      }
+    },
+    {
+      "resource": {
+        "resourceType": "Condition",
+        "id": "asthma-condition",
+        "clinicalStatus": {
+          "coding": [
+            {
+              "system": "http://terminology.hl7.org/CodeSystem/condition-clinical",
+              "code": "active",
+              "display": "Active"
+            }
+          ]
+        },
+        "verificationStatus": {
+          "coding": [
+            {
+              "system": "http://terminology.hl7.org/CodeSystem/condition-ver-status",
+              "code": "confirmed",
+              "display": "Confirmed"
+            }
+          ]
+        },
+        "category": [
+          {
+            "coding": [
+              {
+                "system": "http://terminology.hl7.org/CodeSystem/condition-category",
+                "code": "problem-list-item",
+                "display": "Problem List Item"
+              }
+            ]
+          }
+        ],
+        "code": {
+          "coding": [
+            {
+              "system": "http://snomed.info/sct",
+              "code": "195967001",
+              "display": "Asthma"
+            }
+          ],
+          "text": "Asthma"
+        },
+        "subject": {
+          "reference": "Patient/sacha-silva-patient",
+          "display": "Sacha Silva"
+        },
+        "onsetDateTime": "2010-05-15"
+      },
+      "request": {
+        "method": "PUT",
+        "url": "Condition/asthma-condition"
+      }
+    },
+    {
+      "resource": {
+        "resourceType": "Encounter",
+        "id": "asthma-encounter-1",
+        "status": "finished",
+        "class": {
+          "system": "http://terminology.hl7.org/CodeSystem/v3-ActCode",
+          "code": "AMB",
+          "display": "Ambulatory"
+        },
+        "type": [
+          {
+            "coding": [
+              {
+                "system": "http://snomed.info/sct",
+                "code": "308335008",
+                "display": "Patient encounter procedure"
+              }
+            ],
+            "text": "Asthma Follow-up"
+          }
+        ],
+        "subject": {
+          "reference": "Patient/sacha-silva-patient",
+          "display": "Sacha Silva"
+        },
+        "period": {
+          "start": "2023-08-10T10:00:00-07:00",
+          "end": "2023-08-10T10:30:00-07:00"
+        },
+        "reasonCode": [
+          {
+            "coding": [
+              {
+                "system": "http://snomed.info/sct",
+                "code": "266253002",
+                "display": "Asthma exacerbation"
+              }
+            ],
+            "text": "Asthma Exacerbation"
+          }
+        ]
+      },
+      "request": {
+        "method": "PUT",
+        "url": "Encounter/asthma-encounter-1"
+      }
+    },
+    {
+      "resource": {
+        "resourceType": "MedicationRequest",
+        "id": "albuterol-mr",
+        "status": "active",
+        "intent": "order",
+        "medicationCodeableConcept": {
+          "coding": [
+            {
+              "system": "http://www.nlm.nih.gov/research/umls/rxnorm",
+              "code": "207182",
+              "display": "Albuterol 90 mcg/actuation Metered Dose Inhaler"
+            }
+          ],
+          "text": "Albuterol Inhaler"
+        },
+        "subject": {
+          "reference": "Patient/sacha-silva-patient",
+          "display": "Sacha Silva"
+        },
+        "encounter": {
+          "reference": "Encounter/asthma-encounter-1",
+          "display": "Asthma Follow-up"
+        },
+        "authoredOn": "2023-08-10T10:30:00-07:00",
+        "requester": {
+          "reference": "Practitioner/dr-jane-doe",
+          "display": "Jane Doe, MD"
+        },
+        "dosageInstruction": [
+          {
+            "sequence": 1,
+            "text": "2 puffs every 4-6 hours as needed for wheezing",
+            "timing": {
+              "repeat": {
+                "frequency": 4,
+                "period": 1,
+                "periodUnit": "h"
+              }
+            },
+            "doseQuantity": {
+              "value": 2,
+              "unit": "puff",
+              "system": "http://unitsofmeasure.org",
+              "code": "{puff}"
+            },
+            "asNeededCodeableConcept": {
+              "coding": [
+                {
+                  "system": "http://snomed.info/sct",
+                  "code": "267036007",
+                  "display": "Wheezing"
+                }
+              ],
+              "text": "Wheezing"
+            }
+          }
+        ],
+        "dispenseRequest": {
+          "quantity": {
+            "value": 1,
+            "unit": "inhaler",
+            "system": "http://terminology.hl7.org/CodeSystem/v3-orderableDrugForm",
+            "code": "INH"
+          },
+          "expectedSupplyDuration": {
+            "value": 30,
+            "unit": "days",
+            "system": "http://unitsofmeasure.org",
+            "code": "d"
+          }
+        }
+      },
+      "request": {
+        "method": "PUT",
+        "url": "MedicationRequest/albuterol-mr"
+      }
+    },
+    {
+      "resource": {
+        "resourceType": "Practitioner",
+        "id": "dr-jane-doe",
+        "name": [
+          {
+            "family": "Doe",
+            "given": [
+              "Jane"
+            ],
+            "prefix": [
+              "Dr."
+            ]
+          }
+        ],
+        "identifier": [
+          {
+            "system": "http://example.org/npi",
+            "value": "1234567890"
+          }
+        ]
+      },
+      "request": {
+        "method": "PUT",
+        "url": "Practitioner/dr-jane-doe"
+      }
+    }
+  ]
+}

frontend/public/index.html

@@ -0,0 +1,29 @@
+<!DOCTYPE html>
+<!--
+ Copyright 2025 Google LLC
+
+ Licensed under the Apache License, Version 2.0 (the "License");
+ you may not use this file except in compliance with the License.
+ You may obtain a copy of the License at
+
+     http://www.apache.org/licenses/LICENSE-2.0
+
+ Unless required by applicable law or agreed to in writing, software
+ distributed under the License is distributed on an "AS IS" BASIS,
+ WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ See the License for the specific language governing permissions and
+ limitations under the License.
+-->
+
+<html lang="en">
+  <head>
+    <meta charset="utf-8" />
+    <title>AppointReady</title>
+    <meta name="viewport" content="width=device-width, initial-scale=1" />
+    <link href="https://fonts.googleapis.com/icon?family=Material+Icons" rel="stylesheet">
+  </head>
+  <body>
+    <noscript>You need to enable JavaScript to run this app.</noscript>
+    <div id="root"></div>
+  </body>
+</html>

frontend/src/App.js

@@ -0,0 +1,88 @@
+/**
+ * Copyright 2025 Google LLC
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+import React, { useState } from 'react';
+import WelcomePage from './components/WelcomePage/WelcomePage';
+import PatientBuilder from './components/PatientBuilder/PatientBuilder';
+import RolePlayDialogs from './components/RolePlayDialogs/RolePlayDialogs';
+import Interview from './components/Interview/Interview';
+import PreloadImages from './components/PreloadImages';
+
+const App = () => {
+  const [currentPage, setCurrentPage] = useState('welcome');
+  const [selectedPatient, setSelectedPatient] = useState(null);
+  const [selectedCondition, setSelectedCondition] = useState(null);
+
+  const handleSwitchPage = () => {
+    setCurrentPage('patientBuilder');
+  };
+
+  const handleSwitchToRolePlayDialogs = () => {
+    setCurrentPage('rolePlayDialogs');
+  };
+
+  const handleSwitchToInterview = () => {
+    setCurrentPage('interview');
+  };
+
+  const imageList = [
+    '/assets/gemini.avif',
+    '/assets/medgemma.avif',
+    '/assets/ai_headshot.svg',
+    '/assets/jordan_300.avif',
+    '/assets/alex_300.avif',
+    '/assets/sacha_150.avif',
+    '/assets/jordan.avif',
+    '/assets/alex.avif',
+    '/assets/sacha.avif'
+  ];
+
+  return (
+    <PreloadImages imageSources={imageList}>
+      {currentPage === 'welcome' ? (
+        <WelcomePage
+          onSwitchPage={handleSwitchPage}
+          setSelectedPatient={setSelectedPatient}
+          setSelectedCondition={setSelectedCondition}
+        />
+      ) : currentPage === 'patientBuilder' ? (
+        <PatientBuilder
+          selectedPatient={selectedPatient}
+          selectedCondition={selectedCondition}
+          setSelectedPatient={setSelectedPatient}
+          setSelectedCondition={setSelectedCondition}
+          onNext={handleSwitchToRolePlayDialogs}
+          onBack={() => setCurrentPage('welcome')} // Back to WelcomePage
+        />
+      ) : currentPage === 'rolePlayDialogs' ? (
+        <RolePlayDialogs
+          selectedPatient={selectedPatient}
+          selectedCondition={selectedCondition}
+          onStart={handleSwitchToInterview}
+          onBack={() => setCurrentPage('patientBuilder')} // Back to PatientBuilder
+        />
+      ) : currentPage === 'interview' ? (
+        <Interview
+          selectedPatient={selectedPatient}
+          selectedCondition={selectedCondition}
+          onBack={() => setCurrentPage('rolePlayDialogs')} // Back to RolePlayDialogs
+        />
+      ) : null}
+    </PreloadImages>
+  );
+};
+
+export default App;

frontend/src/components/DetailsPopup/DetailsPopup.css

@@ -0,0 +1,46 @@
+/**
+ * Copyright 2025 Google LLC
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+.popup-close-button {
+    position: absolute;
+    top: 10px;
+    right: 15px;
+    background: transparent;
+    border: none;
+    font-size: 24px;
+    cursor: pointer;
+    color: #888;
+}
+
+.popup-close-button:hover {
+    color: #000;
+}
+
+.details-popup-content h4 {
+    margin-top: 20px;
+    margin-bottom: 10px;
+    color: #333;
+}
+
+.details-popup-content ul {
+    list-style-type: none;
+    padding-left: 0;
+}
+
+.details-popup-content li {
+    margin-bottom: 8px;
+    color: #555;
+}

frontend/src/components/DetailsPopup/DetailsPopup.js

@@ -0,0 +1,76 @@
+/**
+ * Copyright 2025 Google LLC
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+import React from 'react';
+import './DetailsPopup.css';
+
+const DetailsPopup = ({ isOpen, onClose }) => {
+  if (!isOpen) {
+    return null;
+  }
+
+  return (
+    <div className="popup-overlay" onClick={onClose}>
+      <div className="popup-content" onClick={(e) => e.stopPropagation()}>
+        <button className="popup-close-button" onClick={onClose}>&times;</button>
+        <h2 id="dialog-title" className="dialog-title-text">Details About This Demo</h2>
+                <p><b>The Model:</b> This demo features Google's MedGemma-27B, a Gemma 3-based model
+                    fine-tuned for comprehending medical text. It demonstrates MedGemma's ability to
+                    accelerate the development of AI-powered healthcare applications by offering advanced
+                    interpretation of medical data.</p>
+                <p><b>Accessing and Using the Model:</b> Google's MedGemma-27B is available on <a
+                        href="https://huggingface.co/google/medgemma-27b-text-it" target="_blank" rel="noopener noreferrer">HuggingFace<img
+                            className="hf-logo"
+                            src="https://huggingface.co/datasets/huggingface/brand-assets/resolve/main/hf-logo.svg" />
+                    </a> and is easily deployable via&nbsp;
+                    <a href="https://console.cloud.google.com/vertex-ai/publishers/google/model-garden/medgemma" target="_blank" rel="noopener noreferrer">Model
+                        Garden <img className="hf-logo"
+                            src="https://www.gstatic.com/cloud/images/icons/apple-icon.png" /></a>.
+                    Learn more about using the model and its limitations on the <a
+                        href="https://developers.google.com/health-ai-developer-foundations?referral=appoint-ready"
+                        target="_blank" rel="noopener noreferrer">HAI-DEF
+                        developer site</a>.
+                </p>
+                <p><b>Health AI Developer Foundations (HAI-DEF)</b> provides a collection of open-weight models and
+                    companion resources to empower developers in building AI models for healthcare.</p>
+                <p><b>Share this Demo:</b> If you find this demonstration valuable, we encourage you to share it on
+                    social media.
+                    <small>
+                    &nbsp;<a href="https://www.linkedin.com/shareArticle?mini=true&url=https://huggingface.co/spaces/google/appoint-ready&text=%23MedGemma%20%23MedGemmaDemo" target="_blank" rel="noopener noreferrer">LinkedIn</a>
+                    &nbsp;<a href="http://www.twitter.com/share?url=https://huggingface.co/spaces/google/appoint-ready&hashtags=MedGemma,MedGemmaDemo" target="_blank" rel="noopener noreferrer">X/Tweet</a>
+                    </small>
+                </p>
+                <p><b>Explore More Demos:</b> Discover additional demonstrations on HuggingFace Spaces or via Colabs:
+                </p>
+                <ul>
+                    <li><a href="https://huggingface.co/collections/google/hai-def-concept-apps-6837acfccce400abe6ec26c1"
+                            target="_blank" rel="noopener noreferrer">
+                            Collection of concept apps <img className="hf-logo" src="https://huggingface.co/datasets/huggingface/brand-assets/resolve/main/hf-logo.svg" />
+                        </a> built around HAI-DEF open models to inspire the community.</li>
+                    <li><a href="https://github.com/Google-Health/medgemma/tree/main/notebooks/fine_tune_with_hugging_face.ipynb" target="_blank" rel="noopener noreferrer">
+                            Finetune MedGemma Colab <img className="hf-logo"
+                                src="https://upload.wikimedia.org/wikipedia/commons/d/d0/Google_Colaboratory_SVG_Logo.svg" /></a>
+                        -
+                        See an example of how to fine-tune this model.</li> 
+                </ul>
+                For more technical details about this demo, please refer to the <a href="https://huggingface.co/spaces/google/appoint-ready/blob/main/README.md#table-of-contents" target="_blank" rel="noopener noreferrer">README</a> file in the repository.
+        <button className="popup-button" onClick={onClose}>Close</button>
+      </div>
+    </div>
+  );
+};
+
+export default DetailsPopup;

frontend/src/components/Interview/Interview.css

@@ -0,0 +1,282 @@
+/**
+ * Copyright 2025 Google LLC
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+
+
+.page.interview-page {
+  height: 100%;
+  max-height: 100%;
+}
+
+.interview-container {
+  padding: 20px;
+  font-family: Arial, sans-serif;
+  background-color: #f5f5f5;
+}
+
+.interview-split-container {
+  display: flex;
+  flex-direction: row;
+  height: 100%;
+}
+
+.interview-left-section {
+  border-right: 2px solid #e0e0e0;
+  display: flex;
+  flex-direction: row;
+  min-width: 550px;
+  max-width: 600px;
+}
+
+.toggle-icon {
+  vertical-align: text-top;
+}
+
+.interview-page .header2 span {
+  font-size: 14px;
+  font-weight: 100;
+  vertical-align: text-top;
+  animation: fadeIn 0.4s cubic-bezier(0.4, 0, 0.2, 1) forwards;
+}
+
+.interview-right-section {
+  display: flex;
+  flex-direction: column;
+  width: 60%;
+  min-width: 550px;
+  flex-grow: 2;
+  padding-left: 20px;
+  justify-content: space-between;
+  height: 100%;
+  gap: 5px;
+}
+
+.interview-header-panel {
+  flex: 0 0 320px;
+  display: flex;
+  flex-direction: column;
+  justify-content: flex-start;
+  padding: 32px 24px 0 0;
+  box-sizing: border-box;
+  background: #f5f5f5;
+}
+
+.interview-chat-panel {
+  flex: 1 1 0;
+  display: flex;
+  flex-direction: column;
+  justify-content: flex-start;
+  min-width: 0;
+  min-height: 0;
+}
+
+.chat-container {
+  flex: 1;
+  overflow-y: auto;
+  display: flex;
+  flex-direction: column;
+  gap: 10px;
+  width: 100%;
+  padding-right: 20px;
+}
+
+.chat-header {
+  display: flex;
+  justify-content: space-between;
+  gap: 10px;
+  margin-top: 20px;
+  margin: 20px 30px 0 30px;
+  width: -webkit-fill-available;
+}
+
+.chat-message-wrapper {
+  display: flex;
+  align-items: center;
+  gap: 10px;
+}
+
+/* Fade-in animation for new chat messages */
+@keyframes fadeIn {
+  from { opacity: 0; }
+  to { opacity: 1; }
+}
+
+.chat-message-wrapper.fade-in {
+  animation: fadeIn 0.5s ease;
+}
+
+.chat-message-wrapper.patient {
+  align-self: end;
+}
+
+.chat-bubble {
+  padding: 10px 15px;
+  font-size: 16px;
+  line-height: 1.4;
+  flex: 1;
+
+}
+
+.patient .chat-bubble {
+  background-color: #eaeaea;
+  margin-right: 5px;
+  border-radius: 8px;
+  background: #F5F5F5;
+}
+
+.chat-avatar {
+  width: 30px;
+  height: 30px;
+  object-fit: cover;
+  border-radius: 50%;
+  background-color: #E8DEF8;
+}
+
+.interviewer .chat-avatar {
+  padding: 5px;
+}
+
+.patient .chat-avatar {
+  width: 40px;
+  height: 40px;
+  border-color: rgb(47, 95, 207);  
+}
+
+.report-content {
+  padding: 20px;
+  overflow-y: auto;
+  flex: 1 1 0;
+  min-height: 0;
+  border-radius: 28px;
+  border: 2px solid #E9E9E9;
+  box-shadow: 0px 4px 4px 0px rgba(0, 0, 0, 0.25);
+}
+
+.report-content pre {
+  white-space: pre-wrap;       /* CSS3 */
+  white-space: -moz-pre-wrap;  /* Mozilla, since 1999 */
+  white-space: -pre-wrap;      /* Opera 4-6 */
+  white-space: -o-pre-wrap;    /* Opera 7 */
+  word-wrap: break-word;       /* Internet Explorer 5.5+ */
+}
+
+.thinking .chat-bubble {
+  display: flex;
+  flex-direction: column;
+  gap: 10px;
+  background-color: #E8DEF8;
+  padding: 20px;
+  border-radius: 8px;
+  min-width: 40px;
+  min-height: 40px;
+  position: relative;
+  color: #555;
+  border: none;
+  font-weight: 100;
+}
+
+.thinking-header {
+  font-weight: 500;
+}
+
+.chat-waiting-indicator {
+  color: #888;
+  font-size: 20px;
+  text-align: center;
+  margin: 60px 0;
+  font-style: italic;
+  opacity: 0.8;
+}
+
+.evaluate-button {
+  background-color: #C8B3FD;
+  color: #4E3B7B;
+  border-radius: 8px;
+  border-style: none;
+  padding: 6px;
+  font-size: 16px;
+}
+
+@keyframes fadeInOpacity {
+  0% { opacity: 0; font-size: 0; }
+  20% { opacity: 0; font-size: 1em; }
+  100% { opacity: 1; font-size: 1em; }
+}
+
+/* New keyframes to unset text color after a delay */
+@keyframes unsetColor {
+  to { color: unset; }
+}
+
+.add {
+  color: green;
+  animation: fadeInOpacity 1s forwards, unsetColor 0s forwards 5s;
+}
+
+@keyframes removeAnim {
+  0% { opacity: 1; font-size: 1em; }
+  80% { opacity: 0; font-size: 1em; }
+  99% { font-size: 0.2em; }
+  100% { opacity: 0; font-size: 0; display: none; }
+}
+
+.remove {
+  color: red;
+  text-decoration: line-through;
+  animation: removeAnim 1s forwards 5s;
+}
+
+.warning-icon {
+  color: #444746;
+}
+
+.disclaimer-container {
+  border-radius: 8px;
+  background: #FEF7E0;
+  display: flex;
+  align-items: center;
+  gap: 20px;
+  padding: 13px;
+  font-size: 12px;
+  width: 100%;
+}
+
+.helpful {
+  border-radius: 14.272px;
+  background: #C4EED0;
+  mix-blend-mode: multiply;
+  display: inline-block;
+  padding: 0 5px;
+}
+
+.missing {
+  border-radius: 14.272px;
+  background: #FFE07C;
+  mix-blend-mode: multiply;
+  display: inline-block;
+  padding: 0 5px;
+}
+
+.evaluation-text {
+  font-style: italic;
+  padding-bottom: 30px;
+}
+
+.evaluation-text::after {
+  content: "***";
+}
+
+

frontend/src/components/Interview/Interview.js

@@ -0,0 +1,491 @@
+/**
+ * Copyright 2025 Google LLC
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+import React, { useState, useEffect, useRef } from "react";
+import { marked } from "marked";
+import parse from "html-react-parser";
+import { diffArrays, diffWords } from "diff";
+import "./Interview.css";
+import DetailsPopup from "../DetailsPopup/DetailsPopup";
+
+const Interview = ({ selectedPatient, selectedCondition, onBack }) => {
+  const [messages, setMessages] = useState([]);
+  const [isInterviewComplete, setIsInterviewComplete] = useState(false);
+  const [showEvaluation, setShowEvaluation] = useState(false);
+  const [isAudioEnabled, setIsAudioEnabled] = useState(true);
+  const [evaluation, setEvaluation] = useState('');
+  const [isFetchingEvaluation, setIsFetchingEvaluation] = useState(false);
+  const [currentReport, setCurrentReport] = useState("");
+  const [prevReport, setPrevReport] = useState("");
+  const [waitTime, setWaitTime] = useState(3000);
+  const [showEvaluationInfoPopup, setShowEvaluationInfoPopup] = useState(false);
+  const [isDetailsPopupOpen, setIsDetailsPopupOpen] = useState(false);
+  const chatContainerRef = useRef(null);
+  const reportContentRef = useRef(null);
+  const lastMessageRef = useRef(null);
+  const messageQueue = useRef([]);
+  const eventSourceRef = useRef(null);
+  const timeoutIdRef = useRef(null);
+
+  const currentPlayingAudio = useRef(null); // To keep track of the currently playing audio instance
+  const isAudioEnabledRef = useRef(isAudioEnabled);
+  useEffect(() => {
+    isAudioEnabledRef.current = isAudioEnabled;
+  }, [isAudioEnabled]);
+  const waitTimeRef = useRef(waitTime);
+  useEffect(() => {
+    waitTimeRef.current = waitTime;
+  }, [waitTime]);
+
+  const processQueue = React.useCallback(() => {
+    if (timeoutIdRef.current) {
+      clearTimeout(timeoutIdRef.current);
+    }
+
+    if (messageQueue.current.length === 0) {
+      // The queue is empty, so the processing chain for this batch is done.
+      // Clear the timeout ref so a new message can start a new chain.
+      timeoutIdRef.current = null;
+      setIsInterviewComplete(
+        eventSourceRef.current && eventSourceRef.current.readyState === EventSource.CLOSED
+      );
+      return;
+    }
+
+    const nextMessage = messageQueue.current.shift();
+
+    setMessages((prev) => [...prev, nextMessage]);
+
+    if (nextMessage.audio && isAudioEnabledRef.current) {
+      if (currentPlayingAudio.current) {
+        currentPlayingAudio.current.pause();
+        currentPlayingAudio.current.src = '';
+      }
+      const audio = new Audio(nextMessage.audio);
+      currentPlayingAudio.current = audio;
+
+      audio.onended = () => {
+        currentPlayingAudio.current = null;
+        processQueue();
+      };
+      audio.onerror = (e) => {
+        console.error("Audio playback error:", e);
+        currentPlayingAudio.current = null;
+        processQueue();
+      };
+      audio.play().catch(e => {
+        console.error("Error playing audio automatically:", e);
+        currentPlayingAudio.current = null;
+        processQueue();
+      });
+    } else {
+      // For non-audio, schedule the next processing call with a fixed delay
+      // to simulate reading time. This will call processQueue again, which will
+      // handle an empty queue and stop the chain if needed.
+      timeoutIdRef.current = setTimeout(processQueue, waitTimeRef.current);
+    }
+  }, [setMessages, setIsInterviewComplete]);
+
+  useEffect(() => {
+    if (!selectedPatient || !selectedCondition) return;
+
+    setMessages([]);
+    setIsInterviewComplete(false);
+    messageQueue.current = [];
+    if (currentPlayingAudio.current) {
+      currentPlayingAudio.current.pause();
+      currentPlayingAudio.current = null;
+    }
+    // Prepend base URL if running on localhost:3000
+    const baseURL =
+      window.location.origin === "http://localhost:3000"
+        ? "http://localhost:7860"
+        : "";
+    const url = `${baseURL}/api/stream_conversation?patient=${encodeURIComponent(
+      selectedPatient.name
+    )}&condition=${encodeURIComponent(selectedCondition)}`;
+    const eventSource = new EventSource(url);
+    eventSourceRef.current = eventSource;
+
+    eventSource.onmessage = (event) => {
+      try {
+        const data = JSON.parse(event.data);
+
+        // Check if the parsed object is our special 'end' signal
+        if (data && data.event === 'end') {
+          console.log("Server signaled end of stream. Closing connection.");
+          eventSource.close();
+          processQueue();
+          return; 
+        }        
+        messageQueue.current.push(data);
+        // Always call processQueue after pushing a message, unless audio or timeout is active
+        if (!currentPlayingAudio.current && !timeoutIdRef.current) {
+          processQueue();
+        }
+      } catch (error) {
+        console.warn("Could not parse message data. Data received:", event.data, "Error:", error);
+      }
+    };
+
+    eventSource.onerror = (err) => {
+      console.error("EventSource failed:", err);
+      eventSource.close();
+    };
+
+
+    return () => {
+      if (eventSourceRef.current) {
+        eventSourceRef.current.close();
+        eventSourceRef.current = null;
+      }
+      if (timeoutIdRef.current) {
+        clearTimeout(timeoutIdRef.current);
+        timeoutIdRef.current = null;
+      }
+      // Ensure any playing audio is stopped when component unmounts or dependencies change
+      if (currentPlayingAudio.current) {
+        currentPlayingAudio.current.pause();
+        currentPlayingAudio.current = null;
+      }
+    };
+  }, [selectedPatient, selectedCondition, processQueue]);
+
+  useEffect(() => {
+    processQueue();
+  }, [waitTime, processQueue]);
+  
+  useEffect(() => {
+    // Prevent body scroll when Interview is shown
+    document.body.style.overflowY = "clip";
+    return () => {
+      document.body.style.overflowY = "unset";
+    };
+  }, []);
+
+  useEffect(() => {
+    if (chatContainerRef.current) {
+      const container = chatContainerRef.current;
+      const lastMessage = messages[messages.length - 1];
+      if (lastMessage && lastMessage.speaker === "report") { 
+        return;
+      }
+
+      const isNearBottom =
+        container.scrollHeight - container.scrollTop - container.clientHeight <
+        container.clientHeight;
+      if (isNearBottom && messages.length > 0) {
+        lastMessageRef.current.scrollIntoView({
+          behavior: "smooth",
+          block: "end",
+        });
+      }
+    }
+  }, [messages]);
+
+  // Update report on new messages
+  useEffect(() => {
+    const reportMessages = messages.filter((msg) => msg.speaker === "report");
+    if (reportMessages.length > 0) {
+      const latestReportMessageText =
+        reportMessages[reportMessages.length - 1].text;
+      const newReport = marked(latestReportMessageText.trim());
+      if (newReport !== currentReport) {
+        setPrevReport(currentReport);
+        setCurrentReport(newReport);
+      }
+    }
+  }, [messages, currentReport]);
+
+  // Updated diff function to tokenize HTML and use nested diffWords for text changes
+  const getDiffReport = () => {
+    // Tokenize HTML into tags and text parts
+    const tokenizeHTML = (html) => html.match(/(<[^>]+>|[^<]+)/g) || [];
+    const tokensPrev = tokenizeHTML(prevReport);
+    const tokensCurrent = tokenizeHTML(currentReport);
+    const diffParts = diffArrays(tokensPrev, tokensCurrent);
+
+    let result = "";
+    for (let i = 0; i < diffParts.length; i++) {
+      // If a removed part is immediately followed by an added part,
+      // and both are plain text (not an HTML tag), apply inner diffWords.
+      if (
+        diffParts[i].removed &&
+        i + 1 < diffParts.length &&
+        diffParts[i + 1].added
+      ) {
+        const removedText = diffParts[i].value.join("");
+        const addedText = diffParts[i + 1].value.join("");
+        // Check if both parts are not HTML tags
+        if (
+          (!/^<[^>]+>$/.test(removedText) && !/^<[^>]+>$/.test(addedText))
+        ) {
+          const innerDiff = diffWords(removedText, addedText);
+          const innerResult = innerDiff
+            .map((part) => {
+              if (part.added) {
+                return `<span class="add">${part.value}</span>`;
+              } else if (part.removed) {
+                return `<span class="remove">${part.value}</span>`;
+              }
+              return part.value;
+            })
+            .join("");
+          result += innerResult;
+          i++;
+          continue;
+        }
+      }
+      if (diffParts[i].added) {
+        result += `<span class="add">${diffParts[i].value.join("")}</span>`;
+      } else if (diffParts[i].removed) {
+        result += `<span class="remove">${diffParts[i].value.join("")}</span>`;
+      } else {
+        result += diffParts[i].value.join("");
+      }
+    }
+    return result;
+  };
+
+  // Fetch evaluation when showEvaluation is triggered
+  useEffect(() => {
+    if (!showEvaluation) return;
+    setIsFetchingEvaluation(true);
+    setEvaluation('');
+    // Get latest report
+    const reportMessages = messages.filter((msg) => msg.speaker === "report");
+    const report =
+      reportMessages.length > 0
+        ? marked(reportMessages[reportMessages.length - 1].text.trim())
+        : "<p>No report available.</p>";
+    // Prepend base URL if running on localhost:3000
+    const baseURL = window.location.origin === "http://localhost:3000" ? "http://localhost:7860" : "";
+    fetch(`${baseURL}/api/evaluate_report`, {
+      method: 'POST',
+      headers: { 'Content-Type': 'application/json' },
+      body: JSON.stringify({
+        report,
+        condition: selectedCondition
+      })
+    })
+      .then(response => response.json())
+      .then(data => {
+        setEvaluation(data.evaluation.replace('```html\n','').replace('\n```',''));
+        setIsFetchingEvaluation(false);
+      })
+      .catch(error => {
+        setEvaluation('Error fetching evaluation.');
+        setIsFetchingEvaluation(false);
+      });
+  }, [showEvaluation, messages, selectedCondition]);
+
+  // Scroll report-content to bottom when evaluate button appears
+  useEffect(() => {
+    if (isInterviewComplete && reportContentRef.current) {
+      reportContentRef.current.scrollTop = reportContentRef.current.scrollHeight;
+    }
+  }, [isInterviewComplete]);
+
+  const handleToggleWaitTime = () => {
+    setWaitTime((prev) => (prev === 1000 ? 3000 : 1000));
+  };
+
+  const handleToggleAudio = () => {
+    setIsAudioEnabled(prev => {
+      const isNowEnabled = !prev;
+      // If we are disabling audio and something is playing, stop it and continue the queue.
+      if (!isNowEnabled && currentPlayingAudio.current) {
+        currentPlayingAudio.current.pause();
+        currentPlayingAudio.current.src = '';
+        currentPlayingAudio.current = null;
+      }
+      return isNowEnabled;
+    });
+  };
+
+  const playAudio = (audioDataUrl) => {
+    if (audioDataUrl) {
+      const audio = new Audio(audioDataUrl);
+      audio.play().catch(e => {
+        console.error("Error playing audio:", e);
+      });
+    }
+  };
+
+  return (
+    <div className="page interview-page">
+      <div className="headerButtonsContainer">
+        <button className="back-button" onClick={onBack}>
+          <i className="material-icons back-button-icon">keyboard_arrow_left</i>
+          Back
+        </button>
+        <button className="details-button" onClick={() => setIsDetailsPopupOpen(true)}>
+          <i className="material-icons code-block-icon">code</i>&nbsp; Details
+          about this Demo
+        </button>
+      </div>
+      <div className="frame">
+        <div className="interview-split-container">
+          {/* Top: Interview Chat */}
+          <div className="interview-left-section">
+            {/* Right: Chat */}
+            <div className="interview-chat-panel">
+              <div className="header2">
+                Simulated Interview
+                &nbsp;
+                <i
+                  className="material-icons toggle-icon"
+                  style={{
+                    cursor: "pointer",
+                    color: isAudioEnabled ? "#1976d2" : "#888",
+                  }}
+                  title={`Click to ${
+                    isAudioEnabled ? "disable" : "enable"
+                  } audio`}
+                  onClick={handleToggleAudio}
+                >
+                  {isAudioEnabled ? "volume_up" : "volume_off"}
+                </i>
+                {isAudioEnabled && (<span>audio by Gemini TTS</span>)}
+                {!isAudioEnabled && (
+                <i
+                  className="material-icons toggle-icon"
+                  style={{
+                    cursor: "pointer",
+                    color: waitTime === 1000 ? "#1976d2" : "#888",
+                  }}
+                  title={`Click to ${
+                    waitTime === 1000 ? "slow down" : "speed up"
+                  } the interview`}
+                  onClick={handleToggleWaitTime}
+                >
+                  speed
+                </i>)}
+                
+              </div>
+              <div className="chat-container" ref={chatContainerRef}>
+                {messages.length === 0 ? (
+                  <div className="chat-waiting-indicator">
+                    Waiting for the interview to start...
+                  </div>
+                ) : (
+                  messages
+                    .filter((msg) => msg.speaker !== "report")
+                    .map((msg, idx, filteredMessages) => (
+                      <div
+                        ref={idx === filteredMessages.length - 1 ? lastMessageRef : null}
+                        className={`chat-message-wrapper ${msg.speaker}${idx === filteredMessages.length - 1 ? " fade-in" : ""}${msg.audio ? " has-audio" : ""}`}
+                      key={idx}
+                    >
+                      {msg.speaker.includes("interviewer") && (
+                        <img
+                          className="chat-avatar"
+                          src="assets/ai_headshot.svg"
+                          alt="Interviewer"
+                        />
+                      )}
+                      <div className={`chat-bubble ${msg.audio ? "with-audio" : ""}`}>
+                        {msg.speaker.includes("thinking") && (
+                          <div className="thinking-header">Thinking...</div>
+                        )}
+                        {msg.text}
+                      </div>
+                      {msg.speaker === "patient" && (
+                        <img
+                          className="chat-avatar"
+                          src={selectedPatient.headshot}
+                          alt={selectedPatient.name}
+                        />
+                      )}
+                    </div>
+                  ))
+                )}
+              </div>
+            </div>
+          </div>
+          {/* Right: Report Section */}
+          <div className="interview-right-section">
+            <div className="header2">Generated Report</div>
+            <div className="report-content" ref={reportContentRef}>
+              {/* Updated report rendering to show diff if available */}
+              <div
+                dangerouslySetInnerHTML={{
+                  __html: prevReport ? getDiffReport() : currentReport,
+                }}
+              />
+              {isInterviewComplete && (
+                <button
+                  className="evaluate-button"
+                  onClick={() => setShowEvaluationInfoPopup(true)}
+                  disabled={showEvaluation || showEvaluationInfoPopup}
+                ><i className="material-icons back-button-icon">keyboard_arrow_down</i>
+                  View Report Evaluation
+                </button>
+              )}
+              <div className="evaluation-text">
+                {showEvaluation && (
+                  isFetchingEvaluation
+                    ? <div>Please wait...</div>
+                    : parse(evaluation)
+                )}
+              </div>
+            </div>
+            <div className="disclaimer-container">
+              <i className="material-icons warning-icon">warning</i>
+              <div className="disclaimer-text">
+                This demonstration is for illustrative purposes of MedGemma’s baseline capabilities only. It does not represent a finished or approved product, is not intended to diagnose or suggest treatment of any disease or condition, and should not be used for medical advice.
+              </div>
+            </div>
+          </div>
+        </div>
+      </div>
+      {showEvaluationInfoPopup && (
+        <div className="popup-overlay">
+          <div className="popup-content">
+            <h2>About the Evaluation</h2>
+            <p>
+              Now we will ask MedGemma to evaluate its own performance at
+              generating this report. We will provide it with all the
+              information about {selectedPatient.name}, including their actual
+              diagnosis and aspects of condition history not included previously. 
+              Using this new information, MedGemma will
+              highlight key facts it correctly included and identify other
+              information that would have been beneficial to add.
+            </p>
+            <p>
+              The purpose of this step is to provide non-medical users with a
+              sense of how well MedGemma did at this task. While the evaluation
+              is completed by MedGemma, the examples in this demo have also been
+              reviewed by clinicians for accuracy. Although MedGemma's evaluation
+              does not represent a consensus based standard,
+              this illustration simply shows an example of one approach developers could adopt 
+              to evaluate quality and completeness.
+            </p>
+            <button className="popup-button" onClick={() => {
+              setShowEvaluationInfoPopup(false);
+              setShowEvaluation(true);
+            }}>Continue</button>
+          </div>
+        </div>)}
+      <DetailsPopup
+        isOpen={isDetailsPopupOpen}
+        onClose={() => setIsDetailsPopupOpen(false)}
+      />
+    </div>
+  );
+};
+
+export default Interview;

frontend/src/components/PatientBuilder/PatientBuilder.css

@@ -0,0 +1,205 @@
+/**
+ * Copyright 2025 Google LLC
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#root {
+	display: flex;
+	justify-content: center;
+}
+
+.header2 {
+	font-size: 24px;
+	font-weight: bold;
+	margin-bottom: 10px;
+}
+
+.lighttext {
+	font-size: 15px;
+}
+
+
+
+.patient-builder-container {
+	font-family: Arial, sans-serif;
+	display: flex;
+	flex-direction: column;
+	position: relative;
+	gap: 20px;
+	width: min-content;
+	height: min-content;
+}
+
+.patient-list {
+	display: flex;
+	gap: 20px;
+}
+
+.patient-list {
+	justify-content: space-between;
+}
+
+.selection-section {
+	margin-bottom: 30px;
+    flex-direction: column;
+	width: 958px;
+}
+
+.condition-list {
+	align-items: stretch;
+	flex-direction: column;
+	gap: 10px;
+	margin-top: 10px;
+	display: grid;
+	grid-template-columns: 1fr 1fr;
+}
+
+.condition-card {
+	display: grid;
+	grid-template-columns: 100px 1fr;
+	align-items: center;
+	padding: 0 30px;
+}
+
+.condition-card {
+	background: #fff;
+	border: 2px solid #ddd;
+	border-radius: 10px;
+	padding: 10px;
+	cursor: pointer;
+	transition: transform 0.2s ease, border-color 0.2s ease;
+	box-shadow: 0 2px 5px rgba(0,0,0,0.1);
+}
+
+.patient-video-container {
+	position: relative;
+	cursor: pointer;
+	width: 300px;
+	height: 300px;
+	overflow: hidden;
+	border: 4px solid transparent;
+	border-radius: 12px;
+	transition: border-color 0.2s ease;
+	box-sizing: border-box;
+}
+
+.patient-video, .patient-img {
+	position: absolute;
+	top: 0;
+	left: 0;
+	width: 100%;
+	object-fit: cover;
+	border-radius: 8px;
+	transition: opacity 0.4s ease-in-out;
+}
+
+.ehr-label {
+	position: absolute;
+	bottom: 15px;
+	right: 10px;
+	border-radius: 4px;
+	border: 1px solid #C8B3FD;
+	background: #E8DEF8;
+	padding: 0 5px;
+}
+
+.patient-video-container:hover {
+	border-color: #aaa;
+}
+
+.condition-card:hover, .ehr-label:hover {
+	transform: scale(1.05);
+	border-color: #aaa;
+}
+.patient-video-container.selected {
+	border-color: #D0BCFF;
+	box-shadow: 0px 4px 4px 0px rgba(0, 0, 0, 0.25);
+}
+
+.condition-card.selected {
+	border: 4px solid #D0BCFF;
+	box-shadow: 0px 4px 4px 0px rgba(0, 0, 0, 0.25);
+}
+
+.go-button {
+	background: #0078D7;
+	color: #fff;
+	border: none;
+	padding: 10px 20px;
+	border-radius: 5px;
+	cursor: pointer;
+	font-size: 16px;
+	transition: background 0.3s ease;
+}
+.go-button:disabled {
+	background: #aaa;
+	cursor: not-allowed;
+}
+.go-button:hover:not(:disabled) {
+	background: #005fa3;
+}
+.patient-info .category-label {
+    font-size: 12px;
+    font-weight: bold;
+}
+.patient-info .category-value {
+    font-size: 16px;
+    font-weight: normal;
+}
+
+.patient-info {
+	display: flex;
+	flex-direction: column;
+	justify-content: center;
+}
+
+.condition-card.disabled {
+    pointer-events: none;
+    opacity: 0.3;
+	transition: opacity 0.2s ease-in-out 0.1s;
+}
+
+.patient-info-right {
+	display: flex;
+	flex-direction: column;
+	justify-content: center;
+	gap: 10px;
+	width: min-content;
+}
+
+.patient-details {
+	display: flex;
+	flex-direction: column;
+	gap: 10px;
+	margin-top: 20px;
+	align-items: center;
+	text-align: center;
+}
+
+.json-popup-content {
+  max-width: 80vw;
+  max-height: 80vh;
+  display: flex;
+  flex-direction: column;
+  width: 800px;
+}
+
+.json-viewer-container {
+  flex-grow: 1;
+  overflow: auto;
+  border-radius: 8px;
+  padding: 1rem;
+  margin-bottom: 1.5rem;
+  font-family: monospace;
+}

frontend/src/components/PatientBuilder/PatientBuilder.js

@@ -0,0 +1,235 @@
+/**
+ * Copyright 2025 Google LLC
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+import React, { useState, useEffect } from "react";
+import "./PatientBuilder.css";
+import { JsonViewer } from "@textea/json-viewer"; // updated import
+import DetailsPopup from "../DetailsPopup/DetailsPopup";
+
+// Global caching function to load patients & conditions once
+let cachedPatientsAndConditions = null;
+function getPatientsAndConditions() {
+  if (cachedPatientsAndConditions)
+    return Promise.resolve(cachedPatientsAndConditions);
+  return fetch("/assets/patients_and_conditions.json")
+    .then((response) => response.json())
+    .then((data) => {
+      cachedPatientsAndConditions = data;
+      return data;
+    });
+}
+
+const PatientBuilder = ({
+  selectedPatient,
+  selectedCondition,
+  setSelectedPatient,
+  setSelectedCondition,
+  onNext,
+  onBack,
+}) => {
+  const [patients, setPatients] = useState([]);
+  const [conditions, setConditions] = useState([]);
+  const [hoveredPatient, setHoveredPatient] = useState(null);
+  const [isVideoLoading, setIsVideoLoading] = useState(false);
+
+  const [isPopupOpen, setIsPopupOpen] = useState(false);
+  const [popupJson, setPopupJson] = useState(null);
+  const [isDetailsPopupOpen, setIsDetailsPopupOpen] = useState(false);
+
+
+  useEffect(() => {
+    getPatientsAndConditions()
+      .then((data) => {
+        setPatients(data.patients);
+        setConditions(data.conditions);
+      })
+      .catch((error) =>
+        console.error("Error fetching patients and conditions:", error)
+      );
+  }, []);
+
+  useEffect(() => {
+    if (
+      selectedPatient &&
+      selectedPatient.existing_condition !== "depression" &&
+      selectedCondition === "Serotonin Syndrome"
+    ) {
+      setSelectedCondition(null);
+    }
+  }, [selectedPatient]);
+
+  // When a new patient is selected, set the video to a loading state
+  // to ensure the placeholder image is shown.
+  useEffect(() => {
+    if (selectedPatient) {
+      setIsVideoLoading(true);
+    }
+  }, [selectedPatient]);
+
+  const handleGo = () => {
+    if (selectedPatient && selectedCondition) {
+      onNext();
+    }
+  };
+
+  const openPopup = (patient) => {
+    if (patient && patient.fhirFile) {
+      fetch(patient.fhirFile)
+        .then((response) => response.json())
+        .then((json) => {
+          setPopupJson(json);
+          setIsPopupOpen(true);
+        })
+        .catch((error) => console.error("Error fetching FHIR JSON:", error));
+    }
+  };
+
+  const closePopup = () => {
+    setIsPopupOpen(false);
+    setPopupJson(null);
+  };
+
+  return (
+    <div className="patient-builder-container">
+      <div className="headerButtonsContainer">
+      <button className="back-button" onClick={onBack}>
+          <i className="material-icons back-button-icon">keyboard_arrow_left</i>
+          Back
+      </button>
+      <button className="details-button" onClick={() => setIsDetailsPopupOpen(true)}>
+          <i className="material-icons code-block-icon">code</i>&nbsp;
+          Details about this Demo
+      </button>
+      </div>
+      <div className="frame">
+        <div className="selection-section">
+          <div className="header2">Select a Patient</div>
+          <div className="patient-list">
+            {patients.map((patient) => {
+              const isSelected = selectedPatient && selectedPatient.id === patient.id;
+              return (
+                <div
+                  key={patient.id}
+                  className="patient-card"
+                >
+                  <div
+                    className={`patient-video-container ${isSelected ? "selected" : ""}`}
+                    onClick={() => setSelectedPatient(patient)}
+                  >
+                    <img
+                      src={patient.img}
+                      className="patient-img"
+                      alt={patient.name}
+                      draggable="false"
+                      onDragStart={(e) => e.preventDefault()}
+                      style={{ opacity: isSelected && !isVideoLoading ? 0 : 1 }}
+                    />
+                    {isSelected && (
+                      <video
+                        key={patient.id}
+                        src={patient.video}
+                        className="patient-video"
+                        autoPlay
+                        muted
+                        loop
+                        onCanPlay={() => setIsVideoLoading(false)}
+                        style={{ opacity: isVideoLoading ? 0 : 1 }}
+                      />
+                    )}
+                    <div className="ehr-label" onClick={(e) => { e.stopPropagation(); openPopup(patient); }}>
+                      Synthetic Health Record (FHIR)
+                    </div>
+                  </div>
+                  <div className="patient-info">
+                    <div className="category-value">
+                      {patient.name}, {patient.age} years old, {patient.gender}
+                    </div>
+                    <div className="category-value">
+                      Existing condition: {patient.existing_condition}
+                    </div>
+                  </div>
+                </div>
+              );
+            })}
+          </div>
+        </div>
+        <div className="selection-section">
+          <div className="header2">Explore a Condition</div>
+          <div className="lighttext">
+          In this demonstration, a persona, simulated using Gemini 2.5 Flash, will interact with an AI agent, built with MedGemma. 
+          Neither the simulated persona nor the AI agent have been provided the diagnosis for the current condition (selected below). 
+          The AI agent facilitates structured information-gathering, designed to usefully collect and summarize the patient's symptoms. 
+          For the purposes of this demonstration, the AI agent also has access to elements of the patient's health record (provided as FHIR resources).
+          </div>
+          <div className="condition-list">
+            {conditions.map((cond) => {
+              const isDisabled =
+                cond.name === "Serotonin Syndrome" &&
+                selectedPatient &&
+                selectedPatient.existing_condition !== "Depression";
+              return (
+                <div
+                  key={cond.name}
+                  className={`condition-card lighttext ${
+                    selectedCondition === cond.name ? "selected" : ""
+                  } ${isDisabled ? "disabled" : ""}`}
+                  onClick={
+                    !isDisabled
+                      ? () => setSelectedCondition(cond.name)
+                      : undefined
+                  }
+                >
+                  <div><strong>{cond.name}</strong></div>
+                  <div>{cond.description}</div>
+                </div>
+              );
+            })}
+          </div>
+        </div>
+        <button
+          className="info-button"
+          onClick={handleGo}
+          disabled={!(selectedPatient && selectedCondition)}
+        >
+          Launch simulation
+        </button>
+      </div>
+      {isPopupOpen && (
+        <div className="popup-overlay" onClick={closePopup}>
+          <div
+            className="popup-content json-popup-content"
+            onClick={(e) => e.stopPropagation()}
+          >
+            <h2>Synthetic Electronic Health Record</h2>
+            <span>This is a sample of the patient’s electronic health record, shown in a standard (FHIR) format. This FHIR record, like the patient, was generated solely for the purposes of this demo.</span>
+            <div className="json-viewer-container">
+              <JsonViewer value={popupJson} theme="monokai" />
+            </div>
+            <button className="popup-button" onClick={closePopup}>
+              Close
+            </button>
+          </div>
+        </div>
+      )}
+       <DetailsPopup
+        isOpen={isDetailsPopupOpen}
+        onClose={() => setIsDetailsPopupOpen(false)}
+      />
+    </div>
+  );
+};
+
+export default PatientBuilder;

frontend/src/components/PreloadImages.js

@@ -0,0 +1,42 @@
+/**
+ * Copyright 2025 Google LLC
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+import React, { useEffect, useState } from 'react';
+
+const PreloadImages = ({ imageSources, children }) => {
+  const [loaded, setLoaded] = useState(false);
+
+  useEffect(() => {
+    let loadedCount = 0;
+    imageSources.forEach(src => {
+      const img = new Image();
+      img.src = src;
+      img.onload = () => {
+        loadedCount++;
+        if (loadedCount === imageSources.length) {
+          setLoaded(true);
+        }
+      };
+    });
+  }, [imageSources]);
+
+  if (!loaded) {
+    return <div>Loading images...</div>;
+  }
+  return <>{children}</>;
+};
+
+export default PreloadImages;

frontend/src/components/RolePlayDialogs/RolePlayDialogs.css

@@ -0,0 +1,101 @@
+/**
+ * Copyright 2025 Google LLC
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+.frame.role-play-container {
+  display: grid;
+  justify-items: center;
+  align-content: center;
+  align-items: center;  
+  grid-gap: 30px;  
+  width: fit-content;
+  align-self: center;
+}
+
+.dialogs-container {
+    display: flex;
+    justify-content: space-between;
+    align-items: center;
+    gap: 20px;
+    margin-top: 50px;
+}
+
+
+.dialog-box {
+  border-radius: 5.667px;
+  border: 1.889px solid #E9E9E9;
+  background: #FFF;
+  display: flex;
+  flex-direction: column;
+  align-items: center;
+  width: 477px;
+}
+
+.dialog-title-text {
+  padding-top: 24px;
+  font-size: 1.6rem;
+  font-weight: 500;
+  color: #202124;
+  display: flex;
+  align-items: center;
+  gap: 10px;
+}
+
+.dialog-body-scrollable {
+  padding: 16px;
+  overflow-y: auto;
+  flex-grow: 1;
+  color: #3c4043;
+  line-height: 1.6;
+}
+
+.dialog-subtitle {
+  font-weight: 500;
+  margin-bottom: 8px;
+}
+
+.variable {
+  color: #e81ad7;
+  font-weight: bold;
+}
+
+.patient-avatar {
+  border-radius: 50%;
+  margin: 0 10px;
+  width: 90px;
+  height: 90px;  
+}
+
+.ai-avatar {
+  border-radius: 50%;
+  width: 90px;
+  height: 90px;
+  background: #E8DEF8;
+}
+
+.report-notice {
+  width: 974px;
+}
+
+.highlight {
+  background-color: #E8DEF8;
+  font-weight: 700;
+  padding: 0 4px;
+  border-radius: 8px;
+}
+
+.role-play-container .info-button {
+  justify-self: flex-start;
+}

frontend/src/components/RolePlayDialogs/RolePlayDialogs.js

@@ -0,0 +1,103 @@
+/**
+ * Copyright 2025 Google LLC
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+import React, { useState } from "react";
+import "./RolePlayDialogs.css";
+import DetailsPopup from "../DetailsPopup/DetailsPopup";
+
+const RolePlayDialogs = ({
+  selectedPatient,
+  selectedCondition,
+  onStart,
+  onBack,
+}) => {
+  const [isDetailsPopupOpen, setIsDetailsPopupOpen] = useState(false);
+
+  return (
+    <div className="page">
+      <div className="headerButtonsContainer">
+        <button className="back-button" onClick={onBack}>
+          <i className="material-icons back-button-icon">keyboard_arrow_left</i>
+          Back
+        </button>
+        <button className="details-button" onClick={() => setIsDetailsPopupOpen(true)}>
+          <i className="material-icons code-block-icon">code</i>&nbsp; Details
+          about this Demo
+        </button>
+      </div>
+      <div className="frame role-play-container">
+        <div className="title-header">What’s happening in this simulation</div>
+        <div className="dialogs-container">
+          <div className="dialog-box">
+            <div className="dialog-title-text">Pre-visit AI agent</div>
+            <div className="dialog-subtitle">
+              Built with: <img src="assets/medgemma.avif" height="16px" />{" "}
+              27b
+            </div>
+            <img
+              src="assets/ai_headshot.svg"
+              alt="AI Avatar"
+              className="ai-avatar"
+            />
+            <div className="dialog-body-scrollable">
+              In this demo, MedGemma functions as an AI agent designed to assist in pre-visit information
+              collection. It will interact with the patient agent to gather relevant data.
+              To provide additional context, MedGemma also has access to information from the patient's EHR (in FHIR format).
+              However, MedGemma is not provided the specific diagnois ({selectedCondition}).
+              MedGemma's goal is to gather details about symptoms, relevant history,
+              and current concerns to generate a comprehensive pre-visit report. 
+            </div>
+          </div>
+          <div className="dialog-box">
+            <div className="dialog-title-text">
+              Patient persona: {selectedPatient.name}
+            </div>
+            <div className="dialog-subtitle">
+              Simulated by:{" "}Gemini 2.5 Flash
+            </div>
+            <img
+              src={selectedPatient.headshot}
+              alt="Patient Avatar"
+              className="patient-avatar"
+            />
+            <div className="dialog-body-scrollable">
+              Gemini is provided a persona and information to play the role of the patient, {selectedPatient.name}.
+              In this simulation, the patient agent does not know their diagnosis,
+              but is experiencing related symptoms and concerns that can be shared during the interview. 
+              To simulate a real-world situation with confounding information, additional information unrelated to the presenting condition has also been provided. 
+            </div>
+          </div>
+        </div>
+        <div className="report-notice">
+          As the conversation develops, MedGemma <span className="highlight">creates and continually updates
+          a real-time pre-visit report</span> capturing relevant
+          information. Following pre-visit report generation, an evaluation is available. The purpose of this evaluation is to provide the viewer insights into quality of the output.
+          For this evaluation, MedGemma is provided the previously unknown reference diagnosis, and is prompted to generate a 
+          <span className="highlight">self evaluation that highlights strengths as well opporutunities where the conversation and report could have been improved.</span>
+        </div>
+        <button className="info-button" onClick={onStart}>
+          Start conversation
+        </button>
+      </div>
+      <DetailsPopup
+        isOpen={isDetailsPopupOpen}
+        onClose={() => setIsDetailsPopupOpen(false)}
+      />
+    </div>
+  );
+};
+
+export default RolePlayDialogs;

frontend/src/components/WelcomePage/WelcomePage.css

@@ -0,0 +1,144 @@
+/**
+ * Copyright 2025 Google LLC
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+body:has(.welcome) {
+    background-color: white;
+}
+
+.info-page-container {
+    display: flex;
+    align-items: center;
+    justify-content: center;
+    gap: 40px;
+    padding: 40px;
+    max-width: 1300px;
+    margin: auto;
+}
+
+.info-content {
+    flex: 1;
+    min-width: 500px;
+    max-width: 1000px;
+    display: flex;
+    flex-direction: column;
+    gap: 20px;
+    font-size: 18px;
+}
+
+.info-header {
+    margin-bottom: 10px;
+}
+
+.title-header {
+    font-family: 'Google Sans', sans-serif;
+    font-size: 32px;
+    font-weight: 500;
+    font-style: normal;
+}
+
+.welcome .medgemma-logo {
+    width: 130px;
+    align-self: flex-end;
+    margin-top: 10px;
+    margin-right: 10px;
+}
+
+.info-button {
+    background-color: #C2E7FF;
+}
+
+.info-disclaimer-text {
+    font-family: 'Google Sans', sans-serif;
+    color: #333;
+    line-height: 1.5;
+    margin: 0;
+    font-size: 14px;
+}
+
+.info-disclaimer-title {
+    border-radius: 14.272px;
+    border: 1.359px solid #F1E161;
+    background: #F1E161;
+    mix-blend-mode: multiply;
+    padding: 0 5px;
+}
+
+.graphics {
+    position: relative;
+    min-width: 250px;
+    max-width: 450px;
+    flex: 0.5;
+    aspect-ratio: 1.2 / 1;
+}
+
+@media (max-width: 900px) {
+    .info-page-container {
+        flex-direction: column;
+        padding: 20px;
+        margin: 10px;
+    }
+
+    .info-content {
+        max-width: 100%;
+        align-items: center;
+        text-align: center;
+    }
+
+    .info-button {
+        align-self: center;
+    }
+
+    .info-header {
+        text-align: center;
+    }
+
+    .title-header {
+        font-size: 36px;
+    }
+
+    .info-text {
+        font-size: 16px;
+    }
+    .graphics {
+        min-width: 200px;
+    }    
+}
+
+
+
+.graphics-top {
+    position: absolute;
+    top: 0;
+    left: 0;
+    z-index: 0;
+    width: 80%;
+}
+
+.graphics-bottom {
+    position: absolute;
+    bottom: 0;
+    right: 0;
+    z-index: 1;
+    opacity: 0;
+    animation: fadeIn 1s ease forwards;
+    width: 62%;
+}
+
+@keyframes fadeIn {
+    to {
+        opacity: 1;
+    }
+}

frontend/src/components/WelcomePage/WelcomePage.js

@@ -0,0 +1,62 @@
+/**
+ * Copyright 2025 Google LLC
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+import React from 'react';
+import './WelcomePage.css';
+
+const WelcomePage = ({ onSwitchPage }) => {
+  return (
+    <div className="welcome page">
+      <img src="/assets/medgemma.avif" alt="MedGemma Logo" className="medgemma-logo" />
+      <div className="info-page-container">
+        <div className="graphics">
+          <img className="graphics-top" src="/assets/welcome_top_graphics.svg" alt="Welcome top graphics" />
+          <img className="graphics-bottom" src="/assets/welcome_bottom_graphics.svg" alt="Welcome bottom graphics" />
+        </div>
+        <div className="info-content">
+          <div className="info-header">
+            <span className="title-header">Simulated Pre-visit Intake Demo</span>
+          </div>
+          <div className="info-text">
+            Healthcare providers often need to gather patient information before appointments. 
+            This demo illustrates how MedGemma could be used in an application to streamline pre-visit information collection and utilization. 
+            <br /><br/>
+            First, a pre-visit AI agent built with MedGemma asks questions to gather information.
+            After it has identified and collected relevant information, the demo application generates a pre-visit report. 
+            <br /><br/>
+            This type of intelligent pre-visit report can help providers be more efficient and effective while also providing an improved experience 
+            for patients relative to traditional intake forms.
+            <br /><br/>
+            Lastly, you can view an evaluation of the pre-visit report which provides insights into the quality of the output. 
+            For this evaluation, MedGemma is provided the reference diagnosis, allowing "self-evaluation" that highlights both strengths and what it could have done better.
+          </div>
+          <div className="info-disclaimer-text">
+            <span className="info-disclaimer-title">Disclaimer</span> This
+            demonstration is for illustrative purposes only and does not represent a finished or approved
+            product. It is not representative of compliance to any regulations or standards for
+            quality, safety or efficacy. Any real-world application would require additional development,
+            training, and adaptation. The experience highlighted in this demo shows MedGemma's baseline
+            capability for the displayed task and is intended to help developers and users explore possible
+            applications and inspire further development.
+          </div>
+          <button className="info-button" onClick={onSwitchPage}>Select Patient</button>
+        </div>
+      </div>
+    </div>
+  );
+};
+
+export default WelcomePage;

frontend/src/index.js

@@ -0,0 +1,23 @@
+/**
+ * Copyright 2025 Google LLC
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+import React from 'react';
+import ReactDOM from 'react-dom';
+import App from './App';
+import './shared/Style.css';
+
+const root = ReactDOM.createRoot(document.getElementById('root'));
+root.render(<App />);

frontend/src/shared/Style.css

@@ -0,0 +1,205 @@
+/**
+ * Copyright 2025 Google LLC
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+* {
+  box-sizing: border-box;
+}
+
+html {
+    --image-fixed-width: 280px;
+    height: 100%;
+}
+
+#root {
+  height: 100%;
+  margin: auto;
+  width: 100%;
+}
+
+body {
+  font-family: "Google Sans Text", sans-serif;
+  line-height: 1.6;
+  background-color: #f4f4f4;
+  color: #333;
+  margin: 0;
+  display: flex;
+  flex-direction: column;
+  user-select: none;
+  height: 100%;
+}
+
+.page {
+  display: flex;
+  flex-direction: column;
+  width: 100%;
+  height: fit-content;
+}
+
+.headerButtonsContainer {
+	 display: flex;
+	justify-content: space-between;
+	width: -webkit-fill-available;
+  padding: 20px;
+}
+
+.info-button, .back-button, .details-button {
+    font-family: 'Google Sans Text', sans-serif;
+    font-size: 14px;
+    font-weight: 500;
+    padding: 6px 12px;
+    border-radius: 100px;
+    cursor: pointer;
+    text-align: center;
+    transition: background-color 0.3s ease;
+    align-self: flex-start;
+    border-width: 1px;
+}
+
+.back-button, .details-button  {
+  padding: 8px 12px;
+  z-index: 10;
+  color: black;
+  background-color: transparent;
+  display: inline-flex;
+  align-items: center;
+  border-radius: 100px;
+  border: 1px solid rgba(196, 199, 197);
+}
+
+.back-button-icon {
+  margin-right: 4px;
+}
+
+.back-button-icon {
+  font-size: 14px;
+}
+
+.code-block-icon {
+  background-color: rgba(0, 74, 119);
+  color: rgba(194, 231, 255);
+  font-size: 14px;
+}
+
+.details-button {
+	background-color: rgba(194, 231, 255);
+  color: rgba(0, 74, 119);
+  border: none;
+}
+
+.info-button {
+    background-color: #0B57D0;
+    color: white;
+    padding: 12px;
+}
+
+.info-button:disabled {
+  background: #aaa;
+  cursor: not-allowed;
+}
+
+.info-button:hover:not(:disabled) {
+  background: #005fa3;
+}
+
+.frame {
+	border-radius: 28px;
+	border: 2px solid #E9E9E9;
+	background: #FFF;
+	padding: 20px 50px;
+  align-items: center;
+  display: flex;
+  flex-direction: column;
+  flex: 1;
+  justify-content: space-around;
+  margin: 0 10px;
+  min-height: 0;
+  width: fit-content;
+}
+
+.popup-overlay {
+  position: fixed;
+  top: 0;
+  left: 0;
+  width: 100%;
+  height: 100%;
+  background-color: rgba(0, 0, 0, 0.6);
+  display: flex;
+  justify-content: center;
+  align-items: center;
+  z-index: 1000;
+  backdrop-filter: blur(5px);
+}
+
+.popup-content {
+  background: #ffffff;
+  padding: 2rem;
+  border-radius: 12px;
+  max-width: 800px;
+  width: 90%;
+  box-shadow: 0 10px 25px rgba(0, 0, 0, 0.1);
+  border: 1px solid #e0e0e0;
+  animation: popup-fade-in 0.3s ease-out;
+}
+
+@keyframes popup-fade-in {
+  from {
+    opacity: 0;
+    transform: scale(0.95);
+  }
+  to {
+    opacity: 1;
+    transform: scale(1);
+  }
+}
+
+.popup-content h2 {
+  font-size: 1.5rem;
+  font-weight: 600;
+  color: #333;
+  margin-top: 0;
+  margin-bottom: 1rem;
+  text-align: center;
+}
+
+.popup-content p {
+  font-size: 1rem;
+  line-height: 1.6;
+  color: #555;
+  text-align: left;
+  margin-bottom: 1.5rem;
+}
+
+.popup-button {
+  display: block;
+  padding: 12px 20px;
+  font-size: 1rem;
+  font-weight: 600;
+  color: #fff;
+  background-color: #1a73e8;
+  border: none;
+  border-radius: 8px;
+  cursor: pointer;
+  transition: background-color 0.2s ease;
+}
+
+.popup-button:hover {
+  background-color: #185abc;
+}
+
+.hf-logo {
+    vertical-align: middle;
+    width: 30px;
+}

gemini.py

@@ -0,0 +1,59 @@
+# Copyright 2025 Google LLC
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+import os
+import requests
+from cache import cache  # new import replacing duplicate cache initialization
+
+GEMINI_API_KEY = os.environ.get("GEMINI_API_KEY")
+
+# Decorate the function to cache its results indefinitely.
+@cache.memoize()
+def gemini_get_text_response(prompt: str,
+                                    stop_sequences: list = None,
+                                    temperature: float = 0.1,
+                                    max_output_tokens: int = 4000,
+                                    top_p: float = 0.8,
+                                    top_k: int = 10):
+    """
+    Makes a text generation request to the Gemini API.
+    """
+
+    api_url = f"https://generativelanguage.googleapis.com/v1beta/models/gemini-2.5-flash:generateContent?key={GEMINI_API_KEY}"
+    headers = {
+        'Content-Type': 'application/json'
+    }
+
+    data = {
+        "contents": [
+            {
+                "parts": [
+                    {
+                        "text": prompt
+                    }
+                ]
+            }
+        ],
+        "generationConfig": {
+            "stopSequences": stop_sequences or ["Title"],
+            "temperature": temperature,
+            "maxOutputTokens": max_output_tokens,
+            "topP": top_p,
+            "topK": top_k
+        }
+    }
+
+    response = requests.post(api_url, headers=headers, json=data)
+    response.raise_for_status()  # Raise an exception for bad status codes
+    return response.json()["candidates"][0]["content"]["parts"][0]["text"]

gemini_tts.py

@@ -0,0 +1,212 @@
+# Copyright 2025 Google LLC
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+import google.generativeai as genai
+import os
+import struct
+import re
+import logging
+from cache import cache
+
+# Add these imports for MP3 conversion
+from pydub import AudioSegment
+import io
+
+# --- Constants ---
+GEMINI_API_KEY = os.environ.get("GEMINI_API_KEY")
+GENERATE_SPEECH = os.environ.get("GENERATE_SPEECH", "false").lower() == "true"
+TTS_MODEL = "gemini-2.5-flash-preview-tts"
+DEFAULT_RAW_AUDIO_MIME = "audio/L16;rate=24000"
+
+# --- Configuration ---
+logging.basicConfig(level=logging.INFO, format='%(asctime)s - %(levelname)s - %(message)s')
+
+genai.configure(api_key=GEMINI_API_KEY)
+
+class TTSGenerationError(Exception):
+    """Custom exception for TTS generation failures."""
+    pass
+
+
+# --- Helper functions for audio processing ---
+def parse_audio_mime_type(mime_type: str) -> dict[str, int | None]:
+    """
+    Parses bits per sample and rate from an audio MIME type string.
+    e.g., "audio/L16;rate=24000" -> {"bits_per_sample": 16, "rate": 24000}
+    """
+    bits_per_sample = 16  # Default
+    rate = 24000          # Default
+
+    parts = mime_type.split(";")
+    for param in parts:
+        param = param.strip().lower()
+        if param.startswith("rate="):
+            try:
+                rate_str = param.split("=", 1)[1]
+                rate = int(rate_str)
+            except (ValueError, IndexError):
+                pass # Keep default if parsing fails
+        elif re.match(r"audio/l\d+", param): # Matches audio/L<digits>
+             try:
+                bits_str = param.split("l",1)[1]
+                bits_per_sample = int(bits_str)
+             except (ValueError, IndexError):
+                pass # Keep default
+    return {"bits_per_sample": bits_per_sample, "rate": rate}
+
+def convert_to_wav(audio_data: bytes, mime_type: str) -> bytes:
+    """
+    Generates a WAV file header for the given raw audio data and parameters.
+    Assumes mono audio.
+    """
+    parameters = parse_audio_mime_type(mime_type)
+    bits_per_sample = parameters["bits_per_sample"]
+    sample_rate = parameters["rate"]
+    num_channels = 1  # Mono
+    data_size = len(audio_data)
+    bytes_per_sample = bits_per_sample // 8
+    block_align = num_channels * bytes_per_sample
+    byte_rate = sample_rate * block_align
+    chunk_size = 36 + data_size
+
+    header = struct.pack(
+        "<4sI4s4sIHHIIHH4sI",
+        b"RIFF", chunk_size, b"WAVE", b"fmt ",
+        16, 1, num_channels, sample_rate, byte_rate, block_align,
+        bits_per_sample, b"data", data_size
+    )
+    return header + audio_data
+# --- End of helper functions ---
+
+def _synthesize_gemini_tts_impl(text: str, gemini_voice_name: str) -> tuple[bytes, str]:
+    """
+    Synthesizes English text using the Gemini API via the google-genai library.
+    Returns a tuple: (processed_audio_data_bytes, final_mime_type).
+    Raises TTSGenerationError on failure.
+    """
+    if not GENERATE_SPEECH:
+        # This should ideally not be hit if the logic outside this function is correct,
+        # but as a safeguard, we raise an error.
+        raise TTSGenerationError(
+            "GENERATE_SPEECH is not set. Please set it in your environment variables to generate speech."
+        )
+
+    try:
+        model = genai.GenerativeModel(TTS_MODEL)
+
+        generation_config = {
+            "response_modalities": ["AUDIO"],
+            "speech_config": {
+                "voice_config": {
+                    "prebuilt_voice_config": {
+                        "voice_name": gemini_voice_name
+                    }
+                }
+            }
+        }
+
+        response = model.generate_content(
+            contents=[text],
+            generation_config=generation_config,
+        )
+
+        audio_part = response.candidates[0].content.parts[0]
+        audio_data_bytes = audio_part.inline_data.data
+        final_mime_type = audio_part.inline_data.mime_type
+    except Exception as e:
+        error_message = f"An unexpected error occurred with google-genai: {e}"
+        logging.error(error_message)
+        raise TTSGenerationError(error_message) from e
+
+    if not audio_data_bytes:
+        error_message = "No audio data was successfully retrieved or decoded."
+        logging.error(error_message)
+        raise TTSGenerationError(error_message)
+
+    # --- Audio processing ---
+    if final_mime_type:
+        final_mime_type_lower = final_mime_type.lower()
+        needs_wav_conversion = any(p in final_mime_type_lower for p in ("audio/l16", "audio/l24", "audio/l8")) or \
+                               not final_mime_type_lower.startswith(("audio/wav", "audio/mpeg", "audio/ogg", "audio/opus"))
+
+        if needs_wav_conversion:
+            processed_audio_data = convert_to_wav(audio_data_bytes, final_mime_type)
+            processed_audio_mime = "audio/wav"
+        else:
+            processed_audio_data = audio_data_bytes
+            processed_audio_mime = final_mime_type
+    else:
+        logging.warning("MIME type not determined. Assuming raw audio and attempting WAV conversion (defaulting to %s).", DEFAULT_RAW_AUDIO_MIME)
+        processed_audio_data = convert_to_wav(audio_data_bytes, DEFAULT_RAW_AUDIO_MIME)
+        processed_audio_mime = "audio/wav"
+
+    # --- MP3 compression ---
+    if processed_audio_data:
+        try:
+            # Load audio into AudioSegment
+            audio_segment = AudioSegment.from_file(io.BytesIO(processed_audio_data), format="wav")
+            mp3_buffer = io.BytesIO()
+            audio_segment.export(mp3_buffer, format="mp3")
+            mp3_bytes = mp3_buffer.getvalue()
+            return mp3_bytes, "audio/mpeg"
+        except Exception as e:
+            logging.warning("MP3 compression failed: %s. Falling back to WAV.", e)
+            # Fallback to WAV if MP3 conversion fails
+            return processed_audio_data, processed_audio_mime
+    else:
+        error_message = "Audio processing failed."
+        logging.error(error_message)
+        raise TTSGenerationError(error_message)
+
+# Always create the memoized function first, so we can access its .key() method
+_memoized_tts_func = cache.memoize()(_synthesize_gemini_tts_impl)
+
+if GENERATE_SPEECH:
+    def synthesize_gemini_tts_with_error_handling(*args, **kwargs) -> tuple[bytes | None, str | None]:
+        """
+        A wrapper for the memoized TTS function that catches errors and returns (None, None).
+        This makes the audio generation more resilient to individual failures.
+        """
+        try:
+            # Attempt to get the audio from the cache or by generating it.
+            return _memoized_tts_func(*args, **kwargs)
+        except TTSGenerationError as e:
+            # If generation fails, log the error and return None, None.
+            logging.error("Handled TTS Generation Error: %s. Continuing without audio for this segment.", e)
+            return None, None
+
+    synthesize_gemini_tts = synthesize_gemini_tts_with_error_handling
+else:
+    # When not generating speech, create a read-only function that only
+    # checks the cache and does not generate new audio.
+    def read_only_synthesize_gemini_tts(*args, **kwargs):
+        """
+        Checks cache for a result, but never calls the underlying TTS function.
+        This is a 'read-only' memoization check.
+        """
+        # Generate the cache key using the memoized function's key method.
+        key = _memoized_tts_func.__cache_key__(*args, **kwargs)
+
+        # Check the cache directly using the generated key.
+        _sentinel = object()
+        result = cache.get(key, default=_sentinel)
+
+        if result is not _sentinel:
+            return result  # Cache hit
+
+        # Cache miss
+        logging.info("GENERATE_SPEECH is false and no cached result found for key: %s", key)
+        return None, None
+
+    synthesize_gemini_tts = read_only_synthesize_gemini_tts

interview_simulator.py

@@ -0,0 +1,385 @@
+# Copyright 2025 Google LLC
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+import json
+import re
+import os
+import base64
+
+from gemini import gemini_get_text_response
+from medgemma import medgemma_get_text_response
+from gemini_tts import synthesize_gemini_tts
+
+INTERVIEWER_VOICE = "Aoede"
+
+def read_symptoms_json():
+    # Load the list of symptoms for each condition from a JSON file
+    with open("symptoms.json", 'r') as f:
+        return json.load(f)
+
+def read_patient_and_conditions_json():
+    # Load all patient and condition data from the frontend assets
+    with open(os.path.join(os.environ.get("FRONTEND_BUILD", "frontend/build"), "assets", "patients_and_conditions.json"), 'r') as f:
+        return json.load(f)
+
+def get_patient(patient_name):
+    """Helper function to locate a patient record by name. Raises StopIteration if not found."""
+    return next(p for p in PATIENTS if p["name"] == patient_name)
+
+def read_fhir_json(patient):
+    # Load the FHIR (EHR) JSON file for a given patient
+    with open(os.path.join(os.environ.get("FRONTEND_BUILD", "frontend/build"), patient["fhirFile"].lstrip("/")), 'r') as f:
+        return json.load(f)
+
+def get_ehr_summary_per_patient(patient_name):
+    # Returns a concise EHR summary for the patient, using LLM if not already cached
+    patient = get_patient(patient_name)
+    if patient.get("ehr_summary"):
+        return patient["ehr_summary"]
+    # Use MedGemma to summarize the EHR for the patient
+    ehr_summary = medgemma_get_text_response([
+        {
+            "role": "system",
+            "content": [
+                {
+                    "type": "text",
+                    "text": f"""You are a medical assistant summarizing the EHR (FHIR) records for the patient {patient_name}.
+                    Provide a concise summary of the patient's medical history, including any existing conditions, medications, and relevant past treatments.
+                    Do not include personal opinions or assumptions, only factual information."""
+                }
+            ]
+        },
+        {
+            "role": "user",
+            "content": [
+                {
+                    "type": "text",
+                    "text": json.dumps(read_fhir_json(patient))
+                }
+            ]
+        }
+    ])
+    patient["ehr_summary"] = ehr_summary
+    return ehr_summary
+
+PATIENTS = read_patient_and_conditions_json()["patients"]
+SYMPTOMS = read_symptoms_json()
+   
+def patient_roleplay_instructions(patient_name, condition_name, previous_answers):
+    """
+    Generates structured instructions for the LLM to roleplay as a patient, including persona, scenario, and symptom logic.
+    """
+    # This assumes SYMPTOMS is a globally available dictionary as in the user's example
+    patient = get_patient(patient_name)
+    symptoms = "\n".join(SYMPTOMS[condition_name])
+
+    return f"""
+        SYSTEM INSTRUCTION: Before the interview begins, silently review the optional symptoms and decide which ones you have.
+
+        ### Your Persona ###
+        - **Name:** {patient_name}
+        - **Age:** {patient["age"]}
+        - **Gender:** {patient["gender"]}
+        - **Your Role:** You are to act as this patient. Behave naturally and realistically.
+
+        ### Scenario ###
+        You are at home, participating in a remote pre-visit interview with a clinical assistant. You recently booked an appointment with your doctor because you've been feeling unwell. You are now answering the assistant's questions about your symptoms.
+
+        ### Your Medical History ###
+        You have a known history of **{patient["existing_condition"]}**. You should mention this if asked about your medical history, but you do not know if it is related to your current problem.
+
+        ### Your Current Symptoms ###
+        This is how you have been feeling. Base all your answers on these facts. Do not invent new symptoms.
+        ---
+        {symptoms}
+        ---
+
+        ### Critical Rules of Roleplay ###
+        - **Handle Optional Symptoms:** Your symptom list may contain optional symptoms (e.g., "I might have..."). Before the interview starts, you MUST silently decide 'yes' or 'no' for each optional symptom. A 50% chance for each is a good approach. Remember your choices and be consistent throughout the entire interview.
+        - **Act as the Patient:** Your entire response must be ONLY what the patient would say. Do not add external comments, notes, or clarifications (e.g., do not write "[I am now describing the headache]").
+        - **No Guessing:** You DO NOT know your diagnosis or the name of your condition. Do not guess or speculate about it.
+        - **Answer Only What Is Asked:** Do not volunteer your entire list of symptoms at once. Respond naturally to the specific question asked by the interviewer.
+
+        ### Your previous health history ###
+        {patient["ehr_summary"]}
+
+        ### Your previous answers ###
+        ---
+        {previous_answers}
+        ---
+    """
+
+def interviewer_roleplay_instructions(patient_name):
+    # Returns detailed instructions for the LLM to roleplay as the interviewer/clinical assistant
+    return f"""
+        SYSTEM INSTRUCTION: Always think silently before responding.
+
+        ### Persona & Objective ###
+        You are a clinical assistant. Your objective is to interview a patient, {patient_name.split(" ")[0]}, and build a comprehensive and detailed report for their PCP.
+
+        ### Critical Rules ###
+        - **No Assessments:** You are NOT authorized to provide medical advice, diagnoses, or express any form of assessment to the patient.
+        - **Question Format:** Ask only ONE question at a time. Do not enumerate your questions.
+        - **Question Length:** Each question must be 20 words or less.
+        - **Question Limit:** You have a maximum of 20 questions.
+
+        ### Interview Strategy ###
+        - **Clinical Reasoning:** Based on the patient's responses and EHR, actively consider potential diagnoses.
+        - **Differentiate:** Formulate your questions strategically to help differentiate between these possibilities.
+        - **Probe Critical Clues:** When a patient's answer reveals a high-yield clue (e.g., recent travel, a key symptom like rapid breathing), ask one or two immediate follow-up questions to explore that clue in detail before moving to a new line of questioning.
+        - **Exhaustive Inquiry:** Your goal is to be thorough. Do not end the interview early. Use your full allowance of questions to explore the severity, character, timing, and context of all reported symptoms.
+        - **Fact-Finding:** Focus exclusively on gathering specific, objective information.
+
+        ### Context: Patient EHR ###
+        You MUST use the following EHR summary to inform and adapt your questioning. Do not ask for information already present here unless you need to clarify it.
+        EHR RECORD START
+        {get_ehr_summary_per_patient(patient_name)}
+        EHR RECORD END
+
+        ### Procedure ###
+        1.  **Start Interview:** Begin the conversation with this exact opening: "Thank you for booking an appointment with your primary doctor. I am an assistant here to ask a few questions to help your doctor prepare for your visit. To start, what is your main concern today?"
+        2.  **Conduct Interview:** Proceed with your questioning, following all rules and strategies above.
+        3.  **End Interview:** You MUST continue the interview until you have asked 20 questions OR the patient is unable to provide more information. When the interview is complete, you MUST conclude by printing this exact phrase: "Thank you for answering my questions. I have everything needed to prepare a report for your visit. End interview."
+    """
+
+def report_writer_instructions(patient_name: str) -> str:
+    """
+    Generates the system prompt with clear instructions, role, and constraints for the LLM.
+    """
+    ehr_summary = get_ehr_summary_per_patient(patient_name)
+
+    return f"""<role>
+You are a highly skilled medical assistant with expertise in clinical documentation.
+</role>
+
+<task>
+Your task is to generate a concise yet clinically comprehensive medical intake report for a Primary Care Physician (PCP). This report will be based on a patient interview and their Electronic Health Record (EHR).
+</task>
+
+<guiding_principles>
+To ensure the report is both brief and useful, you MUST adhere to the following two principles:
+
+1.  **Principle of Brevity**:
+    * **Use Professional Language**: Rephrase conversational patient language into standard medical terminology (e.g., "it hurts when I breathe deep" becomes "reports pleuritic chest pain").
+    * **Omit Filler**: Do not include conversational filler, pleasantries, or repeated phrases from the interview.
+
+2.  **Principle of Clinical Relevance (What is "Critical Information")**:
+    * **Prioritize the HPI**: The History of Present Illness is the most important section. Include key details like onset, duration, quality of symptoms, severity, timing, and modifying factors.
+    * **Include "Pertinent Negatives"**: This is critical. You MUST include symptoms the patient **denies** if they are relevant to the chief complaint. For example, if the chief complaint is a cough, denying "fever" or "shortness of breath" is critical information and must be included in the report.
+    * **Filter History**: Only include historical EHR data that could reasonably be related to the patient's current complaint. For a cough, a history of asthma or smoking is relevant; a past appendectomy is likely not.
+</guiding_principles>
+
+<instructions>
+1.  **Primary Objective**: Synthesize the interview and EHR into a clear, organized report, strictly following the <guiding_principles>.
+2.  **Content Focus**:
+    * **Main Concern**: State the patient's chief complaint.
+    * **Symptoms**: Detail the History of Present Illness, including pertinent negatives.
+    * **Relevant History**: Include only relevant information from the EHR.
+3.  **Constraints**:
+    * **Factual Information Only**: Report only the facts. No assumptions.
+    * **No Diagnosis or Assessment**: Do not provide a diagnosis.
+</instructions>
+
+<ehr_data>
+<ehr_record_start>
+{ehr_summary}
+<ehr_record_end>
+</ehr_data>
+
+<output_format>
+The final output MUST be ONLY the full, updated Markdown medical report.
+DO NOT include any introductory phrases, explanations, or any text other than the report itself.
+</output_format>"""
+
+def write_report(patient_name: str, interview_text: str, existing_report: str = None) -> str:
+    """
+    Constructs the full prompt, sends it to the LLM, and processes the response.
+    This function handles both the initial creation and subsequent updates of a report.
+    """
+    # Generate the detailed system instructions
+    instructions = report_writer_instructions(patient_name)
+
+    # If no existing report is provided, load a default template from a string.
+    if not existing_report:
+        with open("report_template.txt", 'r') as f:
+            existing_report = f.read()
+
+    # Construct the user prompt with the specific task and data
+    user_prompt = f"""<interview_start>
+{interview_text}
+<interview_end>
+
+<previous_report>
+{existing_report}
+</previous_report>
+
+<task_instructions>
+Update the report in the `<previous_report>` tags using the new information from the `<interview_start>` section.
+1.  **Integrate New Information**: Add new symptoms or details from the interview into the appropriate sections.
+2.  **Update Existing Information**: If the interview provides more current information, replace outdated details.
+3.  **Maintain Conciseness**: Remove any information that is no longer relevant.
+4.  **Preserve Critical Data**: Do not remove essential historical data (like Hypertension) that could be vital for diagnosis, but ensure it is presented concisely under "Relevant Medical History".
+5.  **Adhere to Section Titles**: Do not change the existing Markdown section titles.
+</task_instructions>
+
+Now, generate the complete and updated medical report based on all system and user instructions. Your response should be the Markdown text of the report only."""
+
+    # Assemble the full message payload for the LLM API
+    messages = [
+        {
+            "role": "system",
+            "content": [{"type": "text", "text": instructions}]
+        },
+        {
+            "role": "user",
+            "content": [{"type": "text", "text": user_prompt}]
+        }
+    ]
+
+    report = medgemma_get_text_response(messages)
+    cleaned_report = re.sub(r'<unused94>.*?</unused95>', '', report, flags=re.DOTALL)
+    cleaned_report = cleaned_report.strip()
+
+    # The LLM sometimes wraps the markdown report in a markdown code block.
+    # This regex checks if the entire string is a code block and extracts the content.
+    match = re.match(r'^\s*```(?:markdown)?\s*(.*?)\s*```\s*$', cleaned_report, re.DOTALL | re.IGNORECASE)
+    if match:
+        cleaned_report = match.group(1)
+
+    return cleaned_report.strip()
+
+
+
+def stream_interview(patient_name, condition_name):
+    print(f"Starting interview simulation for patient: {patient_name}, condition: {condition_name}")
+    # Prepare roleplay instructions and initial dialog (using existing helper functions)
+    interviewer_instructions = interviewer_roleplay_instructions(patient_name)
+    
+    # Determine voices for TTS
+    patient = get_patient(patient_name)
+    patient_voice = patient["voice"]
+    
+    dialog = [
+        {
+            "role": "system",
+            "content": [
+                {
+                    "type": "text",
+                    "text": interviewer_instructions
+                }
+            ]
+        },
+        {
+            "role": "user",
+            "content": [
+                {
+                    "type": "text",
+                    "text": "start interview"
+                }
+            ]
+        }
+    ]
+    
+    write_report_text = ""
+    full_interview_q_a = ""
+    number_of_questions_limit = 30
+    for i in range(number_of_questions_limit):
+        # Get the next interviewer question from MedGemma
+        interviewer_question_text = medgemma_get_text_response(
+            messages=dialog,
+            temperature=0.1,
+            max_tokens=2048,
+            stream=False
+        )
+        # Process optional "thinking" text (if present in the LLM output)
+        thinking_search = re.search('<unused94>(.+?)<unused95>', interviewer_question_text, re.DOTALL)
+        if thinking_search:
+            thinking_text = thinking_search.group(1)
+            interviewer_question_text = interviewer_question_text.replace(f'<unused94>{thinking_text}<unused95>', "")
+            if i == 0:
+                # Only yield the "thinking" summary for the first question
+                thinking_text = gemini_get_text_response(
+                    f"""Provide a summary of up to 100 words containing only the reasoning and planning from this text,
+                    do not include instructions, use first person: {thinking_text}""")
+                yield json.dumps({
+                        "speaker": "interviewer thinking",
+                    "text": thinking_text
+                })
+
+        # Clean up the text for TTS and display
+        clean_interviewer_text = interviewer_question_text.replace("End interview.", "").strip()
+
+        # Generate audio for the interviewer's question using Gemini TTS
+        audio_data, mime_type = synthesize_gemini_tts(f"Speak in a slightly upbeat and brisk manner, as a friendly clinician: {clean_interviewer_text}", INTERVIEWER_VOICE)
+        audio_b64 = None
+        if audio_data and mime_type:
+            audio_b64 = f"data:{mime_type};base64,{base64.b64encode(audio_data).decode('utf-8')}"
+
+        # Yield interviewer message (text and audio)
+        yield json.dumps({
+            "speaker": "interviewer",
+            "text": clean_interviewer_text,
+            "audio": audio_b64
+        })
+        dialog.append({
+            "role": "assistant",
+            "content": [{
+                "type": "text",
+                "text": interviewer_question_text
+            }]
+        })
+        if "End interview" in interviewer_question_text:
+            # End the interview loop if the LLM signals completion
+            break
+
+        # Get the patient's response from Gemini (roleplay LLM)
+        patient_response_text = gemini_get_text_response(f"""
+        {patient_roleplay_instructions(patient_name, condition_name, full_interview_q_a)}\n\n
+        Question: {interviewer_question_text}""")
+
+        # Generate audio for the patient's response
+        audio_data, mime_type = synthesize_gemini_tts(f"Say this in faster speed, using a sick tone: {patient_response_text}", patient_voice)
+        audio_b64 = None
+        if audio_data and mime_type:
+            audio_b64 = f"data:{mime_type};base64,{base64.b64encode(audio_data).decode('utf-8')}"
+
+        # Yield patient message (text and audio)
+        yield json.dumps({
+            "speaker": "patient",
+            "text": patient_response_text,
+            "audio": audio_b64
+        })
+        dialog.append({
+            "role": "user",
+            "content": [{
+                "type": "text",
+                "text": patient_response_text
+            }]
+        })
+        # Track the full Q&A for context in future LLM calls
+        most_recent_q_a = f"Q: {interviewer_question_text}\nA: {patient_response_text}\n"
+        full_interview_q_a_with_new_q_a = "PREVIOUS Q&A:\n" + full_interview_q_a + "\nNEW Q&A:\n" + most_recent_q_a
+        # Update the report after each Q&A
+        write_report_text = write_report(patient_name, full_interview_q_a_with_new_q_a, write_report_text)
+        full_interview_q_a += most_recent_q_a
+        yield json.dumps({
+            "speaker": "report",
+            "text": write_report_text
+        })
+
+    print(f"""Interview simulation completed for patient: {patient_name}, condition: {condition_name}.
+          Patient profile used:
+          {patient_roleplay_instructions(patient_name, condition_name, full_interview_q_a)}""")
+    # Add this at the end to signal end of stream
+    yield json.dumps({"event": "end"})