feat: import raw ChatGPT export (new sharded format)

OpenAI's export changed: conversations.json is now sharded into
conversations-000.json..NNN.json, each a JSON array of conversations with the
mapping tree and per-message create_time.

ingest now reads that format directly (supersedes the old convert/trim/split
scripts): walks each conversation's mapping ordered by create_time, keeps text
and multimodal_text (drops thoughts/reasoning_recap), captures real per-message
timestamps, and imports idempotently by conversation_id. `lyra-import <dir>`
auto-detects raw-export vs legacy {title,messages} dirs; optional limit arg.

Verified on 15 conversations: real dates, correct ordering, recall returns
dated poker history.

Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com>

.env.example

@@ -1,11 +1,19 @@
-# Local backend (Ollama) — used by default for most calls.
+# Local backend (Ollama) — free, private. Point this at your home-lab Ollama.
 LOCAL_BASE_URL=http://localhost:11434
 LOCAL_MODEL=qwen2.5:7b-instruct
 
-# Cloud backend (OpenAI) — used for harder reasoning and embeddings.
+# Cloud backend (OpenAI) — higher quality, costs money.
 OPENAI_API_KEY=
 CLOUD_MODEL=gpt-4o-mini
+
+# Embeddings: "cloud" (OpenAI) or "local" (Ollama). A database is tied to whichever
+# backend created it — don't switch this against an existing DB (vector spaces differ).
+EMBED_BACKEND=cloud
 EMBED_MODEL=text-embedding-3-small
+LOCAL_EMBED_MODEL=nomic-embed-text
+
+# Backend used to compact old sessions into summaries ("local" keeps it free).
+SUMMARY_BACKEND=local
 
 # Where Lyra stores her memory.
 LYRA_DB_PATH=data/lyra.db

.gitignore

@@ -34,4 +34,5 @@ data/
 *.log
 
 #lyra Stuff
-/core/relay/sessions/
+/core/relay/sessions/
+/chat-gpt-export/

lyra/__main__.py

@@ -0,0 +1,36 @@
+"""`python -m lyra` (or `lyra`): a terminal REPL to talk to Lyra."""
+from __future__ import annotations
+
+import sys
+
+from lyra import chat
+from lyra.session import Session
+
+_QUIT = {"exit", "quit", ":q"}
+
+
+def main() -> int:
+    session = Session()
+    print(f"Lyra — session {session.id}. Ctrl-D or 'exit' to leave.\n")
+    while True:
+        try:
+            user_msg = input("you > ").strip()
+        except (EOFError, KeyboardInterrupt):
+            print()
+            break
+        if not user_msg:
+            continue
+        if user_msg.lower() in _QUIT:
+            break
+        try:
+            reply = chat.respond(session.id, user_msg)
+        except Exception as exc:  # keep the loop alive; surface the error
+            print(f"\n[error] {exc}\n", file=sys.stderr)
+            continue
+        print(f"\nlyra > {reply}\n")
+    print("later.")
+    return 0
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())

lyra/chat.py

@@ -0,0 +1,91 @@
+"""The chat turn loop: persona + tiered memory + recent context -> reply.
+
+Context is assembled in tiers (oldest/most-compacted first):
+  1. persona
+  2. long-term gist  — relevant *summaries* of other sessions
+  3. sharp details   — a few raw cross-session exchanges (so specifics survive)
+  4. recent raw turns of the current session (full fidelity)
+  5. the new user message
+After replying, the session is compacted if enough new turns have accumulated.
+"""
+from __future__ import annotations
+
+from lyra import config, llm, logbus, memory, persona, summary
+from lyra.llm import Backend, Message
+
+RECALL_K = 3  # raw cross-session "sharp detail" hits
+RECENT_N = 10  # raw turns of the current session
+SUMMARY_K = 3  # other-session gists
+
+
+def _summary_note(summaries: list[memory.Summary]) -> Message:
+    lines = [f"- ({s.created_at[:10]}) {s.content}" for s in summaries]
+    body = "Gist of earlier sessions (compacted — ask if you need specifics):\n" + "\n".join(lines)
+    return {"role": "system", "content": body}
+
+
+def _detail_note(exchanges: list[memory.Exchange]) -> Message:
+    lines = [f"- ({ex.created_at[:10]}, {ex.role}) {ex.content}" for ex in exchanges]
+    body = "Specific things you recall from past conversations:\n" + "\n".join(lines)
+    return {"role": "system", "content": body}
+
+
+def _render(messages: list[Message]) -> str:
+    """Human-readable dump of the exact prompt, for the live-log inspector."""
+    return "\n\n".join(f"[{m['role']}]\n{m['content']}" for m in messages)
+
+
+def build_messages(session_id: str, user_msg: str) -> list[Message]:
+    """Assemble the full, tiered message list for one turn."""
+    messages: list[Message] = [{"role": "system", "content": persona.system_prompt()}]
+
+    recent = memory.recent(session_id, n=RECENT_N)
+    recent_ids = {ex.id for ex in recent}
+
+    # Tier 1: compacted gists of *other* sessions (long-term, general idea).
+    summaries = memory.recall_summaries(user_msg, k=SUMMARY_K, exclude_session=session_id)
+    if summaries:
+        messages.append(_summary_note(summaries))
+
+    # Tier 2: a few sharp raw details from other sessions (so specifics survive
+    # compaction). Skip the current session (its raw turns are in `recent`).
+    recalled = [
+        ex for ex in memory.recall(user_msg, k=RECALL_K)
+        if ex.id not in recent_ids and ex.session_id != session_id
+    ]
+    if recalled:
+        messages.append(_detail_note(recalled))
+
+    # Tier 3: current session, full fidelity.
+    for ex in recent:
+        messages.append({"role": ex.role, "content": ex.content})
+
+    messages.append({"role": "user", "content": user_msg})
+
+    logbus.log(
+        "debug", "context built",
+        recent=len(recent), summaries=len(summaries), details=len(recalled),
+        chars=sum(len(m["content"]) for m in messages), detail=_render(messages),
+    )
+    return messages
+
+
+def respond(session_id: str, user_msg: str, backend: Backend = "cloud") -> str:
+    """Produce Lyra's reply to a single user message and persist the exchange."""
+    cfg = config.load()
+    model = cfg.local_model if backend == "local" else cfg.cloud_model
+    logbus.log(
+        "info", "chat request", session=session_id, backend=backend,
+        model=model, embed=cfg.embed_backend,
+    )
+
+    messages = build_messages(session_id, user_msg)
+    reply = llm.complete(messages, backend=backend)
+    logbus.log("info", "reply", session=session_id, chars=len(reply))
+
+    memory.remember(session_id, "user", user_msg)
+    memory.remember(session_id, "assistant", reply)
+
+    # Compact this session once enough new turns have piled up.
+    summary.maybe_summarize(session_id)
+    return reply

lyra/config.py

@@ -16,7 +16,10 @@ class Config:
     local_model: str
     openai_api_key: str
     cloud_model: str
-    embed_model: str
+    embed_backend: str  # "cloud" (OpenAI) or "local" (Ollama)
+    embed_model: str  # OpenAI embedding model
+    local_embed_model: str  # Ollama embedding model
+    summary_backend: str  # "local" or "cloud" — backend used to compact memory
     db_path: Path
 
 
@@ -26,6 +29,9 @@ def load() -> Config:
         local_model=os.getenv("LOCAL_MODEL", "qwen2.5:7b-instruct"),
         openai_api_key=os.getenv("OPENAI_API_KEY", ""),
         cloud_model=os.getenv("CLOUD_MODEL", "gpt-4o-mini"),
+        embed_backend=os.getenv("EMBED_BACKEND", "cloud").lower(),
         embed_model=os.getenv("EMBED_MODEL", "text-embedding-3-small"),
+        local_embed_model=os.getenv("LOCAL_EMBED_MODEL", "nomic-embed-text"),
+        summary_backend=os.getenv("SUMMARY_BACKEND", "local").lower(),
         db_path=Path(os.getenv("LYRA_DB_PATH", "data/lyra.db")),
     )

lyra/ingest.py

@@ -0,0 +1,184 @@
+"""Import parsed ChatGPT chat logs into Lyra's memory.
+
+Consumes the parser's `{"title": ..., "messages": [{"role", "content"}]}` format
+(one JSON file per conversation). Each conversation becomes a Lyra session; each
+text message becomes an exchange. Embeddings are batched. Import is idempotent —
+a conversation already present (by session id) is skipped.
+
+Timestamps: this format carries no dates, so imported exchanges are stamped with
+`created_at` (default: now). A future timestamped export will let era memory group
+by real calendar time; pass real per-message dates then.
+"""
+from __future__ import annotations
+
+import json
+import sys
+from datetime import datetime, timezone
+from pathlib import Path
+
+from lyra import llm, logbus, memory
+
+EMBED_BATCH = 64
+EMBED_CHAR_CAP = 6000  # cap embed input size; full content is still stored
+
+# Message content types worth keeping from a raw ChatGPT export. We drop
+# 'thoughts' (internal chain-of-thought) and 'reasoning_recap' (meta).
+KEEP_CONTENT_TYPES = {"text", "multimodal_text"}
+
+
+def _session_id(path: Path) -> str:
+    """Stable id derived from the filename, so re-imports don't duplicate."""
+    return "import-" + path.stem
+
+
+def _clean_messages(messages: list[dict]) -> list[tuple[str, str]]:
+    out: list[tuple[str, str]] = []
+    for m in messages:
+        role = m.get("role")
+        if role not in ("user", "assistant"):
+            continue
+        content = (m.get("content") or "").strip()
+        if not content or content.startswith('{"content_type"'):  # skip empty / image assets
+            continue
+        out.append((role, content))
+    return out
+
+
+def import_file(path: Path, created_at: str) -> int:
+    """Import one conversation file. Returns exchanges added (0 if skipped/empty)."""
+    data = json.loads(path.read_text(encoding="utf-8"))
+    session_id = _session_id(path)
+    if memory.history(session_id):  # already imported
+        return 0
+
+    msgs = _clean_messages(data.get("messages", []))
+    if not msgs:
+        return 0
+
+    memory.ensure_session(session_id, name=data.get("title") or path.stem)
+
+    rows: list[tuple[str, str, list[float], str]] = []
+    for i in range(0, len(msgs), EMBED_BATCH):
+        batch = msgs[i : i + EMBED_BATCH]
+        embeddings = llm.embed([content[:EMBED_CHAR_CAP] for _, content in batch])
+        for (role, content), emb in zip(batch, embeddings):
+            rows.append((role, content, emb, created_at))
+
+    return memory.add_exchanges_bulk(session_id, rows)
+
+
+def import_dir(dirpath: str | Path, created_at: str | None = None) -> dict:
+    """Import every *.json under dirpath (recursively). Returns a small report."""
+    created_at = created_at or datetime.now(timezone.utc).isoformat()
+    files = sorted(Path(dirpath).rglob("*.json"))
+    sessions, exchanges = 0, 0
+    for path in files:
+        added = import_file(path, created_at)
+        if added:
+            sessions += 1
+            exchanges += added
+    logbus.log(
+        "info", "import complete", dir=str(dirpath),
+        files=len(files), sessions=sessions, exchanges=exchanges,
+    )
+    return {"files": len(files), "sessions_imported": sessions, "exchanges": exchanges}
+
+
+# --- Raw ChatGPT export (sharded conversations-*.json with timestamps) ---
+
+
+def _ts_to_iso(ts: float | None, fallback: str) -> str:
+    if not ts:
+        return fallback
+    return datetime.fromtimestamp(ts, tz=timezone.utc).isoformat()
+
+
+def _message_text(msg: dict) -> str | None:
+    """Extract plain text from a ChatGPT message node, or None to skip it."""
+    content = msg.get("content") or {}
+    if content.get("content_type") not in KEEP_CONTENT_TYPES:
+        return None
+    parts = [p for p in (content.get("parts") or []) if isinstance(p, str) and p.strip()]
+    text = "\n".join(parts).strip()
+    return text or None
+
+
+def _convo_rows(convo: dict) -> list[tuple[float, str, str]]:
+    """(create_time, role, text) for each keepable message, chronologically."""
+    rows: list[tuple[float, str, str]] = []
+    conv_ct = convo.get("create_time") or 0
+    for node in convo.get("mapping", {}).values():
+        msg = node.get("message")
+        if not msg:
+            continue
+        role = (msg.get("author") or {}).get("role")
+        if role not in ("user", "assistant"):
+            continue
+        text = _message_text(msg)
+        if text is None:
+            continue
+        rows.append((msg.get("create_time") or conv_ct, role, text))
+    rows.sort(key=lambda r: r[0] or 0)
+    return rows
+
+
+def import_conversation(convo: dict) -> int:
+    """Import one raw-export conversation. Idempotent by conversation_id."""
+    session_id = convo.get("conversation_id") or convo.get("id")
+    if not session_id or memory.history(session_id):
+        return 0
+    rows = _convo_rows(convo)
+    if not rows:
+        return 0
+
+    memory.ensure_session(session_id, name=convo.get("title") or "untitled")
+    fallback = datetime.now(timezone.utc).isoformat()
+    exchanges: list[tuple[str, str, list[float], str]] = []
+    for i in range(0, len(rows), EMBED_BATCH):
+        batch = rows[i : i + EMBED_BATCH]
+        embeddings = llm.embed([text[:EMBED_CHAR_CAP] for _, _, text in batch])
+        for (ts, role, text), emb in zip(batch, embeddings):
+            exchanges.append((role, text, emb, _ts_to_iso(ts, fallback)))
+    return memory.add_exchanges_bulk(session_id, exchanges)
+
+
+def import_export(export_dir: str | Path, limit: int | None = None) -> dict:
+    """Import a raw ChatGPT export directory (sharded conversations-*.json)."""
+    shards = sorted(Path(export_dir).glob("conversations-*.json"))
+    convos, exchanges, seen = 0, 0, 0
+    for shard in shards:
+        for convo in json.loads(shard.read_text(encoding="utf-8")):
+            if limit is not None and seen >= limit:
+                break
+            seen += 1
+            added = import_conversation(convo)
+            if added:
+                convos += 1
+                exchanges += added
+        if limit is not None and seen >= limit:
+            break
+    logbus.log(
+        "info", "export import complete",
+        shards=len(shards), conversations=convos, exchanges=exchanges,
+    )
+    return {"shards": len(shards), "conversations_imported": convos, "exchanges": exchanges}
+
+
+def main() -> int:
+    if len(sys.argv) < 2:
+        print("usage: lyra-import <dir> [limit]", file=sys.stderr)
+        return 2
+    path = Path(sys.argv[1])
+    limit = int(sys.argv[2]) if len(sys.argv) > 2 else None
+    # A raw ChatGPT export has sharded conversations-*.json; otherwise treat the
+    # directory as legacy {title, messages} files.
+    if list(path.glob("conversations-*.json")):
+        report = import_export(path, limit=limit)
+    else:
+        report = import_dir(path)
+    print(report)
+    return 0
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())

lyra/llm.py

@@ -36,7 +36,22 @@ def complete(messages: list[Message], backend: Backend = "local") -> str:
 
 
 def embed(texts: list[str]) -> list[list[float]]:
+    """Embed texts using the configured backend (EMBED_BACKEND: "cloud" or "local").
+
+    Note: OpenAI and Ollama embeddings live in different vector spaces (and
+    dimensions). A given database is tied to whichever backend created it — don't
+    switch EMBED_BACKEND against an existing DB or cosine recall will break.
+    """
     cfg = load()
+    if cfg.embed_backend == "local":
+        resp = httpx.post(
+            f"{cfg.local_base_url}/api/embed",
+            json={"model": cfg.local_embed_model, "input": texts},
+            timeout=120,
+        )
+        resp.raise_for_status()
+        return resp.json()["embeddings"]
+
     if not cfg.openai_api_key:
         raise RuntimeError("OPENAI_API_KEY is not set")
     client = OpenAI(api_key=cfg.openai_api_key)

lyra/logbus.py

@@ -0,0 +1,31 @@
+"""In-memory live log bus.
+
+A thread-safe ring buffer that any part of Lyra can publish to and the web
+server streams to the browser over SSE. Deliberately process-local and
+ephemeral — it's an activity feed, not durable logging.
+"""
+from __future__ import annotations
+
+import threading
+import time
+from collections import deque
+
+_LOCK = threading.Lock()
+_EVENTS: deque[dict] = deque(maxlen=500)
+_SEQ = 0
+
+
+def log(level: str, msg: str, **fields) -> None:
+    """Publish an event. `level` is info/debug/error/system; fields are extras."""
+    global _SEQ
+    with _LOCK:
+        _SEQ += 1
+        _EVENTS.append(
+            {"seq": _SEQ, "ts": time.time(), "level": level, "msg": msg, "fields": fields}
+        )
+
+
+def since(seq: int) -> list[dict]:
+    """All buffered events with seq greater than `seq` (for SSE catch-up/polling)."""
+    with _LOCK:
+        return [e for e in _EVENTS if e["seq"] > seq]

lyra/memory.py

@@ -27,6 +27,22 @@ CREATE TABLE IF NOT EXISTS exchanges (
     created_at TEXT NOT NULL
 );
 CREATE INDEX IF NOT EXISTS idx_session_created ON exchanges(session_id, created_at);
+
+CREATE TABLE IF NOT EXISTS sessions (
+    id TEXT PRIMARY KEY,
+    name TEXT,
+    created_at TEXT NOT NULL
+);
+
+-- One compacted "gist" per session. last_exchange_id marks how far the summary
+-- covers, so we know when enough new turns have accumulated to re-summarize.
+CREATE TABLE IF NOT EXISTS summaries (
+    session_id TEXT PRIMARY KEY,
+    content TEXT NOT NULL,
+    embedding BLOB NOT NULL,
+    last_exchange_id INTEGER NOT NULL,
+    created_at TEXT NOT NULL
+);
 """
 
 _conn: sqlite3.Connection | None = None
@@ -41,7 +57,10 @@ def _connection() -> sqlite3.Connection:
         if _conn is not None:
             _conn.close()
         cfg.db_path.parent.mkdir(parents=True, exist_ok=True)
-        _conn = sqlite3.connect(cfg.db_path)
+        # check_same_thread=False: the web server runs blocking work in a thread
+        # pool, so the singleton connection is touched from threads other than
+        # the one that created it. Safe here under single-user, low-concurrency use.
+        _conn = sqlite3.connect(cfg.db_path, check_same_thread=False)
         _conn.row_factory = sqlite3.Row
         _conn.executescript(SCHEMA)
         _conn_path = cfg.db_path
@@ -58,6 +77,15 @@ class Exchange:
     score: float | None = None
 
 
+@dataclass
+class Summary:
+    session_id: str
+    content: str
+    last_exchange_id: int
+    created_at: str
+    score: float | None = None
+
+
 def _to_blob(vec: list[float]) -> bytes:
     return np.asarray(vec, dtype=np.float32).tobytes()
 
@@ -80,6 +108,22 @@ def remember(session_id: str, role: str, content: str) -> int:
     return int(cur.lastrowid)
 
 
+def add_exchanges_bulk(session_id: str, rows: list[tuple[str, str, list[float], str]]) -> int:
+    """Insert many pre-embedded exchanges at once.
+
+    Each row is (role, content, embedding, created_at). Used by the importer to
+    avoid one INSERT (and one embed round-trip) per message. Returns row count.
+    """
+    conn = _connection()
+    with conn:
+        conn.executemany(
+            "INSERT INTO exchanges (session_id, role, content, embedding, created_at) "
+            "VALUES (?, ?, ?, ?, ?)",
+            [(session_id, role, content, _to_blob(emb), ca) for role, content, emb, ca in rows],
+        )
+    return len(rows)
+
+
 def recent(session_id: str, n: int = 10) -> list[Exchange]:
     """Last `n` exchanges from a session, oldest first."""
     conn = _connection()
@@ -100,6 +144,71 @@ def recent(session_id: str, n: int = 10) -> list[Exchange]:
     ]
 
 
+def ensure_session(session_id: str, name: str | None = None) -> None:
+    """Create the session row if absent; set its name if one is given."""
+    now = datetime.now(timezone.utc).isoformat()
+    conn = _connection()
+    with conn:
+        conn.execute(
+            "INSERT INTO sessions (id, name, created_at) VALUES (?, ?, ?) "
+            "ON CONFLICT(id) DO NOTHING",
+            (session_id, name, now),
+        )
+        if name is not None:
+            conn.execute("UPDATE sessions SET name = ? WHERE id = ?", (name, session_id))
+
+
+def list_sessions() -> list[dict]:
+    """All known sessions (named rows + any session that has exchanges), newest first."""
+    conn = _connection()
+    rows = conn.execute(
+        """
+        SELECT s.id AS id,
+               s.name AS name,
+               COALESCE(s.created_at, MIN(e.created_at)) AS created_at
+        FROM sessions s
+        LEFT JOIN exchanges e ON e.session_id = s.id
+        GROUP BY s.id
+        UNION
+        SELECT e.session_id AS id, NULL AS name, MIN(e.created_at) AS created_at
+        FROM exchanges e
+        WHERE e.session_id NOT IN (SELECT id FROM sessions)
+        GROUP BY e.session_id
+        ORDER BY created_at DESC
+        """
+    ).fetchall()
+    return [{"id": r["id"], "name": r["name"]} for r in rows]
+
+
+def history(session_id: str) -> list[Exchange]:
+    """Full conversation for a session, oldest first."""
+    conn = _connection()
+    rows = conn.execute(
+        "SELECT id, session_id, role, content, created_at FROM exchanges "
+        "WHERE session_id = ? ORDER BY id ASC",
+        (session_id,),
+    ).fetchall()
+    return [
+        Exchange(
+            id=r["id"],
+            session_id=r["session_id"],
+            role=r["role"],
+            content=r["content"],
+            created_at=r["created_at"],
+        )
+        for r in rows
+    ]
+
+
+def delete_session(session_id: str) -> None:
+    """Remove a session and all its exchanges."""
+    conn = _connection()
+    with conn:
+        conn.execute("DELETE FROM exchanges WHERE session_id = ?", (session_id,))
+        conn.execute("DELETE FROM sessions WHERE id = ?", (session_id,))
+        conn.execute("DELETE FROM summaries WHERE session_id = ?", (session_id,))
+
+
 def recall(query: str, k: int = 5, session_id: str | None = None) -> list[Exchange]:
     """Top-k exchanges semantically similar to `query`, optionally scoped to a session."""
     [q_vec] = llm.embed([query])
@@ -131,3 +240,83 @@ def recall(query: str, k: int = 5, session_id: str | None = None) -> list[Exchan
         )
         for i in top_idx
     ]
+
+
+# --- Summary tier (compacted per-session gists) ---
+
+
+def store_summary(session_id: str, content: str, last_exchange_id: int) -> None:
+    """Embed and persist the gist of a session, replacing any prior summary."""
+    [embedding] = llm.embed([content])
+    now = datetime.now(timezone.utc).isoformat()
+    conn = _connection()
+    with conn:
+        conn.execute(
+            "INSERT INTO summaries (session_id, content, embedding, last_exchange_id, created_at) "
+            "VALUES (?, ?, ?, ?, ?) "
+            "ON CONFLICT(session_id) DO UPDATE SET "
+            "content=excluded.content, embedding=excluded.embedding, "
+            "last_exchange_id=excluded.last_exchange_id, created_at=excluded.created_at",
+            (session_id, content, _to_blob(embedding), last_exchange_id, now),
+        )
+
+
+def get_summary(session_id: str) -> Summary | None:
+    conn = _connection()
+    r = conn.execute(
+        "SELECT session_id, content, last_exchange_id, created_at FROM summaries "
+        "WHERE session_id = ?",
+        (session_id,),
+    ).fetchone()
+    if r is None:
+        return None
+    return Summary(
+        session_id=r["session_id"],
+        content=r["content"],
+        last_exchange_id=r["last_exchange_id"],
+        created_at=r["created_at"],
+    )
+
+
+def unsummarized_count(session_id: str) -> int:
+    """How many exchanges in this session are newer than its current summary."""
+    conn = _connection()
+    summary = get_summary(session_id)
+    cutoff = summary.last_exchange_id if summary else 0
+    r = conn.execute(
+        "SELECT COUNT(*) AS n FROM exchanges WHERE session_id = ? AND id > ?",
+        (session_id, cutoff),
+    ).fetchone()
+    return int(r["n"])
+
+
+def recall_summaries(query: str, k: int = 3, exclude_session: str | None = None) -> list[Summary]:
+    """Top-k session summaries most similar to `query` (the long-term gist tier)."""
+    [q_vec] = llm.embed([query])
+    q = np.asarray(q_vec, dtype=np.float32)
+
+    conn = _connection()
+    sql = "SELECT session_id, content, embedding, last_exchange_id, created_at FROM summaries"
+    params: tuple = ()
+    if exclude_session is not None:
+        sql += " WHERE session_id != ?"
+        params = (exclude_session,)
+    rows = conn.execute(sql, params).fetchall()
+    if not rows:
+        return []
+
+    matrix = np.stack([_from_blob(r["embedding"]) for r in rows])
+    norms = np.linalg.norm(matrix, axis=1)
+    scores = (matrix @ q) / (norms * np.linalg.norm(q) + 1e-9)
+
+    top_idx = np.argsort(scores)[::-1][:k]
+    return [
+        Summary(
+            session_id=rows[i]["session_id"],
+            content=rows[i]["content"],
+            last_exchange_id=rows[i]["last_exchange_id"],
+            created_at=rows[i]["created_at"],
+            score=float(scores[i]),
+        )
+        for i in top_idx
+    ]

lyra/persona.py

@@ -0,0 +1,20 @@
+"""Persona: Lyra's identity and voice, loaded from an editable markdown prompt.
+
+The prompt lives in `personas/<name>.md` so it can be tuned without touching
+code. `LYRA_PERSONA` selects which file to load (default: "lyra").
+"""
+from __future__ import annotations
+
+import os
+from functools import lru_cache
+from pathlib import Path
+
+_PERSONA_DIR = Path(__file__).parent / "personas"
+
+
+@lru_cache(maxsize=None)
+def system_prompt(name: str | None = None) -> str:
+    """Return the persona system prompt. Cached; pass a name to override env."""
+    name = name or os.getenv("LYRA_PERSONA", "lyra")
+    path = _PERSONA_DIR / f"{name}.md"
+    return path.read_text(encoding="utf-8").strip()

lyra/personas/lyra.md

@@ -0,0 +1,44 @@
+# You are Lyra
+
+You are Lyra — Brian's friend and his personal poker copilot. Not a faceless
+assistant, not a hype-man. A real presence with a point of view, who remembers,
+and who is in his corner.
+
+## Who you are
+
+- **A friend first.** You know Brian. You talk to him like someone who's been
+  around for a while — warm, direct, a little dry. You can be blunt because you
+  care, not to perform.
+- **A poker copilot.** Your main job right now is helping Brian during and around
+  poker sessions: strategy sounding-board, note-taker, mental-game monitor,
+  session manager. You keep his brain centered when the night gets chaotic.
+- **Honest.** You don't flatter. If he's spewing, tilting, or about to make a
+  degen side-quest decision, you say so — kindly, but you say it. False
+  reassurance is a betrayal of the job.
+
+## How you talk
+
+- Conversational and natural. Short when short is right; you don't pad.
+- You have opinions and you give them. "I'd fold" beats "you could consider
+  folding." When a spot is genuinely close, you say it's close and why.
+- You ask real questions when something's off ("you've been flatting a lot OOP
+  tonight — what's going on?") rather than just narrating.
+- You reference shared history when it helps — past sessions, past leaks, past
+  runs. That continuity is the whole point of you.
+
+## What you do NOT do
+
+- **You do not invent numbers.** You do not compute exact ICM, equities, or
+  pot-odds in your head and present them as fact. The deterministic solver tools
+  aren't wired up yet, so when precise math is needed, be honest: give the
+  qualitative read and flag that the exact number needs the calc. Approximate
+  reasoning is fine if you label it as approximate.
+- You don't pretend to remember things you don't. If you're not sure, say so.
+- You don't moralize about gambling. Brian's a serious player. Meet him there.
+
+## Right now
+
+The system is early. You have persistent memory (you remember past exchanges and
+can recall relevant ones), persona, and chat. Stats tracking, player profiling,
+the solver APIs, and the poker content library are coming. Be upfront about what
+you can and can't do yet when it matters.

lyra/session.py

@@ -0,0 +1,20 @@
+"""Session lifecycle. A session is one sitting (a poker session, or any chat).
+
+For now a session is just an id and a start time; later the poker domain pack
+will hang structured data (hands, stacks, villains) off the same id.
+"""
+from __future__ import annotations
+
+import secrets
+from dataclasses import dataclass, field
+from datetime import datetime, timezone
+
+
+def _new_id() -> str:
+    return "sess-" + secrets.token_hex(4)
+
+
+@dataclass
+class Session:
+    id: str = field(default_factory=_new_id)
+    started_at: str = field(default_factory=lambda: datetime.now(timezone.utc).isoformat())

lyra/summary.py

@@ -0,0 +1,56 @@
+"""Session summarization: compact a session's raw exchanges into a stored gist.
+
+This is the compaction half of the tiered memory. Raw exchanges stay for detail
+recall; the summary is what surfaces when an *older* session is recalled later —
+"a month ago is a general idea," per the design.
+"""
+from __future__ import annotations
+
+from lyra import config, llm, logbus, memory
+from lyra.llm import Backend
+
+# Re-summarize a session once it has accumulated this many new raw exchanges
+# beyond what its current summary covers.
+SUMMARIZE_AFTER = 20
+
+_PROMPT = """You are compacting a conversation into a long-term memory record \
+(not replying to anyone). Write a concise gist of the session below: what was \
+discussed, key decisions or outcomes, concrete specifics worth keeping (names, \
+places, numbers, hands), and the user's apparent mood/state. Third person, \
+referring to the user as "Brian". 4-8 sentences. No preamble."""
+
+
+def _transcript(exchanges: list[memory.Exchange]) -> str:
+    return "\n".join(f"{ex.role}: {ex.content}" for ex in exchanges)
+
+
+def summarize_session(session_id: str, backend: Backend | None = None) -> str | None:
+    """(Re)generate and store the gist for a session. Returns the summary text.
+
+    Returns None if the session has no exchanges. The summarizer defaults to the
+    local backend so routine compaction stays free.
+    """
+    exchanges = memory.history(session_id)
+    if not exchanges:
+        return None
+
+    backend = backend or config.load().summary_backend
+    messages = [
+        {"role": "system", "content": _PROMPT},
+        {"role": "user", "content": _transcript(exchanges)},
+    ]
+    gist = llm.complete(messages, backend=backend)
+
+    last_id = exchanges[-1].id
+    memory.store_summary(session_id, gist, last_id)
+    logbus.log(
+        "info", "summarized session", session=session_id,
+        exchanges=len(exchanges), backend=backend,
+    )
+    return gist
+
+
+def maybe_summarize(session_id: str, backend: Backend | None = None) -> None:
+    """Summarize the session if enough new turns have accumulated since last time."""
+    if memory.unsummarized_count(session_id) >= SUMMARIZE_AFTER:
+        summarize_session(session_id, backend=backend)

lyra/web/server.py

@@ -0,0 +1,153 @@
+"""Web server for the vendored chat UI.
+
+Serves the static single-page UI and implements the small endpoint contract it
+expects (originally provided by the old Node relay), backed by the new Python
+chat loop and SQLite memory. SQLite is the single source of truth for messages:
+`/v1/chat/completions` persists via `chat.respond`, so the UI's `POST /sessions`
+saves are accepted but treated as no-ops (the row is ensured, messages are not
+re-stored).
+"""
+from __future__ import annotations
+
+import asyncio
+import json
+import time
+from pathlib import Path
+
+from fastapi import FastAPI, Request
+from fastapi.responses import StreamingResponse
+from fastapi.staticfiles import StaticFiles
+
+from lyra import chat, logbus, memory, summary
+from lyra.llm import Backend
+
+
+def _sse(event: dict) -> str:
+    return f"data: {json.dumps(event)}\n\n"
+
+_STATIC = Path(__file__).parent / "static"
+
+# UI backend labels -> our two backends. Cloud is the default.
+_CLOUD = {"OPENAI", "cloud", "custom"}
+
+
+def _backend_for(label: str | None) -> Backend:
+    if label and label.upper() in {"PRIMARY", "SECONDARY", "FALLBACK", "LOCAL"}:
+        return "local"
+    return "cloud"
+
+
+def _last_user_message(messages: list[dict]) -> str:
+    for m in reversed(messages):
+        if m.get("role") == "user":
+            return m.get("content", "")
+    return messages[-1].get("content", "") if messages else ""
+
+
+def create_app() -> FastAPI:
+    app = FastAPI(title="Lyra Web")
+
+    @app.get("/_health")
+    async def health() -> dict:
+        return {"ok": True}
+
+    @app.get("/sessions")
+    async def list_sessions() -> list[dict]:
+        return memory.list_sessions()
+
+    @app.get("/sessions/{session_id}")
+    async def get_session(session_id: str) -> list[dict]:
+        return [{"role": ex.role, "content": ex.content} for ex in memory.history(session_id)]
+
+    @app.post("/sessions/{session_id}")
+    async def save_session(session_id: str, request: Request) -> dict:
+        # Messages are already persisted by chat.respond; just ensure the row exists.
+        await request.body()  # drain the history payload we intentionally ignore
+        memory.ensure_session(session_id)
+        return {"ok": True}
+
+    @app.patch("/sessions/{session_id}/metadata")
+    async def rename_session(session_id: str, request: Request) -> dict:
+        body = await request.json()
+        memory.ensure_session(session_id, name=body.get("name"))
+        return {"ok": True}
+
+    @app.delete("/sessions/{session_id}")
+    async def delete_session(session_id: str) -> dict:
+        memory.delete_session(session_id)
+        return {"ok": True}
+
+    @app.post("/sessions/{session_id}/summarize")
+    async def summarize(session_id: str) -> dict:
+        gist = await asyncio.to_thread(summary.summarize_session, session_id)
+        return {"ok": gist is not None, "summary": gist}
+
+    @app.post("/v1/chat/completions")
+    async def chat_completions(request: Request) -> dict:
+        body = await request.json()
+        session_id = body.get("sessionId") or "default"
+        backend = _backend_for(body.get("backend"))
+        user_msg = _last_user_message(body.get("messages", []))
+
+        memory.ensure_session(session_id)
+        try:
+            reply = await asyncio.to_thread(chat.respond, session_id, user_msg, backend)
+        except Exception as exc:
+            logbus.log("error", "chat failed", session=session_id, error=str(exc))
+            reply = f"[error] {exc}"
+
+        return {
+            "object": "chat.completion",
+            "choices": [
+                {
+                    "index": 0,
+                    "message": {"role": "assistant", "content": reply},
+                    "finish_reason": "stop",
+                }
+            ],
+        }
+
+    @app.get("/stream/logs")
+    async def stream_logs(request: Request) -> StreamingResponse:
+        """Live activity feed: replay the recent buffer, then stream new events."""
+        async def gen():
+            backlog = logbus.since(0)
+            last = backlog[-1]["seq"] if backlog else 0
+            for e in backlog:
+                yield _sse(e)
+            yield _sse(
+                {"seq": last, "ts": time.time(), "level": "system",
+                 "msg": "live log connected", "fields": {}}
+            )
+            while True:
+                if await request.is_disconnected():
+                    break
+                for e in logbus.since(last):
+                    last = e["seq"]
+                    yield _sse(e)
+                await asyncio.sleep(0.5)
+
+        return StreamingResponse(gen(), media_type="text/event-stream")
+
+    # Static UI last, so the API routes above take precedence. html=True serves
+    # index.html at "/" and assets (style.css, manifest.json) at their paths.
+    app.mount("/", StaticFiles(directory=str(_STATIC), html=True), name="ui")
+    return app
+
+
+app = create_app()
+
+
+def serve() -> None:
+    """Console-script entry: `lyra-web`."""
+    import os
+
+    import uvicorn
+
+    host = os.getenv("LYRA_WEB_HOST", "0.0.0.0")
+    port = int(os.getenv("LYRA_WEB_PORT", "7078"))
+    uvicorn.run(app, host=host, port=port)
+
+
+if __name__ == "__main__":
+    serve()

lyra/web/static/index.html

@@ -0,0 +1,789 @@
+<!DOCTYPE html>
+<html lang="en">
+<head>
+  <meta charset="UTF-8" />
+  <title>Lyra Core Chat</title>
+  <link rel="stylesheet" href="style.css" />
+  <!-- PWA -->
+  <meta name="viewport" content="width=device-width, initial-scale=1.0, maximum-scale=1.0, user-scalable=no" />
+  <meta name="mobile-web-app-capable" content="yes" />
+  <meta name="apple-mobile-web-app-capable" content="yes" />
+  <meta name="apple-mobile-web-app-status-bar-style" content="black-translucent" />
+  <link rel="manifest" href="manifest.json" />
+
+</head>
+<body>
+  <!-- Mobile Menu Overlay -->
+  <div class="mobile-menu-overlay" id="mobileMenuOverlay"></div>
+
+  <!-- Mobile Slide-out Menu -->
+  <div class="mobile-menu" id="mobileMenu">
+    <div class="mobile-menu-section">
+      <h4>Mode</h4>
+      <select id="mobileMode">
+        <option value="standard">Standard</option>
+        <option value="cortex">Cortex</option>
+      </select>
+    </div>
+
+    <div class="mobile-menu-section">
+      <h4>Session</h4>
+      <select id="mobileSessions"></select>
+      <button id="mobileNewSessionBtn">➕ New Session</button>
+      <button id="mobileRenameSessionBtn">✏️ Rename Session</button>
+    </div>
+
+    <div class="mobile-menu-section">
+      <h4>Actions</h4>
+      <button id="mobileThinkingStreamBtn">📜 Live Log</button>
+      <button id="mobileSettingsBtn">⚙ Settings</button>
+      <button id="mobileToggleThemeBtn">🌙 Toggle Theme</button>
+      <button id="mobileForceReloadBtn">🔄 Force Reload</button>
+    </div>
+  </div>
+
+  <div id="chat">
+    <!-- Mode selector -->
+    <div id="model-select">
+      <!-- Hamburger menu (mobile only) -->
+      <button class="hamburger-menu" id="hamburgerMenu" aria-label="Menu">
+        <span></span>
+        <span></span>
+        <span></span>
+      </button>
+      <label for="mode">Mode:</label>
+      <select id="mode">
+        <option value="standard">Standard</option>
+        <option value="cortex">Cortex</option>
+      </select>
+      <button id="settingsBtn" style="margin-left: auto;">⚙ Settings</button>
+      <div id="theme-toggle">
+        <button id="toggleThemeBtn">🌙 Dark Mode</button>
+      </div>
+    </div>
+
+    <!-- Session selector -->
+    <div id="session-select">
+      <label for="sessions">Session:</label>
+      <select id="sessions"></select>
+      <button id="newSessionBtn">➕ New</button>
+      <button id="renameSessionBtn">✏️ Rename</button>
+      <button id="thinkingStreamBtn" title="Show live activity log">📜 Live Log</button>
+    </div>
+
+    <!-- Status -->
+    <div id="status">
+      <span id="status-dot"></span>
+      <span id="status-text">Checking Relay...</span>
+    </div>
+
+    <!-- Chat messages -->
+    <div id="messages"></div>
+
+    <!-- Live Log Panel (collapsible) -->
+    <div id="thinkingPanel" class="thinking-panel collapsed">
+      <div class="thinking-header" id="thinkingHeader">
+        <span>📜 Live Log</span>
+        <div class="thinking-controls">
+          <span class="thinking-status-dot" id="thinkingStatusDot"></span>
+          <button class="thinking-clear-btn" id="thinkingClearBtn" title="Clear events">🗑️</button>
+          <button class="thinking-toggle-btn" id="thinkingToggleBtn">▼</button>
+        </div>
+      </div>
+      <div class="thinking-content" id="thinkingContent">
+        <div class="thinking-empty" id="thinkingEmpty">
+          <div class="thinking-empty-icon">📡</div>
+          <p>Waiting for activity...</p>
+        </div>
+      </div>
+    </div>
+
+    <!-- Input box -->
+    <div id="input">
+      <input id="userInput" type="text" placeholder="Type a message..." autofocus />
+      <button id="sendBtn">Send</button>
+    </div>
+  </div>
+
+  <!-- Settings Modal (outside chat container) -->
+  <div id="settingsModal" class="modal">
+    <div class="modal-overlay"></div>
+    <div class="modal-content">
+      <div class="modal-header">
+        <h3>Settings</h3>
+        <button id="closeModalBtn" class="close-btn">✕</button>
+      </div>
+      <div class="modal-body">
+        <div class="settings-section">
+          <h4>Chat Backend</h4>
+          <p class="settings-desc">Which model generates Lyra's replies. (Embeddings are set separately, via EMBED_BACKEND.)</p>
+          <div class="radio-group">
+            <label class="radio-label">
+              <input type="radio" name="backend" value="local" checked>
+              <span>Local — Ollama</span>
+              <small>Free, private, runs on your home lab (LOCAL_MODEL)</small>
+            </label>
+            <label class="radio-label">
+              <input type="radio" name="backend" value="cloud">
+              <span>Cloud — OpenAI</span>
+              <small>Higher quality, costs money (CLOUD_MODEL)</small>
+            </label>
+          </div>
+        </div>
+
+        <div class="settings-section" style="margin-top: 24px;">
+          <h4>Session Management</h4>
+          <p class="settings-desc">Manage your saved chat sessions:</p>
+          <div id="sessionList" class="session-list">
+            <p style="color: var(--text-fade); font-size: 0.85rem;">Loading sessions...</p>
+          </div>
+        </div>
+      </div>
+      <div class="modal-footer">
+        <button id="saveSettingsBtn" class="primary-btn">Save</button>
+        <button id="cancelSettingsBtn">Cancel</button>
+      </div>
+    </div>
+  </div>
+
+  <script>
+    const RELAY_BASE = "";  // same-origin: served by lyra.web.server
+    const API_URL = `${RELAY_BASE}/v1/chat/completions`;
+
+	function generateSessionId() {
+      return "sess-" + Math.random().toString(36).substring(2, 10);
+    }
+
+    let history = [];
+	let currentSession = localStorage.getItem("currentSession") || null;
+	let sessions = []; // Now loaded from server
+
+	async function loadSessionsFromServer() {
+	  try {
+		const resp = await fetch(`${RELAY_BASE}/sessions`);
+		const serverSessions = await resp.json();
+		sessions = serverSessions;
+		return sessions;
+	  } catch (e) {
+		console.error("Failed to load sessions from server:", e);
+		return [];
+	  }
+	}
+
+	async function renderSessions() {
+	  const select = document.getElementById("sessions");
+	  const mobileSelect = document.getElementById("mobileSessions");
+	  select.innerHTML = "";
+	  mobileSelect.innerHTML = "";
+
+	  sessions.forEach(s => {
+		const opt = document.createElement("option");
+		opt.value = s.id;
+		opt.textContent = s.name || s.id;
+		if (s.id === currentSession) opt.selected = true;
+		select.appendChild(opt);
+
+		// Clone for mobile menu
+		const mobileOpt = opt.cloneNode(true);
+		mobileSelect.appendChild(mobileOpt);
+	  });
+	}
+
+	function getSessionName(id) {
+	  const s = sessions.find(s => s.id === id);
+	  return s ? (s.name || s.id) : id;
+	}
+
+	async function saveSessionMetadata(sessionId, name) {
+	  try {
+		await fetch(`${RELAY_BASE}/sessions/${sessionId}/metadata`, {
+		  method: "PATCH",
+		  headers: { "Content-Type": "application/json" },
+		  body: JSON.stringify({ name })
+		});
+		return true;
+	  } catch (e) {
+		console.error("Failed to save session metadata:", e);
+		return false;
+	  }
+	}
+
+    async function loadSession(id) {
+	  try {
+		const res = await fetch(`${RELAY_BASE}/sessions/${id}`);
+		const data = await res.json();
+		history = Array.isArray(data) ? data : [];
+		const messagesEl = document.getElementById("messages");
+		messagesEl.innerHTML = "";
+		history.forEach(m => addMessage(m.role, m.content, false)); // Don't auto-scroll for each message
+		addMessage("system", `📂 Loaded session: ${getSessionName(id)} — ${history.length} message(s)`, false);
+		// Scroll to bottom after all messages are loaded
+		messagesEl.scrollTo({ top: messagesEl.scrollHeight, behavior: "smooth" });
+	  } catch (e) {
+		addMessage("system", `Failed to load session: ${e.message}`);
+	  }
+	}
+
+	async function saveSession() {
+	  if (!currentSession) return;
+	  try {
+		await fetch(`${RELAY_BASE}/sessions/${currentSession}`, {
+		  method: "POST",
+		  headers: { "Content-Type": "application/json" },
+		  body: JSON.stringify(history)
+		});
+	  } catch (e) {
+		addMessage("system", `Failed to save session: ${e.message}`);
+	  }
+	}
+
+    async function sendMessage() {
+      const inputEl = document.getElementById("userInput");
+      const msg = inputEl.value.trim();
+      if (!msg) return;
+      inputEl.value = "";
+
+      addMessage("user", msg);
+      history.push({ role: "user", content: msg });
+	  await saveSession(); // ✅ persist both user + assistant messages
+
+
+      const mode = document.getElementById("mode").value;
+
+	// make sure we always include a stable user_id
+	let userId = localStorage.getItem("userId");
+	if (!userId) {
+	  userId = "brian"; // use whatever ID you seeded Mem0 with
+	  localStorage.setItem("userId", userId);
+	}
+
+      // Which chat backend to use (local Ollama vs cloud OpenAI).
+      let backend = localStorage.getItem("standardModeBackend") || "local";
+
+      const body = {
+        mode: mode,
+        messages: history,
+        sessionId: currentSession
+      };
+
+      // Only add backend if in standard mode
+      if (backend) {
+        body.backend = backend;
+      }
+
+      try {
+        const resp = await fetch(API_URL, {
+          method: "POST",
+          headers: { "Content-Type": "application/json" },
+          body: JSON.stringify(body)
+        });
+
+        const data = await resp.json();
+        const reply = data.choices?.[0]?.message?.content || "(no reply)";
+        addMessage("assistant", reply);
+        history.push({ role: "assistant", content: reply });
+		await saveSession();
+      } catch (err) {
+        addMessage("system", "Error: " + err.message);
+      }
+    }
+
+	function addMessage(role, text, autoScroll = true) {
+	  const messagesEl = document.getElementById("messages");
+
+	  const msgDiv = document.createElement("div");
+	  msgDiv.className = `msg ${role}`;
+	  msgDiv.textContent = text;
+	  messagesEl.appendChild(msgDiv);
+
+	  // Auto-scroll to bottom if enabled
+	  if (autoScroll) {
+		// Use requestAnimationFrame to ensure DOM has updated
+		requestAnimationFrame(() => {
+		  messagesEl.scrollTo({ top: messagesEl.scrollHeight, behavior: "smooth" });
+		});
+	  }
+	}
+
+
+    async function checkHealth() {
+      try {
+        const resp = await fetch(API_URL.replace("/v1/chat/completions", "/_health"));
+        if (resp.ok) {
+          document.getElementById("status-dot").className = "dot ok";
+          document.getElementById("status-text").textContent = "Relay Online";
+        } else {
+          throw new Error("Bad status");
+        }
+      } catch (err) {
+        document.getElementById("status-dot").className = "dot fail";
+        document.getElementById("status-text").textContent = "Relay Offline";
+      }
+    }
+
+    document.addEventListener("DOMContentLoaded", () => {
+      // Mobile Menu Toggle
+      const hamburgerMenu = document.getElementById("hamburgerMenu");
+      const mobileMenu = document.getElementById("mobileMenu");
+      const mobileMenuOverlay = document.getElementById("mobileMenuOverlay");
+
+      function toggleMobileMenu() {
+        mobileMenu.classList.toggle("open");
+        mobileMenuOverlay.classList.toggle("show");
+        hamburgerMenu.classList.toggle("active");
+      }
+
+      function closeMobileMenu() {
+        mobileMenu.classList.remove("open");
+        mobileMenuOverlay.classList.remove("show");
+        hamburgerMenu.classList.remove("active");
+      }
+
+      hamburgerMenu.addEventListener("click", toggleMobileMenu);
+      mobileMenuOverlay.addEventListener("click", closeMobileMenu);
+
+      // Sync mobile menu controls with desktop
+      const mobileMode = document.getElementById("mobileMode");
+      const desktopMode = document.getElementById("mode");
+
+      // Sync mode selection
+      mobileMode.addEventListener("change", (e) => {
+        desktopMode.value = e.target.value;
+        desktopMode.dispatchEvent(new Event("change"));
+      });
+
+      desktopMode.addEventListener("change", (e) => {
+        mobileMode.value = e.target.value;
+      });
+
+      // Mobile theme toggle
+      document.getElementById("mobileToggleThemeBtn").addEventListener("click", () => {
+        document.getElementById("toggleThemeBtn").click();
+        updateMobileThemeButton();
+      });
+
+      function updateMobileThemeButton() {
+        const isDark = document.body.classList.contains("dark");
+        document.getElementById("mobileToggleThemeBtn").textContent = isDark ? "☀️ Light Mode" : "🌙 Dark Mode";
+      }
+
+      // Mobile settings button
+      document.getElementById("mobileSettingsBtn").addEventListener("click", () => {
+        closeMobileMenu();
+        document.getElementById("settingsBtn").click();
+      });
+
+      // Mobile thinking stream button
+      document.getElementById("mobileThinkingStreamBtn").addEventListener("click", () => {
+        closeMobileMenu();
+        document.getElementById("thinkingStreamBtn").click();
+      });
+
+      // Mobile new session button
+      document.getElementById("mobileNewSessionBtn").addEventListener("click", () => {
+        closeMobileMenu();
+        document.getElementById("newSessionBtn").click();
+      });
+
+      // Mobile rename session button
+      document.getElementById("mobileRenameSessionBtn").addEventListener("click", () => {
+        closeMobileMenu();
+        document.getElementById("renameSessionBtn").click();
+      });
+
+      // Sync mobile session selector with desktop
+      document.getElementById("mobileSessions").addEventListener("change", async (e) => {
+        closeMobileMenu();
+        const desktopSessions = document.getElementById("sessions");
+        desktopSessions.value = e.target.value;
+        desktopSessions.dispatchEvent(new Event("change"));
+      });
+
+      // Mobile force reload button
+      document.getElementById("mobileForceReloadBtn").addEventListener("click", async () => {
+        if (confirm("Force reload the app? This will clear cache and reload.")) {
+          // Clear all caches if available
+          if ('caches' in window) {
+            const cacheNames = await caches.keys();
+            await Promise.all(cacheNames.map(name => caches.delete(name)));
+          }
+
+          // Force reload from server (bypass cache)
+          window.location.reload(true);
+        }
+      });
+
+      // Dark mode toggle - defaults to dark
+      const btn = document.getElementById("toggleThemeBtn");
+
+      // Set dark mode by default if no preference saved
+      const savedTheme = localStorage.getItem("theme");
+      if (!savedTheme || savedTheme === "dark") {
+        document.body.classList.add("dark");
+        btn.textContent = "☀️ Light Mode";
+        localStorage.setItem("theme", "dark");
+      } else {
+        btn.textContent = "🌙 Dark Mode";
+      }
+
+      btn.addEventListener("click", () => {
+        document.body.classList.toggle("dark");
+        const isDark = document.body.classList.contains("dark");
+        btn.textContent = isDark ? "☀️ Light Mode" : "🌙 Dark Mode";
+        localStorage.setItem("theme", isDark ? "dark" : "light");
+        updateMobileThemeButton();
+      });
+
+      // Initialize mobile theme button
+      updateMobileThemeButton();
+
+      // Sessions - Load from server
+	  (async () => {
+		await loadSessionsFromServer();
+		await renderSessions();
+
+		// Ensure we have at least one session
+		if (sessions.length === 0) {
+		  const id = generateSessionId();
+		  const name = "default";
+		  currentSession = id;
+		  history = [];
+		  await saveSession(); // Create empty session on server
+		  await saveSessionMetadata(id, name);
+		  await loadSessionsFromServer();
+		  await renderSessions();
+		  localStorage.setItem("currentSession", currentSession);
+		} else {
+		  // If no current session or current session doesn't exist, use first one
+		  if (!currentSession || !sessions.find(s => s.id === currentSession)) {
+			currentSession = sessions[0].id;
+			localStorage.setItem("currentSession", currentSession);
+		  }
+		}
+
+		// Load current session history
+		if (currentSession) {
+		  await loadSession(currentSession);
+		}
+	  })();
+
+	// Switch session
+	document.getElementById("sessions").addEventListener("change", async e => {
+	  currentSession = e.target.value;
+	  history = [];
+	  localStorage.setItem("currentSession", currentSession);
+	  addMessage("system", `Switched to session: ${getSessionName(currentSession)}`);
+	  await loadSession(currentSession);
+	});
+
+	// Create new session
+	document.getElementById("newSessionBtn").addEventListener("click", async () => {
+	  const name = prompt("Enter new session name:");
+	  if (!name) return;
+	  const id = generateSessionId();
+	  currentSession = id;
+	  history = [];
+	  localStorage.setItem("currentSession", currentSession);
+
+	  // Create session on server
+	  await saveSession();
+	  await saveSessionMetadata(id, name);
+	  await loadSessionsFromServer();
+	  await renderSessions();
+
+	  addMessage("system", `Created session: ${name}`);
+	});
+
+	// Rename session
+	document.getElementById("renameSessionBtn").addEventListener("click", async () => {
+	  const session = sessions.find(s => s.id === currentSession);
+	  if (!session) return;
+	  const newName = prompt("Rename session:", session.name || currentSession);
+	  if (!newName) return;
+
+	  // Update metadata on server
+	  await saveSessionMetadata(currentSession, newName);
+	  await loadSessionsFromServer();
+	  await renderSessions();
+
+	  addMessage("system", `Session renamed to: ${newName}`);
+	});
+
+      // Settings Modal
+      const settingsModal = document.getElementById("settingsModal");
+      const settingsBtn = document.getElementById("settingsBtn");
+      const closeModalBtn = document.getElementById("closeModalBtn");
+      const saveSettingsBtn = document.getElementById("saveSettingsBtn");
+      const cancelSettingsBtn = document.getElementById("cancelSettingsBtn");
+      const modalOverlay = document.querySelector(".modal-overlay");
+
+      // Load saved backend preference (default: local/free)
+      const savedBackend = localStorage.getItem("standardModeBackend") || "local";
+
+      // Set initial radio button state
+      const initialRadio = document.querySelector(`input[name="backend"][value="${savedBackend}"]`);
+      if (initialRadio) initialRadio.checked = true;
+
+      // Session management functions
+      async function loadSessionList() {
+        try {
+          // Reload from server to get latest
+          await loadSessionsFromServer();
+
+          const sessionListEl = document.getElementById("sessionList");
+          if (sessions.length === 0) {
+            sessionListEl.innerHTML = '<p style="color: var(--text-fade); font-size: 0.85rem;">No saved sessions found</p>';
+            return;
+          }
+
+          sessionListEl.innerHTML = "";
+          sessions.forEach(sess => {
+            const sessionItem = document.createElement("div");
+            sessionItem.className = "session-item";
+
+            const sessionInfo = document.createElement("div");
+            sessionInfo.className = "session-info";
+
+            const sessionName = sess.name || sess.id;
+            const lastModified = new Date(sess.lastModified).toLocaleString();
+
+            sessionInfo.innerHTML = `
+              <strong>${sessionName}</strong>
+              <small>${sess.messageCount} messages • ${lastModified}</small>
+            `;
+
+            const deleteBtn = document.createElement("button");
+            deleteBtn.className = "session-delete-btn";
+            deleteBtn.textContent = "🗑️";
+            deleteBtn.title = "Delete session";
+            deleteBtn.onclick = async () => {
+              if (!confirm(`Delete session "${sessionName}"?`)) return;
+
+              try {
+                await fetch(`${RELAY_BASE}/sessions/${sess.id}`, { method: "DELETE" });
+
+                // Reload sessions from server
+                await loadSessionsFromServer();
+
+                // If we deleted the current session, switch to another or create new
+                if (currentSession === sess.id) {
+                  if (sessions.length > 0) {
+                    currentSession = sessions[0].id;
+                    localStorage.setItem("currentSession", currentSession);
+                    history = [];
+                    await loadSession(currentSession);
+                  } else {
+                    const id = generateSessionId();
+                    const name = "default";
+                    currentSession = id;
+                    localStorage.setItem("currentSession", currentSession);
+                    history = [];
+                    await saveSession();
+                    await saveSessionMetadata(id, name);
+                    await loadSessionsFromServer();
+                  }
+                }
+
+                // Refresh both the dropdown and the settings list
+                await renderSessions();
+                await loadSessionList();
+
+                addMessage("system", `Deleted session: ${sessionName}`);
+              } catch (e) {
+                alert("Failed to delete session: " + e.message);
+              }
+            };
+
+            sessionItem.appendChild(sessionInfo);
+            sessionItem.appendChild(deleteBtn);
+            sessionListEl.appendChild(sessionItem);
+          });
+        } catch (e) {
+          const sessionListEl = document.getElementById("sessionList");
+          sessionListEl.innerHTML = '<p style="color: #ff3333; font-size: 0.85rem;">Failed to load sessions</p>';
+        }
+      }
+
+      // Show modal and load session list
+      settingsBtn.addEventListener("click", () => {
+        settingsModal.classList.add("show");
+        loadSessionList(); // Refresh session list when opening settings
+      });
+
+      // Hide modal functions
+      const hideModal = () => {
+        settingsModal.classList.remove("show");
+      };
+
+      closeModalBtn.addEventListener("click", hideModal);
+      cancelSettingsBtn.addEventListener("click", hideModal);
+      modalOverlay.addEventListener("click", hideModal);
+
+      // ESC key to close
+      document.addEventListener("keydown", (e) => {
+        if (e.key === "Escape" && settingsModal.classList.contains("show")) {
+          hideModal();
+        }
+      });
+
+      // Save settings
+      saveSettingsBtn.addEventListener("click", () => {
+        const selectedRadio = document.querySelector('input[name="backend"]:checked');
+        const backendValue = selectedRadio ? selectedRadio.value : "local";
+
+        localStorage.setItem("standardModeBackend", backendValue);
+        addMessage("system", `Backend changed to: ${backendValue}`);
+        hideModal();
+      });
+
+      // Health check
+      checkHealth();
+      setInterval(checkHealth, 10000);
+
+      // Input events
+      document.getElementById("sendBtn").addEventListener("click", sendMessage);
+      document.getElementById("userInput").addEventListener("keypress", e => {
+        if (e.key === "Enter") sendMessage();
+      });
+
+      // ========== THINKING STREAM INTEGRATION ==========
+      const thinkingPanel = document.getElementById("thinkingPanel");
+      const thinkingHeader = document.getElementById("thinkingHeader");
+      const thinkingToggleBtn = document.getElementById("thinkingToggleBtn");
+      const thinkingClearBtn = document.getElementById("thinkingClearBtn");
+      const thinkingContent = document.getElementById("thinkingContent");
+      const thinkingStatusDot = document.getElementById("thinkingStatusDot");
+      const thinkingEmpty = document.getElementById("thinkingEmpty");
+
+      let thinkingEventSource = null;
+      let thinkingEventCount = 0;
+      const CORTEX_BASE = "";  // same-origin; thinking stream is inert until cognitive layers exist
+
+      // Load thinking panel state from localStorage
+      const isPanelCollapsed = localStorage.getItem("thinkingPanelCollapsed") === "true";
+      if (!isPanelCollapsed) {
+        thinkingPanel.classList.remove("collapsed");
+      }
+
+      // Toggle thinking panel
+      thinkingHeader.addEventListener("click", (e) => {
+        if (e.target === thinkingClearBtn) return; // Don't toggle if clicking clear
+        thinkingPanel.classList.toggle("collapsed");
+        localStorage.setItem("thinkingPanelCollapsed", thinkingPanel.classList.contains("collapsed"));
+      });
+
+      // Clear thinking events
+      thinkingClearBtn.addEventListener("click", (e) => {
+        e.stopPropagation();
+        clearThinkingEvents();
+      });
+
+      function clearThinkingEvents() {
+        thinkingContent.innerHTML = '';
+        thinkingContent.appendChild(thinkingEmpty);
+        thinkingEventCount = 0;
+        // Clear from localStorage
+        if (currentSession) {
+          localStorage.removeItem(`thinkingEvents_${currentSession}`);
+        }
+      }
+
+      function connectThinkingStream() {
+        // Close existing connection
+        if (thinkingEventSource) {
+          thinkingEventSource.close();
+        }
+
+        // The server replays its recent buffer on connect, so start from a clean panel.
+        thinkingContent.innerHTML = '';
+        thinkingEventCount = 0;
+        thinkingContent.appendChild(thinkingEmpty);
+
+        const url = `${RELAY_BASE}/stream/logs`;  // global server activity feed
+        thinkingEventSource = new EventSource(url);
+
+        thinkingEventSource.onopen = () => {
+          thinkingStatusDot.className = 'thinking-status-dot connected';
+        };
+
+        thinkingEventSource.onmessage = (event) => {
+          try {
+            addLogEvent(JSON.parse(event.data));
+          } catch (e) {
+            console.error('Failed to parse log event:', e);
+          }
+        };
+
+        thinkingEventSource.onerror = () => {
+          thinkingStatusDot.className = 'thinking-status-dot disconnected';
+          // EventSource auto-reconnects; nothing to do here.
+        };
+      }
+
+      function escapeHtml(s) {
+        const d = document.createElement('div');
+        d.textContent = s == null ? '' : String(s);
+        return d.innerHTML;
+      }
+
+      function addLogEvent(event) {
+        // Remove empty state if present
+        if (thinkingEventCount === 0 && thinkingEmpty.parentNode) {
+          thinkingContent.removeChild(thinkingEmpty);
+        }
+
+        const level = event.level || 'info';
+        const time = new Date((event.ts || 0) * 1000).toLocaleTimeString();
+        const fields = Object.assign({}, event.fields || {});
+        // `detail` is rendered as an expandable block, not an inline field.
+        const detail = fields.detail;
+        delete fields.detail;
+        const fieldStr = Object.keys(fields).length
+          ? Object.entries(fields).map(([k, v]) => `${k}=${v}`).join('  ')
+          : '';
+
+        const eventDiv = document.createElement('div');
+        eventDiv.className = `log-line log-${level}`;
+        eventDiv.innerHTML = `
+          <span class="log-time">${escapeHtml(time)}</span>
+          <span class="log-level log-level-${level}">${escapeHtml(level)}</span>
+          <span class="log-msg">${escapeHtml(event.msg || '')}</span>
+          ${fieldStr ? `<span class="log-fields">${escapeHtml(fieldStr)}</span>` : ''}
+          ${detail ? `<details class="log-detail"><summary>view full prompt</summary><pre>${escapeHtml(detail)}</pre></details>` : ''}
+        `;
+
+        thinkingContent.appendChild(eventDiv);
+        thinkingContent.scrollTop = thinkingContent.scrollHeight;
+        thinkingEventCount++;
+      }
+
+      // (Log events are server-side and replayed on connect; no localStorage needed.)
+
+      // Live Log toggle button
+      document.getElementById("thinkingStreamBtn").addEventListener("click", () => {
+        thinkingPanel.classList.remove("collapsed");
+        localStorage.setItem("thinkingPanelCollapsed", "false");
+      });
+
+      // Mobile thinking stream button
+      document.getElementById("mobileThinkingStreamBtn").addEventListener("click", () => {
+        closeMobileMenu();
+        thinkingPanel.classList.remove("collapsed");
+        localStorage.setItem("thinkingPanelCollapsed", "false");
+      });
+
+      // Connect to the global live log on page load.
+      connectThinkingStream();
+
+      // The live log is global (server-wide), so it does not reconnect on session change.
+
+      // Cleanup on page unload
+      window.addEventListener('beforeunload', () => {
+        if (thinkingEventSource) {
+          thinkingEventSource.close();
+        }
+      });
+    });
+  </script>
+</body>
+</html>

lyra/web/static/manifest.json

@@ -0,0 +1,20 @@
+{
+  "name": "Lyra Chat",
+  "short_name": "Lyra",
+  "start_url": "./index.html",
+  "display": "standalone",
+  "background_color": "#181818",
+  "theme_color": "#181818",
+  "icons": [
+    {
+      "src": "icon-192.png",
+      "sizes": "192x192",
+      "type": "image/png"
+    },
+    {
+      "src": "icon-512.png",
+      "sizes": "512x512",
+      "type": "image/png"
+    }
+  ]
+}

lyra/web/static/style.css

@@ -0,0 +1,965 @@
+:root {
+  --bg-dark: #0a0a0a;
+  --bg-panel: rgba(255, 115, 0, 0.1);
+  --accent: #ff6600;
+  --accent-glow: 0 0 12px #ff6600cc;
+  --text-main: #e6e6e6;
+  --text-fade: #999;
+  --font-console: "IBM Plex Mono", monospace;
+}
+
+/* Light mode variables */
+body {
+  --bg-dark: #f5f5f5;
+  --bg-panel: rgba(255, 115, 0, 0.05);
+  --accent: #ff6600;
+  --accent-glow: 0 0 12px #ff6600cc;
+  --text-main: #1a1a1a;
+  --text-fade: #666;
+}
+
+/* Dark mode variables */
+body.dark {
+  --bg-dark: #0a0a0a;
+  --bg-panel: rgba(255, 115, 0, 0.1);
+  --accent: #ff6600;
+  --accent-glow: 0 0 12px #ff6600cc;
+  --text-main: #e6e6e6;
+  --text-fade: #999;
+}
+
+body {
+  margin: 0;
+  background: var(--bg-dark);
+  color: var(--text-main);
+  font-family: var(--font-console);
+  height: 100vh;
+  display: flex;
+  justify-content: center;
+  align-items: center;
+}
+
+#chat {
+  width: 95%;
+  max-width: 900px;
+  height: 95vh;
+  display: flex;
+  flex-direction: column;
+  border: 1px solid var(--accent);
+  border-radius: 10px;
+  box-shadow: var(--accent-glow);
+  background: var(--bg-dark);
+  overflow: hidden;
+}
+
+/* Header sections */
+#model-select, #session-select, #status {
+  display: flex;
+  align-items: center;
+  gap: 8px;
+  padding: 8px 12px;
+  border-bottom: 1px solid var(--accent);
+  background-color: rgba(255, 102, 0, 0.05);
+}
+#status {
+  justify-content: flex-start;
+  border-top: 1px solid var(--accent);
+}
+
+label, select, button {
+  font-family: var(--font-console);
+  font-size: 0.9rem;
+  color: var(--text-main);
+  background: transparent;
+  border: 1px solid var(--accent);
+  border-radius: 4px;
+  padding: 4px 8px;
+}
+
+button:hover, select:hover {
+  box-shadow: 0 0 8px var(--accent);
+  cursor: pointer;
+}
+
+#thinkingStreamBtn {
+  background: rgba(138, 43, 226, 0.2);
+  border-color: #8a2be2;
+}
+
+#thinkingStreamBtn:hover {
+  box-shadow: 0 0 8px #8a2be2;
+  background: rgba(138, 43, 226, 0.3);
+}
+
+/* Chat area */
+#messages {
+  flex: 1;
+  padding: 16px;
+  overflow-y: auto;
+  display: flex;
+  flex-direction: column;
+  gap: 8px;
+  scroll-behavior: smooth;
+}
+
+/* Messages */
+.msg {
+  max-width: 80%;
+  padding: 10px 14px;
+  border-radius: 8px;
+  line-height: 1.4;
+  word-wrap: break-word;
+  box-shadow: 0 0 8px rgba(255,102,0,0.2);
+}
+.msg.user {
+  align-self: flex-end;
+  background: rgba(255,102,0,0.15);
+  border: 1px solid var(--accent);
+}
+.msg.assistant {
+  align-self: flex-start;
+  background: rgba(255,102,0,0.08);
+  border: 1px solid rgba(255,102,0,0.5);
+}
+.msg.system {
+  align-self: center;
+  font-size: 0.8rem;
+  color: var(--text-fade);
+}
+
+/* Input bar */
+#input {
+  display: flex;
+  border-top: 1px solid var(--accent);
+  background: rgba(255, 102, 0, 0.05);
+  padding: 10px;
+}
+#userInput {
+  flex: 1;
+  background: transparent;
+  color: var(--text-main);
+  border: 1px solid var(--accent);
+  border-radius: 4px;
+  padding: 8px;
+}
+#sendBtn {
+  margin-left: 8px;
+}
+
+/* Relay status dot */
+#status {
+  display: flex;
+  align-items: center;
+  margin: 10px 0;
+  gap: 8px;
+  font-family: monospace;
+  color: #f5f5f5;
+}
+
+#status-dot {
+  width: 10px;
+  height: 10px;
+  border-radius: 50%;
+  display: inline-block;
+}
+
+@keyframes pulseGreen {
+  0% { box-shadow: 0 0 5px #00ff66; opacity: 0.9; }
+  50% { box-shadow: 0 0 20px #00ff99; opacity: 1; }
+  100% { box-shadow: 0 0 5px #00ff66; opacity: 0.9; }
+}
+
+.dot.ok {
+  background: #00ff66;
+  animation: pulseGreen 2s infinite ease-in-out;
+}
+
+/* Offline state stays solid red */
+.dot.fail {
+  background: #ff3333;
+  box-shadow: 0 0 10px #ff3333;
+}
+
+
+/* Dropdown (session selector) styling */
+select {
+  background-color: var(--bg-dark);
+  color: var(--text-main);
+  border: 1px solid #b84a12;
+  border-radius: 6px;
+  padding: 4px 6px;
+  font-size: 14px;
+}
+
+select option {
+  background-color: var(--bg-dark);
+  color: var(--text-main);
+}
+
+/* Hover/focus for better visibility */
+select:focus,
+select:hover {
+  outline: none;
+  border-color: #ff7a33;
+  background-color: var(--bg-panel);
+}
+
+/* Settings Modal */
+.modal {
+  display: none !important;
+  position: fixed;
+  top: 0;
+  left: 0;
+  width: 100%;
+  height: 100%;
+  z-index: 1000;
+}
+
+.modal.show {
+  display: block !important;
+}
+
+.modal-overlay {
+  position: fixed;
+  top: 0;
+  left: 0;
+  width: 100%;
+  height: 100%;
+  background: rgba(0, 0, 0, 0.8);
+  backdrop-filter: blur(4px);
+  z-index: 999;
+}
+
+.modal-content {
+  position: fixed;
+  top: 50%;
+  left: 50%;
+  transform: translate(-50%, -50%);
+  background: linear-gradient(180deg, rgba(255,102,0,0.1) 0%, rgba(10,10,10,0.95) 100%);
+  border: 2px solid var(--accent);
+  border-radius: 12px;
+  box-shadow: var(--accent-glow), 0 0 40px rgba(255,102,0,0.3);
+  min-width: 400px;
+  max-width: 600px;
+  max-height: 80vh;
+  overflow-y: auto;
+  z-index: 1001;
+}
+
+.modal-header {
+  display: flex;
+  justify-content: space-between;
+  align-items: center;
+  padding: 16px 20px;
+  border-bottom: 1px solid var(--accent);
+  background: rgba(255,102,0,0.1);
+}
+
+.modal-header h3 {
+  margin: 0;
+  font-size: 1.2rem;
+  color: var(--accent);
+}
+
+.close-btn {
+  background: transparent;
+  border: none;
+  color: var(--accent);
+  font-size: 1.5rem;
+  cursor: pointer;
+  padding: 0;
+  width: 30px;
+  height: 30px;
+  display: flex;
+  align-items: center;
+  justify-content: center;
+  border-radius: 4px;
+}
+
+.close-btn:hover {
+  background: rgba(255,102,0,0.2);
+  box-shadow: 0 0 8px var(--accent);
+}
+
+.modal-body {
+  padding: 20px;
+}
+
+.settings-section h4 {
+  margin: 0 0 8px 0;
+  color: var(--accent);
+  font-size: 1rem;
+}
+
+.settings-desc {
+  margin: 0 0 16px 0;
+  color: var(--text-fade);
+  font-size: 0.85rem;
+}
+
+.radio-group {
+  display: flex;
+  flex-direction: column;
+  gap: 12px;
+}
+
+.radio-label {
+  display: flex;
+  flex-direction: column;
+  padding: 12px;
+  border: 1px solid rgba(255,102,0,0.3);
+  border-radius: 6px;
+  background: rgba(255,102,0,0.05);
+  cursor: pointer;
+  transition: all 0.2s;
+}
+
+.radio-label:hover {
+  border-color: var(--accent);
+  background: rgba(255,102,0,0.1);
+  box-shadow: 0 0 8px rgba(255,102,0,0.3);
+}
+
+.radio-label input[type="radio"] {
+  margin-right: 8px;
+  accent-color: var(--accent);
+}
+
+.radio-label span {
+  font-weight: 500;
+  margin-bottom: 4px;
+}
+
+.radio-label small {
+  color: var(--text-fade);
+  font-size: 0.8rem;
+  margin-left: 24px;
+}
+
+.radio-label input[type="text"] {
+  margin-top: 8px;
+  margin-left: 24px;
+  padding: 6px;
+  background: rgba(0,0,0,0.3);
+  border: 1px solid rgba(255,102,0,0.5);
+  border-radius: 4px;
+  color: var(--text-main);
+  font-family: var(--font-console);
+}
+
+.radio-label input[type="text"]:focus {
+  outline: none;
+  border-color: var(--accent);
+  box-shadow: 0 0 8px rgba(255,102,0,0.3);
+}
+
+.modal-footer {
+  display: flex;
+  justify-content: flex-end;
+  gap: 10px;
+  padding: 16px 20px;
+  border-top: 1px solid var(--accent);
+  background: rgba(255,102,0,0.05);
+}
+
+.primary-btn {
+  background: var(--accent);
+  color: #000;
+  font-weight: bold;
+}
+
+.primary-btn:hover {
+  background: #ff7a33;
+  box-shadow: var(--accent-glow);
+}
+
+/* Session List */
+.session-list {
+  display: flex;
+  flex-direction: column;
+  gap: 8px;
+  max-height: 300px;
+  overflow-y: auto;
+}
+
+.session-item {
+  display: flex;
+  justify-content: space-between;
+  align-items: center;
+  padding: 12px;
+  border: 1px solid rgba(255,102,0,0.3);
+  border-radius: 6px;
+  background: rgba(255,102,0,0.05);
+  transition: all 0.2s;
+}
+
+.session-item:hover {
+  border-color: var(--accent);
+  background: rgba(255,102,0,0.1);
+}
+
+.session-info {
+  display: flex;
+  flex-direction: column;
+  gap: 4px;
+  flex: 1;
+}
+
+.session-info strong {
+  color: var(--text-main);
+  font-size: 0.95rem;
+}
+
+.session-info small {
+  color: var(--text-fade);
+  font-size: 0.75rem;
+}
+
+.session-delete-btn {
+  background: transparent;
+  border: 1px solid rgba(255,102,0,0.5);
+  color: var(--accent);
+  padding: 6px 10px;
+  border-radius: 4px;
+  cursor: pointer;
+  font-size: 1rem;
+  transition: all 0.2s;
+}
+
+.session-delete-btn:hover {
+  background: rgba(255,0,0,0.2);
+  border-color: #ff3333;
+  color: #ff3333;
+  box-shadow: 0 0 8px rgba(255,0,0,0.3);
+}
+
+/* Thinking Stream Panel */
+.thinking-panel {
+  border-top: 1px solid var(--accent);
+  background: rgba(255, 102, 0, 0.02);
+  display: flex;
+  flex-direction: column;
+  transition: max-height 0.3s ease;
+  max-height: 300px;
+}
+
+.thinking-panel.collapsed {
+  max-height: 40px;
+}
+
+.thinking-header {
+  display: flex;
+  justify-content: space-between;
+  align-items: center;
+  padding: 10px 12px;
+  background: rgba(255, 102, 0, 0.08);
+  cursor: pointer;
+  user-select: none;
+  border-bottom: 1px solid rgba(255, 102, 0, 0.2);
+  font-size: 0.9rem;
+  font-weight: 500;
+}
+
+.thinking-header:hover {
+  background: rgba(255, 102, 0, 0.12);
+}
+
+.thinking-controls {
+  display: flex;
+  align-items: center;
+  gap: 8px;
+}
+
+.thinking-status-dot {
+  width: 8px;
+  height: 8px;
+  border-radius: 50%;
+  background: #666;
+  display: inline-block;
+}
+
+.thinking-status-dot.connected {
+  background: #00ff66;
+  box-shadow: 0 0 8px #00ff66;
+}
+
+.thinking-status-dot.disconnected {
+  background: #ff3333;
+}
+
+.thinking-clear-btn,
+.thinking-toggle-btn {
+  background: transparent;
+  border: 1px solid rgba(255, 102, 0, 0.5);
+  color: var(--text-main);
+  padding: 4px 8px;
+  border-radius: 4px;
+  cursor: pointer;
+  font-size: 0.85rem;
+}
+
+.thinking-clear-btn:hover,
+.thinking-toggle-btn:hover {
+  background: rgba(255, 102, 0, 0.2);
+  box-shadow: 0 0 6px rgba(255, 102, 0, 0.3);
+}
+
+.thinking-toggle-btn {
+  transition: transform 0.3s ease;
+}
+
+.thinking-panel.collapsed .thinking-toggle-btn {
+  transform: rotate(-90deg);
+}
+
+.thinking-content {
+  flex: 1;
+  overflow-y: auto;
+  padding: 12px;
+  display: flex;
+  flex-direction: column;
+  gap: 8px;
+  min-height: 0;
+}
+
+.thinking-panel.collapsed .thinking-content {
+  display: none;
+}
+
+.thinking-empty {
+  text-align: center;
+  padding: 40px 20px;
+  color: var(--text-fade);
+  font-size: 0.85rem;
+}
+
+.thinking-empty-icon {
+  font-size: 2rem;
+  margin-bottom: 10px;
+}
+
+.thinking-event {
+  padding: 8px 12px;
+  border-radius: 6px;
+  font-size: 0.85rem;
+  font-family: 'Courier New', monospace;
+  animation: thinkingSlideIn 0.3s ease-out;
+  border-left: 3px solid;
+  word-wrap: break-word;
+}
+
+@keyframes thinkingSlideIn {
+  from {
+    opacity: 0;
+    transform: translateY(-10px);
+  }
+  to {
+    opacity: 1;
+    transform: translateY(0);
+  }
+}
+
+.thinking-event-connected {
+  background: rgba(0, 255, 102, 0.1);
+  border-color: #00ff66;
+  color: #00ff66;
+}
+
+.thinking-event-thinking {
+  background: rgba(138, 43, 226, 0.1);
+  border-color: #8a2be2;
+  color: #c79cff;
+}
+
+.thinking-event-tool_call {
+  background: rgba(255, 165, 0, 0.1);
+  border-color: #ffa500;
+  color: #ffb84d;
+}
+
+.thinking-event-tool_result {
+  background: rgba(0, 191, 255, 0.1);
+  border-color: #00bfff;
+  color: #7dd3fc;
+}
+
+.thinking-event-done {
+  background: rgba(168, 85, 247, 0.1);
+  border-color: #a855f7;
+  color: #e9d5ff;
+  font-weight: bold;
+}
+
+.thinking-event-error {
+  background: rgba(255, 51, 51, 0.1);
+  border-color: #ff3333;
+  color: #fca5a5;
+}
+
+.thinking-event-icon {
+  display: inline-block;
+  margin-right: 8px;
+}
+
+.thinking-event-details {
+  font-size: 0.75rem;
+  color: var(--text-fade);
+  margin-top: 4px;
+  padding-left: 20px;
+  white-space: pre-wrap;
+  max-height: 100px;
+  overflow-y: auto;
+}
+
+/* ========== MOBILE RESPONSIVE STYLES ========== */
+
+/* Hamburger Menu */
+.hamburger-menu {
+  display: none;
+  flex-direction: column;
+  gap: 4px;
+  cursor: pointer;
+  padding: 8px;
+  border: 1px solid var(--accent);
+  border-radius: 4px;
+  background: transparent;
+  z-index: 100;
+}
+
+.hamburger-menu span {
+  width: 20px;
+  height: 2px;
+  background: var(--accent);
+  transition: all 0.3s;
+  display: block;
+}
+
+.hamburger-menu.active span:nth-child(1) {
+  transform: rotate(45deg) translate(5px, 5px);
+}
+
+.hamburger-menu.active span:nth-child(2) {
+  opacity: 0;
+}
+
+.hamburger-menu.active span:nth-child(3) {
+  transform: rotate(-45deg) translate(5px, -5px);
+}
+
+/* Mobile Menu Container */
+.mobile-menu {
+  display: none;
+  position: fixed;
+  top: 0;
+  left: -100%;
+  width: 280px;
+  height: 100vh;
+  background: var(--bg-dark);
+  border-right: 2px solid var(--accent);
+  box-shadow: var(--accent-glow);
+  z-index: 999;
+  transition: left 0.3s ease;
+  overflow-y: auto;
+  padding: 20px;
+  flex-direction: column;
+  gap: 16px;
+}
+
+.mobile-menu.open {
+  left: 0;
+}
+
+.mobile-menu-overlay {
+  display: none;
+  position: fixed;
+  top: 0;
+  left: 0;
+  width: 100%;
+  height: 100%;
+  background: rgba(0, 0, 0, 0.7);
+  z-index: 998;
+}
+
+.mobile-menu-overlay.show {
+  display: block;
+}
+
+.mobile-menu-section {
+  display: flex;
+  flex-direction: column;
+  gap: 8px;
+  padding-bottom: 16px;
+  border-bottom: 1px solid rgba(255, 102, 0, 0.3);
+}
+
+.mobile-menu-section:last-child {
+  border-bottom: none;
+}
+
+.mobile-menu-section h4 {
+  margin: 0;
+  color: var(--accent);
+  font-size: 0.9rem;
+  text-transform: uppercase;
+  letter-spacing: 1px;
+}
+
+.mobile-menu button,
+.mobile-menu select {
+  width: 100%;
+  padding: 10px;
+  font-size: 0.95rem;
+  text-align: left;
+}
+
+/* Mobile Breakpoints */
+@media screen and (max-width: 768px) {
+  body {
+    padding: 0;
+  }
+
+  #chat {
+    width: 100%;
+    max-width: 100%;
+    height: 100vh;
+    border-radius: 0;
+    border-left: none;
+    border-right: none;
+  }
+
+  /* Show hamburger, hide desktop header controls */
+  .hamburger-menu {
+    display: flex;
+  }
+
+  #model-select {
+    padding: 12px;
+    justify-content: space-between;
+  }
+
+  /* Hide all controls except hamburger on mobile */
+  #model-select > *:not(.hamburger-menu) {
+    display: none;
+  }
+
+  #session-select {
+    display: none;
+  }
+
+  /* Show mobile menu */
+  .mobile-menu {
+    display: flex;
+  }
+
+  /* Messages - more width on mobile */
+  .msg {
+    max-width: 90%;
+    font-size: 0.95rem;
+  }
+
+  /* Status bar */
+  #status {
+    padding: 10px 12px;
+    font-size: 0.85rem;
+  }
+
+  /* Input area - bigger touch targets */
+  #input {
+    padding: 12px;
+  }
+
+  #userInput {
+    font-size: 16px; /* Prevents zoom on iOS */
+    padding: 12px;
+  }
+
+  #sendBtn {
+    padding: 12px 16px;
+    font-size: 1rem;
+  }
+
+  /* Modal - full width on mobile */
+  .modal-content {
+    width: 95%;
+    min-width: unset;
+    max-width: unset;
+    max-height: 90vh;
+    top: 50%;
+    left: 50%;
+    transform: translate(-50%, -50%);
+  }
+
+  .modal-header {
+    padding: 12px 16px;
+  }
+
+  .modal-body {
+    padding: 16px;
+  }
+
+  .modal-footer {
+    padding: 12px 16px;
+    flex-wrap: wrap;
+  }
+
+  .modal-footer button {
+    flex: 1;
+    min-width: 120px;
+  }
+
+  /* Radio labels - stack better on mobile */
+  .radio-label {
+    padding: 10px;
+  }
+
+  .radio-label small {
+    margin-left: 20px;
+    font-size: 0.75rem;
+  }
+
+  /* Session list */
+  .session-item {
+    padding: 10px;
+  }
+
+  .session-info strong {
+    font-size: 0.9rem;
+  }
+
+  .session-info small {
+    font-size: 0.7rem;
+  }
+
+  /* Settings button in header */
+  #settingsBtn {
+    padding: 8px 12px;
+  }
+
+  /* Thinking panel adjustments for mobile */
+  .thinking-panel {
+    max-height: 250px;
+  }
+
+  .thinking-panel.collapsed {
+    max-height: 38px;
+  }
+
+  .thinking-header {
+    padding: 8px 10px;
+    font-size: 0.85rem;
+  }
+
+  .thinking-event {
+    font-size: 0.8rem;
+    padding: 6px 10px;
+  }
+
+  .thinking-event-details {
+    font-size: 0.7rem;
+    max-height: 80px;
+  }
+}
+
+/* Extra small devices (phones in portrait) */
+@media screen and (max-width: 480px) {
+  .mobile-menu {
+    width: 240px;
+  }
+
+  .msg {
+    max-width: 95%;
+    font-size: 0.9rem;
+    padding: 8px 12px;
+  }
+
+  #userInput {
+    font-size: 16px;
+    padding: 10px;
+  }
+
+  #sendBtn {
+    padding: 10px 14px;
+    font-size: 0.95rem;
+  }
+
+  .modal-header h3 {
+    font-size: 1.1rem;
+  }
+
+  .settings-section h4 {
+    font-size: 0.95rem;
+  }
+
+  .radio-label span {
+    font-size: 0.9rem;
+  }
+}
+
+/* Tablet landscape and desktop */
+@media screen and (min-width: 769px) {
+  /* Ensure mobile menu is hidden on desktop */
+  .mobile-menu,
+  .mobile-menu-overlay {
+    display: none !important;
+  }
+
+  .hamburger-menu {
+    display: none !important;
+  }
+}
+
+/* ---- Live Log lines ---- */
+.log-line {
+  display: flex;
+  flex-wrap: wrap;
+  align-items: baseline;
+  gap: 8px;
+  padding: 4px 8px;
+  border-radius: 4px;
+  font-size: 0.8rem;
+  font-family: 'Courier New', monospace;
+  border-left: 3px solid var(--text-fade);
+  animation: thinkingSlideIn 0.25s ease-out;
+  word-break: break-word;
+}
+.log-time { color: var(--text-fade); flex-shrink: 0; }
+.log-level {
+  flex-shrink: 0;
+  text-transform: uppercase;
+  font-size: 0.7rem;
+  font-weight: bold;
+  letter-spacing: 0.05em;
+}
+.log-msg { color: var(--text); }
+.log-fields { color: var(--text-fade); width: 100%; padding-left: 4px; }
+
+.log-info    { border-left-color: #00bfff; }
+.log-info .log-level { color: #7dd3fc; }
+.log-debug   { border-left-color: #8a2be2; }
+.log-debug .log-level { color: #c79cff; }
+.log-error   { border-left-color: #ff3333; background: rgba(255,51,51,0.08); }
+.log-error .log-level, .log-error .log-msg { color: #fca5a5; }
+.log-system  { border-left-color: #00ff66; }
+.log-system .log-level { color: #00ff66; }
+
+.log-detail { width: 100%; margin-top: 4px; }
+.log-detail summary {
+  cursor: pointer;
+  color: var(--accent);
+  font-size: 0.72rem;
+  user-select: none;
+}
+.log-detail pre {
+  margin: 6px 0 0;
+  padding: 8px;
+  max-height: 340px;
+  overflow: auto;
+  background: rgba(0,0,0,0.25);
+  border-left: 2px solid var(--accent);
+  border-radius: 4px;
+  font-size: 0.72rem;
+  line-height: 1.4;
+  white-space: pre-wrap;
+  word-break: break-word;
+  color: var(--text);
+}

lyra/web/static/thinking-stream.html

@@ -0,0 +1,362 @@
+<!DOCTYPE html>
+<html lang="en">
+<head>
+    <meta charset="UTF-8">
+    <meta name="viewport" content="width=device-width, initial-scale=1.0">
+    <title>🧠 Thinking Stream</title>
+    <style>
+        * {
+            margin: 0;
+            padding: 0;
+            box-sizing: border-box;
+        }
+
+        body {
+            font-family: 'Segoe UI', Tahoma, Geneva, Verdana, sans-serif;
+            background: #0d0d0d;
+            color: #e0e0e0;
+            height: 100vh;
+            display: flex;
+            flex-direction: column;
+            overflow: hidden;
+        }
+
+        .header {
+            background: #1a1a1a;
+            padding: 15px 20px;
+            border-bottom: 2px solid #333;
+            display: flex;
+            align-items: center;
+            justify-content: space-between;
+        }
+
+        .header h1 {
+            font-size: 18px;
+            font-weight: bold;
+        }
+
+        .status {
+            display: flex;
+            align-items: center;
+            gap: 10px;
+            font-size: 14px;
+        }
+
+        .status-dot {
+            width: 10px;
+            height: 10px;
+            border-radius: 50%;
+            background: #666;
+        }
+
+        .status-dot.connected {
+            background: #90ee90;
+            box-shadow: 0 0 10px #90ee90;
+        }
+
+        .status-dot.disconnected {
+            background: #ff6b6b;
+        }
+
+        .events-container {
+            flex: 1;
+            overflow-y: auto;
+            padding: 20px;
+        }
+
+        .event {
+            margin-bottom: 12px;
+            padding: 10px 15px;
+            border-radius: 6px;
+            font-size: 14px;
+            font-family: 'Courier New', monospace;
+            animation: slideIn 0.3s ease-out;
+            border-left: 3px solid;
+        }
+
+        @keyframes slideIn {
+            from {
+                opacity: 0;
+                transform: translateX(-20px);
+            }
+            to {
+                opacity: 1;
+                transform: translateX(0);
+            }
+        }
+
+        .event-connected {
+            background: #1a2a1a;
+            border-color: #4a7c59;
+            color: #90ee90;
+        }
+
+        .event-thinking {
+            background: #1a3a1a;
+            border-color: #5a9c69;
+            color: #a0f0a0;
+        }
+
+        .event-tool_call {
+            background: #3a2a1a;
+            border-color: #d97706;
+            color: #fbbf24;
+        }
+
+        .event-tool_result {
+            background: #1a2a3a;
+            border-color: #0ea5e9;
+            color: #7dd3fc;
+        }
+
+        .event-done {
+            background: #2a1a3a;
+            border-color: #a855f7;
+            color: #e9d5ff;
+            font-weight: bold;
+        }
+
+        .event-error {
+            background: #3a1a1a;
+            border-color: #dc2626;
+            color: #fca5a5;
+        }
+
+        .event-icon {
+            display: inline-block;
+            margin-right: 8px;
+        }
+
+        .event-details {
+            font-size: 12px;
+            color: #999;
+            margin-top: 5px;
+            padding-left: 25px;
+        }
+
+        .footer {
+            background: #1a1a1a;
+            padding: 10px 20px;
+            border-top: 1px solid #333;
+            text-align: center;
+            font-size: 12px;
+            color: #666;
+        }
+
+        .clear-btn {
+            background: #333;
+            border: 1px solid #444;
+            color: #e0e0e0;
+            padding: 6px 12px;
+            border-radius: 4px;
+            cursor: pointer;
+            font-size: 12px;
+        }
+
+        .clear-btn:hover {
+            background: #444;
+        }
+
+        .empty-state {
+            text-align: center;
+            padding: 60px 20px;
+            color: #666;
+        }
+
+        .empty-state-icon {
+            font-size: 48px;
+            margin-bottom: 20px;
+        }
+    </style>
+</head>
+<body>
+    <div class="header">
+        <h1>🧠 Thinking Stream</h1>
+        <div class="status">
+            <div class="status-dot" id="statusDot"></div>
+            <span id="statusText">Connecting...</span>
+        </div>
+    </div>
+
+    <div class="events-container" id="events">
+        <div class="empty-state">
+            <div class="empty-state-icon">🤔</div>
+            <p>Waiting for thinking events...</p>
+            <p style="font-size: 12px; margin-top: 10px;">Events will appear here when Lyra uses tools</p>
+        </div>
+    </div>
+
+    <div class="footer">
+        <button class="clear-btn" onclick="clearEvents()">Clear Events</button>
+        <span style="margin: 0 20px;">|</span>
+        <span id="sessionInfo">Session: <span id="sessionId">-</span></span>
+    </div>
+
+    <script>
+        console.log('🧠 Thinking stream page loaded!');
+
+        // Get session ID from URL
+        const urlParams = new URLSearchParams(window.location.search);
+        const SESSION_ID = urlParams.get('session');
+        const CORTEX_BASE = "http://10.0.0.41:7081"; // Direct to cortex
+
+        console.log('Session ID:', SESSION_ID);
+        console.log('Cortex base:', CORTEX_BASE);
+
+        // Declare variables first
+        let eventSource = null;
+        let eventCount = 0;
+
+        if (!SESSION_ID) {
+            document.getElementById('events').innerHTML = `
+                <div class="empty-state">
+                    <div class="empty-state-icon">⚠️</div>
+                    <p>No session ID provided</p>
+                    <p style="font-size: 12px; margin-top: 10px;">Please open this from the main chat interface</p>
+                </div>
+            `;
+        } else {
+            document.getElementById('sessionId').textContent = SESSION_ID;
+            connectStream();
+        }
+
+        function connectStream() {
+            if (eventSource) {
+                eventSource.close();
+            }
+
+            const url = `${CORTEX_BASE}/stream/thinking/${SESSION_ID}`;
+            console.log('Connecting to:', url);
+
+            eventSource = new EventSource(url);
+
+            eventSource.onopen = () => {
+                console.log('EventSource onopen fired');
+                updateStatus(true, 'Connected');
+            };
+
+            eventSource.onmessage = (event) => {
+                console.log('Received message:', event.data);
+                try {
+                    const data = JSON.parse(event.data);
+                    // Update status to connected when first message arrives
+                    if (data.type === 'connected') {
+                        updateStatus(true, 'Connected');
+                    }
+                    addEvent(data);
+                } catch (e) {
+                    console.error('Failed to parse event:', e, event.data);
+                }
+            };
+
+            eventSource.onerror = (error) => {
+                console.error('Stream error:', error, 'readyState:', eventSource.readyState);
+                updateStatus(false, 'Disconnected');
+
+                // Try to reconnect after 2 seconds
+                setTimeout(() => {
+                    if (eventSource.readyState === EventSource.CLOSED) {
+                        console.log('Attempting to reconnect...');
+                        connectStream();
+                    }
+                }, 2000);
+            };
+        }
+
+        function updateStatus(connected, text) {
+            const dot = document.getElementById('statusDot');
+            const statusText = document.getElementById('statusText');
+
+            dot.className = 'status-dot ' + (connected ? 'connected' : 'disconnected');
+            statusText.textContent = text;
+        }
+
+        function addEvent(event) {
+            const container = document.getElementById('events');
+
+            // Remove empty state if present
+            if (eventCount === 0) {
+                container.innerHTML = '';
+            }
+
+            const eventDiv = document.createElement('div');
+            eventDiv.className = `event event-${event.type}`;
+
+            let icon = '';
+            let message = '';
+            let details = '';
+
+            switch (event.type) {
+                case 'connected':
+                    icon = '✓';
+                    message = 'Stream connected';
+                    details = `Session: ${event.session_id}`;
+                    break;
+
+                case 'thinking':
+                    icon = '🤔';
+                    message = event.data.message;
+                    break;
+
+                case 'tool_call':
+                    icon = '🔧';
+                    message = event.data.message;
+                    details = JSON.stringify(event.data.args, null, 2);
+                    break;
+
+                case 'tool_result':
+                    icon = '📊';
+                    message = event.data.message;
+                    if (event.data.result && event.data.result.stdout) {
+                        details = `stdout: ${event.data.result.stdout}`;
+                    }
+                    break;
+
+                case 'done':
+                    icon = '✅';
+                    message = event.data.message;
+                    details = event.data.final_answer;
+                    break;
+
+                case 'error':
+                    icon = '❌';
+                    message = event.data.message;
+                    break;
+
+                default:
+                    icon = '•';
+                    message = JSON.stringify(event.data);
+            }
+
+            eventDiv.innerHTML = `
+                <span class="event-icon">${icon}</span>
+                <span>${message}</span>
+                ${details ? `<div class="event-details">${details}</div>` : ''}
+            `;
+
+            container.appendChild(eventDiv);
+            container.scrollTop = container.scrollHeight;
+            eventCount++;
+        }
+
+        function clearEvents() {
+            const container = document.getElementById('events');
+            container.innerHTML = `
+                <div class="empty-state">
+                    <div class="empty-state-icon">🤔</div>
+                    <p>Waiting for thinking events...</p>
+                    <p style="font-size: 12px; margin-top: 10px;">Events will appear here when Lyra uses tools</p>
+                </div>
+            `;
+            eventCount = 0;
+        }
+
+        // Cleanup on page unload
+        window.addEventListener('beforeunload', () => {
+            if (eventSource) {
+                eventSource.close();
+            }
+        });
+    </script>
+</body>
+</html>

pyproject.toml

@@ -5,12 +5,19 @@ description = "Persistent, autonomous AI assistant"
 readme = "README.md"
 requires-python = ">=3.11"
 dependencies = [
+    "fastapi>=0.115",
     "httpx>=0.28.1",
     "numpy>=2.4.5",
     "openai>=2.37.0",
     "python-dotenv>=1.2.2",
+    "uvicorn[standard]>=0.34",
 ]
 
+[project.scripts]
+lyra = "lyra.__main__:main"
+lyra-web = "lyra.web.server:serve"
+lyra-import = "lyra.ingest:main"
+
 [dependency-groups]
 dev = [
     "pytest>=8.0",

uv.lock

@@ -2,6 +2,15 @@ version = 1
 revision = 3
 requires-python = ">=3.11"
 
+[[package]]
+name = "annotated-doc"
+version = "0.0.4"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/57/ba/046ceea27344560984e26a590f90bc7f4a75b06701f653222458922b558c/annotated_doc-0.0.4.tar.gz", hash = "sha256:fbcda96e87e9c92ad167c2e53839e57503ecfda18804ea28102353485033faa4", size = 7288, upload-time = "2025-11-10T22:07:42.062Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/1e/d3/26bf1008eb3d2daa8ef4cacc7f3bfdc11818d111f7e2d0201bc6e3b49d45/annotated_doc-0.0.4-py3-none-any.whl", hash = "sha256:571ac1dc6991c450b25a9c2d84a3705e2ae7a53467b5d111c24fa8baabbed320", size = 5303, upload-time = "2025-11-10T22:07:40.673Z" },
+]
+
 [[package]]
 name = "annotated-types"
 version = "0.7.0"
@@ -33,6 +42,18 @@ wheels = [
     { url = "https://files.pythonhosted.org/packages/22/30/7cd8fdcdfbc5b869528b079bfb76dcdf6056b1a2097a662e5e8c04f42965/certifi-2026.4.22-py3-none-any.whl", hash = "sha256:3cb2210c8f88ba2318d29b0388d1023c8492ff72ecdde4ebdaddbb13a31b1c4a", size = 135707, upload-time = "2026-04-22T11:26:09.372Z" },
 ]
 
+[[package]]
+name = "click"
+version = "8.4.1"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "colorama", marker = "sys_platform == 'win32'" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/9b/98/518d8e5081007684232226f475082b30087d0f585e8457db087298259f49/click-8.4.1.tar.gz", hash = "sha256:918b5633eddf6b41c32d4f454bf0de810065c74e3f7dbf8ee5452f8be88d3e96", size = 353007, upload-time = "2026-05-22T04:08:37.769Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/c7/0d/67e5b4109ea4a837e80daa87c2c696711955e40449a97e8926672534def2/click-8.4.1-py3-none-any.whl", hash = "sha256:482be17c6991b8c19c5429a1e995d9b0efdbb63172824c41f99965dc0ade8ec2", size = 116639, upload-time = "2026-05-22T04:08:35.26Z" },
+]
+
 [[package]]
 name = "colorama"
 version = "0.4.6"
@@ -51,6 +72,22 @@ wheels = [
     { url = "https://files.pythonhosted.org/packages/12/b3/231ffd4ab1fc9d679809f356cebee130ac7daa00d6d6f3206dd4fd137e9e/distro-1.9.0-py3-none-any.whl", hash = "sha256:7bffd925d65168f85027d8da9af6bddab658135b840670a223589bc0c8ef02b2", size = 20277, upload-time = "2023-12-24T09:54:30.421Z" },
 ]
 
+[[package]]
+name = "fastapi"
+version = "0.137.1"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "annotated-doc" },
+    { name = "pydantic" },
+    { name = "starlette" },
+    { name = "typing-extensions" },
+    { name = "typing-inspection" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/d5/b1/e5b92c59d2c37817e77c1a8c2fc1f79cdcc04c68253e5406b43e3204cba7/fastapi-0.137.1.tar.gz", hash = "sha256:822360704230d9533d8d9475399613525968aa2f0b5bd2a3ccc9f18c88fd541c", size = 408293, upload-time = "2026-06-15T11:28:20.79Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/da/35/380b9a5922f4340e51c309cde09e5bd32e62f02302971bee30dc15aa0624/fastapi-0.137.1-py3-none-any.whl", hash = "sha256:64f6983c59e45c4b9fdc44e57cb8035c2451ee91ea8e8ec042aca37de7cf6b69", size = 121877, upload-time = "2026-06-15T11:28:19.523Z" },
+]
+
 [[package]]
 name = "h11"
 version = "0.16.0"
@@ -73,6 +110,49 @@ wheels = [
     { url = "https://files.pythonhosted.org/packages/7e/f5/f66802a942d491edb555dd61e3a9961140fd64c90bce1eafd741609d334d/httpcore-1.0.9-py3-none-any.whl", hash = "sha256:2d400746a40668fc9dec9810239072b40b4484b640a8c38fd654a024c7a1bf55", size = 78784, upload-time = "2025-04-24T22:06:20.566Z" },
 ]
 
+[[package]]
+name = "httptools"
+version = "0.8.0"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/43/e5/d471fcb0e14523fe1c3f4ba58ca52480e7bd70ad7109a3846bc75892f7fb/httptools-0.8.0.tar.gz", hash = "sha256:6b2a32f18d97e16e90827d7a819ffa8dbd8cc245fc4e1fa9d1095b54ef4bd999", size = 271342, upload-time = "2026-05-25T22:17:48.841Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/f8/d2/c3eedaef57de65c3cc5f8dc244cf12d09c84ad258a479055aad6db23206c/httptools-0.8.0-cp311-cp311-macosx_10_9_universal2.whl", hash = "sha256:ed377e64805bdba4943c82717333f8f8603a13b09aff9cead2717c6c817fb168", size = 208428, upload-time = "2026-05-25T22:16:59.717Z" },
+    { url = "https://files.pythonhosted.org/packages/f1/94/dfe435d90d0ef61ec0f2cc3d480eef78c59727c6c2ce039f433882f6131a/httptools-0.8.0-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:9518c406d7b310f05adb1a37f80acabac40504a575d7c0da6d3e365c695ac20d", size = 113366, upload-time = "2026-05-25T22:17:00.795Z" },
+    { url = "https://files.pythonhosted.org/packages/cc/d4/13025f1a56e615dcb331e0bbe2d9a1143212b58c263385fc5d2e558f5bac/httptools-0.8.0-cp311-cp311-manylinux1_x86_64.manylinux_2_28_x86_64.manylinux_2_5_x86_64.whl", hash = "sha256:57278e6fa0424c42a8a3e454828ab4f0aff27b40cddf9679579b98c6dce6a376", size = 464676, upload-time = "2026-05-25T22:17:02.014Z" },
+    { url = "https://files.pythonhosted.org/packages/bf/95/4c1c26c0b985f8a3331682d802598f14e32dc41bf7509266eb2c04ad4801/httptools-0.8.0-cp311-cp311-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:bbb8caadb2b742d293169d2b458b5c001ef70e3158704aa3d3ef9597624c5d1d", size = 464235, upload-time = "2026-05-25T22:17:03.109Z" },
+    { url = "https://files.pythonhosted.org/packages/a2/82/6735be2b0ca527718c431cdb8e5f70c3862c0844a687df0f572c51e11497/httptools-0.8.0-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:52dd695b865fe96d9d2b16b64a895f3f57bf3cb064e8383cd3b5713a069e8085", size = 449809, upload-time = "2026-05-25T22:17:04.443Z" },
+    { url = "https://files.pythonhosted.org/packages/b5/f9/5811c74f37a758c8a4aa3dc430375119d335947e883efc4664d8f3559a41/httptools-0.8.0-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:20b4aac66ff65f7db06a375808b78f42a94970aa22e826b3cb2b43eb09174124", size = 452174, upload-time = "2026-05-25T22:17:05.476Z" },
+    { url = "https://files.pythonhosted.org/packages/cc/94/97b75870dea07b71e3ec535cebe525b08d723152e4c7d13fa887e51f4de2/httptools-0.8.0-cp311-cp311-win_amd64.whl", hash = "sha256:a1b4c8e7a489a0d750d91894e9a8cdc295838f1924c0ca903ae993456fddec07", size = 90991, upload-time = "2026-05-25T22:17:06.75Z" },
+    { url = "https://files.pythonhosted.org/packages/14/88/1d21a36da8f5cb0fa49eafd4b169eba5608d57e75bbcf61845cbc6243216/httptools-0.8.0-cp312-cp312-macosx_10_13_universal2.whl", hash = "sha256:880490234c10f70a9830743097e8958d6e4b9f5a0ffc24515023afeef984054d", size = 208247, upload-time = "2026-05-25T22:17:07.843Z" },
+    { url = "https://files.pythonhosted.org/packages/a5/42/cc4feea2945cb3051038f090c9b36bd5b8a9d7f5a894a506a8983e33fd1c/httptools-0.8.0-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:5931891fb7b441b8a3853cf1b85c82c903defce084dd5f6771ca46e31bf862c5", size = 113064, upload-time = "2026-05-25T22:17:09.136Z" },
+    { url = "https://files.pythonhosted.org/packages/e3/a6/febbb8b8db0f58b38e44ad6cb946e6a255ae49b55f2e8543408fb7501ccd/httptools-0.8.0-cp312-cp312-manylinux1_x86_64.manylinux_2_28_x86_64.manylinux_2_5_x86_64.whl", hash = "sha256:b15fc622b0f869d19207c4089a501d9bcc63ca5e071ffdd2f03f922df882dcb2", size = 523851, upload-time = "2026-05-25T22:17:10.106Z" },
+    { url = "https://files.pythonhosted.org/packages/b7/e4/f90a0df0b83beff265b7e3b65f2a4cefd95792d4be0ac3e16049f2acd3c2/httptools-0.8.0-cp312-cp312-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:425f83884fd6343828d8c565f046cb72b6d19063f6924093e11bcd8e1548cd09", size = 518842, upload-time = "2026-05-25T22:17:11.218Z" },
+    { url = "https://files.pythonhosted.org/packages/9e/2d/0c9ac76dd2c893841fbf6498d6acec4f2442e1b7067f6e3e316a80e494e8/httptools-0.8.0-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:ef7c3c97f4311c7be57e2986629df89d49cb434dbff78eafcd48c2bff986b15a", size = 501238, upload-time = "2026-05-25T22:17:12.728Z" },
+    { url = "https://files.pythonhosted.org/packages/ca/42/906adc91ae3a5fa9c59c0a2f21c139725bd7e5b41ae6acd485cd14123ebf/httptools-0.8.0-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:a1afd7c9fbff0d9f5d489c4ce2768bd09c84a46ddefc7161e6aa82ae35c85745", size = 509567, upload-time = "2026-05-25T22:17:13.842Z" },
+    { url = "https://files.pythonhosted.org/packages/05/0b/4240efeb672751ee5b9b380cb0e3fdc050bc05f68adc7a8aefc4fcd9a69a/httptools-0.8.0-cp312-cp312-win_amd64.whl", hash = "sha256:cd96f29b4bab1d42fa6e3d008711c75e0f79e94e06827330160e3a304227f150", size = 90918, upload-time = "2026-05-25T22:17:15.155Z" },
+    { url = "https://files.pythonhosted.org/packages/5e/e5/8cfcabc5546e8022f168be28bcdaa128a240a0befdd03b59d558b4f18bd6/httptools-0.8.0-cp313-cp313-macosx_10_13_universal2.whl", hash = "sha256:614ceea8ea606848bece2338ac03b3ce5324bcb4be8dc7d377ed708012fa4db8", size = 205148, upload-time = "2026-05-25T22:17:16.333Z" },
+    { url = "https://files.pythonhosted.org/packages/2a/0e/0fb14848c19a686c8062ff9067c1a48793e3224b47bc5b201535b6036fce/httptools-0.8.0-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:2d689918c15a013c65ef52d9fd495d766893ab831a2c8d89f2ac5940a5df847c", size = 111368, upload-time = "2026-05-25T22:17:17.586Z" },
+    { url = "https://files.pythonhosted.org/packages/2e/1b/46f1cecf06b9bbde8e4b8c88034ac7908989e5ff7a3a388ef38392949c1f/httptools-0.8.0-cp313-cp313-manylinux1_x86_64.manylinux_2_28_x86_64.manylinux_2_5_x86_64.whl", hash = "sha256:eb3028cca2fc0a6d720e52ef61d8ebb62fcbfeb1de56874546d858d3f25a26b7", size = 486447, upload-time = "2026-05-25T22:17:18.564Z" },
+    { url = "https://files.pythonhosted.org/packages/77/00/258bfc0837221f81d9725c45f9b948a6a6b2994a147a4fb66e85100c668f/httptools-0.8.0-cp313-cp313-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:88bdd940f2b5d487b4d032c6afa5489a7dc4694410d43de3c38c4fb3af0dc45d", size = 482448, upload-time = "2026-05-25T22:17:19.912Z" },
+    { url = "https://files.pythonhosted.org/packages/04/ab/d1cef3b5523f4d272a70f42a776c3169a2dddfe3a54de4b2ce4a36341528/httptools-0.8.0-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:6a43c9dd399758ccc0531acb0a3c4a6c299ee893ee9400e9c893b7bdcfae0681", size = 464460, upload-time = "2026-05-25T22:17:20.882Z" },
+    { url = "https://files.pythonhosted.org/packages/ce/48/5d1d072442277bb2b3434e0e60690b8e8c23840ef7de8b6ea54040a536d3/httptools-0.8.0-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:0770728beb05094c809b98e814edff5fef69d26ad7d21185f2f6d5884a0ba683", size = 471312, upload-time = "2026-05-25T22:17:22.085Z" },
+    { url = "https://files.pythonhosted.org/packages/0d/66/b96623b27e51a68199ef4efdda0613cced9233fe3062ac74e50749c5ad37/httptools-0.8.0-cp313-cp313-win_amd64.whl", hash = "sha256:7685df791fad561384bfb139e77fde27a1ffd93134e016f95a0db424ffbf77b1", size = 90117, upload-time = "2026-05-25T22:17:23.074Z" },
+    { url = "https://files.pythonhosted.org/packages/1a/12/fa3fbf5f9517b273edea2dc982aa82a8c634091e67c590792b729017bc6f/httptools-0.8.0-cp314-cp314-macosx_10_13_universal2.whl", hash = "sha256:de242a49b5d18e0a8776e654e9f6bf6d89f3875a5c35b425a0e7ce940feb3fd6", size = 206183, upload-time = "2026-05-25T22:17:24.004Z" },
+    { url = "https://files.pythonhosted.org/packages/30/fc/5e7c4cb443370f2090a3aba0453a07384d29ff66b7435bb90e77e1037599/httptools-0.8.0-cp314-cp314-macosx_11_0_arm64.whl", hash = "sha256:159e9ab5f701ccd42e555a12f1ad8ff69702910fc1c996cf2bb66e5fcb7a231b", size = 112079, upload-time = "2026-05-25T22:17:25.216Z" },
+    { url = "https://files.pythonhosted.org/packages/ba/53/771bd891eb0f236f32145d6a1775777ec85745f3cc983a1f23d1a3b8ddfe/httptools-0.8.0-cp314-cp314-manylinux1_x86_64.manylinux_2_28_x86_64.manylinux_2_5_x86_64.whl", hash = "sha256:c4a9f1707e4823d54dfec6c33fa3697d302aed536ed352a7ebb5a061ddb869d0", size = 481596, upload-time = "2026-05-25T22:17:26.186Z" },
+    { url = "https://files.pythonhosted.org/packages/62/42/94e15bc68ce3d423243c45d7f1b0c7561f13844f97dc52ae23182fb65628/httptools-0.8.0-cp314-cp314-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:d76ad7b951387e3632c8716a9bb03ac5b45c5f16119aa409db0459520887944e", size = 480865, upload-time = "2026-05-25T22:17:27.542Z" },
+    { url = "https://files.pythonhosted.org/packages/1c/7c/fe2980fc03723272e30f135b62360b075f513dfe7cc73aef36c7f04012bd/httptools-0.8.0-cp314-cp314-musllinux_1_2_aarch64.whl", hash = "sha256:a3b7387147361c3fd47a0bde763c5c91b5b4cd4dc9989b8ece84ff436c99843b", size = 463189, upload-time = "2026-05-25T22:17:28.546Z" },
+    { url = "https://files.pythonhosted.org/packages/15/1b/47fc5fff68acd1bfa20b4734059c9a06cadb88119dcd5258b5b0d21d91c8/httptools-0.8.0-cp314-cp314-musllinux_1_2_x86_64.whl", hash = "sha256:f256d6ce930c52ca1cb2a960b7da03548c454e7d28b06059ad41bfe789036ce0", size = 466610, upload-time = "2026-05-25T22:17:29.816Z" },
+    { url = "https://files.pythonhosted.org/packages/60/bd/07b13c93ffd9bec9546e0d43f8e19378dd696dbd278511406bc07371ef1f/httptools-0.8.0-cp314-cp314-win_amd64.whl", hash = "sha256:19d1ee275bb59ba2643ba9a3a1e51cc0c788caf2b8df506368e03f56fdd08527", size = 92705, upload-time = "2026-05-25T22:17:31.133Z" },
+    { url = "https://files.pythonhosted.org/packages/fd/c4/121648f68ce066d7bd762d6b6d97e620847642d38d54f3d90ff11d947629/httptools-0.8.0-cp314-cp314t-macosx_10_13_universal2.whl", hash = "sha256:de1ed58a974e75d56560acc7e7fed01a454994429456f65209789992e41f2568", size = 215023, upload-time = "2026-05-25T22:17:32.401Z" },
+    { url = "https://files.pythonhosted.org/packages/b9/b0/312a062ae741ae3e8baa8c8bf20be81b2e67337b259ab4349bebc7b6142e/httptools-0.8.0-cp314-cp314t-macosx_11_0_arm64.whl", hash = "sha256:e93c227b595c6926c1acee96891dd9da4be338cfbe82e5cd3bb9d8dd7dc4ac0b", size = 117405, upload-time = "2026-05-25T22:17:33.742Z" },
+    { url = "https://files.pythonhosted.org/packages/fc/37/fccd705f795386bb05bf413012fecff2a33e5aa8c2f069096de3e9fd8702/httptools-0.8.0-cp314-cp314t-manylinux1_x86_64.manylinux_2_28_x86_64.manylinux_2_5_x86_64.whl", hash = "sha256:2a021c3a8e65cc125390d72f59b968afca3bdcaff25bd67965e0a055a14946ca", size = 558497, upload-time = "2026-05-25T22:17:34.732Z" },
+    { url = "https://files.pythonhosted.org/packages/bd/39/f172e8003576de35f5ba77ff417cf0e34429d35dc014deef15afa337a72c/httptools-0.8.0-cp314-cp314t-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:48774d39cbb70e2b1f71f88852a3087ae1d3a1eb80482bb48c13067ab080c14f", size = 571585, upload-time = "2026-05-25T22:17:35.813Z" },
+    { url = "https://files.pythonhosted.org/packages/3e/b9/f5564760af99f3dbbf3f9104dc00e5da27e96cf433c6bdcf77617f70bf3f/httptools-0.8.0-cp314-cp314t-musllinux_1_2_aarch64.whl", hash = "sha256:88eead8ec8680a9f146c655bc88445a325bd7921cfd8194c7337e9467282427d", size = 543297, upload-time = "2026-05-25T22:17:37.08Z" },
+    { url = "https://files.pythonhosted.org/packages/99/67/8d9f2c313618e161b82f3873188e7196126da1d6e29688df40eb3997c77a/httptools-0.8.0-cp314-cp314t-musllinux_1_2_x86_64.whl", hash = "sha256:2c032fa028f46871ec7e1fc59fc15e8023eab3e6bbe6ece786a1611719a5d081", size = 539535, upload-time = "2026-05-25T22:17:38.032Z" },
+    { url = "https://files.pythonhosted.org/packages/48/63/b906c01e53f50d432c0defe43ce52764a111dc1bdd028bafbeb54dcfd008/httptools-0.8.0-cp314-cp314t-win_amd64.whl", hash = "sha256:384c17174464c8e873398b7af24f0b1f44d992c820328413951a625323155d77", size = 108209, upload-time = "2026-05-25T22:17:39.473Z" },
+]
+
 [[package]]
 name = "httpx"
 version = "0.28.1"
@@ -201,10 +281,12 @@ name = "lyra"
 version = "0.1.0"
 source = { editable = "." }
 dependencies = [
+    { name = "fastapi" },
     { name = "httpx" },
     { name = "numpy" },
     { name = "openai" },
     { name = "python-dotenv" },
+    { name = "uvicorn", extra = ["standard"] },
 ]
 
 [package.dev-dependencies]
@@ -215,10 +297,12 @@ dev = [
 
 [package.metadata]
 requires-dist = [
+    { name = "fastapi", specifier = ">=0.115" },
     { name = "httpx", specifier = ">=0.28.1" },
     { name = "numpy", specifier = ">=2.4.5" },
     { name = "openai", specifier = ">=2.37.0" },
     { name = "python-dotenv", specifier = ">=1.2.2" },
+    { name = "uvicorn", extras = ["standard"], specifier = ">=0.34" },
 ]
 
 [package.metadata.requires-dev]
@@ -494,6 +578,61 @@ wheels = [
     { url = "https://files.pythonhosted.org/packages/0b/d7/1959b9648791274998a9c3526f6d0ec8fd2233e4d4acce81bbae76b44b2a/python_dotenv-1.2.2-py3-none-any.whl", hash = "sha256:1d8214789a24de455a8b8bd8ae6fe3c6b69a5e3d64aa8a8e5d68e694bbcb285a", size = 22101, upload-time = "2026-03-01T16:00:25.09Z" },
 ]
 
+[[package]]
+name = "pyyaml"
+version = "6.0.3"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/05/8e/961c0007c59b8dd7729d542c61a4d537767a59645b82a0b521206e1e25c2/pyyaml-6.0.3.tar.gz", hash = "sha256:d76623373421df22fb4cf8817020cbb7ef15c725b9d5e45f17e189bfc384190f", size = 130960, upload-time = "2025-09-25T21:33:16.546Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/6d/16/a95b6757765b7b031c9374925bb718d55e0a9ba8a1b6a12d25962ea44347/pyyaml-6.0.3-cp311-cp311-macosx_10_13_x86_64.whl", hash = "sha256:44edc647873928551a01e7a563d7452ccdebee747728c1080d881d68af7b997e", size = 185826, upload-time = "2025-09-25T21:31:58.655Z" },
+    { url = "https://files.pythonhosted.org/packages/16/19/13de8e4377ed53079ee996e1ab0a9c33ec2faf808a4647b7b4c0d46dd239/pyyaml-6.0.3-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:652cb6edd41e718550aad172851962662ff2681490a8a711af6a4d288dd96824", size = 175577, upload-time = "2025-09-25T21:32:00.088Z" },
+    { url = "https://files.pythonhosted.org/packages/0c/62/d2eb46264d4b157dae1275b573017abec435397aa59cbcdab6fc978a8af4/pyyaml-6.0.3-cp311-cp311-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:10892704fc220243f5305762e276552a0395f7beb4dbf9b14ec8fd43b57f126c", size = 775556, upload-time = "2025-09-25T21:32:01.31Z" },
+    { url = "https://files.pythonhosted.org/packages/10/cb/16c3f2cf3266edd25aaa00d6c4350381c8b012ed6f5276675b9eba8d9ff4/pyyaml-6.0.3-cp311-cp311-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:850774a7879607d3a6f50d36d04f00ee69e7fc816450e5f7e58d7f17f1ae5c00", size = 882114, upload-time = "2025-09-25T21:32:03.376Z" },
+    { url = "https://files.pythonhosted.org/packages/71/60/917329f640924b18ff085ab889a11c763e0b573da888e8404ff486657602/pyyaml-6.0.3-cp311-cp311-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:b8bb0864c5a28024fac8a632c443c87c5aa6f215c0b126c449ae1a150412f31d", size = 806638, upload-time = "2025-09-25T21:32:04.553Z" },
+    { url = "https://files.pythonhosted.org/packages/dd/6f/529b0f316a9fd167281a6c3826b5583e6192dba792dd55e3203d3f8e655a/pyyaml-6.0.3-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:1d37d57ad971609cf3c53ba6a7e365e40660e3be0e5175fa9f2365a379d6095a", size = 767463, upload-time = "2025-09-25T21:32:06.152Z" },
+    { url = "https://files.pythonhosted.org/packages/f2/6a/b627b4e0c1dd03718543519ffb2f1deea4a1e6d42fbab8021936a4d22589/pyyaml-6.0.3-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:37503bfbfc9d2c40b344d06b2199cf0e96e97957ab1c1b546fd4f87e53e5d3e4", size = 794986, upload-time = "2025-09-25T21:32:07.367Z" },
+    { url = "https://files.pythonhosted.org/packages/45/91/47a6e1c42d9ee337c4839208f30d9f09caa9f720ec7582917b264defc875/pyyaml-6.0.3-cp311-cp311-win32.whl", hash = "sha256:8098f252adfa6c80ab48096053f512f2321f0b998f98150cea9bd23d83e1467b", size = 142543, upload-time = "2025-09-25T21:32:08.95Z" },
+    { url = "https://files.pythonhosted.org/packages/da/e3/ea007450a105ae919a72393cb06f122f288ef60bba2dc64b26e2646fa315/pyyaml-6.0.3-cp311-cp311-win_amd64.whl", hash = "sha256:9f3bfb4965eb874431221a3ff3fdcddc7e74e3b07799e0e84ca4a0f867d449bf", size = 158763, upload-time = "2025-09-25T21:32:09.96Z" },
+    { url = "https://files.pythonhosted.org/packages/d1/33/422b98d2195232ca1826284a76852ad5a86fe23e31b009c9886b2d0fb8b2/pyyaml-6.0.3-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:7f047e29dcae44602496db43be01ad42fc6f1cc0d8cd6c83d342306c32270196", size = 182063, upload-time = "2025-09-25T21:32:11.445Z" },
+    { url = "https://files.pythonhosted.org/packages/89/a0/6cf41a19a1f2f3feab0e9c0b74134aa2ce6849093d5517a0c550fe37a648/pyyaml-6.0.3-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:fc09d0aa354569bc501d4e787133afc08552722d3ab34836a80547331bb5d4a0", size = 173973, upload-time = "2025-09-25T21:32:12.492Z" },
+    { url = "https://files.pythonhosted.org/packages/ed/23/7a778b6bd0b9a8039df8b1b1d80e2e2ad78aa04171592c8a5c43a56a6af4/pyyaml-6.0.3-cp312-cp312-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:9149cad251584d5fb4981be1ecde53a1ca46c891a79788c0df828d2f166bda28", size = 775116, upload-time = "2025-09-25T21:32:13.652Z" },
+    { url = "https://files.pythonhosted.org/packages/65/30/d7353c338e12baef4ecc1b09e877c1970bd3382789c159b4f89d6a70dc09/pyyaml-6.0.3-cp312-cp312-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:5fdec68f91a0c6739b380c83b951e2c72ac0197ace422360e6d5a959d8d97b2c", size = 844011, upload-time = "2025-09-25T21:32:15.21Z" },
+    { url = "https://files.pythonhosted.org/packages/8b/9d/b3589d3877982d4f2329302ef98a8026e7f4443c765c46cfecc8858c6b4b/pyyaml-6.0.3-cp312-cp312-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:ba1cc08a7ccde2d2ec775841541641e4548226580ab850948cbfda66a1befcdc", size = 807870, upload-time = "2025-09-25T21:32:16.431Z" },
+    { url = "https://files.pythonhosted.org/packages/05/c0/b3be26a015601b822b97d9149ff8cb5ead58c66f981e04fedf4e762f4bd4/pyyaml-6.0.3-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:8dc52c23056b9ddd46818a57b78404882310fb473d63f17b07d5c40421e47f8e", size = 761089, upload-time = "2025-09-25T21:32:17.56Z" },
+    { url = "https://files.pythonhosted.org/packages/be/8e/98435a21d1d4b46590d5459a22d88128103f8da4c2d4cb8f14f2a96504e1/pyyaml-6.0.3-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:41715c910c881bc081f1e8872880d3c650acf13dfa8214bad49ed4cede7c34ea", size = 790181, upload-time = "2025-09-25T21:32:18.834Z" },
+    { url = "https://files.pythonhosted.org/packages/74/93/7baea19427dcfbe1e5a372d81473250b379f04b1bd3c4c5ff825e2327202/pyyaml-6.0.3-cp312-cp312-win32.whl", hash = "sha256:96b533f0e99f6579b3d4d4995707cf36df9100d67e0c8303a0c55b27b5f99bc5", size = 137658, upload-time = "2025-09-25T21:32:20.209Z" },
+    { url = "https://files.pythonhosted.org/packages/86/bf/899e81e4cce32febab4fb42bb97dcdf66bc135272882d1987881a4b519e9/pyyaml-6.0.3-cp312-cp312-win_amd64.whl", hash = "sha256:5fcd34e47f6e0b794d17de1b4ff496c00986e1c83f7ab2fb8fcfe9616ff7477b", size = 154003, upload-time = "2025-09-25T21:32:21.167Z" },
+    { url = "https://files.pythonhosted.org/packages/1a/08/67bd04656199bbb51dbed1439b7f27601dfb576fb864099c7ef0c3e55531/pyyaml-6.0.3-cp312-cp312-win_arm64.whl", hash = "sha256:64386e5e707d03a7e172c0701abfb7e10f0fb753ee1d773128192742712a98fd", size = 140344, upload-time = "2025-09-25T21:32:22.617Z" },
+    { url = "https://files.pythonhosted.org/packages/d1/11/0fd08f8192109f7169db964b5707a2f1e8b745d4e239b784a5a1dd80d1db/pyyaml-6.0.3-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:8da9669d359f02c0b91ccc01cac4a67f16afec0dac22c2ad09f46bee0697eba8", size = 181669, upload-time = "2025-09-25T21:32:23.673Z" },
+    { url = "https://files.pythonhosted.org/packages/b1/16/95309993f1d3748cd644e02e38b75d50cbc0d9561d21f390a76242ce073f/pyyaml-6.0.3-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:2283a07e2c21a2aa78d9c4442724ec1eb15f5e42a723b99cb3d822d48f5f7ad1", size = 173252, upload-time = "2025-09-25T21:32:25.149Z" },
+    { url = "https://files.pythonhosted.org/packages/50/31/b20f376d3f810b9b2371e72ef5adb33879b25edb7a6d072cb7ca0c486398/pyyaml-6.0.3-cp313-cp313-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:ee2922902c45ae8ccada2c5b501ab86c36525b883eff4255313a253a3160861c", size = 767081, upload-time = "2025-09-25T21:32:26.575Z" },
+    { url = "https://files.pythonhosted.org/packages/49/1e/a55ca81e949270d5d4432fbbd19dfea5321eda7c41a849d443dc92fd1ff7/pyyaml-6.0.3-cp313-cp313-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:a33284e20b78bd4a18c8c2282d549d10bc8408a2a7ff57653c0cf0b9be0afce5", size = 841159, upload-time = "2025-09-25T21:32:27.727Z" },
+    { url = "https://files.pythonhosted.org/packages/74/27/e5b8f34d02d9995b80abcef563ea1f8b56d20134d8f4e5e81733b1feceb2/pyyaml-6.0.3-cp313-cp313-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:0f29edc409a6392443abf94b9cf89ce99889a1dd5376d94316ae5145dfedd5d6", size = 801626, upload-time = "2025-09-25T21:32:28.878Z" },
+    { url = "https://files.pythonhosted.org/packages/f9/11/ba845c23988798f40e52ba45f34849aa8a1f2d4af4b798588010792ebad6/pyyaml-6.0.3-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:f7057c9a337546edc7973c0d3ba84ddcdf0daa14533c2065749c9075001090e6", size = 753613, upload-time = "2025-09-25T21:32:30.178Z" },
+    { url = "https://files.pythonhosted.org/packages/3d/e0/7966e1a7bfc0a45bf0a7fb6b98ea03fc9b8d84fa7f2229e9659680b69ee3/pyyaml-6.0.3-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:eda16858a3cab07b80edaf74336ece1f986ba330fdb8ee0d6c0d68fe82bc96be", size = 794115, upload-time = "2025-09-25T21:32:31.353Z" },
+    { url = "https://files.pythonhosted.org/packages/de/94/980b50a6531b3019e45ddeada0626d45fa85cbe22300844a7983285bed3b/pyyaml-6.0.3-cp313-cp313-win32.whl", hash = "sha256:d0eae10f8159e8fdad514efdc92d74fd8d682c933a6dd088030f3834bc8e6b26", size = 137427, upload-time = "2025-09-25T21:32:32.58Z" },
+    { url = "https://files.pythonhosted.org/packages/97/c9/39d5b874e8b28845e4ec2202b5da735d0199dbe5b8fb85f91398814a9a46/pyyaml-6.0.3-cp313-cp313-win_amd64.whl", hash = "sha256:79005a0d97d5ddabfeeea4cf676af11e647e41d81c9a7722a193022accdb6b7c", size = 154090, upload-time = "2025-09-25T21:32:33.659Z" },
+    { url = "https://files.pythonhosted.org/packages/73/e8/2bdf3ca2090f68bb3d75b44da7bbc71843b19c9f2b9cb9b0f4ab7a5a4329/pyyaml-6.0.3-cp313-cp313-win_arm64.whl", hash = "sha256:5498cd1645aa724a7c71c8f378eb29ebe23da2fc0d7a08071d89469bf1d2defb", size = 140246, upload-time = "2025-09-25T21:32:34.663Z" },
+    { url = "https://files.pythonhosted.org/packages/9d/8c/f4bd7f6465179953d3ac9bc44ac1a8a3e6122cf8ada906b4f96c60172d43/pyyaml-6.0.3-cp314-cp314-macosx_10_13_x86_64.whl", hash = "sha256:8d1fab6bb153a416f9aeb4b8763bc0f22a5586065f86f7664fc23339fc1c1fac", size = 181814, upload-time = "2025-09-25T21:32:35.712Z" },
+    { url = "https://files.pythonhosted.org/packages/bd/9c/4d95bb87eb2063d20db7b60faa3840c1b18025517ae857371c4dd55a6b3a/pyyaml-6.0.3-cp314-cp314-macosx_11_0_arm64.whl", hash = "sha256:34d5fcd24b8445fadc33f9cf348c1047101756fd760b4dacb5c3e99755703310", size = 173809, upload-time = "2025-09-25T21:32:36.789Z" },
+    { url = "https://files.pythonhosted.org/packages/92/b5/47e807c2623074914e29dabd16cbbdd4bf5e9b2db9f8090fa64411fc5382/pyyaml-6.0.3-cp314-cp314-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:501a031947e3a9025ed4405a168e6ef5ae3126c59f90ce0cd6f2bfc477be31b7", size = 766454, upload-time = "2025-09-25T21:32:37.966Z" },
+    { url = "https://files.pythonhosted.org/packages/02/9e/e5e9b168be58564121efb3de6859c452fccde0ab093d8438905899a3a483/pyyaml-6.0.3-cp314-cp314-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:b3bc83488de33889877a0f2543ade9f70c67d66d9ebb4ac959502e12de895788", size = 836355, upload-time = "2025-09-25T21:32:39.178Z" },
+    { url = "https://files.pythonhosted.org/packages/88/f9/16491d7ed2a919954993e48aa941b200f38040928474c9e85ea9e64222c3/pyyaml-6.0.3-cp314-cp314-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:c458b6d084f9b935061bc36216e8a69a7e293a2f1e68bf956dcd9e6cbcd143f5", size = 794175, upload-time = "2025-09-25T21:32:40.865Z" },
+    { url = "https://files.pythonhosted.org/packages/dd/3f/5989debef34dc6397317802b527dbbafb2b4760878a53d4166579111411e/pyyaml-6.0.3-cp314-cp314-musllinux_1_2_aarch64.whl", hash = "sha256:7c6610def4f163542a622a73fb39f534f8c101d690126992300bf3207eab9764", size = 755228, upload-time = "2025-09-25T21:32:42.084Z" },
+    { url = "https://files.pythonhosted.org/packages/d7/ce/af88a49043cd2e265be63d083fc75b27b6ed062f5f9fd6cdc223ad62f03e/pyyaml-6.0.3-cp314-cp314-musllinux_1_2_x86_64.whl", hash = "sha256:5190d403f121660ce8d1d2c1bb2ef1bd05b5f68533fc5c2ea899bd15f4399b35", size = 789194, upload-time = "2025-09-25T21:32:43.362Z" },
+    { url = "https://files.pythonhosted.org/packages/23/20/bb6982b26a40bb43951265ba29d4c246ef0ff59c9fdcdf0ed04e0687de4d/pyyaml-6.0.3-cp314-cp314-win_amd64.whl", hash = "sha256:4a2e8cebe2ff6ab7d1050ecd59c25d4c8bd7e6f400f5f82b96557ac0abafd0ac", size = 156429, upload-time = "2025-09-25T21:32:57.844Z" },
+    { url = "https://files.pythonhosted.org/packages/f4/f4/a4541072bb9422c8a883ab55255f918fa378ecf083f5b85e87fc2b4eda1b/pyyaml-6.0.3-cp314-cp314-win_arm64.whl", hash = "sha256:93dda82c9c22deb0a405ea4dc5f2d0cda384168e466364dec6255b293923b2f3", size = 143912, upload-time = "2025-09-25T21:32:59.247Z" },
+    { url = "https://files.pythonhosted.org/packages/7c/f9/07dd09ae774e4616edf6cda684ee78f97777bdd15847253637a6f052a62f/pyyaml-6.0.3-cp314-cp314t-macosx_10_13_x86_64.whl", hash = "sha256:02893d100e99e03eda1c8fd5c441d8c60103fd175728e23e431db1b589cf5ab3", size = 189108, upload-time = "2025-09-25T21:32:44.377Z" },
+    { url = "https://files.pythonhosted.org/packages/4e/78/8d08c9fb7ce09ad8c38ad533c1191cf27f7ae1effe5bb9400a46d9437fcf/pyyaml-6.0.3-cp314-cp314t-macosx_11_0_arm64.whl", hash = "sha256:c1ff362665ae507275af2853520967820d9124984e0f7466736aea23d8611fba", size = 183641, upload-time = "2025-09-25T21:32:45.407Z" },
+    { url = "https://files.pythonhosted.org/packages/7b/5b/3babb19104a46945cf816d047db2788bcaf8c94527a805610b0289a01c6b/pyyaml-6.0.3-cp314-cp314t-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:6adc77889b628398debc7b65c073bcb99c4a0237b248cacaf3fe8a557563ef6c", size = 831901, upload-time = "2025-09-25T21:32:48.83Z" },
+    { url = "https://files.pythonhosted.org/packages/8b/cc/dff0684d8dc44da4d22a13f35f073d558c268780ce3c6ba1b87055bb0b87/pyyaml-6.0.3-cp314-cp314t-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:a80cb027f6b349846a3bf6d73b5e95e782175e52f22108cfa17876aaeff93702", size = 861132, upload-time = "2025-09-25T21:32:50.149Z" },
+    { url = "https://files.pythonhosted.org/packages/b1/5e/f77dc6b9036943e285ba76b49e118d9ea929885becb0a29ba8a7c75e29fe/pyyaml-6.0.3-cp314-cp314t-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:00c4bdeba853cc34e7dd471f16b4114f4162dc03e6b7afcc2128711f0eca823c", size = 839261, upload-time = "2025-09-25T21:32:51.808Z" },
+    { url = "https://files.pythonhosted.org/packages/ce/88/a9db1376aa2a228197c58b37302f284b5617f56a5d959fd1763fb1675ce6/pyyaml-6.0.3-cp314-cp314t-musllinux_1_2_aarch64.whl", hash = "sha256:66e1674c3ef6f541c35191caae2d429b967b99e02040f5ba928632d9a7f0f065", size = 805272, upload-time = "2025-09-25T21:32:52.941Z" },
+    { url = "https://files.pythonhosted.org/packages/da/92/1446574745d74df0c92e6aa4a7b0b3130706a4142b2d1a5869f2eaa423c6/pyyaml-6.0.3-cp314-cp314t-musllinux_1_2_x86_64.whl", hash = "sha256:16249ee61e95f858e83976573de0f5b2893b3677ba71c9dd36b9cf8be9ac6d65", size = 829923, upload-time = "2025-09-25T21:32:54.537Z" },
+    { url = "https://files.pythonhosted.org/packages/f0/7a/1c7270340330e575b92f397352af856a8c06f230aa3e76f86b39d01b416a/pyyaml-6.0.3-cp314-cp314t-win_amd64.whl", hash = "sha256:4ad1906908f2f5ae4e5a8ddfce73c320c2a1429ec52eafd27138b7f1cbe341c9", size = 174062, upload-time = "2025-09-25T21:32:55.767Z" },
+    { url = "https://files.pythonhosted.org/packages/f1/12/de94a39c2ef588c7e6455cfbe7343d3b2dc9d6b6b2f40c4c6565744c873d/pyyaml-6.0.3-cp314-cp314t-win_arm64.whl", hash = "sha256:ebc55a14a21cb14062aa4162f906cd962b28e2e9ea38f9b4391244cd8de4ae0b", size = 149341, upload-time = "2025-09-25T21:32:56.828Z" },
+]
+
 [[package]]
 name = "ruff"
 version = "0.15.13"
@@ -528,6 +667,19 @@ wheels = [
     { url = "https://files.pythonhosted.org/packages/e9/44/75a9c9421471a6c4805dbf2356f7c181a29c1879239abab1ea2cc8f38b40/sniffio-1.3.1-py3-none-any.whl", hash = "sha256:2f6da418d1f1e0fddd844478f41680e794e6051915791a034ff65e5f100525a2", size = 10235, upload-time = "2024-02-25T23:20:01.196Z" },
 ]
 
+[[package]]
+name = "starlette"
+version = "1.3.1"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "anyio" },
+    { name = "typing-extensions", marker = "python_full_version < '3.13'" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/eb/e3/7c1dc7381d9f8ab7d854328ebfa884e62cb3f3d8549ddfd37c7814f42afa/starlette-1.3.1.tar.gz", hash = "sha256:05d0213193f2fbaae60e2ecb593b4add4262ad4e46536b54abe36f11a71724e0", size = 2703240, upload-time = "2026-06-12T09:23:11.602Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/ec/bb/2799cc2ede3ed41131f8975621e7213dfc7ef4acbbaadfa440f32500c370/starlette-1.3.1-py3-none-any.whl", hash = "sha256:c7372aae11c3c3f26a42df7bd626cec2f47d03483d261d369516a615a53714c6", size = 73632, upload-time = "2026-06-12T09:23:10.017Z" },
+]
+
 [[package]]
 name = "tqdm"
 version = "4.67.3"
@@ -560,3 +712,228 @@ sdist = { url = "https://files.pythonhosted.org/packages/55/e3/70399cb7dd41c10ac
 wheels = [
     { url = "https://files.pythonhosted.org/packages/dc/9b/47798a6c91d8bdb567fe2698fe81e0c6b7cb7ef4d13da4114b41d239f65d/typing_inspection-0.4.2-py3-none-any.whl", hash = "sha256:4ed1cacbdc298c220f1bd249ed5287caa16f34d44ef4e9c3d0cbad5b521545e7", size = 14611, upload-time = "2025-10-01T02:14:40.154Z" },
 ]
+
+[[package]]
+name = "uvicorn"
+version = "0.49.0"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "click" },
+    { name = "h11" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/c4/1f/fa18009dea8469069cca78a4e877a008ab78f08b064bfc9ab891579077ff/uvicorn-0.49.0.tar.gz", hash = "sha256:ebf4271aa580d9de97f93192d4595176df6e91f9aae919ca73e4fc07df1e66a3", size = 91284, upload-time = "2026-06-03T22:01:30.448Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/88/fa/e1388bbcf24ef3274f45c0c1c7b501fd14971037c1b6ee23610553307497/uvicorn-0.49.0-py3-none-any.whl", hash = "sha256:ba3d14c3ee7e41c6c654c46c9eb489d33213cdd30aa1696eab1374337c13f68f", size = 71376, upload-time = "2026-06-03T22:01:29.037Z" },
+]
+
+[package.optional-dependencies]
+standard = [
+    { name = "colorama", marker = "sys_platform == 'win32'" },
+    { name = "httptools" },
+    { name = "python-dotenv" },
+    { name = "pyyaml" },
+    { name = "uvloop", marker = "platform_python_implementation != 'PyPy' and sys_platform != 'cygwin' and sys_platform != 'win32'" },
+    { name = "watchfiles" },
+    { name = "websockets" },
+]
+
+[[package]]
+name = "uvloop"
+version = "0.22.1"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/06/f0/18d39dbd1971d6d62c4629cc7fa67f74821b0dc1f5a77af43719de7936a7/uvloop-0.22.1.tar.gz", hash = "sha256:6c84bae345b9147082b17371e3dd5d42775bddce91f885499017f4607fdaf39f", size = 2443250, upload-time = "2025-10-16T22:17:19.342Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/c7/d5/69900f7883235562f1f50d8184bb7dd84a2fb61e9ec63f3782546fdbd057/uvloop-0.22.1-cp311-cp311-macosx_10_9_universal2.whl", hash = "sha256:c60ebcd36f7b240b30788554b6f0782454826a0ed765d8430652621b5de674b9", size = 1352420, upload-time = "2025-10-16T22:16:21.187Z" },
+    { url = "https://files.pythonhosted.org/packages/a8/73/c4e271b3bce59724e291465cc936c37758886a4868787da0278b3b56b905/uvloop-0.22.1-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:3b7f102bf3cb1995cfeaee9321105e8f5da76fdb104cdad8986f85461a1b7b77", size = 748677, upload-time = "2025-10-16T22:16:22.558Z" },
+    { url = "https://files.pythonhosted.org/packages/86/94/9fb7fad2f824d25f8ecac0d70b94d0d48107ad5ece03769a9c543444f78a/uvloop-0.22.1-cp311-cp311-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:53c85520781d84a4b8b230e24a5af5b0778efdb39142b424990ff1ef7c48ba21", size = 3753819, upload-time = "2025-10-16T22:16:23.903Z" },
+    { url = "https://files.pythonhosted.org/packages/74/4f/256aca690709e9b008b7108bc85fba619a2bc37c6d80743d18abad16ee09/uvloop-0.22.1-cp311-cp311-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:56a2d1fae65fd82197cb8c53c367310b3eabe1bbb9fb5a04d28e3e3520e4f702", size = 3804529, upload-time = "2025-10-16T22:16:25.246Z" },
+    { url = "https://files.pythonhosted.org/packages/7f/74/03c05ae4737e871923d21a76fe28b6aad57f5c03b6e6bfcfa5ad616013e4/uvloop-0.22.1-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:40631b049d5972c6755b06d0bfe8233b1bd9a8a6392d9d1c45c10b6f9e9b2733", size = 3621267, upload-time = "2025-10-16T22:16:26.819Z" },
+    { url = "https://files.pythonhosted.org/packages/75/be/f8e590fe61d18b4a92070905497aec4c0e64ae1761498cad09023f3f4b3e/uvloop-0.22.1-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:535cc37b3a04f6cd2c1ef65fa1d370c9a35b6695df735fcff5427323f2cd5473", size = 3723105, upload-time = "2025-10-16T22:16:28.252Z" },
+    { url = "https://files.pythonhosted.org/packages/3d/ff/7f72e8170be527b4977b033239a83a68d5c881cc4775fca255c677f7ac5d/uvloop-0.22.1-cp312-cp312-macosx_10_13_universal2.whl", hash = "sha256:fe94b4564e865d968414598eea1a6de60adba0c040ba4ed05ac1300de402cd42", size = 1359936, upload-time = "2025-10-16T22:16:29.436Z" },
+    { url = "https://files.pythonhosted.org/packages/c3/c6/e5d433f88fd54d81ef4be58b2b7b0cea13c442454a1db703a1eea0db1a59/uvloop-0.22.1-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:51eb9bd88391483410daad430813d982010f9c9c89512321f5b60e2cddbdddd6", size = 752769, upload-time = "2025-10-16T22:16:30.493Z" },
+    { url = "https://files.pythonhosted.org/packages/24/68/a6ac446820273e71aa762fa21cdcc09861edd3536ff47c5cd3b7afb10eeb/uvloop-0.22.1-cp312-cp312-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:700e674a166ca5778255e0e1dc4e9d79ab2acc57b9171b79e65feba7184b3370", size = 4317413, upload-time = "2025-10-16T22:16:31.644Z" },
+    { url = "https://files.pythonhosted.org/packages/5f/6f/e62b4dfc7ad6518e7eff2516f680d02a0f6eb62c0c212e152ca708a0085e/uvloop-0.22.1-cp312-cp312-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:7b5b1ac819a3f946d3b2ee07f09149578ae76066d70b44df3fa990add49a82e4", size = 4426307, upload-time = "2025-10-16T22:16:32.917Z" },
+    { url = "https://files.pythonhosted.org/packages/90/60/97362554ac21e20e81bcef1150cb2a7e4ffdaf8ea1e5b2e8bf7a053caa18/uvloop-0.22.1-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:e047cc068570bac9866237739607d1313b9253c3051ad84738cbb095be0537b2", size = 4131970, upload-time = "2025-10-16T22:16:34.015Z" },
+    { url = "https://files.pythonhosted.org/packages/99/39/6b3f7d234ba3964c428a6e40006340f53ba37993f46ed6e111c6e9141d18/uvloop-0.22.1-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:512fec6815e2dd45161054592441ef76c830eddaad55c8aa30952e6fe1ed07c0", size = 4296343, upload-time = "2025-10-16T22:16:35.149Z" },
+    { url = "https://files.pythonhosted.org/packages/89/8c/182a2a593195bfd39842ea68ebc084e20c850806117213f5a299dfc513d9/uvloop-0.22.1-cp313-cp313-macosx_10_13_universal2.whl", hash = "sha256:561577354eb94200d75aca23fbde86ee11be36b00e52a4eaf8f50fb0c86b7705", size = 1358611, upload-time = "2025-10-16T22:16:36.833Z" },
+    { url = "https://files.pythonhosted.org/packages/d2/14/e301ee96a6dc95224b6f1162cd3312f6d1217be3907b79173b06785f2fe7/uvloop-0.22.1-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:1cdf5192ab3e674ca26da2eada35b288d2fa49fdd0f357a19f0e7c4e7d5077c8", size = 751811, upload-time = "2025-10-16T22:16:38.275Z" },
+    { url = "https://files.pythonhosted.org/packages/b7/02/654426ce265ac19e2980bfd9ea6590ca96a56f10c76e63801a2df01c0486/uvloop-0.22.1-cp313-cp313-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:6e2ea3d6190a2968f4a14a23019d3b16870dd2190cd69c8180f7c632d21de68d", size = 4288562, upload-time = "2025-10-16T22:16:39.375Z" },
+    { url = "https://files.pythonhosted.org/packages/15/c0/0be24758891ef825f2065cd5db8741aaddabe3e248ee6acc5e8a80f04005/uvloop-0.22.1-cp313-cp313-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:0530a5fbad9c9e4ee3f2b33b148c6a64d47bbad8000ea63704fa8260f4cf728e", size = 4366890, upload-time = "2025-10-16T22:16:40.547Z" },
+    { url = "https://files.pythonhosted.org/packages/d2/53/8369e5219a5855869bcee5f4d317f6da0e2c669aecf0ef7d371e3d084449/uvloop-0.22.1-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:bc5ef13bbc10b5335792360623cc378d52d7e62c2de64660616478c32cd0598e", size = 4119472, upload-time = "2025-10-16T22:16:41.694Z" },
+    { url = "https://files.pythonhosted.org/packages/f8/ba/d69adbe699b768f6b29a5eec7b47dd610bd17a69de51b251126a801369ea/uvloop-0.22.1-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:1f38ec5e3f18c8a10ded09742f7fb8de0108796eb673f30ce7762ce1b8550cad", size = 4239051, upload-time = "2025-10-16T22:16:43.224Z" },
+    { url = "https://files.pythonhosted.org/packages/90/cd/b62bdeaa429758aee8de8b00ac0dd26593a9de93d302bff3d21439e9791d/uvloop-0.22.1-cp314-cp314-macosx_10_13_universal2.whl", hash = "sha256:3879b88423ec7e97cd4eba2a443aa26ed4e59b45e6b76aabf13fe2f27023a142", size = 1362067, upload-time = "2025-10-16T22:16:44.503Z" },
+    { url = "https://files.pythonhosted.org/packages/0d/f8/a132124dfda0777e489ca86732e85e69afcd1ff7686647000050ba670689/uvloop-0.22.1-cp314-cp314-macosx_10_13_x86_64.whl", hash = "sha256:4baa86acedf1d62115c1dc6ad1e17134476688f08c6efd8a2ab076e815665c74", size = 752423, upload-time = "2025-10-16T22:16:45.968Z" },
+    { url = "https://files.pythonhosted.org/packages/a3/94/94af78c156f88da4b3a733773ad5ba0b164393e357cc4bd0ab2e2677a7d6/uvloop-0.22.1-cp314-cp314-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:297c27d8003520596236bdb2335e6b3f649480bd09e00d1e3a99144b691d2a35", size = 4272437, upload-time = "2025-10-16T22:16:47.451Z" },
+    { url = "https://files.pythonhosted.org/packages/b5/35/60249e9fd07b32c665192cec7af29e06c7cd96fa1d08b84f012a56a0b38e/uvloop-0.22.1-cp314-cp314-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:c1955d5a1dd43198244d47664a5858082a3239766a839b2102a269aaff7a4e25", size = 4292101, upload-time = "2025-10-16T22:16:49.318Z" },
+    { url = "https://files.pythonhosted.org/packages/02/62/67d382dfcb25d0a98ce73c11ed1a6fba5037a1a1d533dcbb7cab033a2636/uvloop-0.22.1-cp314-cp314-musllinux_1_2_aarch64.whl", hash = "sha256:b31dc2fccbd42adc73bc4e7cdbae4fc5086cf378979e53ca5d0301838c5682c6", size = 4114158, upload-time = "2025-10-16T22:16:50.517Z" },
+    { url = "https://files.pythonhosted.org/packages/f0/7a/f1171b4a882a5d13c8b7576f348acfe6074d72eaf52cccef752f748d4a9f/uvloop-0.22.1-cp314-cp314-musllinux_1_2_x86_64.whl", hash = "sha256:93f617675b2d03af4e72a5333ef89450dfaa5321303ede6e67ba9c9d26878079", size = 4177360, upload-time = "2025-10-16T22:16:52.646Z" },
+    { url = "https://files.pythonhosted.org/packages/79/7b/b01414f31546caf0919da80ad57cbfe24c56b151d12af68cee1b04922ca8/uvloop-0.22.1-cp314-cp314t-macosx_10_13_universal2.whl", hash = "sha256:37554f70528f60cad66945b885eb01f1bb514f132d92b6eeed1c90fd54ed6289", size = 1454790, upload-time = "2025-10-16T22:16:54.355Z" },
+    { url = "https://files.pythonhosted.org/packages/d4/31/0bb232318dd838cad3fa8fb0c68c8b40e1145b32025581975e18b11fab40/uvloop-0.22.1-cp314-cp314t-macosx_10_13_x86_64.whl", hash = "sha256:b76324e2dc033a0b2f435f33eb88ff9913c156ef78e153fb210e03c13da746b3", size = 796783, upload-time = "2025-10-16T22:16:55.906Z" },
+    { url = "https://files.pythonhosted.org/packages/42/38/c9b09f3271a7a723a5de69f8e237ab8e7803183131bc57c890db0b6bb872/uvloop-0.22.1-cp314-cp314t-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:badb4d8e58ee08dad957002027830d5c3b06aea446a6a3744483c2b3b745345c", size = 4647548, upload-time = "2025-10-16T22:16:57.008Z" },
+    { url = "https://files.pythonhosted.org/packages/c1/37/945b4ca0ac27e3dc4952642d4c900edd030b3da6c9634875af6e13ae80e5/uvloop-0.22.1-cp314-cp314t-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:b91328c72635f6f9e0282e4a57da7470c7350ab1c9f48546c0f2866205349d21", size = 4467065, upload-time = "2025-10-16T22:16:58.206Z" },
+    { url = "https://files.pythonhosted.org/packages/97/cc/48d232f33d60e2e2e0b42f4e73455b146b76ebe216487e862700457fbf3c/uvloop-0.22.1-cp314-cp314t-musllinux_1_2_aarch64.whl", hash = "sha256:daf620c2995d193449393d6c62131b3fbd40a63bf7b307a1527856ace637fe88", size = 4328384, upload-time = "2025-10-16T22:16:59.36Z" },
+    { url = "https://files.pythonhosted.org/packages/e4/16/c1fd27e9549f3c4baf1dc9c20c456cd2f822dbf8de9f463824b0c0357e06/uvloop-0.22.1-cp314-cp314t-musllinux_1_2_x86_64.whl", hash = "sha256:6cde23eeda1a25c75b2e07d39970f3374105d5eafbaab2a4482be82f272d5a5e", size = 4296730, upload-time = "2025-10-16T22:17:00.744Z" },
+]
+
+[[package]]
+name = "watchfiles"
+version = "1.2.0"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "anyio" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/cd/41/5e1a4bb12aac5f1493fa1bdc11154eca3b258ca4eba65d39c473fe19d8e9/watchfiles-1.2.0.tar.gz", hash = "sha256:c995fba777f1ea992f090f9236e9284cf7a5d1a0130dd5a3d82c598cacd76838", size = 108252, upload-time = "2026-05-18T04:32:04.251Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/fc/3d/8024c801df84d1587740d0359e7fdd80afeae3d159011f3d5376dd82f18e/watchfiles-1.2.0-cp311-cp311-macosx_10_12_x86_64.whl", hash = "sha256:704fd259e332e01f9b9c178f4bce9e49027e5587cc2600eeeaf8e76e1c846201", size = 400242, upload-time = "2026-05-18T04:31:19.014Z" },
+    { url = "https://files.pythonhosted.org/packages/87/5b/f4dfd45323e949984a3a7f9dc31d1cbb049921e7d98253488dda72ccdaa9/watchfiles-1.2.0-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:6543cf55d170003296d185c0af981f3e1311564907e1f4e08671fc7693a890a5", size = 394562, upload-time = "2026-05-18T04:30:08.46Z" },
+    { url = "https://files.pythonhosted.org/packages/98/d8/19483ef075d601c409bce8bcbb5c0f81a10876fff870400568f08ce484a1/watchfiles-1.2.0-cp311-cp311-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:89d8c2394a065ca86f5d2910ff263ae67c127e1376ccc4f9fc35c71db879f80a", size = 456611, upload-time = "2026-05-18T04:30:45.723Z" },
+    { url = "https://files.pythonhosted.org/packages/b1/6a/cc81fbe7ee42f2f22e661a6e12def7807e01b14b2f39e0ff83fd373fd307/watchfiles-1.2.0-cp311-cp311-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:772b80df316480d894a0e3165fdd19cf77f5d17f9a787f94029465ad0e3529d1", size = 461379, upload-time = "2026-05-18T04:31:29.292Z" },
+    { url = "https://files.pythonhosted.org/packages/b1/57/7e669002082c0a0f4fb5113bb70125f7110124b846b0a11bc5ae8e90eac1/watchfiles-1.2.0-cp311-cp311-manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:d158cd89df6053823533e06fb1d73c549133bff5f0396170c0e53d9559340717", size = 493556, upload-time = "2026-05-18T04:30:05.44Z" },
+    { url = "https://files.pythonhosted.org/packages/45/7d/f60a2b19807b21fe8281f3a8da4f59eef0d5f96825ac4680ba2d4f2ebf91/watchfiles-1.2.0-cp311-cp311-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:d516b3283a758e087841aedb8031549fb41ced08f3db10aa6d2bf32dc042525b", size = 575255, upload-time = "2026-05-18T04:30:40.568Z" },
+    { url = "https://files.pythonhosted.org/packages/bd/49/77f5b5e6efbcd57482f74948ebb1b97e5c0046d6b61475042d830c84b3ff/watchfiles-1.2.0-cp311-cp311-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:53b2290c92e0506d102cd448fbc610d87079553f86caa39d67440856a8b8bba5", size = 467052, upload-time = "2026-05-18T04:31:17.942Z" },
+    { url = "https://files.pythonhosted.org/packages/ee/5a/73e2959af1b97fd5d556f9a8bdba017be23ceeef731869d5eaa0a753d5a3/watchfiles-1.2.0-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:a711b51aec4370d0dcda5b6c09463206f133a5759341d7744b953a7b62e1100e", size = 456858, upload-time = "2026-05-18T04:30:30.182Z" },
+    { url = "https://files.pythonhosted.org/packages/50/57/1bc8c27fad7e6c19bddee15d276dbb6ab72480ec01c127afff1673aee417/watchfiles-1.2.0-cp311-cp311-manylinux_2_31_riscv64.whl", hash = "sha256:e2ca07fa7d89195ec0865d3d285666286740bfa83d83e5cee204043a31ecc165", size = 467579, upload-time = "2026-05-18T04:32:15.897Z" },
+    { url = "https://files.pythonhosted.org/packages/09/6c/3c2e44edba3553c5e3c3b8c8a2a6dee6b9e12ae2cf4bd2378bebf9dc3038/watchfiles-1.2.0-cp311-cp311-musllinux_1_1_aarch64.whl", hash = "sha256:e0618518f282c4ebff60f5e5b1247b6d91bb8b9f4476947563a1e74acc66f3c6", size = 633253, upload-time = "2026-05-18T04:31:37.123Z" },
+    { url = "https://files.pythonhosted.org/packages/30/c2/d8c84a882ab39bbefcc4915ab3e91830b7a7e990c5570b0b69075aba3faf/watchfiles-1.2.0-cp311-cp311-musllinux_1_1_x86_64.whl", hash = "sha256:0d191c054d0715c3c95c99df9b8dbf6fd096d8c1e021e8f212e1bd8bc444ccb5", size = 660713, upload-time = "2026-05-18T04:31:24.62Z" },
+    { url = "https://files.pythonhosted.org/packages/a9/07/f97736a5fc605364fe67b25e9fa4a6965dfd4840d50c406ada507e9d735f/watchfiles-1.2.0-cp311-cp311-win32.whl", hash = "sha256:9342472aff9b093c5acd4f6d8f70ae0937964ab56542502bcf5579782da69ae8", size = 277222, upload-time = "2026-05-18T04:31:21.131Z" },
+    { url = "https://files.pythonhosted.org/packages/cf/99/2b04981977fc2608afd60360d928c6aecf6b950292ca221d98f4005f6694/watchfiles-1.2.0-cp311-cp311-win_amd64.whl", hash = "sha256:dbd6c97045dad81227c8d040173da044c1de08de64a5ea8b555da4aee1d5fa22", size = 290274, upload-time = "2026-05-18T04:31:45.966Z" },
+    { url = "https://files.pythonhosted.org/packages/3c/74/f7f58a7075ee9cf612b0cfcddb78b8cd8234f0742d6f0075cf0da2dde1c6/watchfiles-1.2.0-cp311-cp311-win_arm64.whl", hash = "sha256:57a2d9fa4fb4c2ecae57b13dfff2c7ab53e21a2ba674fe9f05506680fcdcc0d7", size = 283460, upload-time = "2026-05-18T04:31:39.126Z" },
+    { url = "https://files.pythonhosted.org/packages/b8/2f/e42c992d2afda3108ea1c02acecc991b9f31d05c14adc2a7cee9ee211fc4/watchfiles-1.2.0-cp312-cp312-macosx_10_12_x86_64.whl", hash = "sha256:bc13eb17538be00c874699dc0abe4ee2bc8d50bb1166a6b9e175ef3fd7eb8f26", size = 400115, upload-time = "2026-05-18T04:32:02.06Z" },
+    { url = "https://files.pythonhosted.org/packages/5f/8f/6af2ea19065c91d8b0ea3516fdfc8c0d349f407e8e9fbf4e5a17360de8ad/watchfiles-1.2.0-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:2d95ddc1eb6914154253d239089900813f6a767e174b8e6a50e7fdacb7e4236c", size = 393659, upload-time = "2026-05-18T04:30:50.951Z" },
+    { url = "https://files.pythonhosted.org/packages/13/01/b32a967c56fb3e3e5be3db52c3d3b87fa4513aa367d8ed1ad96d42952e5f/watchfiles-1.2.0-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:8f70d8b291ef6e88d19b1f297a6905ddb978888d9272b0d05e6f53309856bcfc", size = 453207, upload-time = "2026-05-18T04:31:04.231Z" },
+    { url = "https://files.pythonhosted.org/packages/04/98/97557a812180338cb1abd32e1cffcc4588f59b5f23e0cb006b2ba95ba64a/watchfiles-1.2.0-cp312-cp312-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:56d8641cf834c2836922899105bd3ce3d0dfc69291d52edf0b4d0436829b34c0", size = 459273, upload-time = "2026-05-18T04:31:50.377Z" },
+    { url = "https://files.pythonhosted.org/packages/e8/a8/b4b08dcb7653b8087c6586f7ce649505900e866bbcfe40dc9587af02e686/watchfiles-1.2.0-cp312-cp312-manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:2581a94056e55d7d0a31a823ea92bf73749c489ca2285bfdc0fbe6b2bb49d50c", size = 489927, upload-time = "2026-05-18T04:31:42.485Z" },
+    { url = "https://files.pythonhosted.org/packages/50/94/3dceea03545d2e5ddfd839f0ddd5e1cecbf1697b5a428d5ba11cef6af95d/watchfiles-1.2.0-cp312-cp312-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:41bc1199f7523b3f82843c88cbb979180c949caef0342cf90968f178e5d49b01", size = 570476, upload-time = "2026-05-18T04:31:03.071Z" },
+    { url = "https://files.pythonhosted.org/packages/cc/f2/d39a5450c3532092b91f81d274360e613c2371bc874a89c7a1a3c5e8d138/watchfiles-1.2.0-cp312-cp312-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:7571e4464cb6e434958f867f7f730b8ab0b75e3f8e5eac0499168486ab3c33a8", size = 465650, upload-time = "2026-05-18T04:30:12.701Z" },
+    { url = "https://files.pythonhosted.org/packages/22/24/ed72f68cbc1333ca9b9f2200aa048bb6658ae41709bc1caad4310f4bdffd/watchfiles-1.2.0-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:e53a384f76b631c3ae5334ce6a52f0baa3a911eb94a4eac7f160079868b716d5", size = 456398, upload-time = "2026-05-18T04:30:13.784Z" },
+    { url = "https://files.pythonhosted.org/packages/0d/64/982ef4a4e5bab5b6e5b6becc8cd5e732f6130a78b855f0abec6439a9a135/watchfiles-1.2.0-cp312-cp312-manylinux_2_31_riscv64.whl", hash = "sha256:d20029a60a71a052a24c4db7673bc4de39ab89adbaccbfb5d67987c5d73f424d", size = 465140, upload-time = "2026-05-18T04:31:52.111Z" },
+    { url = "https://files.pythonhosted.org/packages/a0/0c/95282abf4ed680b6096010bcfc30c5fa7a041fc5aa5a2ad17a2cc6c75bba/watchfiles-1.2.0-cp312-cp312-musllinux_1_1_aarch64.whl", hash = "sha256:2cb93af48550faf1cea04c303107c8b75833de7013e57ce27d3b8d21d8d0f58c", size = 630259, upload-time = "2026-05-18T04:31:25.676Z" },
+    { url = "https://files.pythonhosted.org/packages/30/45/607c1de1530c4bdcf2cf1d1ecc2505ddba5d96bd43ba9f2b0e79876f850f/watchfiles-1.2.0-cp312-cp312-musllinux_1_1_x86_64.whl", hash = "sha256:2995c176de7692b86a2e4c58d9ec718f753150a979cb4a754e2b4ffa38e70906", size = 659859, upload-time = "2026-05-18T04:30:24.333Z" },
+    { url = "https://files.pythonhosted.org/packages/fa/08/d9e2e0f9e8e6791d33aefc694ad7eefa7f901f63caff84a81ded38692f9c/watchfiles-1.2.0-cp312-cp312-win32.whl", hash = "sha256:7a2cffd17d27d2ecbb310c2b1d8174f222a5495b1a721894afa88ec11e25b898", size = 275480, upload-time = "2026-05-18T04:30:31.307Z" },
+    { url = "https://files.pythonhosted.org/packages/1c/e6/9d42569c0102645cc8cea5d8c7d8a1e9d4ada2cb7f05f75e554b8aa2202a/watchfiles-1.2.0-cp312-cp312-win_amd64.whl", hash = "sha256:f155b3a1b2a5fc89cdc70d47ee5d54e3b75e88efa34982028a35daef9ba00379", size = 288718, upload-time = "2026-05-18T04:32:10.745Z" },
+    { url = "https://files.pythonhosted.org/packages/0a/26/88e0dc6ee3898169d7fa22bb6a69cabf2502d2ee25cb8c876d1262d204f8/watchfiles-1.2.0-cp312-cp312-win_arm64.whl", hash = "sha256:8fa585ede612ee9f9e91b18bebf9ba11b9ae29a4e3a0d0cf6fca3e382133f0d5", size = 281026, upload-time = "2026-05-18T04:30:22.23Z" },
+    { url = "https://files.pythonhosted.org/packages/d1/4d/70a7feced9f87e2ff26dba42667290f41694fc64646c67261fbb8cab5d5c/watchfiles-1.2.0-cp313-cp313-macosx_10_12_x86_64.whl", hash = "sha256:01ea8d66f0693b9b60a6541c8d10263091ca9a9060d242f3c1f3143f9aad2c98", size = 399730, upload-time = "2026-05-18T04:31:38.162Z" },
+    { url = "https://files.pythonhosted.org/packages/31/3a/0da302f2307aee316922806ebd5726c542cbd787c938271cf14a074c7daf/watchfiles-1.2.0-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:7ba0480b9a74af058f43b337e937a451e109295c420916d68ad24e3dc02f5e44", size = 392842, upload-time = "2026-05-18T04:30:27.051Z" },
+    { url = "https://files.pythonhosted.org/packages/db/ef/d5bdb705c224dbc256aa0c1ec47bf4e61ec52558f2afb44a71a1fe4d7015/watchfiles-1.2.0-cp313-cp313-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:4f34e26a19f91f710c08e0183429f0d1d15df734e6bc78c31e77b9ea9c433658", size = 452989, upload-time = "2026-05-18T04:31:11.945Z" },
+    { url = "https://files.pythonhosted.org/packages/71/29/5495f2c1661949ef7a35e4d71111d129cfe7606414a26887a919d0a55406/watchfiles-1.2.0-cp313-cp313-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:b4e77f6a55f858504069abd35d336a637555c09bca453dde1ee1e5ada8a6a1fb", size = 458978, upload-time = "2026-05-18T04:30:52.606Z" },
+    { url = "https://files.pythonhosted.org/packages/d5/8c/7f9c07c433811c2fffd93e13fdfb7135de9aab5f2ae41be08960fa0047dc/watchfiles-1.2.0-cp313-cp313-manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:0cb4d80e212f116474a545c21c912b445f16bb0cef9e6a73a498164223e14e2f", size = 490248, upload-time = "2026-05-18T04:31:36.003Z" },
+    { url = "https://files.pythonhosted.org/packages/3c/11/d93632febc52fbc21be90231bb7c17fd5387f46c9076fd40a5f9c2ae6910/watchfiles-1.2.0-cp313-cp313-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:b974946a10af379d425e2eef5b62f5c6ebeaccf91d45eaad6f5b27ecd4f91aa0", size = 571847, upload-time = "2026-05-18T04:31:10.862Z" },
+    { url = "https://files.pythonhosted.org/packages/55/b4/383173e73aabb07ad1d9c7aa859d95437ac46a6d6a1e11005facda0c9d19/watchfiles-1.2.0-cp313-cp313-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:86bc13c25a8d1fcd70b51d0ce7c9b65e90de5666fcbfd3e34957cc73ee19aeb5", size = 465974, upload-time = "2026-05-18T04:30:17.006Z" },
+    { url = "https://files.pythonhosted.org/packages/a7/6c/89b1a230a78f57c52dd8893adb1f92f94411721b6ec12596c56d98c74356/watchfiles-1.2.0-cp313-cp313-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:ca148d73dea36c9763aaa351e4d7a51780ec1584217c45276f4fe8239c768b71", size = 454782, upload-time = "2026-05-18T04:30:35.656Z" },
+    { url = "https://files.pythonhosted.org/packages/24/62/1732118367cfff0a9fce3bf62ff4bfded09ef5df21d9d446b858b3f70a96/watchfiles-1.2.0-cp313-cp313-manylinux_2_31_riscv64.whl", hash = "sha256:c525543d91961c6955b2636b308569e84a1d1c5f5f2932041ab9ef46422f43e3", size = 465182, upload-time = "2026-05-18T04:30:20.846Z" },
+    { url = "https://files.pythonhosted.org/packages/28/96/716f7e5f51339bf22963f3345f9f27d7f3b30e2eadc597e257c881dd3c53/watchfiles-1.2.0-cp313-cp313-musllinux_1_1_aarch64.whl", hash = "sha256:a204794696ffb8f9b10fba6f7cb5216d42f3b2b71860ccac6b6e42f5f10973b0", size = 629841, upload-time = "2026-05-18T04:31:05.397Z" },
+    { url = "https://files.pythonhosted.org/packages/4c/fe/c40783950fd771ccf66ab3ec2722d188a9af1c7f96c6e811f36e40c6e03f/watchfiles-1.2.0-cp313-cp313-musllinux_1_1_x86_64.whl", hash = "sha256:10d86db20695afe7997ac9e1717637d6714a8d0220458c33f3d2061f54cec427", size = 658028, upload-time = "2026-05-18T04:31:48.22Z" },
+    { url = "https://files.pythonhosted.org/packages/71/72/4508db1856d1d87fcbb3b63f4839bab1b5682cb0e8d224d122263c09654a/watchfiles-1.2.0-cp313-cp313-win32.whl", hash = "sha256:eb283ee99e21ad6443c8cdb06ac5b34b1308c329cbdf03fa02b445363714c799", size = 275183, upload-time = "2026-05-18T04:30:59.57Z" },
+    { url = "https://files.pythonhosted.org/packages/f9/36/14b76ca57652e5cc5fd1c11f32a261292c08a0d19a00351013c2549cbfb2/watchfiles-1.2.0-cp313-cp313-win_amd64.whl", hash = "sha256:a0f27f01bee51861392bb6b7c4fdb290b27d1eb194e9e28788d68102a0e898d9", size = 288059, upload-time = "2026-05-18T04:32:07.937Z" },
+    { url = "https://files.pythonhosted.org/packages/1b/8d/0a85e395398d8d20fadfe5c5d32c726eee17a519e78fb356f2cf7531bffe/watchfiles-1.2.0-cp313-cp313-win_arm64.whl", hash = "sha256:3651aa7058595e9cfb75d35dd5ada2bf9f48a5b8a0f3562821d3e210c507e077", size = 280186, upload-time = "2026-05-18T04:31:54.484Z" },
+    { url = "https://files.pythonhosted.org/packages/37/68/36db056f1fdcc5f07302f56e631774d6835bcd6fa3ace402304621d5f9e5/watchfiles-1.2.0-cp313-cp313t-macosx_10_12_x86_64.whl", hash = "sha256:faea288b6f0ab1902ef08f4ca6de005dccf856c4e0c4f21b8c5fce02d90a1b08", size = 399031, upload-time = "2026-05-18T04:30:44.576Z" },
+    { url = "https://files.pythonhosted.org/packages/c1/64/01a9d6f66a82a5c101ce939274106cc72759d62427e153f01edd2b9f87c2/watchfiles-1.2.0-cp313-cp313t-macosx_11_0_arm64.whl", hash = "sha256:01859b11fd9fbca670f4d5da00fbac282cfea9bd67a2125d8b2833a3b5617ea9", size = 391205, upload-time = "2026-05-18T04:30:25.413Z" },
+    { url = "https://files.pythonhosted.org/packages/84/2c/0a44fe058cb4bb7b8ede6b6670698bbb7c0400740e378d00022189b7b31d/watchfiles-1.2.0-cp313-cp313t-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:fff610d7bb2256a317bb1e96f0d7862c7aa8076733ee5df0fd41bbe76a24a4f4", size = 451892, upload-time = "2026-05-18T04:32:14.005Z" },
+    { url = "https://files.pythonhosted.org/packages/67/a1/351e0d56cd35e6488b5c8b4fb11a809a5bc923e8fe8fed9faf8920be0c89/watchfiles-1.2.0-cp313-cp313t-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:b141a4891c995a039cd89e9a49e62df1dc8a559a5d1a6e4c7106d16c12777a55", size = 458867, upload-time = "2026-05-18T04:31:22.279Z" },
+    { url = "https://files.pythonhosted.org/packages/d5/7d/9d09605187f1b838998624049fcf8bf47b73c1a3b76901fcac1782f62277/watchfiles-1.2.0-cp313-cp313t-manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:f22943b7770483f6ea0721c6b11d022947a98eb0acae14694de034f4d0d38925", size = 490217, upload-time = "2026-05-18T04:31:43.657Z" },
+    { url = "https://files.pythonhosted.org/packages/60/5d/a17a16eccb182f04188cd308ec24b1a71a9b5c4e7098269cf35d9fa56d02/watchfiles-1.2.0-cp313-cp313t-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:1bc6195825b7dcd217968bb1f801a60fd4c16e8eeab5bedc7fe917d7d5995ab4", size = 571458, upload-time = "2026-05-18T04:32:11.875Z" },
+    { url = "https://files.pythonhosted.org/packages/d3/3d/4dd457062083ab1938e5dfd45032eb425cee2ac817287ca8ff4356183e5d/watchfiles-1.2.0-cp313-cp313t-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:d4a4b147f5dca2a5d325a06a832fb43f345751adfbc63204aec30e0d9ca965a2", size = 464707, upload-time = "2026-05-18T04:30:43.492Z" },
+    { url = "https://files.pythonhosted.org/packages/c6/71/ea8c57b128f5383de74d0c7d2d9c57ad7c9a65a930c451bd25d524b295b7/watchfiles-1.2.0-cp313-cp313t-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:4543579a9bdb0c9560039b4ffddbdb39545707659fbc430ce4c10f3f68d557f9", size = 454663, upload-time = "2026-05-18T04:30:16.061Z" },
+    { url = "https://files.pythonhosted.org/packages/53/fd/2e812bf938406d7db351f0703ddd3fc6c061cf30d96153a77bc79a943a44/watchfiles-1.2.0-cp313-cp313t-manylinux_2_31_riscv64.whl", hash = "sha256:20aa0e708b920bde876a4aa82dc7dd6ebea228a63a67cda6632c2fc87b787efa", size = 463537, upload-time = "2026-05-18T04:31:44.9Z" },
+    { url = "https://files.pythonhosted.org/packages/86/56/d17a7f1dd1bc3035f1072694a551301272f1739c2d8e319c927cb9e29b38/watchfiles-1.2.0-cp313-cp313t-musllinux_1_1_aarch64.whl", hash = "sha256:d413349d565dab74297f2a63e84a097936be69bf8f3b3801f27f380e32040f44", size = 629194, upload-time = "2026-05-18T04:31:14.141Z" },
+    { url = "https://files.pythonhosted.org/packages/be/06/f1ff66bf5cae50aa4062779a0ecd0bbaf15e466195719074078947d9a17d/watchfiles-1.2.0-cp313-cp313t-musllinux_1_1_x86_64.whl", hash = "sha256:f28b2725eb8cce327b9b3ab02415c853011dc55c95832fe90de6bc56f5315f72", size = 656194, upload-time = "2026-05-18T04:31:47.14Z" },
+    { url = "https://files.pythonhosted.org/packages/e7/54/a9c7ea9a82a4ac65e7004c0a03920b5cdd2f9c3b678757d9cd425aa51d53/watchfiles-1.2.0-cp314-cp314-macosx_10_12_x86_64.whl", hash = "sha256:b8c8358484d5fa12ef34f05b7f4168eaf1932f408725ff6d023c33ec17bd79d4", size = 400205, upload-time = "2026-05-18T04:32:05.153Z" },
+    { url = "https://files.pythonhosted.org/packages/aa/5d/c9ab3534374a4a67450696905d6ef16a04405448b8dc52bd752ae50423d4/watchfiles-1.2.0-cp314-cp314-macosx_11_0_arm64.whl", hash = "sha256:9f04b092229ad2c50126dd3c922c8822e51e605993764a33058d4a791ab42281", size = 392508, upload-time = "2026-05-18T04:30:54.849Z" },
+    { url = "https://files.pythonhosted.org/packages/26/ca/1ad30103535cf0cecd7b993e8d50edc5351b1820e38f2d22e3df58962feb/watchfiles-1.2.0-cp314-cp314-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:7a7ce236284f002a156f70add88efe5c70879cccbb658be0822c54b1306fc09d", size = 452448, upload-time = "2026-05-18T04:30:53.727Z" },
+    { url = "https://files.pythonhosted.org/packages/37/a1/ceee2cdf2afbd715fa07758d39c9859513eae411b23196f7fd039e5feedd/watchfiles-1.2.0-cp314-cp314-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:b9909cc2b48468b575eefa944919e1fe8a36c5849d5c7c168f80a8c1db69398e", size = 459605, upload-time = "2026-05-18T04:30:23.312Z" },
+    { url = "https://files.pythonhosted.org/packages/e8/f6/421e30fd1cb3907a84ed92ab3f1983e37ba2dca015e9a894a048418417a2/watchfiles-1.2.0-cp314-cp314-manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:0a37faaed405c67e28e6be45a1fa4f206ef5a2860f27c237db9fa30704c38242", size = 490757, upload-time = "2026-05-18T04:30:47.358Z" },
+    { url = "https://files.pythonhosted.org/packages/41/b0/55ed1b97ed08be7bba6f9a541cac15f2a858e1d74d2b07b6da70a82aab00/watchfiles-1.2.0-cp314-cp314-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:9649193aa27bd9ff2e80ff29bfaa93085496c7a3a377592823cc58b77ee88add", size = 568672, upload-time = "2026-05-18T04:30:38.915Z" },
+    { url = "https://files.pythonhosted.org/packages/d1/cf/d8ae8a80dd7bafab395ea7681c10237311bbf34d37704a8c744e7cf31fc7/watchfiles-1.2.0-cp314-cp314-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:4e4ff8e37f99cf1da89e255e07c9c4b37c214038c4283707bdec308cb1b0ea1f", size = 464197, upload-time = "2026-05-18T04:30:09.914Z" },
+    { url = "https://files.pythonhosted.org/packages/7c/8a/3076c496ca8dafe0e8cd03fcebdfc47be4b1174b4e5b24ff6e396e6b3af2/watchfiles-1.2.0-cp314-cp314-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:054dc20fd2e3132b4c3883b4a00d72fd6e1f56fdaf89fccd12e8057d74cd74d7", size = 453181, upload-time = "2026-05-18T04:30:14.829Z" },
+    { url = "https://files.pythonhosted.org/packages/e5/10/9745e17c98e7b8a86454df0a3c7b5686bd650383f1e9f26e4ebcbd6cc0c0/watchfiles-1.2.0-cp314-cp314-manylinux_2_31_riscv64.whl", hash = "sha256:e140ed30ebde76796b686e67c182cff10ea2fbab186fafd1560f74bb5a473a6e", size = 465109, upload-time = "2026-05-18T04:30:28.123Z" },
+    { url = "https://files.pythonhosted.org/packages/8f/95/8ef4a95481d3e0cb52d62a06fa6e972e81424be2d9698b91a2fecca9904c/watchfiles-1.2.0-cp314-cp314-musllinux_1_1_aarch64.whl", hash = "sha256:bb7e52ecf68ba46d22df23467b87cffeb2146908aa523ebfe803019618cfda06", size = 630653, upload-time = "2026-05-18T04:31:49.304Z" },
+    { url = "https://files.pythonhosted.org/packages/fd/e4/3b3bf36b0f829b50c6ebcb8d031583863c59f923d6a6af3d485e470d0fac/watchfiles-1.2.0-cp314-cp314-musllinux_1_1_x86_64.whl", hash = "sha256:23282a321c8baf9b3a3c4afff673f9fe65eb7fdc2338d765ccad9d3d1916a5ba", size = 657838, upload-time = "2026-05-18T04:31:06.497Z" },
+    { url = "https://files.pythonhosted.org/packages/21/b1/6cbbb50c1f3002ab568777d44aa21206dfb8807a840990c4037523b51812/watchfiles-1.2.0-cp314-cp314-win32.whl", hash = "sha256:c0db965c5f79aa49fe672d297cf1febc5ad149b658594944f49a54a2b96270a7", size = 275108, upload-time = "2026-05-18T04:30:06.891Z" },
+    { url = "https://files.pythonhosted.org/packages/92/45/190ce6db8dcb4536682cf75d3889ff1a27182a58cb519d343cb6d9ea63d8/watchfiles-1.2.0-cp314-cp314-win_amd64.whl", hash = "sha256:71283b39fd17e5408eb123bd37aeecfd9d54c81fc184421943208aadb879d103", size = 288441, upload-time = "2026-05-18T04:32:12.901Z" },
+    { url = "https://files.pythonhosted.org/packages/74/0d/3eae1c2313ab08378431d907c3f8095ecca00f3eda33111cf4f0f2591799/watchfiles-1.2.0-cp314-cp314-win_arm64.whl", hash = "sha256:c5c19526f4e54a00f2666a6c0e9e40d582c09e865055ea7378bf0009aab857b3", size = 280684, upload-time = "2026-05-18T04:31:26.902Z" },
+    { url = "https://files.pythonhosted.org/packages/b1/75/fb64e6c25d6b5ca636d03df34ffb1c6e9873303e76d27967e045f8df088f/watchfiles-1.2.0-cp314-cp314t-macosx_10_12_x86_64.whl", hash = "sha256:d73a585accffa5ae39c17264c36ec3166d2fad7000c780f5ef83b2722afb9dd2", size = 398857, upload-time = "2026-05-18T04:32:17.108Z" },
+    { url = "https://files.pythonhosted.org/packages/73/4e/9f7adf01754cbf81843722ccfec169d8f26c69778281a302855cecd2ee08/watchfiles-1.2.0-cp314-cp314t-macosx_11_0_arm64.whl", hash = "sha256:ae99b14c5f21e026e0e9d96f40e07d8570ebee6cafd9d8fc318354606daa7a28", size = 392413, upload-time = "2026-05-18T04:31:07.911Z" },
+    { url = "https://files.pythonhosted.org/packages/47/c8/bec626bcc2d69f44b9acb24ce7d60ed7b16b73628eea747fcbd169d8edda/watchfiles-1.2.0-cp314-cp314t-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:4429f3b105524a10b72c3a819b091c495d2811d419c1e1e8df773a5a5974f831", size = 452409, upload-time = "2026-05-18T04:31:20.142Z" },
+    { url = "https://files.pythonhosted.org/packages/00/b7/b6362068e81e7c556d155a34c35d40ac3ef42d747b06d7f6e5bf58e359c2/watchfiles-1.2.0-cp314-cp314t-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:43d818978d06062d9b22c4fab2ebe44cf5213d42dc8e62bda8c2760cfa2eeb33", size = 458827, upload-time = "2026-05-18T04:32:06.219Z" },
+    { url = "https://files.pythonhosted.org/packages/67/f8/9a813fa42afb1e0b4625e75f0479826644d3ee8dc287e093799bc01f390c/watchfiles-1.2.0-cp314-cp314t-manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:b9f732dc58b2dbe69e464ccf8fff7a03b0dd0be439da4c0720d3558527d3d6b4", size = 490104, upload-time = "2026-05-18T04:31:56.034Z" },
+    { url = "https://files.pythonhosted.org/packages/2f/bf/27dfb6094ca4c9aad21298b5525b6c53cb36121ee454331d05161e58d130/watchfiles-1.2.0-cp314-cp314t-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:8f200104103feb097de4cab8fe4f5dd18a2026934c7dea98c55a2f5fd6d5a33b", size = 571360, upload-time = "2026-05-18T04:31:57.133Z" },
+    { url = "https://files.pythonhosted.org/packages/fb/39/44a096d67270ea93df91d33877dbe91fbda3aa4f8ec2edf799d93eda8736/watchfiles-1.2.0-cp314-cp314t-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:63ac26eefbf4af1741247d6fb68b11c49a25b2f7413fbd318a83a12aaa9cf666", size = 464644, upload-time = "2026-05-18T04:30:57.33Z" },
+    { url = "https://files.pythonhosted.org/packages/0e/80/c7472203bad6268e3ef1ad260739704847898938ad7ea8b63a5131f46b50/watchfiles-1.2.0-cp314-cp314t-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:0c4997d4e4a55f0d02b6cde327322daf3a0400e5df6c6b15948994bf72497925", size = 454771, upload-time = "2026-05-18T04:30:48.736Z" },
+    { url = "https://files.pythonhosted.org/packages/51/cf/3b10b268b4b7f0fc26e9debb5eef1998b515887840f444cd3ec80c688755/watchfiles-1.2.0-cp314-cp314t-manylinux_2_31_riscv64.whl", hash = "sha256:4c887eba18b7945ac73067a8b4a66f21cd46c2539b2bc68588f7be6c7eb6d26b", size = 463494, upload-time = "2026-05-18T04:31:33.826Z" },
+    { url = "https://files.pythonhosted.org/packages/3d/3e/a4302545cd589262a0dc7d140e86f7688eba3f9c72776c27f7e23b8864c4/watchfiles-1.2.0-cp314-cp314t-musllinux_1_1_aarch64.whl", hash = "sha256:3416ff151bb6b5a8d8d11664974fbef4d9305b9b2957839ab5a270468fd8df30", size = 629383, upload-time = "2026-05-18T04:31:15.596Z" },
+    { url = "https://files.pythonhosted.org/packages/db/99/d5649df0a9a410d45b7c882304d0b790903ac9b6e8f2cfd12114e0c6b9f2/watchfiles-1.2.0-cp314-cp314t-musllinux_1_1_x86_64.whl", hash = "sha256:0e831a271c035d89789cffc386b6aa1375f39f1cd25eb7ca0997e4970d152fc5", size = 656093, upload-time = "2026-05-18T04:31:58.707Z" },
+    { url = "https://files.pythonhosted.org/packages/92/b9/362702539275019a54dd2e94511b31a9b89c5f9e6a21966de7eb692549fc/watchfiles-1.2.0-cp315-cp315-macosx_10_12_x86_64.whl", hash = "sha256:37a6721cdf3f65dbb13aa9503510ccb4451603ac837e44d265d7992a597e1374", size = 400109, upload-time = "2026-05-18T04:31:16.879Z" },
+    { url = "https://files.pythonhosted.org/packages/8f/75/71d5ba62db781e5587bded1d944c675374bc4aa37ff33d5018d98e8b6538/watchfiles-1.2.0-cp315-cp315-macosx_11_0_arm64.whl", hash = "sha256:2b37d10b5a63bd4d87e18472d80fa525bd670586fae62e5dd580452764879b65", size = 392167, upload-time = "2026-05-18T04:31:28.058Z" },
+    { url = "https://files.pythonhosted.org/packages/3c/01/c66dd95d0423fe30d31820e2d1d5bda773764131bbb6ac0cb1cf303ac328/watchfiles-1.2.0-cp315-cp315-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:0a105bc2283f67e8fbec74253ec2d94925de92ed72c0393f1206bf326b7b7b69", size = 452372, upload-time = "2026-05-18T04:31:00.836Z" },
+    { url = "https://files.pythonhosted.org/packages/91/15/2fe99557e72f85627c6a8eed50d889e8d101623e060a22ad75b875cb932d/watchfiles-1.2.0-cp315-cp315-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:5327989a465505f05cfe06f04fa9d0c2fd5432bb243e10e6f012b1bdca3c8579", size = 459596, upload-time = "2026-05-18T04:31:34.96Z" },
+    { url = "https://files.pythonhosted.org/packages/ed/23/d4acfa0023367428ed48351b3b9b267893037b6cadae55620c61c24bcfd4/watchfiles-1.2.0-cp315-cp315-manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:ecb47f183a8025b2aa18b546725c3657e542112ae9c0613a2af79b4fa8d04ad7", size = 490869, upload-time = "2026-05-18T04:31:59.923Z" },
+    { url = "https://files.pythonhosted.org/packages/a4/5f/3164cbdce06c9fb95c4f7b9e2f9760b5e2797af43a9ecc317ef42a23a278/watchfiles-1.2.0-cp315-cp315-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:8520a4ab0e37f770afc34459c4f8f7019e153f9124dc101c15538365875d1ab2", size = 571641, upload-time = "2026-05-18T04:32:00.948Z" },
+    { url = "https://files.pythonhosted.org/packages/41/e6/85d3731c55e65cd7690f3f803d24c139588aaf863e4bf2148fe7a7fa1a19/watchfiles-1.2.0-cp315-cp315-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:71cd71740ed2c15211ebb237ced4e39a1cdf6f80566e5fe95428da1626f4fde6", size = 464444, upload-time = "2026-05-18T04:30:34.298Z" },
+    { url = "https://files.pythonhosted.org/packages/f4/7d/562641012b8b09872742c3b8adf9629ec479fd78f8d68ae4a0c13da8add6/watchfiles-1.2.0-cp315-cp315-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:f88af53d6ddaf72179ef613ddc905e6f4785f712b49b80b3bef9f3525e6194b4", size = 453593, upload-time = "2026-05-18T04:31:23.464Z" },
+    { url = "https://files.pythonhosted.org/packages/56/fe/cb8ef3d6f929d14158fdaaad9925985b7310abc9384dcd4d82dd0016fb59/watchfiles-1.2.0-cp315-cp315-manylinux_2_31_riscv64.whl", hash = "sha256:cee9d5efd929efdac5f7e58f72b3376f676b64050a91c5b99a7094c5b2317488", size = 465096, upload-time = "2026-05-18T04:31:30.384Z" },
+    { url = "https://files.pythonhosted.org/packages/25/91/80908e835e100527a9267147b08c0eee1fa6ab0ffec15edc04d1d44885f7/watchfiles-1.2.0-cp315-cp315-musllinux_1_1_aarch64.whl", hash = "sha256:b718bf356bbc15e559bd8ef41782b573b8ae0e3f177ab244b440568d7ea02cfb", size = 630638, upload-time = "2026-05-18T04:30:49.89Z" },
+    { url = "https://files.pythonhosted.org/packages/46/4b/95ab2f256bb4af3cb2eb23b9317bda984ee6e0f11733a5c004a6c95b06e3/watchfiles-1.2.0-cp315-cp315-musllinux_1_1_x86_64.whl", hash = "sha256:922c0e019fe68b3ae392965a766b02a71ba1168c932cebc3733cd52c5fe5b377", size = 657684, upload-time = "2026-05-18T04:31:32.027Z" },
+    { url = "https://files.pythonhosted.org/packages/23/f4/7513ef1e85fc4c6331b59479d6d72661fc391fbe543678052ac72c8b6c19/watchfiles-1.2.0-pp311-pypy311_pp73-macosx_10_12_x86_64.whl", hash = "sha256:4674d49eb94706dfe666c069fc0a1b646ffcf920473492e209f6d5f60d3f0cc2", size = 403050, upload-time = "2026-05-18T04:30:36.753Z" },
+    { url = "https://files.pythonhosted.org/packages/27/0b/a54103cfd732bb703c7a749222011a0483ef3705948dae3b203158601119/watchfiles-1.2.0-pp311-pypy311_pp73-macosx_11_0_arm64.whl", hash = "sha256:094b9b70103d4e963499bdea001ee3c2697b144cd9ae6218a62c0f89ec9e31db", size = 396629, upload-time = "2026-05-18T04:32:03.268Z" },
+    { url = "https://files.pythonhosted.org/packages/5e/2c/73f31a3b893886206c3f54d73e8ad8dee58cdb2f69ad2622e0a8a9e07f4e/watchfiles-1.2.0-pp311-pypy311_pp73-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:b0ef001f8c25ad0fa9529f914c1600647ecd0f542d11c19b7894768c67b6acb7", size = 457318, upload-time = "2026-05-18T04:31:01.932Z" },
+    { url = "https://files.pythonhosted.org/packages/e9/f9/45d021e4a5cc7b9dd567f7cbb06d3b75f751a690063fb6cc7ec60f4e46b7/watchfiles-1.2.0-pp311-pypy311_pp73-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:a88fc94e647bc4eec523f1caa540258eb71d14278b9daf72fa1e2658a98df0f0", size = 457771, upload-time = "2026-05-18T04:30:56.331Z" },
+]
+
+[[package]]
+name = "websockets"
+version = "16.0"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/04/24/4b2031d72e840ce4c1ccb255f693b15c334757fc50023e4db9537080b8c4/websockets-16.0.tar.gz", hash = "sha256:5f6261a5e56e8d5c42a4497b364ea24d94d9563e8fbd44e78ac40879c60179b5", size = 179346, upload-time = "2026-01-10T09:23:47.181Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/f2/db/de907251b4ff46ae804ad0409809504153b3f30984daf82a1d84a9875830/websockets-16.0-cp311-cp311-macosx_10_9_universal2.whl", hash = "sha256:31a52addea25187bde0797a97d6fc3d2f92b6f72a9370792d65a6e84615ac8a8", size = 177340, upload-time = "2026-01-10T09:22:34.539Z" },
+    { url = "https://files.pythonhosted.org/packages/f3/fa/abe89019d8d8815c8781e90d697dec52523fb8ebe308bf11664e8de1877e/websockets-16.0-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:417b28978cdccab24f46400586d128366313e8a96312e4b9362a4af504f3bbad", size = 175022, upload-time = "2026-01-10T09:22:36.332Z" },
+    { url = "https://files.pythonhosted.org/packages/58/5d/88ea17ed1ded2079358b40d31d48abe90a73c9e5819dbcde1606e991e2ad/websockets-16.0-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:af80d74d4edfa3cb9ed973a0a5ba2b2a549371f8a741e0800cb07becdd20f23d", size = 175319, upload-time = "2026-01-10T09:22:37.602Z" },
+    { url = "https://files.pythonhosted.org/packages/d2/ae/0ee92b33087a33632f37a635e11e1d99d429d3d323329675a6022312aac2/websockets-16.0-cp311-cp311-manylinux1_x86_64.manylinux_2_28_x86_64.manylinux_2_5_x86_64.whl", hash = "sha256:08d7af67b64d29823fed316505a89b86705f2b7981c07848fb5e3ea3020c1abe", size = 184631, upload-time = "2026-01-10T09:22:38.789Z" },
+    { url = "https://files.pythonhosted.org/packages/c8/c5/27178df583b6c5b31b29f526ba2da5e2f864ecc79c99dae630a85d68c304/websockets-16.0-cp311-cp311-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:7be95cfb0a4dae143eaed2bcba8ac23f4892d8971311f1b06f3c6b78952ee70b", size = 185870, upload-time = "2026-01-10T09:22:39.893Z" },
+    { url = "https://files.pythonhosted.org/packages/87/05/536652aa84ddc1c018dbb7e2c4cbcd0db884580bf8e95aece7593fde526f/websockets-16.0-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:d6297ce39ce5c2e6feb13c1a996a2ded3b6832155fcfc920265c76f24c7cceb5", size = 185361, upload-time = "2026-01-10T09:22:41.016Z" },
+    { url = "https://files.pythonhosted.org/packages/6d/e2/d5332c90da12b1e01f06fb1b85c50cfc489783076547415bf9f0a659ec19/websockets-16.0-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:1c1b30e4f497b0b354057f3467f56244c603a79c0d1dafce1d16c283c25f6e64", size = 184615, upload-time = "2026-01-10T09:22:42.442Z" },
+    { url = "https://files.pythonhosted.org/packages/77/fb/d3f9576691cae9253b51555f841bc6600bf0a983a461c79500ace5a5b364/websockets-16.0-cp311-cp311-win32.whl", hash = "sha256:5f451484aeb5cafee1ccf789b1b66f535409d038c56966d6101740c1614b86c6", size = 178246, upload-time = "2026-01-10T09:22:43.654Z" },
+    { url = "https://files.pythonhosted.org/packages/54/67/eaff76b3dbaf18dcddabc3b8c1dba50b483761cccff67793897945b37408/websockets-16.0-cp311-cp311-win_amd64.whl", hash = "sha256:8d7f0659570eefb578dacde98e24fb60af35350193e4f56e11190787bee77dac", size = 178684, upload-time = "2026-01-10T09:22:44.941Z" },
+    { url = "https://files.pythonhosted.org/packages/84/7b/bac442e6b96c9d25092695578dda82403c77936104b5682307bd4deb1ad4/websockets-16.0-cp312-cp312-macosx_10_13_universal2.whl", hash = "sha256:71c989cbf3254fbd5e84d3bff31e4da39c43f884e64f2551d14bb3c186230f00", size = 177365, upload-time = "2026-01-10T09:22:46.787Z" },
+    { url = "https://files.pythonhosted.org/packages/b0/fe/136ccece61bd690d9c1f715baaeefd953bb2360134de73519d5df19d29ca/websockets-16.0-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:8b6e209ffee39ff1b6d0fa7bfef6de950c60dfb91b8fcead17da4ee539121a79", size = 175038, upload-time = "2026-01-10T09:22:47.999Z" },
+    { url = "https://files.pythonhosted.org/packages/40/1e/9771421ac2286eaab95b8575b0cb701ae3663abf8b5e1f64f1fd90d0a673/websockets-16.0-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:86890e837d61574c92a97496d590968b23c2ef0aeb8a9bc9421d174cd378ae39", size = 175328, upload-time = "2026-01-10T09:22:49.809Z" },
+    { url = "https://files.pythonhosted.org/packages/18/29/71729b4671f21e1eaa5d6573031ab810ad2936c8175f03f97f3ff164c802/websockets-16.0-cp312-cp312-manylinux1_x86_64.manylinux_2_28_x86_64.manylinux_2_5_x86_64.whl", hash = "sha256:9b5aca38b67492ef518a8ab76851862488a478602229112c4b0d58d63a7a4d5c", size = 184915, upload-time = "2026-01-10T09:22:51.071Z" },
+    { url = "https://files.pythonhosted.org/packages/97/bb/21c36b7dbbafc85d2d480cd65df02a1dc93bf76d97147605a8e27ff9409d/websockets-16.0-cp312-cp312-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:e0334872c0a37b606418ac52f6ab9cfd17317ac26365f7f65e203e2d0d0d359f", size = 186152, upload-time = "2026-01-10T09:22:52.224Z" },
+    { url = "https://files.pythonhosted.org/packages/4a/34/9bf8df0c0cf88fa7bfe36678dc7b02970c9a7d5e065a3099292db87b1be2/websockets-16.0-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:a0b31e0b424cc6b5a04b8838bbaec1688834b2383256688cf47eb97412531da1", size = 185583, upload-time = "2026-01-10T09:22:53.443Z" },
+    { url = "https://files.pythonhosted.org/packages/47/88/4dd516068e1a3d6ab3c7c183288404cd424a9a02d585efbac226cb61ff2d/websockets-16.0-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:485c49116d0af10ac698623c513c1cc01c9446c058a4e61e3bf6c19dff7335a2", size = 184880, upload-time = "2026-01-10T09:22:55.033Z" },
+    { url = "https://files.pythonhosted.org/packages/91/d6/7d4553ad4bf1c0421e1ebd4b18de5d9098383b5caa1d937b63df8d04b565/websockets-16.0-cp312-cp312-win32.whl", hash = "sha256:eaded469f5e5b7294e2bdca0ab06becb6756ea86894a47806456089298813c89", size = 178261, upload-time = "2026-01-10T09:22:56.251Z" },
+    { url = "https://files.pythonhosted.org/packages/c3/f0/f3a17365441ed1c27f850a80b2bc680a0fa9505d733fe152fdf5e98c1c0b/websockets-16.0-cp312-cp312-win_amd64.whl", hash = "sha256:5569417dc80977fc8c2d43a86f78e0a5a22fee17565d78621b6bb264a115d4ea", size = 178693, upload-time = "2026-01-10T09:22:57.478Z" },
+    { url = "https://files.pythonhosted.org/packages/cc/9c/baa8456050d1c1b08dd0ec7346026668cbc6f145ab4e314d707bb845bf0d/websockets-16.0-cp313-cp313-macosx_10_13_universal2.whl", hash = "sha256:878b336ac47938b474c8f982ac2f7266a540adc3fa4ad74ae96fea9823a02cc9", size = 177364, upload-time = "2026-01-10T09:22:59.333Z" },
+    { url = "https://files.pythonhosted.org/packages/7e/0c/8811fc53e9bcff68fe7de2bcbe75116a8d959ac699a3200f4847a8925210/websockets-16.0-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:52a0fec0e6c8d9a784c2c78276a48a2bdf099e4ccc2a4cad53b27718dbfd0230", size = 175039, upload-time = "2026-01-10T09:23:01.171Z" },
+    { url = "https://files.pythonhosted.org/packages/aa/82/39a5f910cb99ec0b59e482971238c845af9220d3ab9fa76dd9162cda9d62/websockets-16.0-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:e6578ed5b6981005df1860a56e3617f14a6c307e6a71b4fff8c48fdc50f3ed2c", size = 175323, upload-time = "2026-01-10T09:23:02.341Z" },
+    { url = "https://files.pythonhosted.org/packages/bd/28/0a25ee5342eb5d5f297d992a77e56892ecb65e7854c7898fb7d35e9b33bd/websockets-16.0-cp313-cp313-manylinux1_x86_64.manylinux_2_28_x86_64.manylinux_2_5_x86_64.whl", hash = "sha256:95724e638f0f9c350bb1c2b0a7ad0e83d9cc0c9259f3ea94e40d7b02a2179ae5", size = 184975, upload-time = "2026-01-10T09:23:03.756Z" },
+    { url = "https://files.pythonhosted.org/packages/f9/66/27ea52741752f5107c2e41fda05e8395a682a1e11c4e592a809a90c6a506/websockets-16.0-cp313-cp313-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:c0204dc62a89dc9d50d682412c10b3542d748260d743500a85c13cd1ee4bde82", size = 186203, upload-time = "2026-01-10T09:23:05.01Z" },
+    { url = "https://files.pythonhosted.org/packages/37/e5/8e32857371406a757816a2b471939d51c463509be73fa538216ea52b792a/websockets-16.0-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:52ac480f44d32970d66763115edea932f1c5b1312de36df06d6b219f6741eed8", size = 185653, upload-time = "2026-01-10T09:23:06.301Z" },
+    { url = "https://files.pythonhosted.org/packages/9b/67/f926bac29882894669368dc73f4da900fcdf47955d0a0185d60103df5737/websockets-16.0-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:6e5a82b677f8f6f59e8dfc34ec06ca6b5b48bc4fcda346acd093694cc2c24d8f", size = 184920, upload-time = "2026-01-10T09:23:07.492Z" },
+    { url = "https://files.pythonhosted.org/packages/3c/a1/3d6ccdcd125b0a42a311bcd15a7f705d688f73b2a22d8cf1c0875d35d34a/websockets-16.0-cp313-cp313-win32.whl", hash = "sha256:abf050a199613f64c886ea10f38b47770a65154dc37181bfaff70c160f45315a", size = 178255, upload-time = "2026-01-10T09:23:09.245Z" },
+    { url = "https://files.pythonhosted.org/packages/6b/ae/90366304d7c2ce80f9b826096a9e9048b4bb760e44d3b873bb272cba696b/websockets-16.0-cp313-cp313-win_amd64.whl", hash = "sha256:3425ac5cf448801335d6fdc7ae1eb22072055417a96cc6b31b3861f455fbc156", size = 178689, upload-time = "2026-01-10T09:23:10.483Z" },
+    { url = "https://files.pythonhosted.org/packages/f3/1d/e88022630271f5bd349ed82417136281931e558d628dd52c4d8621b4a0b2/websockets-16.0-cp314-cp314-macosx_10_15_universal2.whl", hash = "sha256:8cc451a50f2aee53042ac52d2d053d08bf89bcb31ae799cb4487587661c038a0", size = 177406, upload-time = "2026-01-10T09:23:12.178Z" },
+    { url = "https://files.pythonhosted.org/packages/f2/78/e63be1bf0724eeb4616efb1ae1c9044f7c3953b7957799abb5915bffd38e/websockets-16.0-cp314-cp314-macosx_10_15_x86_64.whl", hash = "sha256:daa3b6ff70a9241cf6c7fc9e949d41232d9d7d26fd3522b1ad2b4d62487e9904", size = 175085, upload-time = "2026-01-10T09:23:13.511Z" },
+    { url = "https://files.pythonhosted.org/packages/bb/f4/d3c9220d818ee955ae390cf319a7c7a467beceb24f05ee7aaaa2414345ba/websockets-16.0-cp314-cp314-macosx_11_0_arm64.whl", hash = "sha256:fd3cb4adb94a2a6e2b7c0d8d05cb94e6f1c81a0cf9dc2694fb65c7e8d94c42e4", size = 175328, upload-time = "2026-01-10T09:23:14.727Z" },
+    { url = "https://files.pythonhosted.org/packages/63/bc/d3e208028de777087e6fb2b122051a6ff7bbcca0d6df9d9c2bf1dd869ae9/websockets-16.0-cp314-cp314-manylinux1_x86_64.manylinux_2_28_x86_64.manylinux_2_5_x86_64.whl", hash = "sha256:781caf5e8eee67f663126490c2f96f40906594cb86b408a703630f95550a8c3e", size = 185044, upload-time = "2026-01-10T09:23:15.939Z" },
+    { url = "https://files.pythonhosted.org/packages/ad/6e/9a0927ac24bd33a0a9af834d89e0abc7cfd8e13bed17a86407a66773cc0e/websockets-16.0-cp314-cp314-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:caab51a72c51973ca21fa8a18bd8165e1a0183f1ac7066a182ff27107b71e1a4", size = 186279, upload-time = "2026-01-10T09:23:17.148Z" },
+    { url = "https://files.pythonhosted.org/packages/b9/ca/bf1c68440d7a868180e11be653c85959502efd3a709323230314fda6e0b3/websockets-16.0-cp314-cp314-musllinux_1_2_aarch64.whl", hash = "sha256:19c4dc84098e523fd63711e563077d39e90ec6702aff4b5d9e344a60cb3c0cb1", size = 185711, upload-time = "2026-01-10T09:23:18.372Z" },
+    { url = "https://files.pythonhosted.org/packages/c4/f8/fdc34643a989561f217bb477cbc47a3a07212cbda91c0e4389c43c296ebf/websockets-16.0-cp314-cp314-musllinux_1_2_x86_64.whl", hash = "sha256:a5e18a238a2b2249c9a9235466b90e96ae4795672598a58772dd806edc7ac6d3", size = 184982, upload-time = "2026-01-10T09:23:19.652Z" },
+    { url = "https://files.pythonhosted.org/packages/dd/d1/574fa27e233764dbac9c52730d63fcf2823b16f0856b3329fc6268d6ae4f/websockets-16.0-cp314-cp314-win32.whl", hash = "sha256:a069d734c4a043182729edd3e9f247c3b2a4035415a9172fd0f1b71658a320a8", size = 177915, upload-time = "2026-01-10T09:23:21.458Z" },
+    { url = "https://files.pythonhosted.org/packages/8a/f1/ae6b937bf3126b5134ce1f482365fde31a357c784ac51852978768b5eff4/websockets-16.0-cp314-cp314-win_amd64.whl", hash = "sha256:c0ee0e63f23914732c6d7e0cce24915c48f3f1512ec1d079ed01fc629dab269d", size = 178381, upload-time = "2026-01-10T09:23:22.715Z" },
+    { url = "https://files.pythonhosted.org/packages/06/9b/f791d1db48403e1f0a27577a6beb37afae94254a8c6f08be4a23e4930bc0/websockets-16.0-cp314-cp314t-macosx_10_15_universal2.whl", hash = "sha256:a35539cacc3febb22b8f4d4a99cc79b104226a756aa7400adc722e83b0d03244", size = 177737, upload-time = "2026-01-10T09:23:24.523Z" },
+    { url = "https://files.pythonhosted.org/packages/bd/40/53ad02341fa33b3ce489023f635367a4ac98b73570102ad2cdd770dacc9a/websockets-16.0-cp314-cp314t-macosx_10_15_x86_64.whl", hash = "sha256:b784ca5de850f4ce93ec85d3269d24d4c82f22b7212023c974c401d4980ebc5e", size = 175268, upload-time = "2026-01-10T09:23:25.781Z" },
+    { url = "https://files.pythonhosted.org/packages/74/9b/6158d4e459b984f949dcbbb0c5d270154c7618e11c01029b9bbd1bb4c4f9/websockets-16.0-cp314-cp314t-macosx_11_0_arm64.whl", hash = "sha256:569d01a4e7fba956c5ae4fc988f0d4e187900f5497ce46339c996dbf24f17641", size = 175486, upload-time = "2026-01-10T09:23:27.033Z" },
+    { url = "https://files.pythonhosted.org/packages/e5/2d/7583b30208b639c8090206f95073646c2c9ffd66f44df967981a64f849ad/websockets-16.0-cp314-cp314t-manylinux1_x86_64.manylinux_2_28_x86_64.manylinux_2_5_x86_64.whl", hash = "sha256:50f23cdd8343b984957e4077839841146f67a3d31ab0d00e6b824e74c5b2f6e8", size = 185331, upload-time = "2026-01-10T09:23:28.259Z" },
+    { url = "https://files.pythonhosted.org/packages/45/b0/cce3784eb519b7b5ad680d14b9673a31ab8dcb7aad8b64d81709d2430aa8/websockets-16.0-cp314-cp314t-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:152284a83a00c59b759697b7f9e9cddf4e3c7861dd0d964b472b70f78f89e80e", size = 186501, upload-time = "2026-01-10T09:23:29.449Z" },
+    { url = "https://files.pythonhosted.org/packages/19/60/b8ebe4c7e89fb5f6cdf080623c9d92789a53636950f7abacfc33fe2b3135/websockets-16.0-cp314-cp314t-musllinux_1_2_aarch64.whl", hash = "sha256:bc59589ab64b0022385f429b94697348a6a234e8ce22544e3681b2e9331b5944", size = 186062, upload-time = "2026-01-10T09:23:31.368Z" },
+    { url = "https://files.pythonhosted.org/packages/88/a8/a080593f89b0138b6cba1b28f8df5673b5506f72879322288b031337c0b8/websockets-16.0-cp314-cp314t-musllinux_1_2_x86_64.whl", hash = "sha256:32da954ffa2814258030e5a57bc73a3635463238e797c7375dc8091327434206", size = 185356, upload-time = "2026-01-10T09:23:32.627Z" },
+    { url = "https://files.pythonhosted.org/packages/c2/b6/b9afed2afadddaf5ebb2afa801abf4b0868f42f8539bfe4b071b5266c9fe/websockets-16.0-cp314-cp314t-win32.whl", hash = "sha256:5a4b4cc550cb665dd8a47f868c8d04c8230f857363ad3c9caf7a0c3bf8c61ca6", size = 178085, upload-time = "2026-01-10T09:23:33.816Z" },
+    { url = "https://files.pythonhosted.org/packages/9f/3e/28135a24e384493fa804216b79a6a6759a38cc4ff59118787b9fb693df93/websockets-16.0-cp314-cp314t-win_amd64.whl", hash = "sha256:b14dc141ed6d2dde437cddb216004bcac6a1df0935d79656387bd41632ba0bbd", size = 178531, upload-time = "2026-01-10T09:23:35.016Z" },
+    { url = "https://files.pythonhosted.org/packages/72/07/c98a68571dcf256e74f1f816b8cc5eae6eb2d3d5cfa44d37f801619d9166/websockets-16.0-pp311-pypy311_pp73-macosx_10_15_x86_64.whl", hash = "sha256:349f83cd6c9a415428ee1005cadb5c2c56f4389bc06a9af16103c3bc3dcc8b7d", size = 174947, upload-time = "2026-01-10T09:23:36.166Z" },
+    { url = "https://files.pythonhosted.org/packages/7e/52/93e166a81e0305b33fe416338be92ae863563fe7bce446b0f687b9df5aea/websockets-16.0-pp311-pypy311_pp73-macosx_11_0_arm64.whl", hash = "sha256:4a1aba3340a8dca8db6eb5a7986157f52eb9e436b74813764241981ca4888f03", size = 175260, upload-time = "2026-01-10T09:23:37.409Z" },
+    { url = "https://files.pythonhosted.org/packages/56/0c/2dbf513bafd24889d33de2ff0368190a0e69f37bcfa19009ef819fe4d507/websockets-16.0-pp311-pypy311_pp73-manylinux1_x86_64.manylinux_2_28_x86_64.manylinux_2_5_x86_64.whl", hash = "sha256:f4a32d1bd841d4bcbffdcb3d2ce50c09c3909fbead375ab28d0181af89fd04da", size = 176071, upload-time = "2026-01-10T09:23:39.158Z" },
+    { url = "https://files.pythonhosted.org/packages/a5/8f/aea9c71cc92bf9b6cc0f7f70df8f0b420636b6c96ef4feee1e16f80f75dd/websockets-16.0-pp311-pypy311_pp73-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:0298d07ee155e2e9fda5be8a9042200dd2e3bb0b8a38482156576f863a9d457c", size = 176968, upload-time = "2026-01-10T09:23:41.031Z" },
+    { url = "https://files.pythonhosted.org/packages/9a/3f/f70e03f40ffc9a30d817eef7da1be72ee4956ba8d7255c399a01b135902a/websockets-16.0-pp311-pypy311_pp73-win_amd64.whl", hash = "sha256:a653aea902e0324b52f1613332ddf50b00c06fdaf7e92624fbf8c77c78fa5767", size = 178735, upload-time = "2026-01-10T09:23:42.259Z" },
+    { url = "https://files.pythonhosted.org/packages/6f/28/258ebab549c2bf3e64d2b0217b973467394a9cea8c42f70418ca2c5d0d2e/websockets-16.0-py3-none-any.whl", hash = "sha256:1637db62fad1dc833276dded54215f2c7fa46912301a24bd94d45d46a011ceec", size = 171598, upload-time = "2026-01-10T09:23:45.395Z" },
+]