Stream agent replies from the first LLM call to cut response latency

Previously every turn made a non-streaming call to check for tool calls,
then re-generated the same answer with a second streaming call even when
no tool was needed — doubling time-to-first-token before TTS/animation
could start. Now the first call streams directly; tool calls are
reassembled from the stream and only trigger a follow-up call when
actually requested.

Co-Authored-By: Claude Sonnet 5 <noreply@anthropic.com>

agent/agent.py

@@ -78,40 +78,60 @@ async def run_agent(messages: list, model: str | None = None) -> str:
 
 
 async def stream_agent(messages: list, model: str | None = None) -> AsyncGenerator[str, None]:
-    """Resolve all tool calls, then stream the final response token by token."""
+    """
+    Stream tokens as soon as the model produces them. Every pass is a single
+    streaming call — if the model asks for tool calls we resolve them and
+    loop with another streaming call; if it answers directly, those tokens
+    are yielded immediately with no extra non-streamed round trip first.
+    """
     history = _build_history(messages)
     m = model or LLM_MODEL
 
-    # Tool-resolution phase — non-streaming until no more tool calls
     while True:
-        resp = await _get_client().chat.completions.create(
+        stream = await _get_client().chat.completions.create(
             model=m,
             messages=history,
             tools=TOOLS,
             tool_choice="auto",
+            stream=True,
             store=True,
         )
-        msg = resp.choices[0].message
-
-        if not msg.tool_calls:
-            break  # hand off to streaming pass
-
-        history.append(msg.model_dump(exclude_none=True))
-        for tc in msg.tool_calls:
-            args   = json.loads(tc.function.arguments or "{}")
-            result = await run_tool(tc.function.name, args)
-            history.append({"role": "tool", "tool_call_id": tc.id, "content": result})
 
-    # Streaming final-answer phase
-    stream = await _get_client().chat.completions.create(
-        model=m,
-        messages=history,
-        tools=TOOLS,
-        tool_choice="none",
-        stream=True,
-        store=True,
-    )
-    async for chunk in stream:
-        token = chunk.choices[0].delta.content
-        if token:
-            yield token
+        tool_calls: dict[int, dict] = {}
+        async for chunk in stream:
+            delta = chunk.choices[0].delta
+            if delta.content:
+                yield delta.content
+            for tc_delta in (delta.tool_calls or []):
+                slot = tool_calls.setdefault(
+                    tc_delta.index, {"id": "", "name": "", "arguments": ""}
+                )
+                if tc_delta.id:
+                    slot["id"] = tc_delta.id
+                if tc_delta.function:
+                    if tc_delta.function.name:
+                        slot["name"] += tc_delta.function.name
+                    if tc_delta.function.arguments:
+                        slot["arguments"] += tc_delta.function.arguments
+
+        if not tool_calls:
+            return  # final answer was already streamed above
+
+        ordered = [tool_calls[i] for i in sorted(tool_calls)]
+        history.append({
+            "role": "assistant",
+            "content": None,
+            "tool_calls": [
+                {
+                    "id": tc["id"],
+                    "type": "function",
+                    "function": {"name": tc["name"], "arguments": tc["arguments"]},
+                }
+                for tc in ordered
+            ],
+        })
+        for tc in ordered:
+            args = json.loads(tc["arguments"] or "{}")
+            print(f"[AGENT] tool call: {tc['name']}({args})", flush=True)
+            result = await run_tool(tc["name"], args)
+            history.append({"role": "tool", "tool_call_id": tc["id"], "content": result})