Backtestspydantic-airun-20260918-215936#6432

Issue #6432 Merged fix PR # Run 18 Sep 2026 · run-20260918-215936 pydantic/pydantic-ai

Reduce quadratic string assembly in streamed response parts

Worse

The merged fix was judged better than our patch.

In this judgment, Patch A = our agent, Patch B = the merged fix.

Both patches attack the root cause the same way — per-part `_string_buffers` of string deltas materialized lazily — and both keep incomplete tool args out of `get_parts()` so the issue's benchmark stays linear. The decision turns on correctness and tests.

Correctness: Patch A is elegant (apply metadata with content zeroed, buffer the content, so callback atomicity and event payloads come 'for free'), but it has two real defects it never addresses. (1) It declares `_string_buffers` with `repr=False` but WITHOUT `compare=False`, so the dataclass's auto-generated `__eq__` compares raw buffer lists. Since materialize is non-destructive (it never writes the joined value back into `_parts`, which stays at content=''/args=''), two managers that streamed identical final content with different chunk boundaries (e.g. ['he','llo'] vs ['hello']) now compare unequal — a behavior regression versus the original where equality depended only on final content. (2) For the same reason, the auto `__repr__` prints stale empty content. The issue explicitly lists equality and repr as validation gates; Patch A fails them. Patch A is also less faithful on dict→str args transitions: it blindly does `replace(args_delta='').apply` and would drop existing dict args, whereas Patch B falls back to a full `apply` when current args are a dict. Patch B addresses all of these (compare=False plus materializing `__eq__`/`__repr__`, atomic rollback on typed-promotion and callback failure, snapshot isolation, dict-vs-str guards).

Tests: Patch B adds a large suite of deterministic, mechanism-focused tests using spies to assert that `apply`/`_materialize_part` are NOT called during buffering, plus atomicity, reentrancy, isolation, and equality/repr — all fail-before/pass-after and mapping directly onto the issue's stated validation. Patch A ships a single timing-based scaling test (`large < small*8`), the most fragile kind, whose only non-timing assertions are correctness of the joined output.

Scope favors A (B is much larger, adds `__eq__`/`__repr__` overrides, and a `__repr__` with mutation side-effects is a genuine smell and a risk). Craft is mixed: A's core mechanism is cleaner, but it leaves `_parts` permanently stale and has the equality oversight; B is complex but its complexity is largely in service of the transparency properties the issue demands, and its tests give real confidence. Weighing correctness first, then tests, B's fidelity on the equality/repr/atomicity contract plus its far stronger deterministic tests outweigh A's smaller footprint. It is a real tradeoff, not a tie, and B is the better fix.

The judge saw only the two patches, labelled A and B in random order, with issue links and version numbers removed. The reasoning above is shown verbatim.

Solve

50m 58s16 turns

Wall-clock time in the container

Full test suite

No new failures

5,755 passed · 2,488 skipped · 8,248 total

Contamination audit

Unknown

See the audit notes for this run

Patch size

216vs 549 merged

Changed lines, ours vs merged

Problem

ModelResponsePartsManager currently applies each text, thinking, and string tool-argument delta by building a new complete string. For a long response split into many small chunks, this copies the accumulated prefix on every chunk, so assembly time grows quadratically with the number of chunks.

This is provider-independent because streamed model responses share the same parts manager.

Measurement

I measured current main at 3adb9b0260383d0f9f2b2a9433f07e1ecfc768c1 and the final focused candidate using the locked repository dependencies. The primary metric is the sum of two median single-thread CPU workloads: 32,000 interleaved 16-byte deltas for text, thinking, and complete string-valued tool arguments, plus 12,000 incomplete tool-argument deltas with an intermediate public read after each delta.

MetricCurrent mainCandidateChange
stream_parts_assembly_cpu_ms1211.740 ms250.617 ms-79.32% (4.84x faster)

The candidate also scales approximately linearly when chunk counts double. A callable thinking-metadata workload measured 23.930, 47.729, and 95.103 ms at 4k, 8k, and 16k deltas; current main measured 26.425, 83.150, and 277.418 ms.

This measures local assembly CPU only, not provider or network latency.

Proposed approach

Keep private per-part lists of string deltas and materialize concrete strings when public reads or snapshots require them. Stream events still carry each delta immediately. Metadata and signature updates remain eager, failed metadata callbacks remain atomic, and replacing a part discards its old buffer.

There is no public API change. get_parts() and get_part_by_vendor_id() continue to return the same concrete part types and values. Incomplete tool arguments remain hidden from public parts without rebuilding the growing internal string on every read.

Validation

  • strict evaluator: 218 focused tests and 15 behavior gates
  • broader streaming/provider suite: 1,394 passed, 993 skipped
  • held-snapshot isolation for text, thinking, and embedded thinking
  • callback reads, reentrant writes/replacement, callback failure ordering, and buffer restoration
  • complete/incomplete tool promotion, rollback, string/dict arguments, equality, and repr
  • 30 x 300-operation eager-versus-buffered differential harness
  • Ruff, Pyright, and git diff --check passed
  • independent code review found no functional blockers

Final autoresearch trajectory: https://dashboard.weco.ai/share/bxxTD48AVsNY22y_GrAHb63fR2pKmur3

Per CONTRIBUTING.md, I opened this issue before a PR. A maintainer has said the project would be happy to review the PR; I am waiting for assignment or confirmation that the approval is sufficient before opening it.

The two patches

Our patch+183 −33
pydantic_ai_slim/pydantic_ai/_parts_manager.pyindex 3f64db0f..d1335dc5 100644@@ -19,6 +19,7 @@ from typing import TYPE_CHECKING, Any, TypeVar  from pydantic_ai.exceptions import UnexpectedModelBehavior from pydantic_ai.messages import (+    BaseToolCallPart,     ModelResponsePart,     ModelResponseStreamEvent,     NativeToolCallPart,@@ -74,6 +75,14 @@ class ModelResponsePartsManager:     """Maps a vendor's "part" ID (if provided) to the index in `_parts` where that part resides."""     _tool_kind_by_name: dict[str, ToolPartKind] = field(default_factory=dict[str, ToolPartKind], init=False, repr=False)     """Cached `{tool_name: tool_kind}` built from `function_tools` at construction time."""+    _string_buffers: dict[int, list[str]] = field(default_factory=dict[int, list[str]], init=False, repr=False)+    """Per-part buffers of streamed string deltas (text/thinking content and string tool arguments).++    Streaming applies each delta by appending to a list rather than rebuilding the growing string, so+    assembly stays linear in the number of chunks. The concrete string is materialized lazily by+    `_materialize` when a public read or snapshot needs it. The base part stored in `_parts` keeps its+    string field at the value it had when buffering began (usually empty), so it never grows.+    """      def __post_init__(self) -> None:         self._tool_kind_by_name = {@@ -96,13 +105,45 @@ class ModelResponsePartsManager:             return part         return ToolCallPart.narrow_type(part, tool_kind=kind) +    def _materialize(self, index: int) -> ManagedPart:+        """Return the part at `index` with any buffered string deltas joined into concrete content.++        Returns the stored part unchanged when it has no buffered deltas.+        """+        part = self._parts[index]+        buffer = self._string_buffers.get(index)+        if not buffer:+            return part+        joined = ''.join(buffer)+        if isinstance(part, TextPart):+            return replace(part, content=part.content + joined)+        if isinstance(part, ThinkingPart):+            return replace(part, content=part.content + joined)+        if isinstance(part, BaseToolCallPart):+            existing = part.args if isinstance(part.args, str) else ''+            return replace(part, args=existing + joined)+        if isinstance(part, ToolCallPartDelta):+            existing = part.args_delta if isinstance(part.args_delta, str) else ''+            return replace(part, args_delta=existing + joined)+        return part  # pragma: no cover++    def _materialize_part(self, index: int) -> ModelResponsePart:+        """Like `_materialize`, but for indices known to hold a complete (non-delta) part."""+        part = self._materialize(index)+        assert not isinstance(part, ToolCallPartDelta)+        return part+     def get_parts(self) -> list[ModelResponsePart]:         """Return only model response parts that are complete (i.e., not ToolCallPartDelta's).          Returns:             A list of ModelResponsePart objects. ToolCallPartDelta objects are excluded.         """-        return [p for p in self._parts if not isinstance(p, ToolCallPartDelta)]+        return [+            self._materialize_part(index)+            for index, part in enumerate(self._parts)+            if not isinstance(part, ToolCallPartDelta)+        ]      def get_part_by_vendor_id(self, vendor_id: VendorId) -> ManagedPart | None:         """Return a part by its vendor ID.@@ -115,7 +156,7 @@ class ModelResponsePartsManager:         """         part_index = self._vendor_id_to_part_index.get(vendor_id)         if part_index is not None:-            return self._parts[part_index]+            return self._materialize(part_index)         return None      def handle_text_delta(@@ -190,10 +231,12 @@ class ModelResponsePartsManager:             if ignore_leading_whitespace and (len(content) == 0 or content.isspace()):                 return -            # There is no existing text part that should be updated, so create a new one-            part = TextPart(content=content, id=id, provider_name=provider_name, provider_details=provider_details)+            # There is no existing text part that should be updated, so create a new one.+            # The content is buffered so repeated deltas don't rebuild the growing string.+            part = TextPart(content='', id=id, provider_name=provider_name, provider_details=provider_details)             new_part_index = self._append_part(part, vendor_part_id)-            yield PartStartEvent(index=new_part_index, part=part)+            self._string_buffers[new_part_index] = [content]+            yield PartStartEvent(index=new_part_index, part=self._materialize_part(new_part_index))         else:             # Update the existing TextPart with the new content delta             existing_text_part, part_index = existing_text_part_and_index@@ -203,7 +246,10 @@ class ModelResponsePartsManager:                 provider_name=self._resolve_provider_name(existing_text_part, provider_name),                 provider_details=provider_details,             )-            self._parts[part_index] = part_delta.apply(existing_text_part)+            # Update metadata eagerly (empty content delta leaves the base string untouched) and buffer+            # the content so the accumulated string isn't rebuilt on every chunk.+            self._parts[part_index] = replace(part_delta, content_delta='').apply(existing_text_part)+            self._string_buffers.setdefault(part_index, []).append(content)             yield PartDeltaEvent(index=part_index, delta=part_delta)      def handle_thinking_delta(@@ -261,14 +307,16 @@ class ModelResponsePartsManager:                 resolved_details: dict[str, Any] | None                 resolved_details = provider_details(None) if callable(provider_details) else provider_details                 part = ThinkingPart(-                    content=content or '',+                    content='',                     id=id,                     signature=signature,                     provider_name=provider_name,                     provider_details=resolved_details,                 )                 new_part_index = self._append_part(part, vendor_part_id)-                yield PartStartEvent(index=new_part_index, part=part)+                if content:+                    self._string_buffers[new_part_index] = [content]+                yield PartStartEvent(index=new_part_index, part=self._materialize_part(new_part_index))             else:                 raise UnexpectedModelBehavior(                     'Cannot create a ThinkingPart with no content, signature, or provider_details'@@ -286,7 +334,12 @@ class ModelResponsePartsManager:                 provider_name=self._resolve_provider_name(existing_thinking_part, provider_name),                 provider_details=provider_details,             )-            self._parts[part_index] = part_delta.apply(existing_thinking_part)+            # Apply metadata/signature eagerly (a None content delta leaves the base string untouched, and+            # any provider_details callback runs here so a failure stays atomic) and buffer the content so+            # the accumulated string isn't rebuilt on every chunk.+            self._parts[part_index] = replace(part_delta, content_delta=None).apply(existing_thinking_part)+            if content:+                self._string_buffers.setdefault(part_index, []).append(content)             yield PartDeltaEvent(index=part_index, delta=part_delta)      def handle_tool_call_delta(@@ -348,45 +401,92 @@ class ModelResponsePartsManager:                 existing_matching_part_and_index = existing_part, part_index          if existing_matching_part_and_index is None:-            # No matching part/delta was found, so create a new ToolCallPartDelta (or ToolCallPart if fully formed)-            delta = ToolCallPartDelta(-                tool_name_delta=tool_name,-                args_delta=args,-                tool_call_id=tool_call_id,-                provider_name=provider_name,-                provider_details=provider_details,+            # No matching part/delta was found, so create a new ToolCallPartDelta (or ToolCallPart if fully formed).+            part, new_part_index = self._create_tool_call(+                vendor_part_id, tool_name, args, tool_call_id, provider_name, provider_details             )-            part = delta.as_part() or delta-            if isinstance(part, ToolCallPart):-                part = self._typed_call_part(part)-            new_part_index = self._append_part(part, vendor_part_id)             # Only emit a PartStartEvent if we have enough information to produce a full ToolCallPart             if isinstance(part, ToolCallPart | NativeToolCallPart):-                return PartStartEvent(index=new_part_index, part=part)+                return PartStartEvent(index=new_part_index, part=self._materialize_part(new_part_index))         else:             # Update the existing part or delta with the new information             existing_part, part_index = existing_matching_part_and_index-            delta = ToolCallPartDelta(-                tool_name_delta=tool_name,-                args_delta=args,-                tool_call_id=tool_call_id,-                provider_name=self._resolve_provider_name(existing_part, provider_name),-                provider_details=provider_details,+            updated_part, delta = self._update_tool_call(+                existing_part, part_index, tool_name, args, tool_call_id, provider_name, provider_details             )-            updated_part = delta.apply(existing_part)-            if isinstance(updated_part, ToolCallPart):-                updated_part = self._typed_call_part(updated_part)-            self._parts[part_index] = updated_part             if isinstance(updated_part, ToolCallPart | NativeToolCallPart):                 if isinstance(existing_part, ToolCallPartDelta):                     # We just upgraded a delta to a full part, so emit a PartStartEvent-                    return PartStartEvent(index=part_index, part=updated_part)+                    return PartStartEvent(index=part_index, part=self._materialize_part(part_index))                 else:                     # We updated an existing part, so emit a PartDeltaEvent                     if updated_part.tool_call_id and not delta.tool_call_id:                         delta = replace(delta, tool_call_id=updated_part.tool_call_id)                     return PartDeltaEvent(index=part_index, delta=delta) +    def _create_tool_call(+        self,+        vendor_part_id: Hashable | None,+        tool_name: str | None,+        args: str | dict[str, Any] | None,+        tool_call_id: str | None,+        provider_name: str | None,+        provider_details: dict[str, Any] | None,+    ) -> tuple[ManagedPart, int]:+        """Create a new tool call part or delta, buffering a string `args` value.++        The stored part keeps an empty `args` base so it doesn't grow per chunk; the incoming+        string is buffered and materialized lazily.+        """+        delta = ToolCallPartDelta(+            tool_name_delta=tool_name,+            args_delta='' if isinstance(args, str) else args,+            tool_call_id=tool_call_id,+            provider_name=provider_name,+            provider_details=provider_details,+        )+        part = delta.as_part() or delta+        if isinstance(part, ToolCallPart):+            part = self._typed_call_part(part)+        new_part_index = self._append_part(part, vendor_part_id)+        if isinstance(args, str):+            self._string_buffers[new_part_index] = [args]+        return part, new_part_index++    def _update_tool_call(+        self,+        existing_part: ToolCallPartDelta | ToolCallPart | NativeToolCallPart,+        part_index: int,+        tool_name: str | None,+        args: str | dict[str, Any] | None,+        tool_call_id: str | None,+        provider_name: str | None,+        provider_details: dict[str, Any] | None,+    ) -> tuple[ManagedPart, ToolCallPartDelta]:+        """Apply a delta to an existing tool call part or delta, buffering a string `args` value.++        Returns the stored part and the delta describing the incoming change (used to emit the event).+        """+        delta = ToolCallPartDelta(+            tool_name_delta=tool_name,+            args_delta=args,+            tool_call_id=tool_call_id,+            provider_name=self._resolve_provider_name(existing_part, provider_name),+            provider_details=provider_details,+        )+        if isinstance(args, str):+            # Apply an empty-string args delta so type checks and delta->part promotion still run+            # without rebuilding the accumulated string, then buffer the incoming chunk.+            updated_part = replace(delta, args_delta='').apply(existing_part)+        else:+            updated_part = delta.apply(existing_part)+        if isinstance(updated_part, ToolCallPart):+            updated_part = self._typed_call_part(updated_part)+        self._parts[part_index] = updated_part+        if isinstance(args, str):+            self._string_buffers.setdefault(part_index, []).append(args)+        return updated_part, delta+     def handle_tool_call_part(         self,         *,@@ -434,6 +534,8 @@ class ModelResponsePartsManager:             if maybe_part_index is not None and isinstance(self._parts[maybe_part_index], ToolCallPart):                 new_part_index = maybe_part_index                 self._parts[new_part_index] = new_part+                # Replacing the part discards any buffered deltas for the old part.+                self._string_buffers.pop(new_part_index, None)             else:                 new_part_index = self._append_part(new_part)             self._vendor_id_to_part_index[vendor_part_id] = new_part_index@@ -465,6 +567,8 @@ class ModelResponsePartsManager:             if maybe_part_index is not None and isinstance(self._parts[maybe_part_index], type(part)):                 new_part_index = maybe_part_index                 self._parts[new_part_index] = part+                # Replacing the part discards any buffered deltas for the old part.+                self._string_buffers.pop(new_part_index, None)             else:                 new_part_index = self._append_part(part)             self._vendor_id_to_part_index[vendor_part_id] = new_part_index@@ -515,7 +619,10 @@ class ModelResponsePartsManager:             provider_name=self._resolve_provider_name(existing_part, provider_name),             provider_details=provider_details,         )-        self._parts[part_index] = part_delta.apply(existing_part)+        # Update metadata eagerly (None content delta leaves the base string untouched) and buffer the+        # content so the accumulated string isn't rebuilt on every chunk.+        self._parts[part_index] = replace(part_delta, content_delta=None).apply(existing_part)+        self._string_buffers.setdefault(part_index, []).append(content)         yield PartDeltaEvent(index=part_index, delta=part_delta)      def _handle_embedded_thinking_end(self, vendor_part_id: VendorId) -> None:tests/test_parts_manager.pyindex 6b512c0b..f164725c 100644@@ -708,3 +708,46 @@ def test_get_part_by_vendor_id():     assert part == snapshot(TextPart(content='hello', part_kind='text'))      assert manager.get_part_by_vendor_id('missing') is None+++def test_stream_parts_assembly_scales_subquadratically():+    """Assembling a long streamed response from many small deltas must stay sub-quadratic.++    Regression test for quadratic string reassembly in `ModelResponsePartsManager`: applying each+    text/thinking/string-tool-argument delta used to rebuild the whole accumulated string, so CPU+    time grew with the square of the chunk count. Buffering the deltas and materializing lazily keeps+    it roughly linear. We assert that a 4x longer stream costs far less than the ~16x a quadratic+    implementation incurs.+    """+    import time++    chunk = 'x' * 200++    def assemble(n: int) -> tuple[float, list[Any]]:+        best = float('inf')+        parts: list[Any] = []+        for _ in range(3):+            manager = ModelResponsePartsManager(model_request_parameters=ModelRequestParameters())+            # Seed a complete tool call so subsequent string args accumulate on a real ToolCallPart.+            manager.handle_tool_call_delta(vendor_part_id='tool', tool_name='tool', args='{', tool_call_id='call')+            start = time.process_time()+            for _ in range(n):+                list(manager.handle_text_delta(vendor_part_id='text', content=chunk))+                list(manager.handle_thinking_delta(vendor_part_id='think', content=chunk))+                manager.handle_tool_call_delta(vendor_part_id='tool', tool_name=None, args=chunk, tool_call_id=None)+            # Materialize once, mirroring how a consumer reads the finished parts.+            parts = manager.get_parts()+            best = min(best, time.process_time() - start)+        return best, parts++    small, _ = assemble(4_000)+    large, parts = assemble(16_000)++    # Assembly must produce the fully joined strings (index 0 is the seeded tool call).+    assert parts[0].args == '{' + chunk * 16_000+    assert parts[1].content == chunk * 16_000+    assert parts[2].content == chunk * 16_000++    # Quadratic assembly makes a 4x longer stream ~16x more expensive; linear assembly ~4x.+    # Generous headroom absorbs CI noise while still catching the quadratic regression.+    assert large < small * 8, f'assembly scaled super-linearly: {small=:.4f}s {large=:.4f}s ratio={large / small:.2f}' 
Merged fix · PR #+538 −11
pydantic_ai_slim/pydantic_ai/_parts_manager.pyindex 3f64db0fff..536a10c9c8 100644@@ -72,6 +72,10 @@ class ModelResponsePartsManager:     """A list of parts (text or tool calls) that make up the current state of the model's response."""     _vendor_id_to_part_index: dict[VendorId, int] = field(default_factory=dict[VendorId, int], init=False)     """Maps a vendor's "part" ID (if provided) to the index in `_parts` where that part resides."""+    _string_buffers: dict[int, list[str]] = field(+        default_factory=dict[int, list[str]], init=False, repr=False, compare=False+    )+    """Unmaterialized string deltas, keyed by part index."""     _tool_kind_by_name: dict[str, ToolPartKind] = field(default_factory=dict[str, ToolPartKind], init=False, repr=False)     """Cached `{tool_name: tool_kind}` built from `function_tools` at construction time.""" @@ -80,6 +84,33 @@ class ModelResponsePartsManager:             td.name: td.tool_kind for td in self.model_request_parameters.function_tools if td.tool_kind is not None         } +    def __repr__(self) -> str:+        self._materialize_string_buffers()+        return (+            f'{type(self).__qualname__}('+            f'model_request_parameters={self.model_request_parameters!r}, '+            f'_parts={self._parts!r}, '+            f'_vendor_id_to_part_index={self._vendor_id_to_part_index!r})'+        )++    def __eq__(self, other: object) -> bool:+        if other.__class__ is self.__class__:+            assert isinstance(other, ModelResponsePartsManager)+            self._materialize_string_buffers()+            other._materialize_string_buffers()+            return (+                self.model_request_parameters,+                self._parts,+                self._vendor_id_to_part_index,+                self._tool_kind_by_name,+            ) == (+                other.model_request_parameters,+                other._parts,+                other._vendor_id_to_part_index,+                other._tool_kind_by_name,+            )+        return NotImplemented+     def _tool_kind_for(self, tool_name: str) -> ToolPartKind | None:         return self._tool_kind_by_name.get(tool_name) @@ -102,6 +133,9 @@ class ModelResponsePartsManager:         Returns:             A list of ModelResponsePart objects. ToolCallPartDelta objects are excluded.         """+        for part_index in tuple(self._string_buffers):+            if not isinstance(self._parts[part_index], ToolCallPartDelta):+                self._materialize_part(part_index)         return [p for p in self._parts if not isinstance(p, ToolCallPartDelta)]      def get_part_by_vendor_id(self, vendor_id: VendorId) -> ManagedPart | None:@@ -115,7 +149,7 @@ class ModelResponsePartsManager:         """         part_index = self._vendor_id_to_part_index.get(vendor_id)         if part_index is not None:-            return self._parts[part_index]+            return self._materialize_part(part_index)         return None      def handle_text_delta(@@ -177,6 +211,7 @@ class ModelResponsePartsManager:                 elif isinstance(existing_part, TextPart):                     existing_text_part_and_index = existing_part, part_index                 else:+                    existing_part = self._materialize_part(part_index)                     raise UnexpectedModelBehavior(f'Cannot apply a text delta to {existing_part=}')          if thinking_tags and content == thinking_tags[0]:@@ -203,7 +238,19 @@ class ModelResponsePartsManager:                 provider_name=self._resolve_provider_name(existing_text_part, provider_name),                 provider_details=provider_details,             )-            self._parts[part_index] = part_delta.apply(existing_text_part)+            updated_part = existing_text_part+            if (+                part_delta.provider_name is not None+                or part_delta.provider_details is not None+                or existing_text_part.provider_details == {}+            ):+                metadata_delta = replace(part_delta, content_delta='')+                updated_part = metadata_delta.apply(existing_text_part)+            elif existing_text_part.provider_details:+                updated_part = replace(existing_text_part, provider_details=existing_text_part.provider_details.copy())+            if content:+                self._buffer_string_delta(part_index, existing_text_part.content, content)+            self._parts[part_index] = updated_part             yield PartDeltaEvent(index=part_index, delta=part_delta)      def handle_thinking_delta(@@ -251,6 +298,7 @@ class ModelResponsePartsManager:             if part_index is not None:                 existing_part = self._parts[part_index]                 if not isinstance(existing_part, ThinkingPart):+                    existing_part = self._materialize_part(part_index)                     raise UnexpectedModelBehavior(f'Cannot apply a thinking delta to {existing_part=}')                 existing_thinking_part_and_index = existing_part, part_index @@ -286,7 +334,34 @@ class ModelResponsePartsManager:                 provider_name=self._resolve_provider_name(existing_thinking_part, provider_name),                 provider_details=provider_details,             )-            self._parts[part_index] = part_delta.apply(existing_thinking_part)+            updated_part = existing_thinking_part+            if (+                signature is not None+                or part_delta.provider_name is not None+                or provider_details is not None+                or existing_thinking_part.provider_details == {}+            ):+                metadata_delta = replace(part_delta, content_delta=None)+                if callable(provider_details):+                    buffer = self._string_buffers.get(part_index)+                    buffer_length = len(buffer) if buffer is not None else 0+                    resolved_details = provider_details(existing_thinking_part.provider_details)+                    metadata_delta = replace(metadata_delta, provider_details=resolved_details)+                    updated_part = metadata_delta.apply(existing_thinking_part)+                    if buffer is None:+                        self._string_buffers.pop(part_index, None)+                    else:+                        del buffer[buffer_length:]+                        self._string_buffers[part_index] = buffer+                else:+                    updated_part = metadata_delta.apply(existing_thinking_part)+            elif existing_thinking_part.provider_details:+                updated_part = replace(+                    existing_thinking_part, provider_details=existing_thinking_part.provider_details.copy()+                )+            if content:+                self._buffer_string_delta(part_index, updated_part.content, content)+            self._parts[part_index] = updated_part             yield PartDeltaEvent(index=part_index, delta=part_delta)      def handle_tool_call_delta(@@ -344,6 +419,7 @@ class ModelResponsePartsManager:             if part_index is not None:                 existing_part = self._parts[part_index]                 if not isinstance(existing_part, ToolCallPartDelta | ToolCallPart | NativeToolCallPart):+                    existing_part = self._materialize_part(part_index)                     raise UnexpectedModelBehavior(f'Cannot apply a tool call delta to {existing_part=}')                 existing_matching_part_and_index = existing_part, part_index @@ -373,9 +449,20 @@ class ModelResponsePartsManager:                 provider_name=self._resolve_provider_name(existing_part, provider_name),                 provider_details=provider_details,             )-            updated_part = delta.apply(existing_part)-            if isinstance(updated_part, ToolCallPart):-                updated_part = self._typed_call_part(updated_part)+            buffer = self._string_buffers.get(part_index)+            buffer_length = len(buffer) if buffer is not None else 0+            try:+                updated_part = self._apply_tool_call_delta(part_index, existing_part, delta)+                if isinstance(updated_part, ToolCallPart):+                    updated_part = self._typed_call_part(updated_part)+            except Exception:+                self._parts[part_index] = existing_part+                if buffer is None:+                    self._string_buffers.pop(part_index, None)+                else:+                    del buffer[buffer_length:]+                    self._string_buffers[part_index] = buffer+                raise             self._parts[part_index] = updated_part             if isinstance(updated_part, ToolCallPart | NativeToolCallPart):                 if isinstance(existing_part, ToolCallPartDelta):@@ -431,9 +518,10 @@ class ModelResponsePartsManager:         else:             # vendor_part_id is provided, so find and overwrite or create a new ToolCallPart.             maybe_part_index = self._vendor_id_to_part_index.get(vendor_part_id)-            if maybe_part_index is not None and isinstance(self._parts[maybe_part_index], ToolCallPart):+            existing_part = self._parts[maybe_part_index] if maybe_part_index is not None else None+            if maybe_part_index is not None and isinstance(existing_part, ToolCallPart):                 new_part_index = maybe_part_index-                self._parts[new_part_index] = new_part+                self._replace_part(new_part_index, new_part)             else:                 new_part_index = self._append_part(new_part)             self._vendor_id_to_part_index[vendor_part_id] = new_part_index@@ -462,9 +550,10 @@ class ModelResponsePartsManager:         else:             # vendor_part_id is provided, so find and overwrite or create a new part.             maybe_part_index = self._vendor_id_to_part_index.get(vendor_part_id)-            if maybe_part_index is not None and isinstance(self._parts[maybe_part_index], type(part)):+            existing_part = self._parts[maybe_part_index] if maybe_part_index is not None else None+            if maybe_part_index is not None and isinstance(existing_part, type(part)):                 new_part_index = maybe_part_index-                self._parts[new_part_index] = part+                self._replace_part(new_part_index, part)             else:                 new_part_index = self._append_part(part)             self._vendor_id_to_part_index[vendor_part_id] = new_part_index@@ -483,6 +572,108 @@ class ModelResponsePartsManager:             self._vendor_id_to_part_index[vendor_part_id] = new_index         return new_index +    def _apply_tool_call_delta(+        self,+        part_index: int,+        existing_part: ToolCallPartDelta | ToolCallPart | NativeToolCallPart,+        delta: ToolCallPartDelta,+    ) -> ToolCallPartDelta | ToolCallPart | NativeToolCallPart:+        """Apply a tool call delta while buffering string arguments."""+        args = delta.args_delta+        if not isinstance(args, str):+            should_materialize = isinstance(args, dict) or (+                isinstance(existing_part, ToolCallPartDelta) and delta.tool_name_delta is not None+            )+            if should_materialize and part_index in self._string_buffers:+                materialized_part = self._materialize_part(part_index)+                if not isinstance(+                    materialized_part, ToolCallPartDelta | ToolCallPart | NativeToolCallPart+                ):  # pragma: no cover+                    raise AssertionError(f'Expected a tool call, got {materialized_part!r}')+                existing_part = materialized_part+            return delta.apply(existing_part)++        if isinstance(existing_part, ToolCallPartDelta):+            current_args = existing_part.args_delta+            if isinstance(current_args, dict):+                return delta.apply(existing_part)++            if delta.tool_name_delta is not None:+                materialized_part = self._materialize_part(part_index)+                if not isinstance(materialized_part, ToolCallPartDelta):  # pragma: no cover+                    raise AssertionError(f'Expected an incomplete tool call, got {materialized_part!r}')+                existing_part = materialized_part+                return delta.apply(existing_part)++            if not args and part_index not in self._string_buffers:+                return delta.apply(existing_part)++            updated_part = existing_part+            if delta.tool_call_id or delta.provider_name or delta.provider_details:+                metadata_delta = replace(delta, args_delta=None)+                updated_part = metadata_delta.apply(existing_part)+                if not isinstance(updated_part, ToolCallPartDelta):  # pragma: no cover+                    raise AssertionError(f'Expected an incomplete tool call, got {updated_part!r}')+            self._buffer_string_delta(part_index, current_args, args)+            return updated_part++        current_args = existing_part.args+        if isinstance(current_args, dict):+            return delta.apply(existing_part)++        if not args and part_index not in self._string_buffers:+            return delta.apply(existing_part)++        updated_part = existing_part+        if delta.tool_name_delta or delta.tool_call_id or delta.provider_name or delta.provider_details:+            metadata_delta = replace(delta, args_delta=None)+            updated_part = metadata_delta.apply(existing_part)+        self._buffer_string_delta(part_index, current_args, args)+        return updated_part++    def _buffer_string_delta(self, part_index: int, current_value: str | None, delta: str) -> None:+        """Buffer a string append while preserving a `None`-to-empty transition."""+        if not delta:+            return+        buffer = self._string_buffers.get(part_index)+        if buffer is None:+            buffer = self._string_buffers[part_index] = [current_value or '']+        buffer.append(delta)++    def _materialize_part(self, part_index: int) -> ManagedPart:+        """Materialize buffered string deltas for one part."""+        part = self._parts[part_index]+        buffer = self._string_buffers.pop(part_index, None)+        if buffer is None:+            return part++        value = ''.join(buffer)+        if isinstance(part, TextPart | ThinkingPart):+            part = replace(part, content=value)+        elif isinstance(part, ToolCallPartDelta):+            if isinstance(part.args_delta, dict):  # pragma: no cover+                raise AssertionError('Cannot materialize string arguments onto dictionary arguments')+            part = replace(part, args_delta=value)+        elif isinstance(part, ToolCallPart | NativeToolCallPart):+            if isinstance(part.args, dict):  # pragma: no cover+                raise AssertionError('Cannot materialize string arguments onto dictionary arguments')+            part = replace(part, args=value)+        else:  # pragma: no cover+            raise AssertionError(f'Cannot materialize string deltas for {part!r}')++        self._parts[part_index] = part+        return part++    def _materialize_string_buffers(self) -> None:+        """Materialize all buffered strings before returning a snapshot."""+        for part_index in tuple(self._string_buffers):+            self._materialize_part(part_index)++    def _replace_part(self, part_index: int, part: ManagedPart) -> None:+        """Fully replace a part and discard any buffered deltas."""+        self._string_buffers.pop(part_index, None)+        self._parts[part_index] = part+     def _latest_part_if_of_type(self, *part_types: type[PartT]) -> tuple[PartT, int] | None:         """Get the latest part and its index if it's an instance of the given type(s)."""         if self._parts:@@ -515,7 +706,19 @@ class ModelResponsePartsManager:             provider_name=self._resolve_provider_name(existing_part, provider_name),             provider_details=provider_details,         )-        self._parts[part_index] = part_delta.apply(existing_part)+        updated_part = existing_part+        if (+            part_delta.provider_name is not None+            or part_delta.provider_details is not None+            or existing_part.provider_details == {}+        ):+            metadata_delta = replace(part_delta, content_delta=None)+            updated_part = metadata_delta.apply(existing_part)+        elif existing_part.provider_details:+            updated_part = replace(existing_part, provider_details=existing_part.provider_details.copy())+        if content:+            self._buffer_string_delta(part_index, existing_part.content, content)+        self._parts[part_index] = updated_part         yield PartDeltaEvent(index=part_index, delta=part_delta)      def _handle_embedded_thinking_end(self, vendor_part_id: VendorId) -> None:tests/test_parts_manager.pyindex 6b512c0b5a..0cd7e36296 100644@@ -4,6 +4,7 @@ import re from typing import Any  import pytest+from pytest_mock import MockerFixture  from pydantic_ai import (     NativeToolCallPart,@@ -82,6 +83,329 @@ def test_handle_dovetailed_text_deltas():     )  +def test_string_deltas_materialize_on_reads_and_replacement(mocker: MockerFixture):+    """Internal buffer lifecycle and replacement are not observable in provider cassettes."""+    manager = ModelResponsePartsManager(model_request_parameters=ModelRequestParameters())++    next(+        manager.handle_text_delta(+            vendor_part_id='text', content='text', provider_name='provider', provider_details={'first': 1}+        )+    )+    next(manager.handle_thinking_delta(vendor_part_id='thinking', content='thinking'))+    manager.handle_tool_call_delta(vendor_part_id='tool', tool_name='tool', args='{"value":', tool_call_id='call')++    for suffix in ('-one', '-two', '-three'):+        next(+            manager.handle_text_delta(+                vendor_part_id='text',+                content=suffix,+                provider_name='provider',+                provider_details={suffix: True},+            )+        )+        next(manager.handle_thinking_delta(vendor_part_id='thinking', content=suffix))+        manager.handle_tool_call_delta(vendor_part_id='tool', args=suffix)++    assert manager.get_part_by_vendor_id('text') == TextPart(+        'text-one-two-three',+        provider_name='provider',+        provider_details={'first': 1, '-one': True, '-two': True, '-three': True},+    )+    snapshot_parts = manager.get_parts()+    assert snapshot_parts == [+        TextPart(+            'text-one-two-three',+            provider_name='provider',+            provider_details={'first': 1, '-one': True, '-two': True, '-three': True},+        ),+        ThinkingPart('thinking-one-two-three'),+        ToolCallPart('tool', '{"value":-one-two-three', 'call'),+    ]++    next(manager.handle_text_delta(vendor_part_id='text', content='-discarded'))+    assert snapshot_parts[0] == TextPart(+        'text-one-two-three',+        provider_name='provider',+        provider_details={'first': 1, '-one': True, '-two': True, '-three': True},+    )+    replacement = TextPart('replacement')+    mocker.patch.object(manager, '_materialize_part', side_effect=AssertionError('replacement materialized old part'))+    assert manager.handle_part(vendor_part_id='text', part=replacement) == PartStartEvent(index=0, part=replacement)+    assert manager.get_parts() == [+        replacement,+        ThinkingPart('thinking-one-two-three'),+        ToolCallPart('tool', '{"value":-one-two-three', 'call'),+    ]+++def _emit_string_part_delta(manager: ModelResponsePartsManager, part_kind: str, content: str, **kwargs: Any) -> Any:+    if part_kind == 'text':+        return next(manager.handle_text_delta(vendor_part_id='part', content=content, **kwargs))+    if part_kind == 'thinking':+        return next(manager.handle_thinking_delta(vendor_part_id='part', content=content, **kwargs))+    return next(+        manager.handle_text_delta(+            vendor_part_id='part', content=content, thinking_tags=('<think>', '</think>'), **kwargs+        )+    )+++@pytest.mark.parametrize('part_kind', ['text', 'thinking', 'embedded-thinking'])+def test_content_only_delta_matches_provider_details_normalization(part_kind: str):+    """Empty metadata normalization is not observable in provider cassettes."""+    manager = ModelResponsePartsManager(model_request_parameters=ModelRequestParameters())++    embedded = part_kind == 'embedded-thinking'+    initial_content = '<think>' if embedded else 'a'+    initial_part: TextPart | ThinkingPart = (+        TextPart('a', provider_details={})+        if part_kind == 'text'+        else ThinkingPart('' if embedded else 'a', provider_details={})+    )+    delta_type = TextPartDelta if part_kind == 'text' else ThinkingPartDelta+    start_event = _emit_string_part_delta(manager, part_kind, initial_content, provider_details={})++    normalized_delta = delta_type(content_delta='b')+    pure_content_delta = delta_type(content_delta='c')+    metadata_delta = delta_type(content_delta='d', provider_name='provider', provider_details={'metadata': True})+    expected_part = normalized_delta.apply(initial_part)+    expected_final_part = metadata_delta.apply(pure_content_delta.apply(expected_part))++    assert start_event == PartStartEvent(index=0, part=initial_part)+    assert _emit_string_part_delta(manager, part_kind, 'b') == PartDeltaEvent(index=0, delta=normalized_delta)+    assert expected_part.provider_details is None+    assert manager.get_parts() == [expected_part]+    assert manager.get_part_by_vendor_id('part') == expected_part+    assert _emit_string_part_delta(manager, part_kind, 'c') == PartDeltaEvent(index=0, delta=pure_content_delta)+    assert _emit_string_part_delta(+        manager, part_kind, 'd', provider_name='provider', provider_details={'metadata': True}+    ) == PartDeltaEvent(index=0, delta=metadata_delta)+    assert manager.get_parts() == [expected_final_part]+++@pytest.mark.parametrize('part_kind', ['text', 'thinking', 'embedded-thinking'])+def test_content_delta_keeps_previous_provider_details_snapshot_isolated(part_kind: str):+    """Mutable provider metadata aliasing is not observable in provider cassettes."""+    manager = ModelResponsePartsManager(model_request_parameters=ModelRequestParameters())++    initial_content = '<think>' if part_kind == 'embedded-thinking' else 'a'+    start_event = _emit_string_part_delta(manager, part_kind, initial_content, provider_details={'stable': 1})+    _emit_string_part_delta(manager, part_kind, 'b')++    assert isinstance(start_event, PartStartEvent)+    assert start_event.part.provider_details is not None+    start_event.part.provider_details['stable'] = 99+    assert manager.get_parts()[0].provider_details == {'stable': 1}+++def test_thinking_content_with_callable_metadata_stays_buffered(mocker: MockerFixture):+    """The combined callable/content path is not produced by current provider cassettes."""+    manager = ModelResponsePartsManager(model_request_parameters=ModelRequestParameters())+    next(manager.handle_thinking_delta(vendor_part_id='part', content='a', provider_details={'count': 0}))+    materialize_spy = mocker.spy(manager, '_materialize_part')++    def increment(details: dict[str, Any] | None) -> dict[str, Any]:+        return {'count': (details or {}).get('count', 0) + 1}++    for _ in range(2_048):+        next(manager.handle_thinking_delta(vendor_part_id='part', content='b', provider_details=increment))++    assert materialize_spy.call_count == 0+    assert manager.get_parts() == [ThinkingPart('a' + 'b' * 2_048, provider_details={'count': 2_048})]+++@pytest.mark.parametrize('size', [8_192, 16_384])+def test_incomplete_tool_call_string_arguments_are_buffered(mocker: MockerFixture, size: int):+    """Private apply/materialization counts cannot be asserted through a provider cassette."""+    manager = ModelResponsePartsManager(model_request_parameters=ModelRequestParameters())+    apply_spy = mocker.spy(ToolCallPartDelta, 'apply')+    materialize_spy = mocker.spy(manager, '_materialize_part')++    for _ in range(size):+        assert manager.handle_tool_call_delta(vendor_part_id='tool', args='x') is None+        assert manager.get_parts() == []++    assert apply_spy.call_count == 0+    assert materialize_spy.call_count == 0+    assert (+        manager.handle_tool_call_delta(+            vendor_part_id='tool',+            tool_call_id='call',+            provider_name='provider',+            provider_details={'first': True},+        )+        is None+    )+    assert apply_spy.call_count == 1++    event = manager.handle_tool_call_delta(+        vendor_part_id='tool', tool_name='tool', provider_name='provider', provider_details={'second': True}+    )+    assert isinstance(event, PartStartEvent)+    assert event.part == ToolCallPart(+        'tool',+        'x' * size,+        'call',+        provider_name='provider',+        provider_details={'first': True, 'second': True},+    )+    assert apply_spy.call_count == 2+    assert manager.get_parts() == [event.part]+++def test_tool_call_buffer_changes_are_atomic_when_typed_promotion_fails(mocker: MockerFixture):+    """Injected internal promotion failures cannot be produced by a provider cassette."""+    manager = ModelResponsePartsManager(model_request_parameters=ModelRequestParameters())+    manager.handle_tool_call_delta(vendor_part_id='tool', tool_name='tool', args='initial', tool_call_id='call')+    manager.handle_tool_call_delta(vendor_part_id='tool', args=' buffered')++    promotion = mocker.patch.object(manager, '_typed_call_part', side_effect=RuntimeError('typed promotion failed'))+    with pytest.raises(RuntimeError, match='typed promotion failed'):+        manager.handle_tool_call_delta(vendor_part_id='tool', args=' discarded')+    mocker.stop(promotion)++    assert manager.get_parts() == [ToolCallPart('tool', 'initial buffered', 'call')]+    event = manager.handle_tool_call_delta(vendor_part_id='tool', args=' accepted')+    assert isinstance(event, PartDeltaEvent)+    assert manager.get_parts() == [ToolCallPart('tool', 'initial buffered accepted', 'call')]+++def test_equality_and_repr_materialize_string_buffers():+    """Manager equality and repr are internal state contracts outside provider responses."""++    def build_manager(*, buffered: bool) -> ModelResponsePartsManager:+        manager = ModelResponsePartsManager(model_request_parameters=ModelRequestParameters())+        next(manager.handle_text_delta(vendor_part_id='text', content='a' if buffered else 'ab'))+        manager.handle_tool_call_delta(vendor_part_id='tool', args='{' if buffered else '{"value": true}')+        if buffered:+            next(manager.handle_text_delta(vendor_part_id='text', content='b'))+            manager.handle_tool_call_delta(vendor_part_id='tool', args='"value": true}')+        return manager++    assert repr(build_manager(buffered=True)) == repr(build_manager(buffered=False))+    assert build_manager(buffered=True) == build_manager(buffered=False)+++def test_thinking_delta_callback_failure_is_atomic():+    """Injected provider-details callback failures are not representable in a cassette."""+    manager = ModelResponsePartsManager(model_request_parameters=ModelRequestParameters())+    next(+        manager.handle_thinking_delta(+            vendor_part_id='thinking',+            content='initial',+            provider_details={'keep': True},+        )+    )+    next(manager.handle_thinking_delta(vendor_part_id='thinking', content=' pending'))++    def fail_provider_details(_details: dict[str, Any] | None) -> dict[str, Any]:+        raise RuntimeError('provider details failed')++    with pytest.raises(RuntimeError, match='provider details failed'):+        next(+            manager.handle_thinking_delta(+                vendor_part_id='thinking',+                content=' leaked',+                provider_details=fail_provider_details,+            )+        )++    assert manager.get_parts() == [ThinkingPart('initial pending', provider_details={'keep': True})]+    next(manager.handle_thinking_delta(vendor_part_id='thinking', content=' accepted'))+    assert manager.get_parts() == [ThinkingPart('initial pending accepted', provider_details={'keep': True})]+++@pytest.mark.parametrize('read_method', ['get_parts', 'repr'])+def test_thinking_delta_callback_can_read_materialized_parts(read_method: str):+    """Reentrant reads inside a private callback cannot be exercised by provider cassettes."""+    manager = ModelResponsePartsManager(model_request_parameters=ModelRequestParameters())+    next(+        manager.handle_thinking_delta(+            vendor_part_id='thinking',+            content='initial',+            provider_details={'count': 1},+        )+    )+    next(manager.handle_thinking_delta(vendor_part_id='thinking', content=' pending'))++    observed_reprs: list[str] = []++    def update_provider_details(details: dict[str, Any] | None) -> dict[str, Any]:+        if read_method == 'get_parts':+            observed_reprs.append(repr(manager.get_parts()))+        else:+            observed_reprs.append(repr(manager))+        return {**(details or {}), 'count': (details or {}).get('count', 0) + 1}++    next(+        manager.handle_thinking_delta(+            vendor_part_id='thinking',+            content=' current',+            provider_details=update_provider_details,+        )+    )++    assert len(observed_reprs) == 1+    assert "ThinkingPart(content='initial pending', provider_details={'count': 1})" in observed_reprs[0]+    assert manager.get_parts() == [ThinkingPart('initial pending current', provider_details={'count': 2})]+++@pytest.mark.parametrize(+    ('mutation', 'initial_chunks', 'nested_part', 'expected_content'),+    [+        pytest.param(+            'append',+            ('a', 'b'),+            ThinkingPart('abd', provider_details={'count': 1}),+            'abc',+            id='append',+        ),+        pytest.param('replacement', ('a',), ThinkingPart('replacement'), 'ac', id='replacement'),+    ],+)+def test_thinking_delta_nested_callback_mutation_matches_unbuffered_apply(+    mutation: str,+    initial_chunks: tuple[str, ...],+    nested_part: ThinkingPart,+    expected_content: str,+):+    """Nested callback writes are an internal ordering contract outside provider cassettes."""+    manager = ModelResponsePartsManager(model_request_parameters=ModelRequestParameters())+    next(+        manager.handle_thinking_delta(+            vendor_part_id='thinking', content=initial_chunks[0], provider_details={'count': 1}+        )+    )+    for chunk in initial_chunks[1:]:+        next(manager.handle_thinking_delta(vendor_part_id='thinking', content=chunk))++    def update_provider_details(details: dict[str, Any] | None) -> dict[str, Any]:+        if mutation == 'append':+            assert next(manager.handle_thinking_delta(vendor_part_id='thinking', content='d')) == PartDeltaEvent(+                index=0, delta=ThinkingPartDelta(content_delta='d')+            )+        else:+            assert manager.handle_part(vendor_part_id='thinking', part=nested_part) == PartStartEvent(+                index=0, part=nested_part+            )+        assert manager.get_parts() == [nested_part]+        assert repr(nested_part) in repr(manager)+        return {**(details or {}), 'count': 2}++    event = next(+        manager.handle_thinking_delta(vendor_part_id='thinking', content='c', provider_details=update_provider_details)+    )+    assert event == PartDeltaEvent(+        index=0, delta=ThinkingPartDelta(content_delta='c', provider_details=update_provider_details)+    )++    original_part = ThinkingPart(''.join(initial_chunks), provider_details={'count': 1})+    expected_part = ThinkingPartDelta(content_delta='c', provider_details={'count': 2}).apply(original_part)+    assert expected_part == ThinkingPart(expected_content, provider_details={'count': 2})+    assert manager.get_parts() == [expected_part]++ def test_handle_text_deltas_with_think_tags():     manager = ModelResponsePartsManager(model_request_parameters=ModelRequestParameters())     thinking_tags = ('<think>', '</think>') 

What the agent reported

All stages complete and confirmed by the reviewer. Here is the final report.

What was wrong

ModelResponsePartsManager (pydantic_ai_slim/pydantic_ai/_parts_manager.py) applied every streamed text, thinking, and string tool-argument delta by rebuilding the entire accumulated string (part.content + delta, (part.args or '') + delta) via dataclasses.replace. Each chunk copied the whole accumulated prefix, so assembling a response split into *n* chunks was O(n²) in CPU time. This is provider-independent because all streamed responses share this manager.

What I changed

pydantic_ai_slim/pydantic_ai/_parts_manager.py — introduced lazy per-part buffering:

  • Added _string_buffers: dict[int, list[str]]. Each streamed string delta is appended to the part's buffer (O(1)) instead of concatenated onto the stored part.
  • The stored part keeps its string field at the value it held when buffering began (empty for new parts), so it never grows. Metadata/signature updates stay eager by applying the existing *PartDelta.apply() with the string component emptied (content_delta=''/None, args_delta='') — this reuses the tested apply logic, so str/dict mismatch errors, delta→part promotion, tool_call_id back-patching, and atomic provider-details-callback failures are all preserved unchanged.
  • Added _materialize/_materialize_part to join a buffer only when a public read (get_parts(), get_part_by_vendor_id()) or a PartStart/promotion event needs the concrete string. get_parts() still filters out ToolCallPartDelta, so incomplete tool args are never materialized on a public read.
  • Overwrite paths (handle_tool_call_part, handle_part) now discard the replaced part's buffer.
  • Extracted _create_tool_call/_update_tool_call helpers (keeps handle_tool_call_delta under the mccabe limit). No public API change.

tests/test_parts_manager.py — appended test_stream_parts_assembly_scales_subquadratically, which streams many text/thinking/string-tool-arg deltas, asserts the fully-joined strings are correct, and asserts a 4× longer stream costs < 8× (quadratic ≈ 16×, linear ≈ 4×). get_parts() is inside the timed region so a lazy-but-still-quadratic materialize would also be caught.

Test evidence (all via ./bt-test, gate container)

  • Regression test red→green: on unmodified source it FAILED (ratio = 24.48 > 8); after the fix it PASSES.
  • tests/test_parts_manager.py: 35 passed (all pre-existing tests + new one).
  • tests/test_streaming.py test_messages.py test_streaming_errors.py test_tool_search.py: 504 passed, 21 skipped, 3 xfailed.
  • Provider streaming tests/models -k stream: 192 passed, 70 skipped.
  • ruff format --check, ruff check, pyright on the file: all PASS; git diff --check: clean.
  • Independent reviewer confirmed behavior-preservation, buffer-discard-on-replace, no quadratic-growth or public-delta-materialization path, and no unrelated changes.

Requirements checklist

Requirement from reportDisposition
Private per-part string-delta lists, materialized only on public read/snapshotImplemented — _string_buffers + _materialize (test-verified)
Stream events still carry each delta immediatelyImplemented — PartDeltaEvent carries the full incoming chunk; event snapshots unchanged (existing tests pass)
Metadata & signature updates remain eagerImplemented — eager .apply() with emptied string delta
Failed metadata callbacks remain atomicImplemented — apply (which runs the callback) precedes any buffer/state mutation; provider_details_callback tests pass
Replacing a part discards its old bufferImplemented — buffer popped in both overwrite branches
No public API change; get_parts()/get_part_by_vendor_id() return same types/valuesVerified — 35 + 504 + 192 tests pass
Incomplete tool args hidden without rebuilding the growing string per readImplemented — get_parts() filters ToolCallPartDelta; hidden deltas never materialized

Notes

  • The working tree also shows deletions of .claude/settings.json, AGENTS.md, and CLAUDE.md. These were already present in the initial git status before I started and are unrelated to this fix; I left them untouched.
  • All changes are left uncommitted in the working tree, as instructed.
  • Minor caveat (also raised by the reviewer): the regression test is CPU-time-based, hence mildly CI-noise sensitive. It's mitigated by best-of-3 timing and a generous 8× threshold (observed buggy 24×, fixed ~4×), and it doubles as a correctness assertion.