Ready

.gitignore

@@ -0,0 +1,227 @@
+# Byte-compiled / optimized / DLL files
+__pycache__/
+*.py[cod]
+*$py.class
+
+# C extensions
+*.so
+
+*.pem
+
+# Distribution / packaging
+.Python
+build/
+develop-eggs/
+dist/
+downloads/
+eggs/
+.eggs/
+lib/
+lib64/
+parts/
+sdist/
+var/
+wheels/
+share/python-wheels/
+*.egg-info/
+.installed.cfg
+*.egg
+MANIFEST
+
+*.manifest
+*.spec
+
+# Installer logs
+pip-log.txt
+pip-delete-this-directory.txt
+
+# Unit test / coverage reports
+htmlcov/
+.tox/
+.nox/
+.coverage
+.coverage.*
+.cache
+nosetests.xml
+coverage.xml
+*.cover
+*.py,cover
+.hypothesis/
+.pytest_cache/
+cover/
+
+# Translations
+*.mo
+*.pot
+
+# Django stuff:
+*.log
+local_settings.py
+db.sqlite3
+db.sqlite3-journal
+
+# Flask stuff:
+instance/
+.webassets-cache
+
+# Scrapy stuff:
+.scrapy
+
+# Sphinx documentation
+docs/_build/
+
+# PyBuilder
+.pybuilder/
+target/
+
+# Jupyter Notebook
+.ipynb_checkpoints
+
+# IPython
+profile_default/
+ipython_config.py
+
+# PEP 582; used by e.g. github.com/David-OConnor/pyflow and github.com/pdm-project/pdm
+__pypackages__/
+
+# Celery stuff
+celerybeat-schedule
+celerybeat.pid
+
+# SageMath parsed files
+*.sage.py
+
+# Environments
+.env
+.venv
+env/
+venv/
+ENV/
+env.bak/
+venv.bak/
+
+# Spyder project settings
+.spyderproject
+.spyproject
+
+# Rope project settings
+.ropeproject
+
+# mkdocs documentation
+/site
+
+# mypy
+.mypy_cache/
+.dmypy.json
+dmypy.json
+
+# Pyre type checker
+.pyre/
+
+# pytype static type analyzer
+.pytype/
+
+# Cython debug symbols
+cython_debug/
+
+# PyCharm
+.idea/
+# *.iws
+# *.iml
+# *.ipr
+
+# Visual Studio Code
+.vscode/
+*.code-workspace
+
+# Sublime Text
+*.sublime-project
+*.sublime-workspace
+
+# macOS
+.DS_Store
+.DS_Store?
+._*
+.Spotlight-V100
+.Trashes
+ehthumbs.db
+Thumbs.db
+
+# Windows
+Thumbs.db
+ehthumbs.db
+Desktop.ini
+$RECYCLE.BIN/
+
+# Linux
+*~
+
+# Temporary files
+*.tmp
+*.temp
+*.swp
+*.swo
+*~
+
+# Logs
+*.log
+logs/
+
+# Database files
+*.db
+*.sqlite
+*.sqlite3
+
+# Configuration files with sensitive data
+config.ini
+secrets.json
+.secrets
+credentials.json
+
+# API keys and environment variables
+.env.local
+.env.development
+.env.test
+.env.production
+
+# Machine learning / data science
+*.pkl
+*.pickle
+*.model
+*.h5
+*.hdf5
+data/
+datasets/
+models/
+checkpoints/
+
+# Jupyter specific
+*.ipynb_checkpoints/
+
+# Virtual environment alternatives
+.conda/
+conda-meta/
+miniconda3/
+anaconda3/
+
+
+# IDE and editor files
+.idea/
+*.iml
+*.ipr
+*.iws
+.vscode/
+*.sublime-*
+.atom/
+
+# OS generated files
+.DS_Store*
+.directory
+.Trash-*
+.fuse_hidden*
+
+# Application specific (add your own)
+uploads/
+downloads/
+temp/
+cache/

.pre-commit-config.yaml

@@ -0,0 +1,48 @@
+repos:
+  - repo: https://github.com/pre-commit/pre-commit-hooks
+    rev: v5.0.0
+    hooks:
+      - id: trailing-whitespace
+      - id: end-of-file-fixer
+        exclude: docs/badges
+      - id: check-added-large-files
+        args: ["--maxkb=1024"] # allow up to 1MB
+      - id: check-json
+      - id: check-yaml
+        args: ["--unsafe"] # needed for some mkdocs extensions
+      - id: check-merge-conflict
+      - id: mixed-line-ending
+        args: ["--fix=lf"]
+      - id: check-toml
+      - id: detect-private-key
+
+  - repo: local
+    hooks:
+      - id: sql_formatter
+        name: SQL formatter
+        language: python
+        entry: sql-formatter --max-line-length=270
+        files: \.sql$
+        additional_dependencies: [sql-formatter]
+
+  - repo: https://github.com/kynan/nbstripout
+    rev: 0.8.1
+    hooks:
+      - id: nbstripout
+
+  - repo: https://github.com/astral-sh/ruff-pre-commit
+    rev: v0.12.1
+    hooks:
+      - id: ruff
+
+  - repo: https://github.com/psf/black
+    rev: 25.1.0
+    hooks:
+      - id: black
+        args: ["--target-version", "py311"]
+
+  - repo: https://github.com/Yelp/detect-secrets
+    rev: v1.5.0
+    hooks:
+      - id: detect-secrets
+        exclude: ^(graphql-mock/pnpm-lock\.yaml|.*\.ipynb)$

Makefile

@@ -0,0 +1,26 @@
+.PHONY: setup install clean run
+
+setup:
+	@echo "Setting up local environment..."
+	@scripts/install_uv.sh
+	@uv python install 3.11
+	@scripts/create_venv.sh
+	@. .venv/bin/activate && make install
+	@python -m scripts.setup_ssl
+
+install:
+	@echo "Installing dependencies..."
+	uv pip install -e .
+
+clean:
+	@echo "Cleaning up..."
+	rm -rf .venv
+	rm -rf dist
+	rm -rf *.egg-info
+	find . -type d -name __pycache__ -exec rm -rf {} +
+	find . -type d -name .pytest_cache -exec rm -rf {} +
+	find . -type d -name .ipynb_checkpoints -exec rm -rf {} +
+
+run:
+	@. .venv/bin/activate
+	python -m src.app

README.md

@@ -1,14 +1,127 @@
----
-title: Scout Claims
-emoji: 👀
-colorFrom: blue
-colorTo: pink
-sdk: gradio
-sdk_version: 5.38.0
-app_file: app.py
-pinned: false
-license: apache-2.0
-short_description: ScoutAI is an AI claims assistant to generate claim reports
----
-
-Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference
+![Scout Demo](assets/fireworks_logo.png)
+
+
+# Scout | AI Claims Assistant
+
+> **Automated Insurance Claims Processing powered by Fireworks AI**
+
+Scout is an intelligent claims processing assistant that uses advanced AI to analyze vehicle damage, process incident descriptions, and generate comprehensive claim reports. It showcases cutting-edge AI capabilities including computer vision, speech transcription, natural language processing, and autonomous function calling.
+
+## Key Features
+
+- **Automated Damage Analysis**: AI-powered computer vision analyzes damage photos
+- **Real-time Speech Transcription**: Live audio processing with Fireworks AI
+- **Intelligent Incident Processing**: Advanced NLP extracts structured claim data
+- **Autonomous Function Calling**: AI automatically gathers additional context (weather, driver records)
+- **Professional PDF Generation**: Comprehensive claim reports with all evidence
+- **Real-time Processing**: Sub-30 second end-to-end claim processing
+
+## High-Level Architecture
+
+### Core AI Components (Powered by Fireworks AI)
+
+#### 1. Vision Analysis Module (`image_analysis.py`)
+- **Function**: Analyzes damage photos to determine severity, location, and repair estimates
+- **Output**: Structured JSON with damage classification and cost estimates
+
+#### 2. Speech Transcription Service (`transcription.py`)
+- **Function**: Converts live audio to text with 500ms updates
+- **Features**: Automatic speech recognition with live feedback
+
+#### 3. Incident Processing Engine (`incident_processing.py`)
+- **Function**: Extracts structured claim data from transcribed incident descriptions
+- **Advanced Feature**: **Autonomous Function Calling** (see details below)
+
+#### 4. Report Generation System (`claim_processing.py`)
+- **Technology**: AI-driven professional document generation
+- **Output**: Comprehensive PDF reports with evidence, analysis, and recommendations
+- **Features**: Professional formatting, appendices, and legal disclaimers
+
+### Autonomous Function Calling System
+One of Scout's most advanced features is its **autonomous function calling capability**. The AI automatically determines when additional context would be helpful and calls external functions without human intervention.
+
+#### How It Works:
+
+1. **Analysis Phase**: AI analyzes the incident transcript
+2. **Decision Making**: Determines which external data would improve assessment accuracy
+3. **Autonomous Execution**: Automatically calls relevant functions
+4. **Context Integration**: Incorporates results into final claim analysis
+
+#### Available Functions:
+
+| Function | Purpose | Data Retrieved |
+|----------|---------|----------------|
+| `weather_lookup` | Get weather conditions for incident date/location | Temperature, visibility, precipitation, conditions |
+| `driver_record_check` | Verify other party's driving record | License status, insurance status, violation history, risk assessment |
+
+#### Example Function Call Flow:
+
+```
+User describes incident → AI extracts date/location → AI calls weather_lookup() →
+AI finds other driver name → AI calls driver_record_check() →
+AI incorporates weather + driver data into fault assessment
+```
+
+This autonomous approach means **no manual intervention required** - the AI intelligently gathers the exact context needed for each unique claim.
+
+## Setup Instructions
+
+### Prerequisites
+
+- Python 3.11+
+- Fireworks AI API key ([Get one here](https://fireworks.ai))
+- OpenSSL (for HTTPS/microphone access)
+
+### Quick Start
+
+1. **Clone the repository**
+   ```bash
+   git clone <repository-url>
+   cd scout-claims-assistant
+   ```
+
+2. **Run automated setup**
+   ```bash
+   make setup
+   ```
+   This will:
+   - Install `uv` package manager
+   - Create Python 3.11 virtual environment
+   - Install all dependencies
+   - Generate SSL certificates for HTTPS
+
+3. **Set your API key**: add FIREWORKS_API_KEY to .env
+
+4. **Launch the application**
+   ```bash
+   make run
+   ```
+
+5. **Open in browser**
+   ```
+   https://localhost:7860
+   ```
+   > **Note**: Accept the security warning for self-signed certificates
+
+## How to Use
+
+### Step 1: Upload Damage Photos
+- Upload clear photos of vehicle damage
+- AI analyzes damage severity, location, and repair costs
+- Results appear in real-time
+
+### Step 2: Record Incident Description
+- Click the microphone to start recording
+- Describe the incident including:
+  - **When & Where**: Date, time, location
+  - **Who**: Other parties, witnesses
+  - **What**: How the accident happened
+  - **Injuries**: Any medical concerns
+- Watch live transcription appear as you speak
+
+### Step 3: Generate Professional Report
+- AI processes all information + calls external functions
+- Generates comprehensive PDF claim report
+- Download or submit directly
+
+**Powered by Fireworks AI** | **Built for intelligent claims processing**

notebooks/2-Exercises.ipynb

@@ -0,0 +1,470 @@
+{
+  "cells": [
+    {
+      "cell_type": "markdown",
+      "metadata": {
+        "id": "view-in-github",
+        "colab_type": "text"
+      },
+      "source": [
+        "<a href=\"https://colab.research.google.com/github/RobertoBarrosoLuque/scout-claims/blob/main/notebooks/2-Exercises.ipynb\" target=\"_parent\"><img src=\"https://colab.research.google.com/assets/colab-badge.svg\" alt=\"Open In Colab\"/></a>"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "id": "0",
+      "metadata": {
+        "id": "0"
+      },
+      "source": [
+        "# Exercises: Putting the Building Blocks into Practice\n",
+        "\n",
+        "Welcome to the hands-on portion of the workshop! In these exercises, you will apply the concepts we've learned to solve a few practical problems.\n",
+        "\n",
+        "**Your goals will be to:**\n",
+        "1.  **Extend Function Calling**: Add a new tool for the LLM to use.\n",
+        "2.  **Modify Structured Output**: Change a Pydantic schema to extract additional structured information from an image.\n",
+        "3.  **Bonus! Use Grammar Mode**: Force the LLM to respond in a highly specific, token-efficient format.\n",
+        "\n",
+        "Look out for the lines marked \"TODO\" in each cell; those are where you will write your code. Let's get started!"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "id": "e966e0b4",
+      "metadata": {
+        "id": "e966e0b4"
+      },
+      "outputs": [],
+      "source": [
+        "#\n",
+        "# SETUP CELL #1: PLEASE RUN THIS BEFORE CONTINUING WITH THE EXERCISES.\n",
+        "# RESTART THE RUNTIME AFTER RUNNING THIS CELL IF PROMPTED TO DO SO.\n",
+        "#\n",
+        "!pip install pydantic requests Pillow python-dotenv"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "id": "eac6208b",
+      "metadata": {
+        "id": "eac6208b"
+      },
+      "outputs": [],
+      "source": [
+        "#\n",
+        "# SETUP CELL #2: PLEASE RUN THIS BEFORE CONTINUING WITH THE EXERCISES\n",
+        "#\n",
+        "import os\n",
+        "import io\n",
+        "import base64\n",
+        "from dotenv import load_dotenv\n",
+        "import requests\n",
+        "import json\n",
+        "load_dotenv()\n",
+        "\n",
+        "MODEL_ID = \"accounts/fireworks/models/llama4-scout-instruct-basic\"\n",
+        "\n",
+        "# This pattern is for Google Colab.\n",
+        "# If running locally, set the FIREWORKS_API_KEY environment variable.\n",
+        "try:\n",
+        "    from google.colab import userdata\n",
+        "    FIREWORKS_API_KEY = userdata.get('FIREWORKS_API_KEY')\n",
+        "except ImportError:\n",
+        "    FIREWORKS_API_KEY = os.getenv(\"FIREWORKS_API_KEY\")\n",
+        "\n",
+        "# Make sure to set your FIREWORKS_API_KEY\n",
+        "if not FIREWORKS_API_KEY:\n",
+        "    print(\"⚠️  Warning: FIREWORKS_API_KEY not set. The following cells will not run without it.\")\n",
+        "\n",
+        "# Helper function to prepare images for VLMs.\n",
+        "# It is defined here to be available for later exercises.\n",
+        "def pil_to_base64_dict(pil_image):\n",
+        "    \"\"\"Convert PIL image to the format expected by VLMs\"\"\"\n",
+        "    if pil_image is None:\n",
+        "        return None\n",
+        "\n",
+        "    buffered = io.BytesIO()\n",
+        "    if pil_image.mode != \"RGB\":\n",
+        "        pil_image = pil_image.convert(\"RGB\")\n",
+        "\n",
+        "    pil_image.save(buffered, format=\"JPEG\")\n",
+        "    img_base64 = base64.b64encode(buffered.getvalue()).decode(\"utf-8\")\n",
+        "\n",
+        "    return {\"image\": pil_image, \"path\": \"uploaded_image.jpg\", \"base64\": img_base64}\n",
+        "\n",
+        "# Helper function to make api calls with requests\n",
+        "def make_api_call(payload, tools=None, model_id=None, base_url=None):\n",
+        "    \"\"\"Make API call with requests\"\"\"\n",
+        "    # Use defaults if not provided\n",
+        "    final_model_id = model_id or MODEL_ID\n",
+        "    final_base_url = base_url or \"https://api.fireworks.ai/inference/v1\"\n",
+        "\n",
+        "    # Add model to payload\n",
+        "    payload[\"model\"] = final_model_id\n",
+        "\n",
+        "    # Add tools if provided\n",
+        "    if tools:\n",
+        "        payload[\"tools\"] = tools\n",
+        "        payload[\"tool_choice\"] = \"auto\"\n",
+        "\n",
+        "    headers = {\n",
+        "        \"Authorization\": f\"Bearer {FIREWORKS_API_KEY}\",\n",
+        "        \"Content-Type\": \"application/json\"\n",
+        "    }\n",
+        "\n",
+        "    response = requests.post(\n",
+        "        f\"{final_base_url}/chat/completions\",\n",
+        "        headers=headers,\n",
+        "        json=payload\n",
+        "    )\n",
+        "\n",
+        "    if response.status_code == 200:\n",
+        "        return response.json()\n",
+        "    else:\n",
+        "        raise Exception(f\"API Error: {response.status_code} - {response.text}\")\n",
+        "\n",
+        "print(\"✅ Setup complete. Helper function and API key are ready.\")"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "id": "09bc4200",
+      "metadata": {
+        "id": "09bc4200"
+      },
+      "source": [
+        "## Exercise 1: Extending Function Calling\n",
+        "\n",
+        "[Function calling](https://docs.fireworks.ai/guides/function-calling) allows an LLM to use external tools. Your first task is to give the LLM a new tool.\n",
+        "\n",
+        "**Goal**: Define a new function called `count_letter` that counts the occurrences of a specific letter in a word. You will then define its schema and make it available to the LLM.\n",
+        "\n",
+        "**Your Steps:**\n",
+        "1.  Define the Python function `count_letter`.\n",
+        "2.  Add it to the `available_functions` dictionary.\n",
+        "3.  Define its schema and add it to the `tools` list.\n",
+        "4.  Write a prompt to test your new function"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "id": "99c48d84",
+      "metadata": {
+        "id": "99c48d84"
+      },
+      "outputs": [],
+      "source": [
+        "###\n",
+        "### EXERCISE 1: WRITE YOUR CODE IN THIS CELL\n",
+        "###\n",
+        "import json\n",
+        "\n",
+        "# --- Step 1: Define the Python function and the available functions mapping ---\n",
+        "\n",
+        "# Base function from the previous notebook\n",
+        "def get_weather(location: str) -> str:\n",
+        "    \"\"\"Get current weather for a location\"\"\"\n",
+        "    weather_data = {\"New York\": \"Sunny, 72°F\", \"London\": \"Cloudy, 15°C\", \"Tokyo\": \"Rainy, 20°C\"}\n",
+        "    return weather_data.get(location, \"Weather data not available\")\n",
+        "\n",
+        "# ---TODO Block start---- #\n",
+        "# Define a new function `count_letter` that takes a `word` and a `letter`\n",
+        "# and returns the number of times the letter appears in the word.\n",
+        "def count_letter(): # TODO: Add your function header here\n",
+        "    # TODO: Add your function body here\n",
+        "    pass\n",
+        "# ---TODO Block end---- #\n",
+        "\n",
+        "available_functions = {\n",
+        "    \"get_weather\": get_weather,\n",
+        "    # TODO: Add your new function to this dictionary\n",
+        "}\n",
+        "\n",
+        "\n",
+        "# --- Step 2: Define the function schemas for the LLM ---\n",
+        "\n",
+        "# Base tool schema from the previous notebook\n",
+        "tools = [\n",
+        "    {\n",
+        "        \"type\": \"function\",\n",
+        "        \"function\": {\n",
+        "            \"name\": \"get_weather\",\n",
+        "            \"description\": \"Get current weather for a location\",\n",
+        "            \"parameters\": {\n",
+        "                \"type\": \"object\",\n",
+        "                \"properties\": {\n",
+        "                    \"location\": {\n",
+        "                        \"type\": \"string\",\n",
+        "                        \"description\": \"The city name\"\n",
+        "                        }\n",
+        "                    },\n",
+        "                \"required\": [\"location\"]\n",
+        "            }\n",
+        "        }\n",
+        "    },\n",
+        "    # TODO: Add the JSON schema for your `count_letter` function here.\n",
+        "    # It should have two parameters: \"word\" and \"letter\", both are required strings.\n",
+        "]\n",
+        "\n",
+        "\n",
+        "# --- Step 3: Build your input to the LLM ---\n",
+        "\n",
+        "# Initialize the messages list\n",
+        "messages = [\n",
+        "    {\n",
+        "        \"role\": \"system\",\n",
+        "        \"content\": \"You are a helpful assistant. You have access to a couple of tools, use them when needed.\"\n",
+        "    },\n",
+        "    {\n",
+        "        \"role\": \"user\",\n",
+        "        \"content\": \"\" #TODO: Add your user prompt here\n",
+        "    }\n",
+        "]\n",
+        "\n",
+        "# Create payload\n",
+        "payload = {\n",
+        "    \"messages\": messages,\n",
+        "    \"tools\": tools,\n",
+        "    \"model\": \"accounts/fireworks/models/llama4-maverick-instruct-basic\"\n",
+        "}\n",
+        "\n",
+        "# Get response from LLM\n",
+        "response = make_api_call(payload=payload)\n",
+        "\n",
+        "# Check if the model wants to call a tool/function\n",
+        "if response[\"choices\"][0][\"message\"][\"tool_calls\"]:\n",
+        "    tool_call = response[\"choices\"][0][\"message\"][\"tool_calls\"][0]\n",
+        "    function_name = tool_call[\"function\"][\"name\"]\n",
+        "    function_args = json.loads(tool_call[\"function\"][\"arguments\"])\n",
+        "\n",
+        "    print(f\"LLM wants to call: {function_name}\")\n",
+        "    print(f\"With arguments: {function_args}\")\n",
+        "\n",
+        "    # Execute the function\n",
+        "    function_response = available_functions[function_name](**function_args)\n",
+        "    print(f\"Function result: {function_response}\")\n",
+        "\n",
+        "    # Add the assistant's tool call to the conversation\n",
+        "    messages.append({\n",
+        "        \"role\": \"assistant\",\n",
+        "        \"content\": \"\",\n",
+        "        \"tool_calls\": response[\"choices\"][0][\"message\"][\"tool_calls\"]\n",
+        "    })\n",
+        "\n",
+        "    # Add the function result to the conversation\n",
+        "    messages.append({\n",
+        "        \"role\": \"tool\",\n",
+        "        \"content\": json.dumps(function_response) if isinstance(function_response, dict) else str(function_response)\n",
+        "    })\n",
+        "\n",
+        "    # Create the final payload\n",
+        "    final_payload = {\n",
+        "    \"messages\": messages,\n",
+        "    \"tools\": tools,\n",
+        "    \"model\": \"accounts/fireworks/models/llama4-maverick-instruct-basic\"\n",
+        "    }\n",
+        "\n",
+        "    # Get final response from LLM\n",
+        "    final_response = make_api_call(payload=payload)\n",
+        "\n",
+        "    print(f'Final response: {final_response[\"choices\"][0][\"message\"][\"content\"]}')"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "id": "4d198002",
+      "metadata": {
+        "id": "4d198002"
+      },
+      "source": [
+        "## Exercise 2: Modifying Structured Outputs (JSON Mode)\n",
+        "\n",
+        "Structured output is critical for building reliable applications. Here, you'll modify an existing schema to extract more information from an image.\n",
+        "\n",
+        "**Goal**: Update the `IncidentAnalysis` Pydantic model to also extract the `make` and `model` of the vehicle in the image.\n",
+        "\n",
+        "**Your Steps:**\n",
+        "1.  Add the `make` and `model` fields to the `IncidentAnalysis` Pydantic class.\n",
+        "2.  Run the VLM call using [JSON mode](https://docs.fireworks.ai/structured-responses/structured-response-formatting) to see the new structured output."
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "id": "1dc5d727",
+      "metadata": {
+        "id": "1dc5d727"
+      },
+      "outputs": [],
+      "source": [
+        "###\n",
+        "### EXERCISE 2: WRITE YOUR CODE IN THIS CELL\n",
+        "###\n",
+        "import requests\n",
+        "import io\n",
+        "from PIL import Image\n",
+        "from pydantic import BaseModel, Field\n",
+        "from typing import Literal\n",
+        "\n",
+        "# --- Step 1: Download a sample image ---\n",
+        "url = \"https://raw.githubusercontent.com/RobertoBarrosoLuque/scout-claims/main/images/back_rhs_damage.png\"\n",
+        "response = requests.get(url)\n",
+        "image = Image.open(io.BytesIO(response.content))\n",
+        "print(\"Image downloaded.\")\n",
+        "\n",
+        "\n",
+        "# --- Step 2: Define the output schema ---\n",
+        "# ---TODO Block start---- #\n",
+        "# Add two new string fields to this Pydantic model:\n",
+        "# - `make`: To store the make of the car (e.g., \"Ford\")\n",
+        "# - `model`: To store the model of the car (e.g., \"Mustang\")\n",
+        "class IncidentAnalysis(BaseModel):\n",
+        "    description: str = Field(description=\"A description of the damage to the vehicle.\")\n",
+        "    location: Literal[\"front-left\", \"front-right\", \"back-left\", \"back-right\", \"front\", \"side\"]\n",
+        "    severity: Literal[\"minor\", \"moderate\", \"major\"]\n",
+        "    license_plate: str | None = Field(description=\"The license plate of the vehicle, if visible.\")\n",
+        "# ---TODO Block end---- #\n",
+        "\n",
+        "# --- Step 3: Call the VLM with the new schema ---\n",
+        "# The 'pil_to_base64_dict' function was defined in the setup cell\n",
+        "image_for_llm = pil_to_base64_dict(image)\n",
+        "\n",
+        "# Create payload\n",
+        "prompt = \"Describe the car damage in this image and extract all useful information.\" # TODO: modify the prompt to include the new fields\n",
+        "messages=[\n",
+        "    {\n",
+        "        \"role\": \"user\",\n",
+        "        \"content\": [\n",
+        "            {\"type\": \"image_url\", \"image_url\": {\"url\": f\"data:image/jpeg;base64,{image_for_llm['base64']}\"}},\n",
+        "            {\"type\": \"text\", \"text\": prompt},\n",
+        "        ],\n",
+        "    }\n",
+        "]\n",
+        "response_format={\n",
+        "    \"type\": \"json_object\",\n",
+        "    \"schema\": IncidentAnalysis.model_json_schema(),\n",
+        "}\n",
+        "\n",
+        "payload = {\n",
+        "    \"messages\": messages,\n",
+        "    \"response_format\": response_format,\n",
+        "    \"model\": \"accounts/fireworks/models/llama4-maverick-instruct-basic\"\n",
+        "}\n",
+        "\n",
+        "# Get response from LLM\n",
+        "response = make_api_call(payload=payload)\n",
+        "\n",
+        "\n",
+        "result = json.loads(response[\"choices\"][0][\"message\"][\"content\"])\n",
+        "print(json.dumps(result, indent=2))"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "id": "8e5a2e3d",
+      "metadata": {
+        "id": "8e5a2e3d"
+      },
+      "source": [
+        "## Bonus Exercise: Constrained Output with Grammar Mode\n",
+        "\n",
+        "Sometimes you need the model to respond in a very specific, non-JSON format. This is where [Grammar Mode](https://docs.fireworks.ai/structured-responses/structured-output-grammar-based) excels. It forces the model's output to conform to a strict pattern you define, which can also save output tokens vs. JSON mode and offer even more granular control.\n",
+        "\n",
+        "**Goal**: Use grammar mode to force the model to output *only* the make and model of the car as a single lowercase string (e.g., \"ford mustang\").\n",
+        "\n",
+        "**Your Steps:**\n",
+        "1.  Define a GBNF grammar string.\n",
+        "2.  Call the model using `response_format={\"type\": \"grammar\", \"grammar\": ...}`."
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "id": "1ea8cec3",
+      "metadata": {
+        "id": "1ea8cec3"
+      },
+      "outputs": [],
+      "source": [
+        "###\n",
+        "### BONUS EXERCISE: WRITE YOUR CODE IN THIS CELL\n",
+        "###\n",
+        "\n",
+        "# The 'image' variable and 'pil_to_base64_dict' helper function from previous\n",
+        "# cells are used here. Make sure those cells have been run.\n",
+        "# This assumes the image from Exercise 2 is still loaded.\n",
+        "image_for_llm = pil_to_base64_dict(image)\n",
+        "\n",
+        "\n",
+        "# --- Step 1: Define the GBNF grammar ---\n",
+        "# Define a grammar that forces the output to be:\n",
+        "# 1. A 'make' (one or more lowercase letters).\n",
+        "# 2. Followed by a single space.\n",
+        "# 3. Followed by a 'model' (one or more lowercase letters).\n",
+        "car_grammar = r'''\n",
+        "# TODO: define a grammar that forces the output to satisfy the format specified above (example output: \"ford mustang\")\n",
+        "'''\n",
+        "\n",
+        "# --- Step 2: Define the prompt ---\n",
+        "# Update the prompt to ask the model to identify the make and model and to respond only in the format specified above\n",
+        "prompt = \"\"  # TODO: write your prompt here\n",
+        "\n",
+        "\n",
+        "# --- Step 3: Call the VLM with grammar mode ---\n",
+        "messages=[\n",
+        "    {\n",
+        "        \"role\": \"user\",\n",
+        "        \"content\": [\n",
+        "            {\"type\": \"image_url\", \"image_url\": {\"url\": f\"data:image/jpeg;base64,{image_for_llm['base64']}\"}},\n",
+        "            {\"type\": \"text\", \"text\": prompt},\n",
+        "        ],\n",
+        "    }\n",
+        "]\n",
+        "response_format={\n",
+        "    # TODO: define the response format to use the grammar defined above\n",
+        "}\n",
+        "\n",
+        "# Define payload\n",
+        "payload = {\n",
+        "    \"messages\": messages,\n",
+        "    \"response_format\": response_format,\n",
+        "    \"model\": \"accounts/fireworks/models/llama4-maverick-instruct-basic\"\n",
+        "}\n",
+        "\n",
+        "# Get response from LLM\n",
+        "response = make_api_call(payload=payload)\n",
+        "\n",
+        "print(f'Constrained output from model: {response[\"choices\"][0][\"message\"][\"content\"]}')"
+      ]
+    }
+  ],
+  "metadata": {
+    "colab": {
+      "provenance": [],
+      "include_colab_link": true
+    },
+    "kernelspec": {
+      "display_name": ".venv",
+      "language": "python",
+      "name": "python3"
+    },
+    "language_info": {
+      "codemirror_mode": {
+        "name": "ipython",
+        "version": 2
+      },
+      "file_extension": ".py",
+      "mimetype": "text/x-python",
+      "name": "python",
+      "nbconvert_exporter": "python",
+      "pygments_lexer": "ipython2",
+      "version": "3.11.13"
+    }
+  },
+  "nbformat": 4,
+  "nbformat_minor": 5
+}

notebooks/3-Fine-Tuning.ipynb

@@ -0,0 +1,49 @@
+{
+  "cells": [
+    {
+      "cell_type": "markdown",
+      "metadata": {
+        "id": "view-in-github",
+        "colab_type": "text"
+      },
+      "source": [
+        "<a href=\"https://colab.research.google.com/github/RobertoBarrosoLuque/scout-claims/blob/main/notebooks/3-Fine-Tuning.ipynb\" target=\"_parent\"><img src=\"https://colab.research.google.com/assets/colab-badge.svg\" alt=\"Open In Colab\"/></a>"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "id": "0",
+      "metadata": {
+        "id": "0"
+      },
+      "outputs": [],
+      "source": []
+    }
+  ],
+  "metadata": {
+    "kernelspec": {
+      "display_name": "Python 3",
+      "language": "python",
+      "name": "python3"
+    },
+    "language_info": {
+      "codemirror_mode": {
+        "name": "ipython",
+        "version": 2
+      },
+      "file_extension": ".py",
+      "mimetype": "text/x-python",
+      "name": "python",
+      "nbconvert_exporter": "python",
+      "pygments_lexer": "ipython2",
+      "version": "2.7.6"
+    },
+    "colab": {
+      "provenance": [],
+      "include_colab_link": true
+    }
+  },
+  "nbformat": 4,
+  "nbformat_minor": 5
+}

pyproject.toml

@@ -0,0 +1,23 @@
+[project]
+name = "scout"
+version = "0.1.0"
+description = "An end-to-end car crash claim AI assistant powered by FireworksAI"
+readme = "README.md"
+requires-python = ">=3.11"
+dependencies = [
+    "gradio",
+    "huggingface_hub[cli]",
+    "fireworks-ai",
+    "pre-commit",
+    "soundfile",
+    "scipy>=1.11.0",
+    "websocket-client",
+    "torchaudio",
+    "reportlab",
+    "python-dotenv",
+    "jupyter",
+    "ipython",
+]
+
+[tool.setuptools.packages.find]
+where = ["src"]

scripts/create_venv.sh

@@ -0,0 +1,13 @@
+#!/bin/bash
+
+# Exit on any error
+set -e
+
+# 3. Create a virtual environment if not already created
+VENV_DIR=".venv"
+if [ ! -d "$VENV_DIR" ]; then
+    echo "Virtual environment not found. Creating a new virtual environment..."
+    uv venv --python 3.11
+else
+    echo "Virtual environment already exists."
+fi

scripts/install_uv.sh

@@ -0,0 +1,19 @@
+#!/bin/bash
+
+# Exit on any error
+set -e
+
+# Function to check if a command exists
+command_exists() {
+    command -v "$1" >/dev/null 2>&1
+}
+
+# 1. Check if 'uv' is installed
+if ! command_exists uv; then
+    echo "'uv' is not installed. Installing 'uv'..."
+    # Install 'uv'
+    curl -LsSf https://astral.sh/uv/install.sh | sh
+    source ~/.cargo/env
+else
+    echo "'uv' is already installed."
+fi

scripts/setup_ssl.py

@@ -0,0 +1,97 @@
+import subprocess
+from pathlib import Path
+
+
+def check_openssl():
+    """Check if OpenSSL is available."""
+    try:
+        subprocess.run(["openssl", "version"], capture_output=True, check=True)
+        return True
+    except (subprocess.CalledProcessError, FileNotFoundError):
+        return False
+
+
+def generate_ssl_certificates():
+    """Generate self-signed SSL certificates for local development."""
+    cert_dir = Path("")
+    key_file = cert_dir / "key.pem"
+    cert_file = cert_dir / "cert.pem"
+
+    # Check if certificates already exist
+    if key_file.exists() and cert_file.exists():
+        print("✅ SSL certificates already exist!")
+        return True
+
+    if not check_openssl():
+        print("❌ OpenSSL not found. Please install OpenSSL first.")
+        print("On Ubuntu/Debian: sudo apt-get install openssl")
+        print("On macOS: brew install openssl")
+        print(
+            "On Windows: Download from https://slproweb.com/products/Win32OpenSSL.html"
+        )
+        return False
+
+    print("🔐 Generating self-signed SSL certificates...")
+
+    # Generate private key
+    key_cmd = ["openssl", "genrsa", "-out", str(key_file), "2048"]
+
+    # Generate certificate
+    cert_cmd = [
+        "openssl",
+        "req",
+        "-new",
+        "-x509",
+        "-key",
+        str(key_file),
+        "-out",
+        str(cert_file),
+        "-days",
+        "365",
+        "-subj",
+        "/C=US/ST=CA/L=Local/O=Dev/CN=localhost",
+    ]
+
+    try:
+        subprocess.run(key_cmd, check=True)
+        subprocess.run(cert_cmd, check=True)
+        print("✅ SSL certificates generated successfully!")
+        print(f"   Private key: {key_file}")
+        print(f"   Certificate: {cert_file}")
+        return True
+    except subprocess.CalledProcessError as e:
+        print(f"❌ Failed to generate SSL certificates: {e}")
+        return False
+
+
+def main():
+    """Main function to set up SSL certificates."""
+    print("🚀 Setting up SSL certificates for local HTTPS...")
+
+    if generate_ssl_certificates():
+        print("\n📋 Next steps:")
+        print("1. Run your Gradio app with the generated certificates")
+        print("2. Open https://localhost:7860 in your browser")
+        print(
+            "3. Accept the security warning (click 'Advanced' → 'Proceed to localhost')"
+        )
+        print("4. Allow microphone access when prompted")
+        print(
+            "\n⚠️  Note: You'll see a security warning because these are self-signed certificates."
+        )
+        print(
+            "   This is normal for local development - just click through the warning."
+        )
+    else:
+        print("\n❌ SSL setup failed. Alternative options:")
+        print(
+            "1. Use Chrome with: --unsafely-treat-insecure-origin-as-secure=http://localhost:7860"
+        )
+        print(
+            "2. Use Firefox and set media.devices.insecure.enabled=true in about:config"
+        )
+        print("3. Deploy to a server with proper SSL certificates")
+
+
+if __name__ == "__main__":
+    main()

src/app.py

@@ -0,0 +1,633 @@
+from pathlib import Path
+import gradio as gr
+import threading
+import queue
+import numpy as np
+import base64
+import tempfile
+import os
+from dotenv import load_dotenv
+
+from modules.image_analysis import pil_to_base64_dict, analyze_damage_image
+from modules.transcription import FireworksTranscription
+from modules.incident_processing import process_transcript_description
+from modules.claim_processing import generate_claim_report_pdf
+
+load_dotenv()
+
+_FILE_PATH = Path(__file__).parents[1]
+
+
+class ClaimsAssistantApp:
+    def __init__(self):
+        self.damage_analysis = None
+        self.incident_data = None
+        self.live_transcription = ""
+        self.transcription_lock = threading.Lock()
+        self.is_recording = False
+        self.transcription_service = None
+        self.audio_queue = queue.Queue()
+        self.final_report_pdf = None
+        self.claim_reference = ""
+        self.pdf_temp_path = None
+
+    @staticmethod
+    def format_function_calls_display(incident_data):
+        """Format function calls and external data for display"""
+        if not incident_data or "function_calls_made" not in incident_data:
+            return "", False
+
+        function_calls = incident_data.get("function_calls_made", [])
+        external_data = incident_data.get("external_data_retrieved", {})
+
+        if not function_calls:
+            return "", False
+
+        display_html = """
+        <div style="background: linear-gradient(135deg, #667eea 0%, #764ba2 100%);
+                    color: white; padding: 20px; border-radius: 12px; margin: 15px 0;">
+            <h3 style="margin-top: 0; display: flex; align-items: center;">
+                <span style="margin-right: 10px;">🔧</span>
+                AI Function Calls Executed
+            </h3>
+            <p style="margin-bottom: 15px; opacity: 0.9;">
+                The AI automatically gathered additional context by calling external functions:
+            </p>
+        """
+
+        for i, call in enumerate(function_calls, 1):
+            status_icon = "✅" if call["status"] == "success" else "❌"
+            function_name = call["function_name"]
+
+            display_html += f"""
+            <div style="background: rgba(255,255,255,0.1); padding: 15px; border-radius: 8px; margin: 10px 0;">
+                <h4 style="margin: 0 0 10px 0;">
+                    {status_icon} {i}. {function_name.replace('_', ' ').title()}
+                </h4>
+                <p style="margin: 5px 0; opacity: 0.8; font-size: 14px;">
+                    Status: {call['status'].title()} - {call['message']}
+                </p>
+            """
+
+            if call["status"] == "success" and function_name in external_data:
+                result = external_data[function_name]
+
+                if function_name == "weather_lookup":
+                    display_html += f"""
+                    <div style="margin: 10px 0; padding: 10px; background: rgba(255,255,255,0.1); border-radius: 5px;">
+                        <strong>Weather Conditions:</strong><br/>
+                        🌡️ Temperature: {result.get('temperature', 'N/A')}<br/>
+                        ☁️ Conditions: {result.get('conditions', 'N/A')}<br/>
+                        👁️ Visibility: {result.get('visibility', 'N/A')}<br/>
+                        🌧️ Precipitation: {result.get('precipitation', 'N/A')}
+                    </div>
+                    """
+
+                elif function_name == "driver_record_check":
+                    display_html += f"""
+                    <div style="margin: 10px 0; padding: 10px; background: rgba(255,255,255,0.1); border-radius: 5px;">
+                        <strong>Driver Record:</strong><br/>
+                        🆔 License: {result.get('license_status', 'N/A')}<br/>
+                        🛡️ Insurance: {result.get('insurance_status', 'N/A')}<br/>
+                        📊 Risk Level: {result.get('risk_assessment', 'N/A')}<br/>
+                        📝 Previous Claims: {result.get('previous_claims', 0)}
+                    </div>
+                    """
+
+            display_html += "</div>"
+
+        display_html += """
+            <div style="margin-top: 15px; padding: 10px; background: rgba(255,255,255,0.1); border-radius: 5px;">
+                <small style="opacity: 0.8;">
+                    💡 This additional context helps provide more accurate claim assessment and risk evaluation.
+                </small>
+            </div>
+        </div>
+        """
+
+        return display_html, True
+
+    def create_interface(self):
+        """Create the main Gradio interface"""
+
+        with gr.Blocks(title="Scout Claims", theme=gr.themes.Soft()) as demo:
+            # Header
+            with gr.Row():
+                with gr.Column():
+                    gr.Markdown("# 🚗 Scout | AI Claims Assistant 🚗")
+                    gr.Markdown(
+                        "*Automated Insurance Claims Processing with AI Function Calling*"
+                    )
+
+            # Sidebar (API Key)
+            with gr.Row():
+                with gr.Column(scale=1):
+                    gr.Markdown("### Powered by:")
+                    gr.Image(
+                        value=str(_FILE_PATH / "assets/fireworks_logo.png"),
+                        height=30,
+                        width=100,
+                        show_label=False,
+                        show_download_button=False,
+                        container=False,
+                        show_fullscreen_button=False,
+                    )
+
+                    gr.Markdown("## ⚙️ Configuration")
+
+                    val = os.getenv("FIREWORKS_API_KEY", "")
+
+                    api_key = gr.Textbox(
+                        label="Fireworks AI API Key",
+                        type="password",
+                        placeholder="Enter your Fireworks AI API key",
+                        value=val,
+                        info="Required for AI processing",
+                    )
+
+                    gr.Markdown("## 📋 Instructions")
+                    gr.Markdown(
+                        """
+                    **Step 1:** Upload car damage photo(s) \n
+                    **Step 2:** Use microphone to describe incident \n
+                    **Step 3:** Generate and review claim report \n
+                    """
+                    )
+
+                # Main Content Area
+                with gr.Column(scale=3):
+                    # Step 1: Upload Image
+                    gr.Markdown("## 📷 Step 1: Upload Damage Photos 📷")
+                    with gr.Row():
+                        image_input = gr.Image(
+                            label="Car Damage Photo", type="pil", height=300
+                        )
+
+                        with gr.Column():
+                            analyze_btn = gr.Button(
+                                "🔍 Analyze Damage", variant="primary"
+                            )
+                            damage_status = gr.Textbox(
+                                label="Analysis Status",
+                                value="Ready to analyze damage",
+                                interactive=False,
+                                lines=2,
+                            )
+
+                    # Damage Analysis Results
+                    damage_results = gr.JSON(
+                        label="Damage Analysis Results", visible=False
+                    )
+
+                    gr.Markdown("---")
+
+                    # Step 2: Incident Description with Live Streaming
+                    gr.Markdown("## 🎤 Step 2: Describe the Incident 🎤")
+
+                    with gr.Accordion(
+                        "💡 What to Include in Your Recording", open=True
+                    ):
+                        gr.Markdown(
+                            """
+                        **Please describe the following when you record:**
+
+                        📅 **When & Where:**
+                        - Date and time of the accident
+                        - Street address or intersection
+
+                        👥 **Who Was Involved:**
+                        - Other driver's name and contact info
+                        - Vehicle details (make, model, color, license plate)
+                        - Any witnesses
+
+                        🚗 **What Happened:**
+                        - How the accident occurred
+                        - Who was at fault and why
+                        - Weather and road conditions
+
+                        🏥 **Injuries & Damage:**
+                        - Anyone hurt? How seriously?
+                        - How severe is the vehicle damage?
+
+                        """
+                        )
+
+                    with gr.Row():
+                        # Direct audio input - no toggle button needed
+                        with gr.Column():
+                            audio_input = gr.Audio(
+                                label="🎵 Record Incident Description",
+                                sources=["microphone"],
+                                streaming=True,
+                                format="wav",
+                                show_download_button=False,
+                            )
+                            transcription_display = gr.Textbox(
+                                label="Live Transcription",
+                                placeholder="Click the 'Record' button above to start recording...",
+                                lines=8,
+                                interactive=False,
+                                autoscroll=True,
+                            )
+
+                    process_incident_btn = gr.Button(
+                        "📝 Process Incident", variant="primary"
+                    )
+
+                    incident_status = gr.Textbox(
+                        label="Processing Status",
+                        value="Record audio first to process incident",
+                        interactive=False,
+                        lines=2,
+                    )
+
+                    # NEW: Function calls display
+                    function_calls_display = gr.HTML(
+                        label="AI Function Calls", visible=False
+                    )
+
+                    # Incident Processing Results
+                    incident_results = gr.JSON(
+                        label="Incident Processing Results", visible=False
+                    )
+
+                    gr.Markdown("---")
+
+                    # Step 3: Generate Claim Report
+                    gr.Markdown("## 📄 Step 3: Generate Claim Report 📄")
+
+                    generate_report_btn = gr.Button(
+                        "🚀 Generate Claim Report", variant="primary", size="lg"
+                    )
+
+                    report_status = gr.Textbox(
+                        label="Report Generation Status",
+                        value="Complete steps 1 and 2 to generate report",
+                        interactive=False,
+                        lines=2,
+                    )
+
+                    # Final Report Display - Updated for PDF
+                    with gr.Accordion(
+                        "📋 Generated Claim Report (PDF)", open=False
+                    ) as report_accordion:
+                        # PDF Viewer using HTML iframe
+                        pdf_viewer = gr.HTML(
+                            value="<p style='text-align: center; color: gray;'>PDF report will appear here after generation</p>",
+                            label="Claim Report PDF",
+                        )
+
+                        with gr.Row():
+                            download_btn = gr.DownloadButton(
+                                "💾 Download PDF Report", visible=False
+                            )
+                            submit_btn = gr.Button(
+                                "✅ Submit Claim", variant="stop", visible=False
+                            )
+
+            # Event Handlers
+            def handle_damage_analysis(image, api_key):
+                if image is None:
+                    return (
+                        "❌ Please upload an image first",
+                        gr.update(visible=False),
+                    )
+
+                if not api_key.strip():
+                    return (
+                        "❌ Please enter your Fireworks AI API key first",
+                        gr.update(visible=False),
+                    )
+
+                try:
+                    # Update status to show processing
+                    yield (
+                        "🔄 Analyzing damage... Please wait",
+                        gr.update(visible=False),
+                    )
+
+                    image_dict = pil_to_base64_dict(image)
+                    self.damage_analysis = analyze_damage_image(
+                        image=image_dict, api_key=api_key
+                    )
+
+                    yield (
+                        "✅ Damage analysis completed successfully!",
+                        gr.update(value=self.damage_analysis, visible=True),
+                    )
+                    return None
+
+                except Exception as e:
+                    yield (
+                        f"❌ Error analyzing damage: {str(e)}",
+                        gr.update(visible=False),
+                    )
+                    return None
+
+            def live_transcription_callback(text):
+                """Callback for live transcription updates"""
+                with self.transcription_lock:
+                    self.live_transcription = text
+
+            def initialize_transcription_service(api_key):
+                """Initialize transcription service when audio starts"""
+                if not api_key.strip():
+                    return False
+
+                if not self.transcription_service:
+                    self.transcription_service = FireworksTranscription(api_key)
+                    self.transcription_service.set_callback(live_transcription_callback)
+
+                if not self.is_recording:
+                    self.is_recording = True
+                    self.live_transcription = ""
+                    return self.transcription_service._connect()
+                return True
+
+            def process_audio_stream(audio_tuple, api_key):
+                """Process incoming audio stream for live transcription"""
+                if not audio_tuple:
+                    with self.transcription_lock:
+                        return self.live_transcription
+
+                # Initialize transcription service if needed
+                if not self.is_recording:
+                    if not initialize_transcription_service(api_key):
+                        return "❌ Failed to initialize transcription service. Check your API key."
+
+                try:
+                    sample_rate, audio_data = audio_tuple
+
+                    # Convert audio data to proper format
+                    if not isinstance(audio_data, np.ndarray):
+                        audio_data = np.array(audio_data, dtype=np.float32)
+
+                    if audio_data.dtype != np.float32:
+                        if audio_data.dtype == np.int16:
+                            audio_data = audio_data.astype(np.float32) / 32768.0
+                        elif audio_data.dtype == np.int32:
+                            audio_data = audio_data.astype(np.float32) / 2147483648.0
+                        else:
+                            audio_data = audio_data.astype(np.float32)
+
+                    # Skip if audio is too quiet
+                    if np.max(np.abs(audio_data)) < 0.01:
+                        with self.transcription_lock:
+                            return self.live_transcription
+
+                    # Convert to mono if stereo
+                    if len(audio_data.shape) > 1:
+                        audio_data = np.mean(audio_data, axis=1)
+
+                    # Resample to 16kHz if needed
+                    if sample_rate != 16000:
+                        ratio = 16000 / sample_rate
+                        new_length = int(len(audio_data) * ratio)
+                        if new_length > 0:
+                            audio_data = np.interp(
+                                np.linspace(0, len(audio_data) - 1, new_length),
+                                np.arange(len(audio_data)),
+                                audio_data,
+                            )
+
+                    # Convert to bytes and send to transcription service
+                    audio_bytes = (audio_data * 32767).astype(np.int16).tobytes()
+
+                    if (
+                        self.transcription_service
+                        and self.transcription_service.is_connected
+                    ):
+                        self.transcription_service._send_audio_chunk(audio_bytes)
+
+                except Exception as e:
+                    print(f"Error processing audio stream: {e}")
+
+                # Return current transcription
+                with self.transcription_lock:
+                    return self.live_transcription
+
+            def handle_incident_processing(api_key):
+                """Process the recorded transcription into structured incident data with function calling"""
+                if not self.live_transcription.strip():
+                    return (
+                        "❌ No transcription available. Please record audio first.",
+                        gr.update(visible=False),
+                        gr.update(visible=False),
+                    )
+
+                if not api_key.strip():
+                    return (
+                        "❌ Please enter your Fireworks AI API key first",
+                        gr.update(visible=False),
+                        gr.update(visible=False),
+                    )
+
+                try:
+                    # Update status
+                    yield (
+                        "🔄 Processing incident data ... Please wait",
+                        gr.update(visible=False),
+                        gr.update(visible=False),
+                    )
+
+                    # Use enhanced Fireworks processing with function calling
+                    incident_analysis = process_transcript_description(
+                        transcript=self.live_transcription, api_key=api_key
+                    )
+
+                    # Convert Pydantic model to dict for JSON display
+                    self.incident_data = incident_analysis.model_dump()
+
+                    # Format function calls for display
+                    function_calls_html, show_calls = (
+                        self.format_function_calls_display(self.incident_data)
+                    )
+
+                    # Update status message based on function calls
+                    if show_calls:
+                        status_message = f"✅ Incident processing completed with {len(self.incident_data.get('function_calls_made', []))} AI function calls!"
+                    else:
+                        status_message = (
+                            "✅ Incident processing completed successfully!"
+                        )
+
+                    yield (
+                        status_message,
+                        gr.update(value=function_calls_html, visible=show_calls),
+                        gr.update(value=self.incident_data, visible=True),
+                    )
+                    return None
+
+                except Exception as e:
+                    yield (
+                        f"❌ Error processing incident: {str(e)}",
+                        gr.update(visible=False),
+                        gr.update(visible=False),
+                    )
+                    return None
+
+            def handle_report_generation(api_key):
+                """Generate comprehensive claim report as PDF using AI"""
+                if not self.damage_analysis or not self.incident_data:
+                    return (
+                        "❌ Please complete damage analysis and incident processing first",
+                        "<p style='text-align: center; color: gray;'>PDF report will appear here after generation</p>",
+                        gr.update(visible=False),
+                        gr.update(visible=False),
+                        gr.update(open=False),
+                    )
+
+                if not api_key.strip():
+                    return (
+                        "❌ Please enter your Fireworks AI API key first",
+                        "<p style='text-align: center; color: gray;'>PDF report will appear here after generation</p>",
+                        gr.update(visible=False),
+                        gr.update(visible=False),
+                        gr.update(open=False),
+                    )
+
+                try:
+                    # Show processing status
+                    yield (
+                        "🔄 Generating comprehensive PDF claim report... Please wait",
+                        "<p style='text-align: center; color: gray;'>PDF report will appear here after generation</p>",
+                        gr.update(visible=False),
+                        gr.update(visible=False),
+                        gr.update(open=False),
+                    )
+
+                    # Generate the PDF report
+                    self.final_report_pdf = generate_claim_report_pdf(
+                        damage_analysis=self.damage_analysis,
+                        incident_data=self.incident_data,
+                    )
+
+                    # Extract claim reference for download filename
+                    from datetime import datetime
+
+                    timestamp = datetime.now()
+                    self.claim_reference = f"CLM-{timestamp.strftime('%Y%m%d')}-{timestamp.strftime('%H%M%S')}"
+
+                    # Save PDF to temporary file for viewing and downloading
+                    if self.pdf_temp_path and os.path.exists(self.pdf_temp_path):
+                        os.remove(self.pdf_temp_path)
+
+                    temp_dir = tempfile.gettempdir()
+                    self.pdf_temp_path = os.path.join(
+                        temp_dir, f"{self.claim_reference}.pdf"
+                    )
+
+                    with open(self.pdf_temp_path, "wb") as f:
+                        f.write(self.final_report_pdf)
+
+                    # Create PDF viewer HTML
+                    pdf_base64 = base64.b64encode(self.final_report_pdf).decode("utf-8")
+                    pdf_viewer_html = f"""
+                    <div style="text-align: center; margin: 20px 0;">
+                        <h3 style="color: #2563eb;">📋 Insurance Claim Report - {self.claim_reference}</h3>
+                        <iframe
+                            src="data:application/pdf;base64,{pdf_base64}"
+                            width="100%"
+                            height="800px"
+                            style="border: 2px solid #e5e7eb; border-radius: 8px; box-shadow: 0 4px 6px rgba(0, 0, 0, 0.1);">
+                            <p>Your browser does not support PDF viewing.
+                            <a href="data:application/pdf;base64,{pdf_base64}" download="{self.claim_reference}.pdf">
+                                Click here to download the PDF
+                            </a></p>
+                        </iframe>
+                        <p style="margin-top: 15px; color: #6b7280; font-size: 14px;">
+                            📄 Professional PDF report generated successfully! Use the download button below to save.
+                        </p>
+                    </div>
+                    """
+
+                    yield (
+                        "✅ Professional PDF claim report generated successfully!",
+                        pdf_viewer_html,
+                        gr.update(visible=True, value=self.pdf_temp_path),
+                        gr.update(visible=True),
+                        gr.update(open=True),
+                    )
+                    return None
+
+                except Exception as e:
+                    yield (
+                        f"❌ Error generating PDF report: {str(e)}",
+                        "<p style='text-align: center; color: red;'>Error generating PDF report</p>",
+                        gr.update(visible=False),
+                        gr.update(visible=False),
+                        gr.update(open=False),
+                    )
+                    return None
+
+            def handle_claim_submission():
+                """Handle final claim submission"""
+                if not self.final_report_pdf:
+                    return "❌ No report available to submit"
+
+                return f"🎉 Claim submitted successfully! Reference: {self.claim_reference}"
+
+            def cleanup_temp_files():
+                """Clean up temporary PDF files"""
+                if self.pdf_temp_path and os.path.exists(self.pdf_temp_path):
+                    try:
+                        os.remove(self.pdf_temp_path)
+                    except Exception as e:
+                        print(f"Error deleting temporary PDF file: {e}")
+                        pass
+
+            # Wire up the events
+            analyze_btn.click(
+                fn=handle_damage_analysis,
+                inputs=[image_input, api_key],
+                outputs=[damage_status, damage_results],
+            )
+
+            # Handle streaming audio for live transcription
+            audio_input.stream(
+                fn=process_audio_stream,
+                inputs=[audio_input, api_key],
+                outputs=[transcription_display],
+                time_limit=None,
+                stream_every=0.5,  # Update every 500ms
+                show_progress="hidden",
+            )
+
+            # Updated to include function calls display
+            process_incident_btn.click(
+                fn=handle_incident_processing,
+                inputs=[api_key],
+                outputs=[incident_status, function_calls_display, incident_results],
+            )
+
+            generate_report_btn.click(
+                fn=handle_report_generation,
+                inputs=[api_key],
+                outputs=[
+                    report_status,
+                    pdf_viewer,
+                    download_btn,
+                    submit_btn,
+                    report_accordion,
+                ],
+            )
+
+            submit_btn.click(fn=handle_claim_submission, outputs=[report_status])
+
+            # Clean up on app close
+            demo.load(lambda: None)
+
+        return demo
+
+
+def create_claims_app():
+    """Factory function to create the claims assistant app"""
+    app = ClaimsAssistantApp()
+    return app.create_interface()
+
+
+# Create and launch the demo
+if __name__ == "__main__":
+    print("Starting AI Claims Assistant Demo with Function Calling")
+    demo = create_claims_app()
+    demo.launch()

src/configs/config.yaml

@@ -0,0 +1,11 @@
+analyze_damage_image:
+  model: "accounts/fireworks/models/qwen2p5-vl-32b-instruct"
+  temperature: 0.0
+
+incident_response:
+  model: "accounts/fireworks/models/llama4-scout-instruct-basic"
+  temperature: 0.0
+
+report_generation:
+  model: "accounts/fireworks/models/deepseek-v3-0324"
+  temperature: 0.0

src/configs/config_models.py

@@ -0,0 +1,12 @@
+from pydantic import BaseModel, Field
+
+
+class ModelConfig(BaseModel):
+    model: str
+    temperature: float = Field(default=0.1, ge=0, le=1.0)
+
+
+class StepModelsConfigs(BaseModel):
+    analyze_damage_image: ModelConfig
+    incident_response: ModelConfig
+    report_generation: ModelConfig

src/configs/load_config.py

@@ -0,0 +1,51 @@
+from functools import lru_cache
+from pathlib import Path
+from typing import Any
+import yaml
+
+from configs.config_models import StepModelsConfigs
+
+
+@lru_cache
+def load_config(config_path: Path, _format: str = "dict") -> dict[str, Any] | str:
+    """
+    Load configuration from a YAML file into a dictionary.
+
+    Parameters
+    ----------
+    config_path : Path
+        Path to the YAML configuration file.
+    _format : str, optional
+        The format in which to return the configuration, by default "dict".
+
+    Returns
+    -------
+    dict[str, Any] | str
+        A dictionary containing the configuration parameters if _format="dict",
+        otherwise the raw YAML content as a string.
+    """
+    with open(config_path, "r") as file:
+        content = file.read()
+
+    if _format == "dict":
+        return yaml.safe_load(content)
+    else:
+        return content
+
+
+def load_module_config(config_path, config_model=None):
+    """
+    Load a YAML configuration file and validate against a Pydantic model.
+    """
+    config_data = load_config(config_path)
+
+    if config_model:
+        return config_model(**config_data)
+
+    return config_data
+
+
+PROMPT_LIBRARY = load_config(Path(__file__).parent / "prompt_library.yaml")
+APP_STEPS_CONFIGS = load_module_config(
+    Path(__file__).parent / "config.yaml", StepModelsConfigs
+)

src/configs/prompt_library.yaml

@@ -0,0 +1,87 @@
+vision_damage_analysis:
+  simple: |
+    Describe the car damage in this image.
+
+  intermediate: |
+    Analyze this car damage image and provide:
+
+    1. What type of damage do you see?
+    2. How severe is the damage?
+    3. Which parts of the car are affected?
+    4. Estimate if this is minor, moderate, or major damage.
+
+    Please be specific and detailed in your response.
+
+  advanced: |
+    You are an expert automotive claims adjuster analyzing vehicle damage. Examine this image carefully and provide a comprehensive damage assessment.
+
+    **SEVERITY DEFINITIONS:**
+    - **minor**: Cosmetic damage, scratches, small dents < 2 inches
+    - **moderate**: Noticeable damage affecting function, dents 2-6 inches, cracked lights
+    - **major**: Structural damage, large dents > 6 inches, safety systems affected
+
+    **LOCATION DEFINITIONS:**
+    - **front-left**: Driver side front (hood, front bumper, headlight, driver door front portion)
+    - **front-right**: Passenger side front (hood, front bumper, headlight, passenger door front portion)
+    - **back-left**: Driver side rear (trunk, rear bumper, taillight, driver door rear portion)
+    - **back-right**: Passenger side rear (trunk, rear bumper, taillight, passenger door rear portion)
+
+    **Licence Plate Extraction:**
+    - If the licence plate is present, please extract it and provide it in the response.
+    - Make sure to provide the full plate number and any relevant characters (e.g., dashes, spaces, etc.).
+    - If the licence plate is not present, please provide "N/A" in the response.
+
+    **INSTRUCTIONS:**
+    1. Examine the entire visible vehicle surface
+    2. Identify the primary damage location using the quadrant system
+    3. Assess severity based on size, depth, and functional impact
+    4. Provide the license plate number if present
+    5. Provide a clear, detailed description of what you observe
+    6. If damage spans multiple quadrants, choose the most severely affected area
+    7. Be conservative in estimates - when uncertain, classify as higher severity
+
+    Focus on accuracy and consistency. This analysis will be used for insurance claim processing.
+
+
+incident_processing:
+  simple: |
+    Analyze this transcript of an car crash incident
+
+  intermediate: |
+    Analyze this transcript of an car crash incident and provide:
+
+    1. When and where
+    2. What happened
+    3. Who was involved
+    4. What was the severity
+
+  advanced: |
+    You are an expert automotive claims adjuster analyzing vehicle damage. You have been provided a transcript of an incident and you need to provide a detailed analysis of the incident.
+
+    **INSTRUCTIONS:**
+    1. Analyze the entire transcript
+    2. Indentify when and where the incident occurred
+    3. Identify who was involved
+    5. Identify what exact events took place
+    6. Identify the severity of the incident - to both the car and people
+    7. Be specific and detailed in your response
+
+    If any of the above information is unclear or not provided in the transcript, do not make any thing up. Instead just
+    say "No information provided in the transcript"
+
+    **Example transcript:**
+    <transcript>
+    Yeah so I was driving down the road and I hit a car and I was hurt. This happened today around 3pm
+    the other car involved was a VW sedan driven by a guy called John Doe. It was a pretty minor crash so just
+    a couple of scratchs on the driver side and a few dents on the passenger side. No on was hurt.
+    </transcript>
+
+    **Example response:**
+    <response>
+    When: around 3pm today
+    Where: on the road
+    What happened: I was driving down the road and I hit a car
+    Who was involved: VW sedan driven by a guy called John Doe
+    What was the severity: It was a pretty minor crash so just a couple of scratchs on the driver side and a few dents on the passenger side
+    Was anyone hurt: No one was hurt
+    </response>

src/modules/claim_processing.py

@@ -0,0 +1,789 @@
+from datetime import datetime, timedelta
+from typing import Dict, Any
+import io
+from reportlab.lib.pagesizes import letter
+from reportlab.lib.styles import getSampleStyleSheet, ParagraphStyle
+from reportlab.lib.enums import TA_CENTER, TA_JUSTIFY
+from reportlab.platypus import (
+    SimpleDocTemplate,
+    Paragraph,
+    Spacer,
+    Table,
+    TableStyle,
+    Image,
+)
+from reportlab.lib.units import inch
+from reportlab.lib import colors
+from reportlab.platypus.flowables import HRFlowable
+
+
+def generate_claim_report_pdf(
+    damage_analysis: Dict[str, Any],
+    incident_data: Dict[str, Any],
+    image_path: str = None,
+) -> bytes:
+    """
+    Generate a professional insurance claim report as PDF from analyzed data.
+
+    Args:
+        damage_analysis: Results from image damage analysis
+        incident_data: Processed incident data from transcript
+        image_path: Optional path to the damage photo to include in appendix
+
+    Returns:
+        PDF bytes for the formatted claim report
+    """
+
+    # Create a BytesIO buffer to hold the PDF
+    buffer = io.BytesIO()
+
+    # Generate claim reference number
+    timestamp = datetime.now()
+    claim_ref = f"CLM-{timestamp.strftime('%Y%m%d')}-{timestamp.strftime('%H%M%S')}"
+
+    # Extract key information safely
+    damage_description = damage_analysis.get("description", "Vehicle damage detected")
+    damage_severity = damage_analysis.get("severity", "moderate")
+    damage_location = damage_analysis.get("location", "unknown")
+
+    # Get incident details safely with date conversion
+    date_location = incident_data.get("date_location", {})
+    # Convert relative dates to actual dates
+    actual_date = _convert_relative_date(date_location.get("date", "Not specified"))
+    date_location_converted = {**date_location, "date": actual_date}
+
+    parties_involved = incident_data.get("parties_involved", {})
+    fault_assessment = incident_data.get("fault_assessment", {})
+    incident_description = incident_data.get("incident_description", {})
+    injuries_medical = incident_data.get("injuries_medical", {})
+
+    # Generate assessments
+    priority = _get_priority_level(
+        damage_severity, injuries_medical.get("anyone_injured", "no")
+    )
+    cost_estimate = _estimate_cost_range(damage_severity)
+    recommendation = _get_recommendation(
+        damage_severity, injuries_medical.get("anyone_injured", "no")
+    )
+
+    # Create PDF document with professional margins
+    doc = SimpleDocTemplate(
+        buffer,
+        pagesize=letter,
+        rightMargin=0.75 * inch,
+        leftMargin=0.75 * inch,
+        topMargin=0.75 * inch,
+        bottomMargin=0.75 * inch,
+    )
+
+    # Get styles
+    styles = getSampleStyleSheet()
+
+    # Professional custom styles - all black text
+    title_style = ParagraphStyle(
+        "ProfessionalTitle",
+        parent=styles["Heading1"],
+        fontSize=20,
+        textColor=colors.black,
+        spaceAfter=16,
+        spaceBefore=0,
+        alignment=TA_CENTER,
+        fontName="Helvetica-Bold",
+    )
+
+    header_style = ParagraphStyle(
+        "ProfessionalHeader",
+        parent=styles["Heading2"],
+        fontSize=14,
+        textColor=colors.black,
+        spaceAfter=8,
+        spaceBefore=16,
+        fontName="Helvetica-Bold",
+    )
+
+    subheader_style = ParagraphStyle(
+        "ProfessionalSubHeader",
+        parent=styles["Heading3"],
+        fontSize=12,
+        textColor=colors.black,
+        spaceAfter=6,
+        spaceBefore=8,
+        fontName="Helvetica-Bold",
+    )
+
+    body_style = ParagraphStyle(
+        "ProfessionalBody",
+        parent=styles["Normal"],
+        fontSize=10,
+        spaceAfter=4,
+        fontName="Helvetica",
+        textColor=colors.black,
+        alignment=TA_JUSTIFY,
+    )
+
+    # Professional table style
+    def create_professional_table_style():
+        return TableStyle(
+            [
+                ("BACKGROUND", (0, 0), (0, -1), colors.lightgrey),
+                ("TEXTCOLOR", (0, 0), (-1, -1), colors.black),
+                ("ALIGN", (0, 0), (-1, -1), "LEFT"),
+                ("FONTNAME", (0, 0), (0, -1), "Helvetica-Bold"),
+                ("FONTNAME", (1, 0), (1, -1), "Helvetica"),
+                ("FONTSIZE", (0, 0), (-1, -1), 10),
+                ("GRID", (0, 0), (-1, -1), 1, colors.black),
+                ("VALIGN", (0, 0), (-1, -1), "TOP"),
+                ("LEFTPADDING", (0, 0), (-1, -1), 6),
+                ("RIGHTPADDING", (0, 0), (-1, -1), 6),
+                ("TOPPADDING", (0, 0), (-1, -1), 4),
+                ("BOTTOMPADDING", (0, 0), (-1, -1), 4),
+            ]
+        )
+
+    # Helper function to create table cells with proper text wrapping
+    def create_table_cell(text: str, is_header: bool = False) -> Paragraph:
+        style = ParagraphStyle(
+            "TableCell",
+            parent=styles["Normal"],
+            fontSize=10,
+            textColor=colors.black,
+            fontName="Helvetica-Bold" if is_header else "Helvetica",
+            leftIndent=0,
+            rightIndent=0,
+            spaceAfter=0,
+            spaceBefore=0,
+        )
+        return Paragraph(str(text), style)
+
+    # Build the document content
+    story = []
+
+    # Professional Header
+    story.append(Paragraph("AUTOMOBILE INSURANCE CLAIM REPORT", title_style))
+    story.append(Spacer(1, 12))
+
+    # Claim Information Section
+    claim_info_data = [
+        [
+            create_table_cell("Claim Reference Number:", True),
+            create_table_cell(claim_ref),
+        ],
+        [
+            create_table_cell("Report Generated:", True),
+            create_table_cell(timestamp.strftime("%B %d, %Y at %I:%M %p")),
+        ],
+        [
+            create_table_cell("Claim Status:", True),
+            create_table_cell("Under Review - Pending Adjuster Assignment"),
+        ],
+        [
+            create_table_cell("Processing Priority:", True),
+            create_table_cell(
+                priority.replace("🔴", "").replace("🟡", "").replace("🟢", "").strip()
+            ),
+        ],
+    ]
+
+    claim_info_table = Table(claim_info_data, colWidths=[2.2 * inch, 4.5 * inch])
+    claim_info_table.setStyle(create_professional_table_style())
+    story.append(claim_info_table)
+    story.append(Spacer(1, 16))
+
+    # Executive Summary
+    story.append(Paragraph("EXECUTIVE SUMMARY", header_style))
+    story.append(HRFlowable(width="100%", thickness=1, color=colors.black))
+    story.append(Spacer(1, 8))
+
+    summary_text = f"""
+    This claim involves a motor vehicle accident resulting in <b>{damage_severity.lower()}</b> damage to the
+    insured vehicle's <b>{damage_location.replace('-', ' ').lower()}</b> area. Based on initial assessment
+    of submitted photographic evidence and incident description, this appears to be a legitimate claim
+    {"requiring expedited processing due to reported injuries" if injuries_medical.get('anyone_injured', 'no').lower() == 'yes' else "suitable for standard processing procedures"}.
+    <br/><br/>
+    <b>Primary Recommendation:</b> {recommendation}<br/>
+    <b>Preliminary Cost Assessment:</b> {cost_estimate}
+    """
+
+    story.append(Paragraph(summary_text, body_style))
+    story.append(Spacer(1, 16))
+
+    # Incident Details
+    story.append(Paragraph("INCIDENT DETAILS", header_style))
+    story.append(HRFlowable(width="100%", thickness=1, color=colors.black))
+    story.append(Spacer(1, 8))
+
+    # Date, Time & Location
+    story.append(Paragraph("Date, Time and Location of Loss", subheader_style))
+
+    incident_data_table = [
+        [
+            create_table_cell("Date of Loss:", True),
+            create_table_cell(
+                date_location_converted.get("date", "Not specified in report")
+            ),
+        ],
+        [
+            create_table_cell("Time of Loss:", True),
+            create_table_cell(date_location.get("time", "Not specified in report")),
+        ],
+        [
+            create_table_cell("Location of Loss:", True),
+            create_table_cell(date_location.get("location", "Not specified in report")),
+        ],
+    ]
+
+    incident_table = Table(incident_data_table, colWidths=[2 * inch, 4.7 * inch])
+    incident_table.setStyle(create_professional_table_style())
+    story.append(incident_table)
+    story.append(Spacer(1, 12))
+
+    # Description of Incident
+    story.append(Paragraph("Description of Incident", subheader_style))
+    incident_desc = incident_description.get(
+        "what_happened", "No detailed description provided in initial report"
+    )
+    story.append(Paragraph(incident_desc, body_style))
+    story.append(Spacer(1, 16))
+
+    # Parties Involved
+    story.append(Paragraph("PARTIES INVOLVED", header_style))
+    story.append(HRFlowable(width="100%", thickness=1, color=colors.black))
+    story.append(Spacer(1, 8))
+
+    parties_data = [
+        [
+            create_table_cell("Other Party Driver Name:", True),
+            create_table_cell(
+                parties_involved.get("other_driver_name", "Information not provided")
+            ),
+        ],
+        [
+            create_table_cell("Other Party Vehicle:", True),
+            create_table_cell(
+                parties_involved.get("other_driver_vehicle", "Information not provided")
+            ),
+        ],
+        [
+            create_table_cell("Witness Information:", True),
+            create_table_cell(
+                parties_involved.get("witnesses", "No witnesses reported at this time")
+            ),
+        ],
+    ]
+
+    parties_table = Table(parties_data, colWidths=[2 * inch, 4.7 * inch])
+    parties_table.setStyle(create_professional_table_style())
+    story.append(parties_table)
+    story.append(Spacer(1, 16))
+
+    # Vehicle Damage Assessment
+    story.append(Paragraph("VEHICLE DAMAGE ASSESSMENT", header_style))
+    story.append(HRFlowable(width="100%", thickness=1, color=colors.black))
+    story.append(Spacer(1, 8))
+
+    # Clean up damage description - wrap long text properly
+    damage_desc_clean = _format_damage_description(damage_description)
+
+    damage_data = [
+        [
+            create_table_cell("Damage Severity Classification:", True),
+            create_table_cell(damage_severity.title()),
+        ],
+        [
+            create_table_cell("Primary Damage Location:", True),
+            create_table_cell(damage_location.replace("-", " ").title()),
+        ],
+        [
+            create_table_cell("Damage Description:", True),
+            create_table_cell(damage_desc_clean),
+        ],
+        [
+            create_table_cell("Preliminary Repair Estimate:", True),
+            create_table_cell(cost_estimate),
+        ],
+    ]
+
+    damage_table = Table(damage_data, colWidths=[2 * inch, 4.7 * inch])
+    damage_table.setStyle(create_professional_table_style())
+    story.append(damage_table)
+    story.append(Spacer(1, 12))
+
+    # Evidence Documentation
+    evidence_text = """
+    <b>Photographic Evidence:</b> Digital photographs of vehicle damage received and analyzed using automated assessment tools.<br/>
+    <b>Incident Documentation:</b> Verbal account transcribed and processed for key incident details.
+    """
+    story.append(Paragraph(evidence_text, body_style))
+    story.append(Spacer(1, 16))
+
+    # Injury and Medical Information
+    story.append(Paragraph("INJURY AND MEDICAL INFORMATION", header_style))
+    story.append(HRFlowable(width="100%", thickness=1, color=colors.black))
+    story.append(Spacer(1, 8))
+
+    injury_data = [
+        [
+            create_table_cell("Personal Injuries Reported:", True),
+            create_table_cell(
+                injuries_medical.get("anyone_injured", "Not specified").title()
+            ),
+        ],
+        [
+            create_table_cell("Injury Details:", True),
+            create_table_cell(
+                injuries_medical.get(
+                    "injury_details", "No specific injury details provided"
+                )
+            ),
+        ],
+        [
+            create_table_cell("Medical Treatment Sought:", True),
+            create_table_cell(
+                injuries_medical.get("medical_attention", "Information not available")
+            ),
+        ],
+        [
+            create_table_cell("Injury Severity Assessment:", True),
+            create_table_cell(
+                injuries_medical.get("injury_severity", "None reported").title()
+            ),
+        ],
+    ]
+
+    injury_table = Table(injury_data, colWidths=[2 * inch, 4.7 * inch])
+    injury_table.setStyle(create_professional_table_style())
+    story.append(injury_table)
+    story.append(Spacer(1, 16))
+
+    # Liability Assessment
+    story.append(Paragraph("PRELIMINARY LIABILITY ASSESSMENT", header_style))
+    story.append(HRFlowable(width="100%", thickness=1, color=colors.black))
+    story.append(Spacer(1, 8))
+
+    fault_data = [
+        [
+            create_table_cell("Initial Fault Determination:", True),
+            create_table_cell(
+                _format_fault_determination(
+                    fault_assessment.get("who_at_fault", "Under investigation")
+                )
+            ),
+        ],
+        [
+            create_table_cell("Basis for Determination:", True),
+            create_table_cell(
+                fault_assessment.get(
+                    "reason", "Pending detailed investigation and evidence review"
+                )
+            ),
+        ],
+    ]
+
+    fault_table = Table(fault_data, colWidths=[2 * inch, 4.7 * inch])
+    fault_table.setStyle(create_professional_table_style())
+    story.append(fault_table)
+    story.append(Spacer(1, 16))
+
+    # Cost Analysis
+    story.append(Paragraph("PRELIMINARY COST ANALYSIS", header_style))
+    story.append(HRFlowable(width="100%", thickness=1, color=colors.black))
+    story.append(Spacer(1, 8))
+
+    medical_costs = _format_medical_costs(injuries_medical)
+    total_estimate = _calculate_total_estimate(cost_estimate, injuries_medical)
+
+    cost_data = [
+        [
+            create_table_cell("Vehicle Repair Estimate:", True),
+            create_table_cell(cost_estimate),
+        ],
+        [
+            create_table_cell("Medical Expense Estimate:", True),
+            create_table_cell(medical_costs),
+        ],
+        [
+            create_table_cell("Total Preliminary Estimate:", True),
+            create_table_cell(total_estimate),
+        ],
+    ]
+
+    cost_table = Table(cost_data, colWidths=[2 * inch, 4.7 * inch])
+    cost_style = create_professional_table_style()
+    # Highlight total row
+    cost_style.add("BACKGROUND", (0, 2), (1, 2), colors.lightgrey)
+    cost_style.add("FONTNAME", (0, 2), (1, 2), "Helvetica-Bold")
+    cost_table.setStyle(cost_style)
+
+    story.append(cost_table)
+    story.append(Spacer(1, 16))
+
+    # Action Items and Next Steps
+    story.append(Paragraph("RECOMMENDED ACTION ITEMS", header_style))
+    story.append(HRFlowable(width="100%", thickness=1, color=colors.black))
+    story.append(Spacer(1, 8))
+
+    next_steps = _generate_next_steps_professional(
+        damage_severity, injuries_medical, fault_assessment
+    )
+    story.append(Paragraph(next_steps, body_style))
+    story.append(Spacer(1, 16))
+
+    # Processing Notes
+    story.append(Paragraph("PROCESSING NOTES", header_style))
+    story.append(HRFlowable(width="100%", thickness=1, color=colors.black))
+    story.append(Spacer(1, 8))
+
+    processing_notes = f"""
+    This preliminary assessment was generated using automated analysis tools to expedite initial claim processing.
+    Photographic evidence and incident descriptions were processed using artificial intelligence to provide rapid
+    initial assessment. {"Given the reported injuries, this claim has been flagged for expedited human review." if injuries_medical.get('anyone_injured', 'no').lower() == 'yes' else "Standard processing timeline applies per company guidelines."}
+    Final claim determination requires licensed adjuster review and approval.
+    """
+
+    story.append(Paragraph(processing_notes, body_style))
+    story.append(Spacer(1, 20))
+
+    # Footer Information
+    footer_data = [
+        [
+            create_table_cell("Report Generated By:", True),
+            create_table_cell("AI Claims Processing System"),
+        ],
+        [
+            create_table_cell("Processing Timestamp:", True),
+            create_table_cell(timestamp.strftime("%I:%M %p EST")),
+        ],
+        [
+            create_table_cell("Human Review Status:", True),
+            create_table_cell("Required - Pending Assignment"),
+        ],
+        [
+            create_table_cell("System Confidence Level:", True),
+            create_table_cell("High - Standard Processing Recommended"),
+        ],
+    ]
+
+    footer_table = Table(footer_data, colWidths=[2 * inch, 4.7 * inch])
+    footer_table.setStyle(create_professional_table_style())
+    story.append(footer_table)
+    story.append(Spacer(1, 12))
+
+    # Evidence/Appendix Section
+    story.append(Paragraph("APPENDIX - EVIDENCE DOCUMENTATION", header_style))
+    story.append(HRFlowable(width="100%", thickness=1, color=colors.black))
+    story.append(Spacer(1, 8))
+
+    # Raw transcript section
+    story.append(Paragraph("Raw Incident Description Transcript", subheader_style))
+
+    # Get the original raw description
+    raw_description = incident_description.get(
+        "what_happened", "No transcript available"
+    )
+
+    # Create a formatted transcript
+    transcript_text = f"""
+    <b>Original Incident Account (Unedited):</b><br/><br/>
+    "{raw_description}"
+    <br/><br/>
+    <i>Note: This is the unedited transcript of the policyholder's account of the incident as provided during initial report.</i>
+    """
+
+    story.append(Paragraph(transcript_text, body_style))
+    story.append(Spacer(1, 12))
+
+    # Damage photo section
+    story.append(Paragraph("Photographic Evidence", subheader_style))
+
+    if image_path:
+        try:
+            # Add the damage photo
+            img = Image(image_path, width=4 * inch, height=3 * inch)
+            story.append(img)
+            story.append(Spacer(1, 8))
+
+            photo_caption = Paragraph(
+                "<i>Figure 1: Vehicle damage photograph submitted with initial claim report. "
+                "Image analyzed using automated damage assessment tools.</i>",
+                ParagraphStyle(
+                    "PhotoCaption",
+                    parent=styles["Normal"],
+                    fontSize=9,
+                    textColor=colors.black,
+                    alignment=TA_CENTER,
+                    spaceAfter=8,
+                ),
+            )
+            story.append(photo_caption)
+        except Exception as e:
+            # If image can't be loaded, show placeholder text
+            print(f"Error loading damage photo: {e}")
+            story.append(
+                Paragraph(
+                    "Damage photograph submitted with claim (unable to display in this report format).",
+                    body_style,
+                )
+            )
+    else:
+        story.append(
+            Paragraph(
+                "Damage photograph submitted with claim and analyzed using automated assessment tools. "
+                "Original digital file maintained in claim documentation system.",
+                body_style,
+            )
+        )
+
+    story.append(Spacer(1, 12))
+
+    # Raw damage analysis
+    story.append(Paragraph("Technical Damage Analysis Output", subheader_style))
+
+    # Get the raw damage description
+    raw_damage_analysis = damage_analysis.get(
+        "description", "No technical analysis available"
+    )
+
+    technical_analysis_text = f"""
+    <b>Automated Damage Assessment Output (Technical):</b><br/><br/>
+    {_format_technical_description(raw_damage_analysis)}
+    <br/><br/>
+    <i>Note: This is the raw output from the automated damage assessment system.
+    The summary version appears in the main report above.</i>
+    """
+
+    story.append(Paragraph(technical_analysis_text, body_style))
+    story.append(Spacer(1, 16))
+
+    # Legal Disclaimer
+    disclaimer = Paragraph(
+        "<i>This automated preliminary assessment is provided for initial processing purposes only. "
+        "All claim determinations are subject to policy terms, conditions, and coverage verification. "
+        "Final settlement authority rests with assigned licensed adjuster pending completion of full investigation.</i>",
+        ParagraphStyle(
+            "Disclaimer",
+            parent=styles["Normal"],
+            fontSize=8,
+            textColor=colors.black,
+            alignment=TA_CENTER,
+            leftIndent=0.5 * inch,
+            rightIndent=0.5 * inch,
+        ),
+    )
+    story.append(disclaimer)
+
+    # Build PDF
+    doc.build(story)
+
+    # Get the PDF bytes
+    pdf_bytes = buffer.getvalue()
+    buffer.close()
+
+    return pdf_bytes
+
+
+def _format_damage_description(description: str) -> str:
+    """Clean and format damage description for professional presentation"""
+    if not description or len(description) < 50:
+        return description
+
+    # Remove redundant technical formatting
+    cleaned = description.replace("###", "").replace("**", "").replace("- **", "• ")
+
+    # Extract key summary if description is very long
+    if len(cleaned) > 300:
+        lines = cleaned.split("\n")
+        summary_lines = [
+            line.strip()
+            for line in lines
+            if line.strip()
+            and not line.strip().startswith("##")
+            and len(line.strip()) > 10
+        ][:3]
+        return " ".join(summary_lines[:2]) + "..."
+
+    return cleaned[:250] + "..." if len(cleaned) > 250 else cleaned
+
+
+def _format_fault_determination(fault: str) -> str:
+    """Format fault determination for professional presentation"""
+    fault_map = {
+        "other_driver": "Other Party - Preliminary",
+        "policyholder": "Policyholder - Preliminary",
+        "unclear": "Undetermined - Investigation Required",
+        "both": "Comparative Negligence - Investigation Required",
+    }
+    return fault_map.get(fault.lower(), "Under Investigation")
+
+
+def _get_priority_level(damage_severity: str, injuries_reported: str) -> str:
+    """Determine claim priority using professional terminology"""
+    if injuries_reported.lower() == "yes":
+        return "HIGH PRIORITY - Personal Injury Claim"
+    elif damage_severity.lower() == "major":
+        return "ELEVATED PRIORITY - Significant Property Damage"
+    elif damage_severity.lower() == "moderate":
+        return "STANDARD PRIORITY - Moderate Property Damage"
+    else:
+        return "ROUTINE PRIORITY - Minor Property Damage"
+
+
+def _estimate_cost_range(damage_severity: str) -> str:
+    """Estimate repair costs based on damage severity"""
+    severity_costs = {
+        "minor": "$750 - $2,500",
+        "moderate": "$2,500 - $7,500",
+        "major": "$7,500 - $18,000",
+        "severe": "$18,000 - $35,000",
+    }
+    return severity_costs.get(damage_severity.lower(), "$2,000 - $5,000")
+
+
+def _get_recommendation(damage_severity: str, injuries_reported: str) -> str:
+    """Generate professional recommendation"""
+    if injuries_reported.lower() == "yes":
+        return "IMMEDIATE ACTION REQUIRED: Assign specialist adjuster for personal injury claim within 24 hours"
+    elif damage_severity.lower() in ["major", "severe"]:
+        return "PRIORITY PROCESSING: Schedule comprehensive inspection within 48 hours"
+    else:
+        return "STANDARD PROCESSING: Assign adjuster within normal service level agreement timeframe"
+
+
+def _format_medical_costs(injuries_medical: Dict[str, Any]) -> str:
+    """Format medical cost estimate professionally"""
+    if injuries_medical.get("anyone_injured", "no").lower() == "yes":
+        severity = injuries_medical.get("injury_severity", "minor").lower()
+        if severity == "severe":
+            return "$15,000 - $75,000 (Preliminary)"
+        elif severity == "moderate":
+            return "$3,000 - $15,000 (Preliminary)"
+        else:
+            return "$500 - $3,000 (Preliminary)"
+    return "No medical expenses anticipated"
+
+
+def _calculate_total_estimate(
+    repair_cost: str, injuries_medical: Dict[str, Any]
+) -> str:
+    """Calculate total claim estimate professionally"""
+    if injuries_medical.get("anyone_injured", "no").lower() == "yes":
+        return f"{repair_cost} plus medical expenses (subject to investigation)"
+    return repair_cost
+
+
+def _generate_next_steps_professional(
+    damage_severity: str,
+    injuries_medical: Dict[str, Any],
+    fault_assessment: Dict[str, Any],
+) -> str:
+    """Generate professional action items"""
+
+    steps = []
+
+    # Always required steps
+    steps.append(
+        "1. <b>Adjuster Assignment:</b> Assign licensed adjuster for detailed investigation and coverage verification."
+    )
+    steps.append(
+        "2. <b>Vehicle Inspection:</b> Schedule comprehensive damage assessment with approved appraiser."
+    )
+    steps.append(
+        "3. <b>Third Party Contact:</b> Attempt contact with other party's insurance carrier for coordination."
+    )
+
+    # Conditional steps based on circumstances
+    step_num = 4
+
+    if injuries_medical.get("anyone_injured", "no").lower() == "yes":
+        steps.append(
+            f"{step_num}. <b>Medical Documentation:</b> Request medical records and treatment documentation from healthcare providers."
+        )
+        step_num += 1
+        steps.append(
+            f"{step_num}. <b>Injury Specialist:</b> Engage personal injury specialist for claim evaluation."
+        )
+        step_num += 1
+
+    if fault_assessment.get("who_at_fault", "unclear").lower() == "unclear":
+        steps.append(
+            f"{step_num}. <b>Police Report:</b> Obtain official police report if available for liability determination."
+        )
+        step_num += 1
+
+    if damage_severity.lower() in ["major", "severe"]:
+        steps.append(
+            f"{step_num}. <b>Multiple Estimates:</b> Secure at least two independent repair estimates for cost validation."
+        )
+        step_num += 1
+
+    # Final step
+    steps.append(
+        f"{step_num}. <b>Customer Communication:</b> Contact policyholder within 24 hours to confirm receipt and outline next steps."
+    )
+
+    return "<br/>".join(steps)
+
+
+def _convert_relative_date(date_str: str) -> str:
+    """Convert relative dates like 'today', 'yesterday' to actual dates"""
+    if not date_str or date_str.lower() in ["not specified", "unknown", ""]:
+        return "Not specified in report"
+
+    # Get current date
+    today = datetime.now()
+
+    # Dictionary of relative date conversions
+    relative_dates = {
+        "today": today.strftime("%B %d, %Y"),
+        "yesterday": (today - timedelta(days=1)).strftime("%B %d, %Y"),
+        "yesterday night": (today - timedelta(days=1)).strftime("%B %d, %Y (evening)"),
+        "yesterday evening": (today - timedelta(days=1)).strftime(
+            "%B %d, %Y (evening)"
+        ),
+        "last night": (today - timedelta(days=1)).strftime("%B %d, %Y (night)"),
+        "this morning": today.strftime("%B %d, %Y (morning)"),
+        "this afternoon": today.strftime("%B %d, %Y (afternoon)"),
+        "this evening": today.strftime("%B %d, %Y (evening)"),
+        "2 days ago": (today - timedelta(days=2)).strftime("%B %d, %Y"),
+        "3 days ago": (today - timedelta(days=3)).strftime("%B %d, %Y"),
+        "a few days ago": (today - timedelta(days=2)).strftime(
+            "%B %d, %Y (approximate)"
+        ),
+        "earlier today": today.strftime("%B %d, %Y (earlier)"),
+        "day before yesterday": (today - timedelta(days=2)).strftime("%B %d, %Y"),
+    }
+
+    # Check for exact matches first
+    date_lower = date_str.lower().strip()
+    if date_lower in relative_dates:
+        return relative_dates[date_lower]
+
+    # Check for partial matches
+    for relative_term, actual_date in relative_dates.items():
+        if relative_term in date_lower:
+            return actual_date
+
+    # If no relative date found, return original
+    return date_str
+
+
+def _format_technical_description(description: str) -> str:
+    """Format technical damage description for appendix"""
+    if not description:
+        return "No technical analysis data available"
+
+    # Clean up technical formatting but preserve more detail than main report
+    cleaned = description.replace("###", "").replace("**", "")
+
+    # If it's very long, keep more content than the main report version
+    if len(cleaned) > 800:
+        # Split into sections and keep first few sections
+        sections = cleaned.split("\n\n")
+        important_sections = [
+            s.strip() for s in sections if s.strip() and len(s.strip()) > 20
+        ]
+        return (
+            "\n\n".join(important_sections[:4])
+            + "\n\n[Additional technical details available in system logs]"
+        )
+
+    return cleaned

src/modules/image_analysis.py

@@ -0,0 +1,79 @@
+import json
+from typing import Literal
+
+from fireworks.llm import LLM
+from src.configs.load_config import PROMPT_LIBRARY, APP_STEPS_CONFIGS
+from pydantic import BaseModel
+import io
+import base64
+
+
+class IncidentAnalysis(BaseModel):
+    description: str
+    location: Literal["front-left", "front-right", "back-left", "back-right"]
+    severity: Literal["minor", "moderate", "major"]
+    license_plate: str
+
+
+def get_llm(api_key: str, model: str, temperature: float) -> LLM:
+    return LLM(
+        model=model,
+        temperature=temperature,
+        deployment_type="serverless",
+        api_key=api_key,
+    )
+
+
+def pil_to_base64_dict(pil_image):
+    """Convert PIL image to the format expected by analyze_damage_image"""
+    if pil_image is None:
+        return None
+
+    buffered = io.BytesIO()
+    if pil_image.mode != "RGB":
+        pil_image = pil_image.convert("RGB")
+
+    pil_image.save(buffered, format="JPEG")
+    img_base64 = base64.b64encode(buffered.getvalue()).decode("utf-8")
+
+    return {"image": pil_image, "path": "uploaded_image.jpg", "base64": img_base64}
+
+
+def analyze_damage_image(image, api_key: str, prompt: str = "advanced"):
+    """
+    Analyze the damage in an image using the Fireworks VLM model.
+    """
+    assert (
+        prompt in PROMPT_LIBRARY["vision_damage_analysis"].keys()
+    ), f"Invalid prompt choose from {list(PROMPT_LIBRARY['vision_damage_analysis'].keys())}"
+
+    prompt_text = PROMPT_LIBRARY["vision_damage_analysis"][prompt]
+
+    llm = get_llm(
+        api_key=api_key,
+        model=APP_STEPS_CONFIGS.analyze_damage_image.model,
+        temperature=APP_STEPS_CONFIGS.analyze_damage_image.temperature,
+    )
+    response = llm.chat.completions.create(
+        messages=[
+            {
+                "role": "user",
+                "content": [
+                    {
+                        "type": "image_url",
+                        "image_url": {
+                            "url": f"data:image/jpeg;base64,{image['base64']}"
+                        },
+                    },
+                    {"type": "text", "text": prompt_text},
+                ],
+            }
+        ],
+        response_format={
+            "type": "json_object",
+            "schema": IncidentAnalysis.model_json_schema(),
+        },
+    )
+
+    result = json.loads(response.choices[0].message.content)
+    return result

src/modules/incident_processing.py

@@ -0,0 +1,337 @@
+from modules.image_analysis import get_llm
+from src.configs.load_config import PROMPT_LIBRARY, APP_STEPS_CONFIGS
+from pydantic import BaseModel
+from typing import Optional, Literal, List, Dict, Any
+import json
+import random
+import time
+
+
+class DateLocation(BaseModel):
+    date: Optional[str] = None
+    time: Optional[str] = None
+    location: Optional[str] = None
+
+
+class PartiesInvolved(BaseModel):
+    other_driver_name: Optional[str] = None
+    other_driver_vehicle: Optional[str] = None
+    witnesses: Optional[str] = None
+
+
+class FaultAssessment(BaseModel):
+    who_at_fault: Literal["me", "other_driver", "unclear"]
+    reason: str
+
+
+class IncidentDescription(BaseModel):
+    what_happened: str
+    damage_severity: Literal["minor", "moderate", "severe", "unclear"]
+
+
+class InjuriesMedical(BaseModel):
+    anyone_injured: Literal["yes", "no", "unknown"]
+    injury_details: Optional[str] = None
+    medical_attention: Optional[str] = None
+    injury_severity: Optional[Literal["none", "minor", "moderate", "severe", "unclear"]]
+
+
+class FunctionCallResult(BaseModel):
+    function_name: str
+    result: Dict[str, Any]
+    status: Literal["success", "error"]
+    message: str
+
+
+class IncidentAnalysis(BaseModel):
+    date_location: DateLocation
+    parties_involved: PartiesInvolved
+    fault_assessment: FaultAssessment
+    incident_description: IncidentDescription
+    injuries_medical: InjuriesMedical
+    function_calls_made: List[FunctionCallResult] = []
+    external_data_retrieved: Dict[str, Any] = {}
+
+
+def mock_weather_lookup(date: str, location: str) -> Dict[str, Any]:
+    """Mock function to look up weather conditions for a specific date and location"""
+    time.sleep(0.5)  # Simulate API call delay
+
+    weather_conditions = [
+        "Clear",
+        "Rainy",
+        "Foggy",
+        "Snowy",
+        "Overcast",
+        "Partly Cloudy",
+    ]
+    temperatures = range(20, 85)
+
+    return {
+        "date": date,
+        "location": location,
+        "temperature": f"{random.choice(temperatures)}°F",
+        "conditions": random.choice(weather_conditions),
+        "visibility": random.choice(["Good", "Poor", "Fair"]),
+        "precipitation": random.choice(["None", "Light Rain", "Heavy Rain", "Snow"]),
+        "wind_speed": f"{random.randint(0, 25)} mph",
+    }
+
+
+def mock_driver_record_check(
+    driver_name: str, license_plate: str = None
+) -> Dict[str, Any]:
+    """Mock function to check driver record and vehicle registration"""
+    risk_levels = ["Low", "Medium", "High"]
+
+    return {
+        "driver_found": True,
+        "license_status": random.choice(["Valid", "Suspended", "Expired"]),
+        "insurance_status": random.choice(["Active", "Lapsed", "Unknown"]),
+        "previous_claims": random.randint(0, 5),
+        "violations_last_3_years": random.randint(0, 3),
+        "risk_assessment": random.choice(risk_levels),
+        "vehicle_registration": "Valid" if license_plate else "Not checked",
+    }
+
+
+AVAILABLE_FUNCTIONS = {
+    "weather_lookup": {
+        "name": "weather_lookup",
+        "description": "Look up weather conditions for a specific date and location to understand incident context",
+        "parameters": {
+            "type": "object",
+            "properties": {
+                "date": {"type": "string", "description": "Date of the incident"},
+                "location": {
+                    "type": "string",
+                    "description": "Location where incident occurred",
+                },
+            },
+            "required": ["date", "location"],
+        },
+        "function": mock_weather_lookup,
+    },
+    "driver_record_check": {
+        "name": "driver_record_check",
+        "description": "Check driving record and insurance status of other party involved",
+        "parameters": {
+            "type": "object",
+            "properties": {
+                "driver_name": {
+                    "type": "string",
+                    "description": "Name of the other driver",
+                },
+                "license_plate": {
+                    "type": "string",
+                    "description": "License plate number if available",
+                },
+            },
+            "required": ["driver_name"],
+        },
+        "function": mock_driver_record_check,
+    },
+}
+
+
+def execute_function_call(
+    function_name: str, parameters: Dict[str, Any]
+) -> FunctionCallResult:
+    """Execute a function call and return the result"""
+    try:
+        if function_name not in AVAILABLE_FUNCTIONS:
+            return FunctionCallResult(
+                function_name=function_name,
+                result={},
+                status="error",
+                message=f"Function {function_name} not found",
+            )
+
+        function_impl = AVAILABLE_FUNCTIONS[function_name]["function"]
+        result = function_impl(**parameters)
+
+        return FunctionCallResult(
+            function_name=function_name,
+            result=result,
+            status="success",
+            message=f"Successfully executed {function_name}",
+        )
+
+    except Exception as e:
+        return FunctionCallResult(
+            function_name=function_name,
+            result={},
+            status="error",
+            message=f"Error executing {function_name}: {str(e)}",
+        )
+
+
+def process_transcript_description(transcript: str, api_key: str):
+    """
+    Analyze the provided transcript and extract structured information for insurance claim processing.
+    Now includes function calling capabilities to gather additional context.
+
+    Args:
+        transcript: transcript string to process
+        api_key: api key to use
+
+    Returns:
+        incident_description: incident description with function call results
+    """
+    print("Starting incident analysis with function calling...")
+
+    llm = get_llm(
+        api_key=api_key,
+        model="accounts/fireworks/models/llama4-scout-instruct-basic",
+        temperature=APP_STEPS_CONFIGS.incident_response.temperature,
+    )
+
+    # Enhanced prompt that includes function calling
+    prompt_text = f"""
+    {PROMPT_LIBRARY["incident_processing"]["advanced"]}
+
+    **ADDITIONAL CAPABILITIES:**
+    You now have access to external functions that can help gather additional context for the claim.
+    Based on the transcript, you should consider calling these functions if the information would be helpful:
+
+    Available Functions:
+    {json.dumps([{k: {kk: vv for kk, vv in v.items() if kk != 'function'}} for k, v in AVAILABLE_FUNCTIONS.items()], indent=2)}
+
+    **IMPORTANT:**
+    1. First, extract all the basic incident information from the transcript
+    2. Then determine which functions (if any) would provide helpful additional context
+    3. For each function you want to call, include a "function_calls" section in your response
+    4. I will execute the functions and provide you with the results
+    5. You will then incorporate those results into your final analysis
+
+    **TRANSCRIPT TO ANALYZE:**
+    <transcript>
+    {transcript}
+    </transcript>
+
+    Please provide your initial analysis and specify any function calls you'd like to make.
+    """
+
+    # First pass - get initial analysis and any function calls
+    response = llm.chat.completions.create(
+        messages=[
+            {
+                "role": "system",
+                "content": "You are an expert automotive claims adjuster analyzing vehicle damage with access to external data sources.",
+            },
+            {"role": "user", "content": prompt_text},
+        ],
+        response_format={
+            "type": "json_object",
+            "schema": IncidentAnalysis.model_json_schema(),
+        },
+        temperature=APP_STEPS_CONFIGS.incident_response.temperature,
+    )
+
+    # Parse initial response
+    incident_data = IncidentAnalysis.model_validate_json(
+        response.choices[0].message.content
+    )
+
+    print("Initial analysis complete. Checking for function calls...")
+
+    function_calls_to_make = []
+    external_data = {}
+
+    # Making it more robust by checking for necessary inputs
+    if (
+        incident_data.date_location.date
+        and incident_data.date_location.location
+        and incident_data.date_location.date.lower()
+        not in ["not specified", "unknown", ""]
+    ):
+        function_calls_to_make.append(
+            {
+                "name": "weather_lookup",
+                "params": {
+                    "date": incident_data.date_location.date,
+                    "location": incident_data.date_location.location,
+                },
+            }
+        )
+
+    if (
+        incident_data.parties_involved.other_driver_name
+        and incident_data.parties_involved.other_driver_name.lower()
+        not in ["information not provided", "not specified", ""]
+    ):
+        function_calls_to_make.append(
+            {
+                "name": "driver_record_check",
+                "params": {
+                    "driver_name": incident_data.parties_involved.other_driver_name,
+                    "license_plate": incident_data.parties_involved.other_driver_vehicle,
+                },
+            }
+        )
+
+    # Execute tool calls
+    function_results = []
+    if function_calls_to_make:
+        print(f"Executing {len(function_calls_to_make)} function calls...")
+
+        for call in function_calls_to_make:
+            print(f"  - Calling {call['name']}...")
+            result = execute_function_call(call["name"], call["params"])
+            function_results.append(result)
+
+            if result.status == "success":
+                external_data[call["name"]] = result.result
+
+    incident_data.function_calls_made = function_results
+    incident_data.external_data_retrieved = external_data
+
+    # Update analysis with external data pulled from tools
+    if function_results:
+        print("Incorporating external data into final analysis...")
+
+        enhancement_prompt = f"""
+        Based on the initial incident analysis and the additional data retrieved from external sources,
+        please provide an enhanced analysis that incorporates this new information.
+
+        **INITIAL ANALYSIS:**
+        {incident_data.model_dump_json(indent=2)}
+
+        **EXTERNAL DATA RETRIEVED:**
+        {json.dumps(external_data, indent=2)}
+
+        Please update your analysis to incorporate insights from this external data where relevant.
+        For example:
+        - Weather conditions might affect fault assessment
+        - Other traffic incidents might provide context
+        - Driver record might influence risk assessment
+        - Medical facility info might be relevant for injury cases
+
+        Provide the complete updated analysis.
+        """
+
+        enhanced_response = llm.chat.completions.create(
+            messages=[
+                {
+                    "role": "system",
+                    "content": "You are an expert automotive claims adjuster incorporating external data into your analysis.",
+                },
+                {"role": "user", "content": enhancement_prompt},
+            ],
+            response_format={
+                "type": "json_object",
+                "schema": IncidentAnalysis.model_json_schema(),
+            },
+            temperature=APP_STEPS_CONFIGS.incident_response.temperature,
+        )
+
+        enhanced_data = IncidentAnalysis.model_validate_json(
+            enhanced_response.choices[0].message.content
+        )
+
+        enhanced_data.function_calls_made = function_results
+        enhanced_data.external_data_retrieved = external_data
+        incident_data = enhanced_data
+
+    print("Finished incident analysis with function calling.")
+    return incident_data

src/modules/transcription.py

@@ -0,0 +1,112 @@
+import json
+import threading
+import time
+import urllib.parse
+from typing import Optional, Callable
+import websocket
+
+
+class FireworksTranscription:
+    """Fireworks AI transcription for Gradio integration."""
+
+    WEBSOCKET_URL = "ws://audio-streaming.us-virginia-1.direct.fireworks.ai/v1/audio/transcriptions/streaming"
+
+    def __init__(self, api_key: str):
+        self.api_key = api_key
+        self.websocket_client = None
+        self.is_connected = False
+        self.segments = {}
+        self.lock = threading.Lock()
+        self.transcription_callback: Optional[Callable[[str], None]] = None
+
+    def set_callback(self, callback: Callable[[str], None]):
+        """Set callback to receive live transcription updates."""
+        self.transcription_callback = callback
+
+    def _connect(self) -> bool:
+        """Connect to Fireworks WebSocket."""
+        try:
+            params = urllib.parse.urlencode({"language": "en"})
+            full_url = f"{self.WEBSOCKET_URL}?{params}"
+
+            self.websocket_client = websocket.WebSocketApp(
+                full_url,
+                header={"Authorization": self.api_key},
+                on_open=self._on_open,
+                on_message=self._on_message,
+                on_error=self._on_error,
+            )
+
+            # Start WebSocket in background thread
+            ws_thread = threading.Thread(
+                target=self.websocket_client.run_forever, daemon=True
+            )
+            ws_thread.start()
+
+            # Wait for connection (max 5 seconds)
+            timeout = 5
+            start_time = time.time()
+            while not self.is_connected and (time.time() - start_time) < timeout:
+                time.sleep(0.1)
+
+            return self.is_connected
+
+        except Exception as e:
+            print(f"Connection error: {e}")
+            return False
+
+    def _send_audio_chunk(self, chunk: bytes) -> bool:
+        """Send audio chunk to Fireworks."""
+        if not self.is_connected or not self.websocket_client:
+            return False
+
+        try:
+            self.websocket_client.send(chunk, opcode=websocket.ABNF.OPCODE_BINARY)
+            return True
+        except Exception as e:
+            print(f"Error sending audio chunk: {e}")
+            return False
+
+    def _on_open(self, ws):
+        """Handle WebSocket connection opening."""
+        self.is_connected = True
+        print("✅ Connected to Fireworks transcription service")
+
+    def _on_message(self, ws, message):
+        """Handle transcription messages from Fireworks."""
+        try:
+            data = json.loads(message)
+
+            # Process segments
+            if "segments" in data:
+                with self.lock:
+                    # Update segments
+                    for segment in data["segments"]:
+                        segment_id = segment["id"]
+                        text = segment["text"]
+                        self.segments[segment_id] = text
+
+                    # Build complete current transcription
+                    complete_text = self._build_complete_text()
+
+                    # Call callback with live update
+                    if self.transcription_callback and complete_text.strip():
+                        self.transcription_callback(complete_text)
+
+        except json.JSONDecodeError as e:
+            print(f"Failed to parse message: {e}")
+        except Exception as e:
+            print(f"Error processing message: {e}")
+
+    @staticmethod
+    def _on_error(ws, error):
+        """Handle WebSocket errors."""
+        print(f"WebSocket error: {error}")
+
+    def _build_complete_text(self) -> str:
+        """Build complete text from all segments."""
+        if not self.segments:
+            return ""
+
+        sorted_segments = sorted(self.segments.items(), key=lambda x: int(x[0]))
+        return " ".join(segment[1] for segment in sorted_segments if segment[1].strip())