fix: eliminate redundant stream_complete() call in run_stream

The tool-use loop's final complete() already produces the synthesis
when it returns with no tool_calls. Previously, run_stream discarded
that response and made a second stream_complete() call — doubling
the API cost for tool-using requests.

Now always emit response.content from the loop's final complete() as
a single chunk. This means /ask/stream no longer incrementally streams
tokens for the synthesis, but it eliminates the extra LLM call and
makes cost accounting exact (total_cost now covers all LLM calls).

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

agent_bench/agents/orchestrator.py

@@ -200,7 +200,6 @@ class Orchestrator:
         total_cost = 0.0
 
         # Step 1: Run tool-use loop normally (non-streamed)
-        used_tools = False
         for _ in range(self.max_iterations):
             response = await self.provider.complete(
                 messages, tools=tools, temperature=self.temperature
@@ -209,7 +208,6 @@ class Orchestrator:
             if not response.tool_calls:
                 break
 
-            used_tools = True
             messages.append(
                 Message(
                     role=Role.ASSISTANT,
@@ -235,17 +233,10 @@ class Orchestrator:
             sources=[{"source": s} for s in dict.fromkeys(all_sources)],
         )
 
-        # Step 3: Stream the final synthesis
-        if used_tools:
-            # Tools were used — need a fresh streaming call to synthesize
-            async for chunk in self.provider.stream_complete(
-                messages, temperature=self.temperature
-            ):
-                yield StreamEvent(type="chunk", content=chunk)
-        else:
-            # No tools needed — response already has the answer, emit it
-            # without a redundant second LLM call
-            yield StreamEvent(type="chunk", content=response.content)
+        # Step 3: Emit the final answer as a single chunk.
+        # The loop's last complete() already produced the synthesis — reuse it
+        # instead of making a redundant stream_complete() call.
+        yield StreamEvent(type="chunk", content=response.content)
 
         yield StreamEvent(
             type="done",

tests/test_serving.py

@@ -400,8 +400,8 @@ class TestStreaming:
         assert "FastAPI" in full_text  # MockProvider mentions FastAPI
 
     @pytest.mark.asyncio
-    async def test_stream_mock_provider_3_chunks(self, test_app):
-        """MockProvider yields exactly 3 deterministic chunks."""
+    async def test_stream_emits_single_answer_chunk(self, test_app):
+        """Stream emits the complete answer as a single chunk (no redundant LLM call)."""
         import json as json_mod
 
         async with AsyncClient(
@@ -417,7 +417,8 @@ class TestStreaming:
             if line.startswith("data: ")
             and json_mod.loads(line[6:])["type"] == "chunk"
         ]
-        assert len(chunks) == 3
+        assert len(chunks) == 1
+        assert len(chunks[0]["content"]) > 0
 
     @pytest.mark.asyncio
     async def test_non_streaming_unchanged(self, test_app):