PWA, one send/stop button, audio in and out, web search as a tool

Four pieces of work.

**Installable.** A manifest carrying the instance name, PWA icons rasterised
from the existing mark at design time, a service worker and a themed offline
page. The worker caches the shell only and bails out on /api/, /auth/, /admin/
and anything accepting text/event-stream -- passing a reply stream through a
worker turns it into one delivery at the end, or nothing. It is served from
GET /sw.js rather than the static mount because a worker's scope is the path it
came from.

**Send and Stop are one button.** They were two, and the hidden one was never
hidden: `.btn` is display: inline-flex, which outranks the browser's own
`[hidden] { display: none }`, so Stop sat permanently beside Send. app.css now
forces the attribute to win -- every control toggled with `hidden` depended on
that -- and the composer renders one button carrying both icons, with ui.js
flipping data-composer-action and the type with it.

**Audio.** Speech to text and text to speech against any OpenAI-shaped
/v1/audio/* endpoint: dictate into the composer, have a reply read out.
Instance settings in Admin, per-reader overrides in Settings, with the voice
list discovered from the server where it offers one. Recorded audio is capped
and never written to disk -- it is not an attachment, it has no owner, and
nothing would ever sweep it.

**Web search, as a tool.** This is the tool loop PLAN.md described as the real
work: one reply is now a bounded sequence of requests rather than one. The model
asks, the tool runs, the result goes back and it is asked again, up to three
rounds. Providers are DuckDuckGo (no setup), SearXNG and Firecrawl.

Two decisions worth stating. Tools are only offered to models flagged `tools`,
because an endpoint without support rejects the whole request rather than
ignoring the array -- the same reason images only reach models flagged
`vision`. And tool results are not replayed as context on the next turn, for the
same reasons reasoning is not: the answer already contains what the model made
of them, and replaying stale results into every later request wastes the window
and reliably sends a small model into a search loop. The sources stay visible in
the transcript instead.

Search results are untrusted third-party text and are treated as such: escaped,
and only http/https URLs rendered as links.

338 tests, ruff clean.

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

src/lembas/services/generation.py

@@ -22,10 +22,18 @@ import time
 from dataclasses import dataclass, field
 from datetime import UTC, datetime, timedelta
 
-from lembas.db.models import ROLE_ASSISTANT, ROLE_USER, Chat, Message
+from lembas.db.models import ROLE_ASSISTANT, ROLE_USER, Chat, Message, User
 from lembas.db.session import session_scope
 from lembas.services import chat as chat_service
-from lembas.services.llm.openai_client import LLMError, delta_reasoning, delta_text, stream_chat
+from lembas.services import settings_store
+from lembas.services import tools as tools_service
+from lembas.services.llm.openai_client import (
+    LLMError,
+    delta_reasoning,
+    delta_text,
+    delta_tool_calls,
+    stream_chat,
+)
 from lembas.services.reasoning import REASONING, ReasoningSplitter
 
 log = logging.getLogger(__name__)
@@ -52,6 +60,10 @@ class Generation:
     reasoning: list[str] = field(default_factory=list)
     reasoning_ms: int = 0
 
+    # One entry per tool call made while producing this reply, in order. Shown
+    # live as the model works and kept on the message afterwards.
+    tool_events: list[dict] = field(default_factory=list)
+
     error: str = ""
     stopped: bool = False
     done: bool = False
@@ -130,7 +142,15 @@ async def shutdown() -> None:
 
 
 async def _run(generation: Generation) -> None:
-    """Produce one reply, then persist it. Never raises into the task."""
+    """Produce one reply, then persist it. Never raises into the task.
+
+    A reply is not necessarily one request. When tools are offered and the
+    model asks to use one, the loop below runs it, appends the result to the
+    conversation and asks again -- up to tools_service.MAX_ROUNDS times, after
+    which the model has to answer with what it has. Text produced before a tool
+    call is kept, so a model that narrates what it is about to look up does not
+    lose that when the results come back.
+    """
     splitter = ReasoningSplitter()
     started = time.monotonic()
     reasoning_started: float | None = None
@@ -151,35 +171,89 @@ async def _run(generation: Generation) -> None:
             question = _question_from(payload)
             needs_title = not chat.title_generated
 
-        async for chunk in stream_chat(endpoint, payload):
-            thought = delta_reasoning(chunk)
-            if thought:
-                if reasoning_started is None:
-                    reasoning_started = time.monotonic()
-                generation.reasoning.append(thought)
-                generation.touch()
+            # Read while the session is open: everything below outlives it.
+            offered = tools_service.enabled_tools(db, chat, db.get(User, chat.user_id))
+            search_config = settings_store.search(db) if offered else {}
 
-            text = delta_text(chunk)
-            if text:
-                for kind, piece in splitter.feed(text):
-                    if kind == REASONING:
-                        if reasoning_started is None:
-                            reasoning_started = time.monotonic()
-                        generation.reasoning.append(piece)
-                    else:
-                        if reasoning_started is not None and not generation.reasoning_ms:
-                            generation.reasoning_ms = int(
-                                (time.monotonic() - reasoning_started) * 1000
-                            )
-                        generation.content.append(piece)
-                generation.touch()
+        if offered:
+            payload = {**payload, "tools": offered}
 
-            if generation.cancel:
-                generation.stopped = True
+        for round_number in range(tools_service.MAX_ROUNDS + 1):
+            accumulator = tools_service.ToolCallAccumulator()
+            # Text the model produced in *this* round, needed separately from
+            # generation.content when echoing the assistant turn back.
+            round_text: list[str] = []
+
+            async for chunk in stream_chat(endpoint, payload):
+                thought = delta_reasoning(chunk)
+                if thought:
+                    if reasoning_started is None:
+                        reasoning_started = time.monotonic()
+                    generation.reasoning.append(thought)
+                    generation.touch()
+
+                if offered:
+                    fragments = delta_tool_calls(chunk)
+                    if fragments:
+                        accumulator.feed(fragments)
+
+                text = delta_text(chunk)
+                if text:
+                    for kind, piece in splitter.feed(text):
+                        if kind == REASONING:
+                            if reasoning_started is None:
+                                reasoning_started = time.monotonic()
+                            generation.reasoning.append(piece)
+                        else:
+                            if reasoning_started is not None and not generation.reasoning_ms:
+                                generation.reasoning_ms = int(
+                                    (time.monotonic() - reasoning_started) * 1000
+                                )
+                            generation.content.append(piece)
+                            round_text.append(piece)
+                    generation.touch()
+
+                if generation.cancel:
+                    generation.stopped = True
+                    break
+
+                # Let followers and other tasks run between chunks.
+                await asyncio.sleep(0)
+
+            calls = accumulator.calls
+            if generation.stopped or not calls:
                 break
 
-            # Let followers and other tasks run between chunks.
-            await asyncio.sleep(0)
+            if round_number == tools_service.MAX_ROUNDS:
+                # Out of rounds with the model still asking for tools. Recorded
+                # rather than silently dropped: an answer that stops here needs
+                # to be explicable.
+                generation.tool_events.append(
+                    {
+                        "name": calls[0]["name"],
+                        "status": "error",
+                        "error": (
+                            f"Stopped after {tools_service.MAX_ROUNDS} rounds of tool "
+                            f"calls without an answer."
+                        ),
+                    }
+                )
+                generation.touch()
+                break
+
+            messages = [
+                *payload["messages"],
+                tools_service.assistant_turn(calls, "".join(round_text)),
+            ]
+            for call in calls:
+                outcome = await tools_service.run_tool(
+                    search_config, call["name"], call["arguments"]
+                )
+                generation.tool_events.append(outcome.event)
+                generation.touch()
+                messages.append(tools_service.tool_turn(call, outcome.content))
+
+            payload = {**payload, "messages": messages}
 
         for kind, piece in splitter.flush():
             (generation.reasoning if kind == REASONING else generation.content).append(piece)
@@ -248,6 +322,7 @@ def _persist(generation: Generation, title: str, elapsed: float) -> None:
             message.content = generation.text
             message.reasoning = generation.thinking
             message.reasoning_ms = generation.reasoning_ms
+            message.tool_calls_json = generation.tool_events
             message.error = generation.error
             message.stopped = generation.stopped
             message.complete = True