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/llm/openai_client.py

@@ -77,9 +77,13 @@ class Endpoint:
         return headers
 
 
-def _describe_http_error(exc: httpx.HTTPStatusError) -> str:
+def describe_http_error(exc: httpx.HTTPStatusError) -> str:
     """Turn an upstream error response into something worth reading.
 
+    Public because the audio and search clients talk to the same class of
+    server and want the same translation; LLMError stays the one thing a
+    caller has to catch.
+
     Providers put the useful part in wildly different places, so try the common
     shapes before falling back to the raw body.
     """
@@ -109,7 +113,7 @@ def _describe_http_error(exc: httpx.HTTPStatusError) -> str:
     return friendly or detail or f"The endpoint returned HTTP {status}."
 
 
-def _wrap_transport_error(exc: httpx.RequestError, endpoint: Endpoint) -> LLMError:
+def wrap_transport_error(exc: httpx.RequestError, endpoint: Endpoint) -> LLMError:
     if isinstance(exc, httpx.ConnectError):
         return LLMError(
             f"Could not reach {endpoint.base_url}. Is the endpoint running and "
@@ -131,9 +135,9 @@ async def list_models(endpoint: Endpoint) -> list[dict[str, Any]]:
             response.raise_for_status()
             payload = response.json()
     except httpx.HTTPStatusError as exc:
-        raise LLMError(_describe_http_error(exc), status_code=exc.response.status_code) from exc
+        raise LLMError(describe_http_error(exc), status_code=exc.response.status_code) from exc
     except httpx.RequestError as exc:
-        raise _wrap_transport_error(exc, endpoint) from exc
+        raise wrap_transport_error(exc, endpoint) from exc
     except ValueError as exc:
         raise LLMError("The endpoint returned a response that was not JSON.") from exc
 
@@ -195,9 +199,9 @@ async def stream_chat(
                     continue
 
     except httpx.HTTPStatusError as exc:
-        raise LLMError(_describe_http_error(exc), status_code=exc.response.status_code) from exc
+        raise LLMError(describe_http_error(exc), status_code=exc.response.status_code) from exc
     except httpx.RequestError as exc:
-        raise _wrap_transport_error(exc, endpoint) from exc
+        raise wrap_transport_error(exc, endpoint) from exc
 
 
 async def complete(endpoint: Endpoint, payload: dict[str, Any]) -> str:
@@ -211,9 +215,9 @@ async def complete(endpoint: Endpoint, payload: dict[str, Any]) -> str:
             response.raise_for_status()
             data = response.json()
     except httpx.HTTPStatusError as exc:
-        raise LLMError(_describe_http_error(exc), status_code=exc.response.status_code) from exc
+        raise LLMError(describe_http_error(exc), status_code=exc.response.status_code) from exc
     except httpx.RequestError as exc:
-        raise _wrap_transport_error(exc, endpoint) from exc
+        raise wrap_transport_error(exc, endpoint) from exc
     except ValueError as exc:
         raise LLMError("The endpoint returned a response that was not JSON.") from exc
 
@@ -245,6 +249,40 @@ def delta_reasoning(chunk: dict[str, Any]) -> str:
         return ""
 
 
+def delta_tool_calls(chunk: dict[str, Any]) -> list[dict[str, Any]]:
+    """Pull tool-call fragments out of one streamed chunk.
+
+    Each entry carries an ``index`` and, across chunks, a name that arrives
+    once and an ``arguments`` string that arrives in pieces. Reassembling them
+    is lembas.services.tools.ToolCallAccumulator's job; this only extracts.
+    """
+    try:
+        choices = chunk.get("choices") or []
+        if not choices:
+            return []
+        calls = (choices[0].get("delta") or {}).get("tool_calls")
+        return calls if isinstance(calls, list) else []
+    except (AttributeError, TypeError):
+        return []
+
+
+def finish_reason(chunk: dict[str, Any]) -> str:
+    """Why the model stopped, when the chunk says so.
+
+    ``tool_calls`` here is the signal that the reply is not an answer but a
+    request to run something and come back. Some servers send ``stop`` even
+    when they emitted tool calls, so the accumulator's contents are the real
+    authority and this is only a hint.
+    """
+    try:
+        choices = chunk.get("choices") or []
+        if not choices:
+            return ""
+        return choices[0].get("finish_reason") or ""
+    except (AttributeError, TypeError):
+        return ""
+
+
 def delta_text(chunk: dict[str, Any]) -> str:
     """Pull the text out of one streamed chunk, tolerating provider variation."""
     try: