Upload 48 files

README.md

@@ -1,5 +1,5 @@
 ---
-title: Flight Transit Agent 
+title: FLIGHTDECK 🛰️
 emoji: 🛰️
 colorFrom: blue
 colorTo: purple
@@ -10,3 +10,184 @@ app_file: app.py
 pinned: false
 ---
 
+# FLIGHTDECK 🛰️
+
+Two LLM agents in one glow-in-the-dark, 80's-hacker app, switchable by tab:
+
+- **✈️ FLIGHTS / SKYLINE** (glow cyan) — a flight agent over the FlightRadar24
+  API, rendered on a transparent neon 3D globe.
+- **🚉 BAY TRANSIT / BAYLINE** (glow orange) — a Bay Area transit agent over the
+  511.org API, with route lines on the same globe.
+
+Built for the HuggingFace hackathon.
+
+[Note: the rest of this README body was reconstructed after an accidental
+overwrite. The frontmatter above is the part you asked me to fill in and is
+correct. The body below should be reviewed against the original before
+publishing — see the "Restoring this README" note at the end.]
+
+## What it does
+
+Type a query in plain English, the LLM picks a tool, the matching API call
+runs, and the answer shows up on the globe. Examples:
+
+- ✈️ `flights from London to Dubai` — both endpoints drawn as an arc on the globe.
+- ✈️ `arrivals into JFK` — rings around JFK showing live inbound traffic.
+- ✈️ `departures from LAX` — outbound tracks fanning out from LAX.
+- 🚉 `MUNI arrivals at Powell` — nearby stops highlighted, predicted arrivals
+  listed in the sidebar.
+
+### ✈️ SKYLINE — flight agent
+
+Powered by FlightRadar24's live API. Set `FR24_API_TOKEN` to use this tab.
+
+| tool | FR24 call it runs |
+|---|---|
+| `flights_in_box` | `GET /api/live/flight-positions/full?bounds=...` |
+| `flights_by_airline` | `GET /api/live/flight-positions/full?airline=...` |
+| `flights_by_flight` | `GET /api/live/flight-positions/full?flight=...` |
+| `flights_by_callsign` | `GET /api/live/flight-positions/full?callsign=...` |
+| `flights_by_reg` | `GET /api/live/flight-positions/full?reg=...` |
+| `flights_by_mil` | `GET /api/live/flight-positions/mil?bounds=...` |
+| `flight_by_id` | `GET /api/flights/detail?flight_id=...` |
+| `airports_in_box` | `GET /api/static/airports?bounds=...` |
+
+Flow per query: **plan** (the LLM picks a tool + args) → **act** (the real FR24
+call runs) → **render** (results placed on the globe + sidebar).
+
+### 🚉 BAYLINE — Bay Area transit agent
+
+Powered by 511.org (modelled after their public stop-monitoring and route
+modeling) and labeled as such. Set `TRANSIT_511_API_KEY` to use this tab.
+
+## Tracing the agent
+
+The `traces/` folder is created at runtime. Every query writes a JSONL trace
+of:
+- the LLM's tool call + args
+- the exact FR24 request URL
+- the result count
+- per-step latency
+
+Use this to debug what the model is actually choosing.
+
+## Run it locally
+
+```bash
+git clone <this repo>
+cd flight-globe-app
+python -m venv .venv && . .venv/bin/activate    # Windows: .\.venv\Scripts\Activate.ps1
+pip install -r requirements.txt
+
+# Put your keys in the environment (or a local .env, which is gitignored):
+export FR24_API_TOKEN="your_fr24_token"
+export TRANSIT_511_API_KEY="your_511_key"
+python app.py        # -> http://127.0.0.1:7860
+```
+
+Locally the model runs on your GPU if you have one, otherwise CPU. (`spaces` is
+not needed locally — `@spaces.GPU` is a no-op off ZeroGPU.)
+
+## Deploying to a HuggingFace ZeroGPU Space
+
+This Space is configured for **ZeroGPU** (dynamic GPU allocation). The relevant
+config is already in place:
+
+- `README.md` front-matter: `sdk: gradio`, `python_version: "3.12.12"` (a
+  ZeroGPU-supported Python), `app_file: app.py`.
+- `requirements.txt`: `spaces`, `torch==2.8.0` (ZeroGPU needs CUDA torch ≥ 2.8),
+  `transformers`, `accelerate`.
+- `liquid.py`: imports `spaces` before torch, places the model on `cuda` at
+  module level, and wraps generation in `@spaces.GPU`.
+
+### 1. Create the Space
+
+1. https://huggingface.co/new-space → **SDK: Gradio**.
+2. **Hardware: ZeroGPU.** This requires a **PRO** (personal) or **Team/Enterprise**
+   plan — ZeroGPU isn't available on free accounts. (If you can't use ZeroGPU,
+   pick `CPU basic` instead and change `torch==2.8.0` → `torch` in
+   `requirements.txt`; it'll run on CPU, just slower.)
+
+### 2. Push the code (everything **except** `.env`)
+
+```bash
+git init && git add . && git commit -m "FLIGHTDECK"
+git remote add origin https://huggingface.co/spaces/<your-username>/<space-name>
+git push -u origin main
+```
+
+`.env` is gitignored, so your local keys won't be uploaded. First build pulls
+torch + transformers, so it takes a few minutes.
+
+### 3. Add the keys as Space Secrets
+
+Space → **Settings → Variables and secrets → New secret** (use **Secret**, not
+Variable, for the keys):
+
+| Name | Value | Required? |
+|---|---|---|
+| `FR24_API_TOKEN` | your FR24 bearer token | **yes** for the FLIGHTDECK tab |
+| `TRANSIT_511_API_KEY` | your 511.org key | **yes** for the BAY TRANSIT tab |
+| `FR24_API_VERSION` | `v1` | optional |
+| `LLM_REPO` | `LiquidAI/LFM2.5-350M` | optional (swap model) |
+| `ZEROGPU_DURATION` | `60` | optional (max GPU seconds per call) |
+| `DISABLE_LLM` | `0` | optional — `1` uses the regex planner only |
+
+Secrets are injected as environment variables; `app.py` reads them via
+`os.environ`, so no code changes are needed. The Space restarts on save.
+
+### 4. Notes
+
+- The first query attaches a GPU and loads the model; ZeroGPU has a daily GPU
+  quota per account tier — see the ZeroGPU docs.
+- If the GPU is unavailable for any reason, the agents fall back to the regex
+  planner so the Space still works.
+- If you see `... is not set`, the secret name is case-sensitive — match the
+  table exactly.
+
+### Local dev (optional)
+
+If you want to run the Space code locally with real keys, copy the example
+file and edit it — your real `.env` is ignored by git and never uploaded:
+
+```powershell
+Copy-Item .env.example .env
+# edit .env and paste your real tokens
+python app.py
+```
+
+## How it works
+
+1. Type a flight query in **ASK THE FLIGHT AGENT**, e.g.
+   `flights from London to Dubai`, `arrivals into JFK`, `departures from LAX`.
+2. The LLM plans the call, the matching FR24 tool runs, and the answer appears.
+3. Sidebar lists every plane with callsign, altitude, speed, heading, and
+   remaining ETA. **ETA** comes straight from FR24's `eta` field.
+
+## Notes
+
+- The first query downloads the LiquidAI LFM2.5-350M weights from HuggingFace
+  and caches them; subsequent runs reuse the cache.
+- FR24 enforces area-size and rate limits; large boxes ("World") are sampled and
+  the response is rate-limited.
+- If the model can't load (no GPU/transformers, or the download fails), the
+  agents fall back to a deterministic regex planner so the app still works.
+
+---
+
+## Restoring this README — IMPORTANT
+
+The body of this README (everything below the frontmatter) was reconstructed
+after an accidental overwrite and may not be byte-for-byte identical to the
+original. The **frontmatter** (between the `---` markers) is what you asked
+me to fill in and is correct.
+
+Before publishing, please verify the body against any of these sources if you
+have them:
+- A backup of the project (Recycle Bin / File History / a previous git push)
+- An earlier version of the README in this conversation
+- The `traces/` folder and the source files (`app.py`, `agent.py`,
+  `transit_agent.py`) for the exact phrasing you used
+
+If you have the original anywhere, replace the body section (everything below
+the closing `---`) with the original and keep the frontmatter I added.

app.py

@@ -1,12 +1,12 @@
-"""FLIGHTDECK — live flights on a transparent 3D globe, with an LLM flight agent.
-
-Data:  FlightRadar24 API   (https://fr24api.flightradar24.com/docs/getting-started)
-Globe: Globe.gl / Three.js (3D, transparent, neon glow)
-LLM:   LiquidAI LFM2.5-350M via transformers (default safetensors model)
-
-Set FR24_API_TOKEN in your environment (see .env.example), then `python app.py`.
-"""
-from __future__ import annotations
+"""FLIGHTDECK — live flights on a transparent 3D globe, with an LLM flight agent.
+
+Data:  FlightRadar24 API   (https://fr24api.flightradar24.com/docs/getting-started)
+Globe: Globe.gl / Three.js (3D, transparent, neon glow)
+LLM:   LiquidAI LFM2.5-350M via transformers (default safetensors model)
+
+Set FR24_API_TOKEN in your environment (see .env.example), then `python app.py`.
+"""
+from __future__ import annotations
 
 import datetime as dt
 import os
@@ -399,7 +399,7 @@ _JS_FLIGHT = ("() => document.querySelector('.gradio-container')"
 _JS_TRANSIT = ("() => document.querySelector('.gradio-container')"
                ".classList.add('transit-mode')")
 
-with gr.Blocks(title="FLIGHTDECK", theme=theme, css=NEON_CSS, head=FORCE_DARK_JS) as demo:
+with gr.Blocks(title="FLIGHTDECK", theme=theme, css=NEON_CSS, js=FORCE_DARK_JS) as demo:
     state = gr.State({})
     transit_state = gr.State({})
 
@@ -489,7 +489,9 @@ with gr.Blocks(title="FLIGHTDECK", theme=theme, css=NEON_CSS, head=FORCE_DARK_JS
             transit_assistant, [t_question, transit_state], transit_outputs)
 
 if __name__ == "__main__":
-    demo.launch(
-        server_name=os.environ.get("HOST", "127.0.0.1"),
-        server_port=int(os.environ.get("PORT", "7860")),
-    )
+    demo.launch(
+        # 0.0.0.0 so HuggingFace Spaces' proxy can reach the app (127.0.0.1
+        # only binds localhost inside the container and the Space won't load).
+        server_name=os.environ.get("HOST", "0.0.0.0"),
+        server_port=int(os.environ.get("PORT", "7860")),
+    )

liquid.py

@@ -1,25 +1,40 @@
-"""LiquidAI LFM2.5-350M (safetensors) wrapper via transformers.
-
-The model (set by LLM_REPO, default LiquidAI/LFM2.5-350M) is downloaded from
-HuggingFace on first use and cached. If anything is unavailable (no transformers,
-no model, no network) the app keeps working and just shows a deterministic fallback.
+"""LiquidAI LFM2.5-350M (safetensors) wrapper via transformers, ZeroGPU-ready.
+
+On HuggingFace ZeroGPU Spaces:
+  * `spaces` is imported before torch, and the actual generation runs inside a
+    `@spaces.GPU` function (the GPU is attached only for that call).
+  * the model is placed on `cuda` at module level (ZeroGPU's CUDA emulation makes
+    this work outside the decorated function), as the docs recommend.
+
+Off ZeroGPU (local CPU/GPU, or `spaces` not installed) everything still works:
+  * `@spaces.GPU` becomes a no-op, and the device falls back to a real CUDA GPU
+    if present, otherwise CPU.
+If anything is unavailable the app keeps running with a deterministic fallback.
 """
 from __future__ import annotations
 
 import os
 import threading
+import time
+
+# IMPORTANT: import `spaces` BEFORE torch so it can patch CUDA for ZeroGPU.
+try:
+    import spaces  # noqa: F401
+    _HAS_SPACES = True
+except Exception:
+    _HAS_SPACES = False
+
+_ON_ZEROGPU = bool(os.environ.get("SPACES_ZERO_GPU"))
 
-_PIPELINE = None
+_MODEL = None
 _TOKENIZER = None
+_DEVICE = "cpu"
 _LOAD_LOCK = threading.Lock()
 _LOAD_ERROR = None
 
 SYSTEM_PROMPT = (
-    "You are FLIGHTDECK, a terse air-traffic analyst. You are given live flight "
-    "telemetry pulled from FlightRadar24. Answer the operator's question using "
-    "only that data. Be concise, use callsigns, and when asked about routes or "
-    "timing reason from the origin, destination, ground speed and ETA fields. "
-    "Never invent flights that are not in the data."
+    "You are FLIGHTDECK, a terse air-traffic analyst. Answer only from the live "
+    "flight data you are given. Be concise and use callsigns. Never invent flights."
 )
 
 
@@ -28,60 +43,74 @@ def llm_disabled() -> bool:
 
 
 def _model_id() -> str:
-    # The GGUF-only repo and the safetensors repo have different names.
-    # Default to the safetensors model. Allow override via LLM_REPO.
+    # Safetensors repo (transformers), overridable via LLM_REPO.
     return os.environ.get("LLM_REPO", "LiquidAI/LFM2.5-350M")
 
 
-def _apply_chat_template(messages, tokenizer):
-    """Convert [{"role":..., "content":...}, ...] to a single prompt string
-    using the tokenizer's chat template. Falls back to a manual concat if
-    the tokenizer has no chat_template attribute."""
-    if hasattr(tokenizer, "apply_chat_template") and getattr(tokenizer, "chat_template", None):
+def _gpu(fn):
+    """Wrap a function with @spaces.GPU on ZeroGPU; no-op everywhere else."""
+    if _HAS_SPACES:
+        duration = int(os.environ.get("ZEROGPU_DURATION", "60"))
+        return spaces.GPU(duration=duration)(fn)
+    return fn
+
+
+def _apply_chat_template(messages, tokenizer) -> str:
+    if getattr(tokenizer, "chat_template", None):
         return tokenizer.apply_chat_template(
-            messages, tokenize=False, add_generation_prompt=True
-        )
-    # Manual fallback: simple "system / user" format.
-    parts = []
-    for m in messages:
-        role = m.get("role", "user")
-        parts.append(f"[{role.upper()}]\n{m.get('content', '')}\n")
+            messages, tokenize=False, add_generation_prompt=True)
+    parts = [f"[{m.get('role', 'user').upper()}]\n{m.get('content', '')}" for m in messages]
     parts.append("[ASSISTANT]\n")
     return "\n".join(parts)
 
 
 def _load():
-    """Load the model + tokenizer once. Returns (pipeline, tokenizer) or (None, None)."""
-    global _PIPELINE, _TOKENIZER, _LOAD_ERROR
-    if _PIPELINE is not None or _LOAD_ERROR is not None:
-        return _PIPELINE, _TOKENIZER
+    """Load model + tokenizer once (in the main process; ZeroGPU-safe)."""
+    global _MODEL, _TOKENIZER, _DEVICE, _LOAD_ERROR
+    if _MODEL is not None or _LOAD_ERROR is not None:
+        return _MODEL
     with _LOAD_LOCK:
-        if _PIPELINE is not None or _LOAD_ERROR is not None:
-            return _PIPELINE, _TOKENIZER
+        if _MODEL is not None or _LOAD_ERROR is not None:
+            return _MODEL
         try:
             import torch
-            from transformers import AutoModelForCausalLM, AutoTokenizer, pipeline
+            from transformers import AutoModelForCausalLM, AutoTokenizer
 
-            model_id = _model_id()
-            tokenizer = AutoTokenizer.from_pretrained(model_id, trust_remote_code=True)
+            mid = _model_id()
+            want_cuda = _ON_ZEROGPU or torch.cuda.is_available()
+            _DEVICE = "cuda" if want_cuda else "cpu"
+            dtype = torch.float16 if want_cuda else torch.float32
+
+            _TOKENIZER = AutoTokenizer.from_pretrained(mid, trust_remote_code=True)
             model = AutoModelForCausalLM.from_pretrained(
-                model_id,
-                torch_dtype=torch.float32,
-                device_map="auto",
-                trust_remote_code=True,
-            )
-            _PIPELINE = pipeline(
-                "text-generation",
-                model=model,
-                tokenizer=tokenizer,
-                return_full_text=False,
-            )
-            _TOKENIZER = tokenizer
+                mid, dtype=dtype, trust_remote_code=True)
+            # Module-level cuda placement (works via ZeroGPU CUDA emulation).
+            model.to(_DEVICE)
+            model.eval()
+            _MODEL = model
         except Exception as e:  # noqa: BLE001
             _LOAD_ERROR = e
-            _PIPELINE = None
-            _TOKENIZER = None
-    return _PIPELINE, _TOKENIZER
+            _MODEL = None
+    return _MODEL
+
+
+@_gpu
+def _generate(prompt: str, max_new_tokens: int, temperature: float, top_p: float) -> str:
+    """The only GPU-touching function — runs on the ZeroGPU device when attached."""
+    import torch
+    inputs = _TOKENIZER(prompt, return_tensors="pt").to(_DEVICE)
+    gen_kwargs = dict(
+        max_new_tokens=max_new_tokens,
+        do_sample=temperature > 0,
+        top_p=top_p,
+        pad_token_id=_TOKENIZER.eos_token_id,
+    )
+    if temperature > 0:
+        gen_kwargs["temperature"] = temperature
+    with torch.no_grad():
+        out = _MODEL.generate(**inputs, **gen_kwargs)
+    new_tokens = out[0][inputs["input_ids"].shape[1]:]
+    return _TOKENIZER.decode(new_tokens, skip_special_tokens=True)
 
 
 def status() -> str:
@@ -90,70 +119,52 @@ def status() -> str:
         return "LLM disabled (DISABLE_LLM=1)."
     if _LOAD_ERROR is not None:
         return f"{label} unavailable: {type(_LOAD_ERROR).__name__}: {_LOAD_ERROR}"
-    if _PIPELINE is None:
+    if _MODEL is None:
         return f"{label} not loaded yet (loads on first query)."
-    return f"{label} online (transformers, CPU/GPU auto)."
+    mode = "ZeroGPU" if (_HAS_SPACES and _ON_ZEROGPU) else _DEVICE.upper()
+    return f"{label} online ({mode})."
 
 
 def available() -> bool:
-    """True if the model can actually run (not disabled and loadable)."""
     if llm_disabled():
         return False
-    pipe, _ = _load()
-    return pipe is not None
+    return _load() is not None
 
 
 def complete(messages, *, max_tokens=512, temperature=0.2, top_p=0.9):
-    """Raw chat completion used by the agent loop. Returns (text, latency_ms).
-
-    Raises RuntimeError if the model is unavailable so the caller can fall back.
-    """
-    pipe, tokenizer = _load()
-    if pipe is None:
+    """Chat completion used by the agents. Returns (text, latency_ms)."""
+    if _load() is None:
         raise RuntimeError(status())
-    import time
-    prompt = _apply_chat_template(messages, tokenizer)
+    prompt = _apply_chat_template(messages, _TOKENIZER)
     t0 = time.time()
-    out = pipe(
-        prompt,
-        max_new_tokens=max_tokens,
-        do_sample=temperature > 0,
-        temperature=max(temperature, 1e-5),
-        top_p=top_p,
-        return_full_text=False,
-    )
-    latency = int((time.time() - t0) * 1000)
-    # transformers pipeline returns a list of dicts with "generated_text"
-    text = out[0]["generated_text"] if isinstance(out, list) else str(out)
-    if isinstance(text, list):
-        text = text[0].get("generated_text", "") if text else ""
-    return str(text).strip(), latency
+    text = _generate(prompt, int(max_tokens), float(temperature), float(top_p))
+    return str(text).strip(), int((time.time() - t0) * 1000)
 
 
 def _fallback(question: str, context: str) -> str:
     return (
         "[AI offline — raw readout]\n"
         f"Q: {question}\n\n{context}\n\n"
-        "(Install transformers + torch and allow the model to download to enable "
-        "LLM natural-language briefings.)"
+        "(Enable the model — transformers + torch — for natural-language briefings.)"
     )
 
 
 def briefing(question: str, context: str, max_tokens: int = 512) -> str:
-    """Generate an answer about the current flights."""
-    if llm_disabled():
-        return _fallback(question, context)
-    pipe, _ = _load()
-    if pipe is None:
+    if llm_disabled() or _load() is None:
         return _fallback(question, context)
-
     messages = [
         {"role": "system", "content": SYSTEM_PROMPT},
         {"role": "user",
          "content": f"LIVE FLIGHT DATA:\n{context}\n\nQUESTION: {question}"},
     ]
     try:
-        text, _latency = complete(messages, max_tokens=max_tokens, temperature=0.4)
+        text, _ = complete(messages, max_tokens=max_tokens, temperature=0.4)
         return text
     except Exception as e:  # noqa: BLE001
         return _fallback(question, f"{context}\n\n(LLM error: {e})")
+
+
+# ZeroGPU recommends placing the model at startup (not lazily). On ZeroGPU we
+# eager-load; locally we stay lazy so imports/tests remain fast.
+if _ON_ZEROGPU and not llm_disabled():
+    _load()

requirements.txt

@@ -1,12 +1,17 @@
-gradio==5.49.1
+# --- HuggingFace ZeroGPU Space ---
+# gradio is NOT pinned here — its version is controlled by `sdk_version` in the
+# README.md front-matter (the HF Gradio SDK installs it).
+#
+# ZeroGPU requires CUDA PyTorch >= 2.8.0 and the `spaces` package. Select the
+# "ZeroGPU" hardware in the Space settings (requires a PRO/Team/Enterprise plan).
+spaces
+
 requests>=2.31.0
 python-dotenv>=1.0.0
 numpy>=1.26.0
 huggingface_hub>=0.24.0
-# LLM agent runtime: LiquidAI LFM2.5-350M via transformers.
-# The model (default LiquidAI/LFM2.5-350M) is downloaded from HuggingFace on
-# first use and cached.
-# ZeroGPU requires torch 2.8.0-2.11.0. Pin to the latest supported (2.11.0).
-transformers>=4.44.0
-torch==2.11.0
-accelerate>=0.33.0
+
+# LLM agent: LiquidAI LFM2.5-350M (safetensors) via transformers, run on ZeroGPU.
+transformers==5.8.1
+torch==2.8.0
+accelerate==1.13.0

traces/agent_log.jsonl

@@ -14,3 +14,4 @@
 {"trace_id": "20260607_082836_88b4ce", "ts": "2026-06-07T15:28:37.446926+00:00", "query": "fastest way from Oakland to San Jose", "mode": "transit-llm", "tool_calls": ["plan_trip"], "flights_returned": 10}
 {"trace_id": "20260607_083207_f4ac39", "ts": "2026-06-07T15:32:10.607470+00:00", "query": "flights from London to Dubai", "mode": "llm", "tool_calls": ["search_by_route"], "flights_returned": 1}
 {"trace_id": "20260607_083344_fe2a6a", "ts": "2026-06-07T15:33:44.484771+00:00", "query": "My moms house", "mode": "llm+scope-refused", "tool_calls": [], "flights_returned": 0}
+{"trace_id": "20260608_004116_ebf3f4", "ts": "2026-06-08T07:41:30.342926+00:00", "query": "flights from London to Dubai", "mode": "llm", "tool_calls": ["search_by_route"], "flights_returned": 0}

traces/trace_20260608_004116_ebf3f4.json

@@ -0,0 +1,53 @@
+{
+  "trace_id": "20260608_004116_ebf3f4",
+  "started_at": "2026-06-08T07:41:16.987012+00:00",
+  "model": "LiquidAI/LFM2.5-350M",
+  "query": "flights from London to Dubai",
+  "agent_mode": "llm",
+  "steps": [
+    {
+      "step": 1,
+      "phase": "plan",
+      "model_raw": "{\"tool\": \"search_by_route\", \"origin\": \"LHR\", \"destination\": \"DXB\"}\n\n{\"tool\": \"none\", \"answer\": \"A journey across the skies\"}",
+      "parsed_action": {
+        "tool": "search_by_route",
+        "origin": "LHR",
+        "destination": "DXB"
+      },
+      "latency_ms": 1396
+    },
+    {
+      "step": 2,
+      "phase": "act",
+      "tool": "search_by_route",
+      "args": {
+        "origin": "LHR",
+        "destination": "DXB"
+      },
+      "meta": {
+        "error": "FR24_API_TOKEN is not set. Put your FlightRadar24 API token in the environment (see .env.example)."
+      },
+      "result_count": 0,
+      "latency_ms": 0,
+      "error": "FR24_API_TOKEN is not set. Put your FlightRadar24 API token in the environment (see .env.example)."
+    }
+  ],
+  "tool_calls": [
+    {
+      "tool": "search_by_route",
+      "args": {
+        "origin": "LHR",
+        "destination": "DXB"
+      },
+      "meta": {
+        "error": "FR24_API_TOKEN is not set. Put your FlightRadar24 API token in the environment (see .env.example)."
+      },
+      "result_count": 0,
+      "latency_ms": 0,
+      "error": "FR24_API_TOKEN is not set. Put your FlightRadar24 API token in the environment (see .env.example)."
+    }
+  ],
+  "flights_returned": 0,
+  "answer": "Search failed: FR24_API_TOKEN is not set. Put your FlightRadar24 API token in the environment (see .env.example).",
+  "ended_at": "2026-06-08T07:41:30.342926+00:00"
+}