fix(pydantic-ai): drop removed coalesce_tool_requests kwarg from tutorials [greptile]

PydanticAITurn.__init__ accepts only (stream, model, tracing_handler); the
coalesce_tool_requests workaround was removed now that the unified auto_send
path delivers streamed tool requests natively (Start+Delta+Done). Two tutorial
agents still passed coalesce_tool_requests=True, which would raise TypeError at
runtime (P0):
- 10_async/00_base/harness_pydantic_ai (acp.py)
- 10_async/10_temporal/harness_pydantic_ai (agent.py)

Also refresh the now-stale references to the removed parameter in the sync
tutorial comment and the cross-channel conformance test docstring (AGX1-377 has
landed; streamed tool requests are delivered and asserted).

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

Author: declan-scale

examples/tutorials/00_sync/harness_pydantic_ai/project/acp.py

@@ -85,8 +85,8 @@ async def handle_message_send(
         )
 
         async with agent.run_stream_events(user_message) as stream:
-            # Default coalesce_tool_requests=False preserves token-by-token
-            # tool-call argument streaming on the sync/HTTP channel.
+            # PydanticAITurn preserves token-by-token tool-call argument
+            # streaming (Start+Delta+Done) on the sync/HTTP channel.
             turn = PydanticAITurn(stream, model=MODEL_NAME)
             async for ev in emitter.yield_turn(turn):
                 yield ev

examples/tutorials/10_async/00_base/harness_pydantic_ai/project/acp.py

@@ -1,7 +1,7 @@
 """ACP handler for the async harness Pydantic AI test agent.
 
 This agent exercises the UNIFIED HARNESS SURFACE on the async (Redis-streaming)
-channel — ``UnifiedEmitter.auto_send_turn(PydanticAITurn(..., coalesce_tool_requests=True))``
+channel — ``UnifiedEmitter.auto_send_turn(PydanticAITurn(...))``
 — calling it directly rather than via the ``stream_pydantic_ai_events`` helper
 (which the ``110_pydantic_ai`` tutorial uses). This makes the unified-surface
 wiring explicit at the agent-author level.
@@ -132,13 +132,11 @@ async def tee_messages(upstream) -> AsyncIterator[Any]:
                 yield event
 
         async with agent.run_stream_events(user_message, message_history=previous_messages) as stream:
-            # coalesce_tool_requests=True is required on the async/auto_send
-            # path until AGX1-377 lands: tool requests are delivered as a single
-            # Full(tool_request) rather than streamed Start+Delta+Done.
+            # The unified auto_send path delivers streamed tool requests natively
+            # (Start+Delta+Done), so no coalescing workaround is needed.
             turn = PydanticAITurn(
                 tee_messages(stream),
                 model=MODEL_NAME,
-                coalesce_tool_requests=True,
             )
             result = await emitter.auto_send_turn(turn)
 

examples/tutorials/10_async/10_temporal/harness_pydantic_ai/project/agent.py

@@ -88,15 +88,15 @@ async def event_handler(
 
     The UnifiedEmitter is constructed from ``deps`` (task_id + parent_span_id),
     so tool spans nest under the workflow's per-turn span and messages auto-send
-    to the task stream. ``coalesce_tool_requests=True`` is required on the
-    auto_send path until AGX1-377 lands.
+    to the task stream. The auto_send path delivers streamed tool requests
+    natively, so no coalescing workaround is needed.
     """
     emitter = UnifiedEmitter(
         task_id=run_context.deps.task_id,
         trace_id=run_context.deps.task_id,
         parent_span_id=run_context.deps.parent_span_id,
     )
-    turn = PydanticAITurn(events, model=MODEL_NAME, coalesce_tool_requests=True)
+    turn = PydanticAITurn(events, model=MODEL_NAME)
     await emitter.auto_send_turn(turn)
 
 

tests/lib/core/harness/conformance/test_pydantic_ai_conformance.py

@@ -1,22 +1,17 @@
 """Cross-channel conformance fixtures derived from real pydantic-ai event sequences.
 
 Each fixture is built by running a pydantic_ai event stream through PydanticAITurn
-(default coalesce_tool_requests=False) and collecting the canonical StreamTaskMessage*
-output. These canonical event lists are then registered with the conformance runner and
-exercised by the cross-channel test (yield_events vs auto_send).
+and collecting the canonical StreamTaskMessage* output. These canonical event lists are
+then registered with the conformance runner and exercised by the cross-channel test
+(yield_events vs auto_send).
 
-AGX1-377 NOTE
--------------
+Streamed tool requests
+----------------------
 The pydantic-ai stream emits a tool REQUEST as Start + ToolRequestDelta + Done (not a
-Full event). The runner's current normalization does NOT produce a logical delivery for
-Start+Delta+Done(tool_request): _yield_logical_deliveries only produces a delivery for
-Full(tool_request) or Full(tool_response), and Start+Done for text/reasoning content.
-auto_send likewise drops the Start+Delta+Done(tool_request) shape. Both channels handle
-it consistently (both ignore it), so the cross-channel test PASSES, but it does NOT yet
-assert that the streamed tool-request is actually delivered. Full delivery-equivalence
-coverage for streamed tool requests will land once AGX1-377 fixes the normalization.
-The fixtures below retain the ToolRequestDelta events so they become valid test inputs
-automatically once AGX1-377 lands.
+Full event). AGX1-377 has landed: both the conformance runner and auto_send now deliver
+the Start+Delta+Done(tool_request) shape, so the cross-channel test asserts full
+delivery-equivalence for streamed tool requests. The fixtures below retain the
+ToolRequestDelta events as the streamed tool-request inputs.
 """
 
 from __future__ import annotations
@@ -61,8 +56,7 @@ async def _aiter(events: list[Any]) -> AsyncIterator[Any]:
 async def _canonical(pydantic_events: list[Any]) -> list[Any]:
     """Run pydantic_ai events through PydanticAITurn and collect the output.
 
-    Default coalesce_tool_requests=False means the output equals the bare
-    convert_pydantic_ai_to_agentex_events output.
+    The output equals the bare convert_pydantic_ai_to_agentex_events output.
     """
     turn = PydanticAITurn(_aiter(pydantic_events), model=None)
     return [e async for e in turn.events]