telemetry-dev-openrouter 0.2.1__tar.gz → 0.2.3__tar.gz

{telemetry_dev_openrouter-0.2.1 → telemetry_dev_openrouter-0.2.3}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: telemetry-dev-openrouter
-Version: 0.2.1
+Version: 0.2.3
 Summary: OpenRouter integration for telemetry.dev Python SDK
 Keywords: telemetry,opentelemetry,openrouter,llm,genai,tracing
 Author: telemetry.dev
@@ -134,9 +134,12 @@ still execute and return their normal SDK values without exporting telemetry.
 ## Limitations
 
 - Unconsumed streams end their spans only when the stream is exhausted, errors, or is closed.
-- Streaming output is retained up to 64 KiB and 1,024 items; terminal metadata and usage can still
-  be recorded after the bound is reached. The configured `max_attribute_length` does not shrink this
-  retention bound; the core applies it to the exported attribute after the mask runs.
+- Streaming output is kept up to 16 MiB, and all streams in flight share the `max_stream_bytes`
+  bound of the core (64 MiB by default); terminal metadata and usage can still be recorded after
+  the bound is reached. The configured `max_attribute_length` does not shrink this
+  retention bound; the core applies it to the exported attribute after the mask runs. These bounds
+  need a `telemetry-dev` core with `max_stream_bytes`; with an older core, each stream keeps up to
+  64 KiB and 1,024 items.
 - A chat stream that is cut at the bound, closed early, or fails, and a Responses stream that is cut
   at the bound, ends without a terminal response, or ends with an `error` event set
   `telemetry.dev.capture.truncated = true`. With a mask configured, the incomplete reconstructed

{telemetry_dev_openrouter-0.2.1 → telemetry_dev_openrouter-0.2.3}/README.md

@@ -111,9 +111,12 @@ still execute and return their normal SDK values without exporting telemetry.
 ## Limitations
 
 - Unconsumed streams end their spans only when the stream is exhausted, errors, or is closed.
-- Streaming output is retained up to 64 KiB and 1,024 items; terminal metadata and usage can still
-  be recorded after the bound is reached. The configured `max_attribute_length` does not shrink this
-  retention bound; the core applies it to the exported attribute after the mask runs.
+- Streaming output is kept up to 16 MiB, and all streams in flight share the `max_stream_bytes`
+  bound of the core (64 MiB by default); terminal metadata and usage can still be recorded after
+  the bound is reached. The configured `max_attribute_length` does not shrink this
+  retention bound; the core applies it to the exported attribute after the mask runs. These bounds
+  need a `telemetry-dev` core with `max_stream_bytes`; with an older core, each stream keeps up to
+  64 KiB and 1,024 items.
 - A chat stream that is cut at the bound, closed early, or fails, and a Responses stream that is cut
   at the bound, ends without a terminal response, or ends with an `error` event set
   `telemetry.dev.capture.truncated = true`. With a mask configured, the incomplete reconstructed

{telemetry_dev_openrouter-0.2.1 → telemetry_dev_openrouter-0.2.3}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "telemetry-dev-openrouter"
-version = "0.2.1"
+version = "0.2.3"
 description = "OpenRouter integration for telemetry.dev Python SDK"
 readme = "README.md"
 license = "MIT"

{telemetry_dev_openrouter-0.2.1 → telemetry_dev_openrouter-0.2.3}/pyproject.toml.orig

@@ -1,6 +1,6 @@
 [project]
 name = "telemetry-dev-openrouter"
-version = "0.2.1"
+version = "0.2.3"
 description = "OpenRouter integration for telemetry.dev Python SDK"
 readme = "README.md"
 license = "MIT"

{telemetry_dev_openrouter-0.2.1 → telemetry_dev_openrouter-0.2.3}/src/telemetry_dev_openrouter/__init__.py

@@ -1,10 +1,13 @@
 from __future__ import annotations
 
 import asyncio
+import os
 import threading
 import time
+import weakref
 from collections.abc import AsyncIterator, Awaitable, Callable, Iterator, Mapping, Sequence
-from functools import wraps
+from functools import partial, wraps
+from io import StringIO
 from typing import Any, TypeVar, cast
 
 import telemetry_dev
@@ -12,7 +15,7 @@ from openrouter.chat import Chat
 from openrouter.embeddings import Embeddings
 from openrouter.responses import Responses
 
-__version__ = "0.2.1"
+__version__ = "0.2.3"
 
 RequestMapper = Callable[[Mapping[str, Any]], tuple[str, dict[str, Any]]]
 ResponseMapper = Callable[[Any], dict[str, Any]]
@@ -21,10 +24,8 @@ _PROVIDER = "openrouter"
 _WRAPPED_ATTR = "_telemetry_dev_openrouter_wrapped"
 _ORIGINAL_ATTR = "_telemetry_dev_openrouter_original"
 _CAPTURE_TRUNCATED_ATTRIBUTE = "telemetry.dev.capture.truncated"
-# Retention uses fixed bounds, the same as the TypeScript integration; the core applies
-# max_attribute_length after the mask.
-_STREAM_CAPTURE_MAX_BYTES = 64 * 1024
-_STREAM_CAPTURE_MAX_ITEMS = 1024
+# The core applies max_attribute_length after the mask. More choices than this are not kept.
+_MAX_STREAM_CHOICES = 1024
 _FINISH_REASON_MAX_LENGTH = 128
 _TERMINAL_RESPONSE_EVENTS = frozenset(
     {"response.completed", "response.failed", "response.incomplete"}
@@ -33,6 +34,22 @@ _OMIT = object()
 _ORIGINALS: list[tuple[type[Any], str, Any]] = []
 _installed = False
 _install_lock = threading.Lock()
+
+
+def _reset_install_lock_in_child() -> None:
+    """A thread of the parent can hold the lock at a fork, and only this thread exists here."""
+    global _install_lock
+    _install_lock = threading.Lock()
+
+
+# A hook is enough: a fork that runs no hooks, as uWSGI's fork of its workers by default,
+# starts from its master, which serves no requests. os.register_at_fork cannot remove a hook,
+# and importlib.reload runs this module again with the same globals, so the hook of the first
+# run stays. Windows has no fork.
+if hasattr(os, "register_at_fork") and "_install_fork_hook" not in globals():
+    _install_fork_hook = True
+    os.register_at_fork(after_in_child=_reset_install_lock_in_child)
+
 _T = TypeVar("_T")
 
 
@@ -174,6 +191,12 @@ def _cost_usd(raw_usage: Any) -> float | None:
     return cost if cost is not None else upstream_cost
 
 
+def _prompt_attributes(messages: object) -> dict[str, Any]:
+    # Older cores have no prompt_attributes_for and record a prompt only inside with_prompt.
+    read = getattr(telemetry_dev, "prompt_attributes_for", None)
+    return cast("dict[str, Any]", read(messages)) if callable(read) else {}
+
+
 def _chat_request(params: Mapping[str, Any]) -> tuple[str, dict[str, Any]]:
     model = _string(params.get("model"))
     max_completion_tokens = _number(params.get("max_completion_tokens"))
@@ -193,6 +216,7 @@ def _chat_request(params: Mapping[str, Any]) -> tuple[str, dict[str, Any]]:
             "seed": _number(params.get("seed")),
             "frequency_penalty": _number(params.get("frequency_penalty")),
             "presence_penalty": _number(params.get("presence_penalty")),
+            "attributes": _prompt_attributes(params.get("messages")) or None,
         },
     )
 
@@ -260,6 +284,7 @@ def _responses_request(params: Mapping[str, Any]) -> tuple[str, dict[str, Any]]:
             "max_tokens": _number(params.get("max_output_tokens")),
             "frequency_penalty": _number(params.get("frequency_penalty")),
             "presence_penalty": _number(params.get("presence_penalty")),
+            "attributes": _prompt_attributes(params.get("input")) or None,
         },
     )
 
@@ -382,22 +407,107 @@ def _end_once(handle: telemetry_dev.SpanHandle) -> Callable[..., None]:
     return end
 
 
+# On Python 3.10 and 3.11, StringIO keeps up to 100,000 written strings in a list before it
+# joins them, about 60 bytes each that the stream bound does not charge: 15 bytes a character
+# for 4-character deltas. Deltas are joined 256 at a time, so that those waiting hold under
+# about 22 KB, onto a string that is written once it has 4,096 characters, so that what is
+# written costs about 1.5% more than its text. Python 3.12 dropped the list.
+_DELTA_BATCH = 256
+_WRITE_CHARS = 4096
+
+
+class _DeltaBuffer:
+    # A write takes several steps, unlike one StringIO call, so without the lock a read on
+    # another thread, such as one that closes the stream, could copy a batch twice or drop it.
+    # A fork copies the lock held if another thread was writing, and that thread does not run
+    # in the child to release it. Every fork, also one that runs no at-fork hooks, changes the
+    # process ID, so a child takes a new lock. The check is inline because it runs per delta.
+    # A signal handler runs on the thread it interrupts, so one that reads the stream, such as
+    # one that closes it, can read inside a write. So the lock is reentrant, and each step takes
+    # the deltas and the tail out of the buffer before it joins or writes them, so that a read
+    # inside the step does not write them as well; that read returns a prefix, which can leave
+    # out the deltas being joined. A handler that writes inside a step is not supported. An
+    # exception inside a step, such as KeyboardInterrupt from a handler, puts back the text the
+    # step took unless the StringIO has it, so that a later read still has every delta.
+    __slots__ = ("_buffer", "_lock", "_pending", "_pid", "_tail")
+
+    def __init__(self) -> None:
+        self._buffer = StringIO()
+        self._lock = threading.RLock()
+        self._pid = os.getpid()
+        self._pending: list[str] = []
+        self._tail = ""
+
+    def write(self, text: str) -> None:
+        pid = os.getpid()
+        if self._pid != pid:
+            self._lock = threading.RLock()
+            self._pid = pid
+        with self._lock:
+            self._pending.append(text)
+            if len(self._pending) >= _DELTA_BATCH:
+                self._join(_WRITE_CHARS)
+
+    def getvalue(self) -> str:
+        pid = os.getpid()
+        if self._pid != pid:
+            self._lock = threading.RLock()
+            self._pid = pid
+        with self._lock:
+            self._join(1)
+            return self._buffer.getvalue()
+
+    def _join(self, write_at: int) -> None:
+        if not self._pending and len(self._tail) < write_at:
+            return
+        written = self._buffer.tell()
+        pending: list[str] = []
+        tail = ""
+        try:
+            pending, self._pending = self._pending, []
+            tail, self._tail = self._tail, ""
+            joined = "".join([tail, *pending])
+            if len(joined) >= write_at:
+                self._buffer.write(joined)
+            else:
+                self._tail = joined
+        except BaseException:
+            if self._buffer.tell() == written:
+                self._pending[:0] = pending
+                self._tail = tail + self._tail
+            raise
+
+
 class _ChatChoice:
     def __init__(self) -> None:
         self.role: str | None = None
-        self.content = ""
-        self.reasoning = ""
+        # Deltas are written to buffers and joined when output is read: repeated concatenation
+        # copies the whole text for each delta.
+        self.content_fragments = _DeltaBuffer()
+        self.reasoning_fragments = _DeltaBuffer()
         self.reasoning_details: list[Any] = []
-        self.refusal = ""
+        self.refusal_fragments = _DeltaBuffer()
         self.tool_calls: dict[int, dict[str, Any]] = {}
         self.finish_reason: str | None = None
 
+    @property
+    def content(self) -> str:
+        return self.content_fragments.getvalue()
+
+    @property
+    def reasoning(self) -> str:
+        return self.reasoning_fragments.getvalue()
+
+    @property
+    def refusal(self) -> str:
+        return self.refusal_fragments.getvalue()
+
 
 def _choice_state(
     states: dict[int, _ChatChoice], index: int, budget: telemetry_dev.CaptureBudget
 ) -> _ChatChoice | None:
     if index not in states:
-        if len(states) >= budget.max_items:
+        if len(states) >= _MAX_STREAM_CHOICES:
             budget.truncated = True
             return None
         states[index] = _ChatChoice()
@@ -422,7 +532,10 @@ def _merge_tool_call(state: _ChatChoice, delta: Any) -> None:
         if name is not None:
             current_function["name"] = name
         if isinstance(arguments, str):
-            current_function["arguments"] = f"{current_function.get('arguments', '')}{arguments}"
+            fragments = current_function.get("arguments")
+            if not isinstance(fragments, _DeltaBuffer):
+                fragments = current_function["arguments"] = _DeltaBuffer()
+            fragments.write(arguments)
         current["function"] = current_function
     state.tool_calls[tool_index] = current
 
@@ -443,15 +556,15 @@ def _record_chat_chunk(
         if isinstance(role, str):
             state.role = role
         if isinstance(content, str) and budget.accept(content):
-            state.content += content
+            state.content_fragments.write(content)
         if isinstance(reasoning, str) and budget.accept(reasoning):
-            state.reasoning += reasoning
+            state.reasoning_fragments.write(reasoning)
         for detail in _sequence_items(_field(delta, "reasoning_details")):
             native_detail = _native(detail)
             if native_detail is not None and budget.accept(native_detail):
                 state.reasoning_details.append(native_detail)
         if isinstance(refusal, str) and budget.accept(refusal):
-            state.refusal += refusal
+            state.refusal_fragments.write(refusal)
         for tool_call in _sequence_items(_field(delta, "tool_calls")):
             if budget.accept(tool_call):
                 _merge_tool_call(state, tool_call)
@@ -520,6 +633,16 @@ def _response_event_has_output(event: Any) -> bool:
     )
 
 
+def _joined_tool_call(call: dict[str, Any]) -> dict[str, Any]:
+    function = call.get("function")
+    if not isinstance(function, dict):
+        return call
+    arguments = cast(dict[str, Any], function).get("arguments")
+    if not isinstance(arguments, _DeltaBuffer):
+        return call
+    return {**call, "function": {**function, "arguments": arguments.getvalue()}}
+
+
 def _chat_output(states: Mapping[int, _ChatChoice]) -> list[dict[str, Any]]:
     output: list[dict[str, Any]] = []
     for _, state in sorted(states.items()):
@@ -535,13 +658,57 @@ def _chat_output(states: Mapping[int, _ChatChoice]) -> list[dict[str, Any]]:
         if state.refusal:
             message["refusal"] = state.refusal
         if state.tool_calls:
-            message["tool_calls"] = [call for _, call in sorted(state.tool_calls.items())]
+            message["tool_calls"] = [
+                _joined_tool_call(call) for _, call in sorted(state.tool_calls.items())
+            ]
         output.append(message)
     return output
 
 
 def _stream_capture_budget() -> telemetry_dev.CaptureBudget:
-    return telemetry_dev.CaptureBudget(_STREAM_CAPTURE_MAX_BYTES, _STREAM_CAPTURE_MAX_ITEMS)
+    # Older cores have no for_stream and bound each budget at 64 KiB on its own.
+    for_stream = getattr(telemetry_dev.CaptureBudget, "for_stream", None)
+    budget = for_stream() if callable(for_stream) else telemetry_dev.CaptureBudget()
+    return cast(telemetry_dev.CaptureBudget, budget)
+
+
+def _release_budget(budget: telemetry_dev.CaptureBudget) -> None:
+    release = getattr(budget, "release", None)
+    if callable(release):
+        release()
+
+
+def _measuring_budget(stream: telemetry_dev.CaptureBudget) -> telemetry_dev.CaptureBudget:
+    """An empty budget that measures a value replacing everything ``stream`` holds, within the
+    bound ``stream`` has now, without holding bytes itself."""
+    return telemetry_dev.CaptureBudget(stream.max_bytes, stream.max_items)
+
+
+def _adopt_budget(
+    stream: telemetry_dev.CaptureBudget, measured: telemetry_dev.CaptureBudget
+) -> bool:
+    """Takes the counts of a budget that measured a replacement into the stream's own budget.
+    Returns False, and takes nothing, when another stream took the room after the measure."""
+    # Older cores have no reserve_bytes; there the measure against max_bytes stands.
+    reserve = getattr(stream, "reserve_bytes", None)
+    if callable(reserve):
+        if not reserve(measured.bytes_used):
+            return False
+    else:
+        stream.bytes_used = measured.bytes_used
+    stream.items_used = measured.items_used
+    stream.truncated = measured.truncated
+    return True
+
+
+def _ending_stream(end: Callable[..., None], release: Callable[[], None]) -> Callable[..., None]:
+    def end_stream(**fields: Any) -> None:
+        try:
+            end(**fields)
+        finally:
+            release()
+
+    return end_stream
 
 
 def _capture_masked(handle: telemetry_dev.SpanHandle) -> bool:
@@ -611,6 +778,15 @@ def _hook_response_close(inner: Any, finish: Callable[[], None]) -> None:
     response = getattr(inner, "response", None)
     if response is None:
         return
+    # ``finish`` is a method of the stream wrapper, which holds ``response``: held weakly, the hook
+    # adds no reference cycle, so a dropped wrapper and its stream budget are freed at once.
+    finish_method = weakref.WeakMethod(finish)
+
+    def finish_if_alive() -> None:
+        method = finish_method()
+        if method is not None:
+            method()
+
     close = getattr(response, "close", None)
     if callable(close):
 
@@ -618,7 +794,7 @@ def _hook_response_close(inner: Any, finish: Callable[[], None]) -> None:
             try:
                 return close(*args, **kwargs)
             finally:
-                finish()
+                finish_if_alive()
 
         response.close = _close_hook
     aclose = getattr(response, "aclose", None)
@@ -629,7 +805,7 @@ def _hook_response_close(inner: Any, finish: Callable[[], None]) -> None:
             try:
                 return await aclose_fn(*args, **kwargs)
             finally:
-                finish()
+                finish_if_alive()
 
         response.aclose = _aclose_hook
 
@@ -657,7 +833,6 @@ async def _close_async_stream(inner: Any) -> None:
 class _InstrumentedStream:
     def __init__(self, inner: Any, handle: telemetry_dev.SpanHandle, started_at: float) -> None:
         self._inner = inner
-        self._end = _end_once(handle)
         self._handle = handle
         self._started_at = started_at
         self._states: dict[int, _ChatChoice] = {}
@@ -669,6 +844,9 @@ class _InstrumentedStream:
         self._completed = False
         self._mask_output_when_incomplete = _capture_masked(handle)
         self._budget = _stream_capture_budget()
+        # Bound to the budget, not self, so the callback adds no reference cycle.
+        self._end_stream = _ending_stream(_end_once(handle), partial(_release_budget, self._budget))
+        self._ended = False
         _hook_response_close(inner, self._on_response_close)
 
     def _iterate(self) -> Iterator[Any]:
@@ -739,7 +917,15 @@ class _InstrumentedStream:
     def __getattr__(self, name: str) -> Any:
         return getattr(self._inner, name)
 
+    def _end(self, **fields: Any) -> None:
+        # The span has ended and the stream budget no longer counts bytes, so later events are
+        # not kept.
+        self._ended = True
+        self._end_stream(**fields)
+
     def _record(self, chunk: Any, received_at: float) -> bool:
+        if self._ended:
+            return True
         update = _record_chat_chunk(chunk, self._states, self._budget)
         if _chat_chunk_has_output(chunk):
             record_output_chunk = getattr(self._handle, "record_output_chunk", None)
@@ -762,7 +948,6 @@ class _InstrumentedStream:
 class _InstrumentedAsyncStream:
     def __init__(self, inner: Any, handle: telemetry_dev.SpanHandle, started_at: float) -> None:
         self._inner = inner
-        self._end = _end_once(handle)
         self._handle = handle
         self._started_at = started_at
         self._states: dict[int, _ChatChoice] = {}
@@ -774,6 +959,9 @@ class _InstrumentedAsyncStream:
         self._completed = False
         self._mask_output_when_incomplete = _capture_masked(handle)
         self._budget = _stream_capture_budget()
+        # Bound to the budget, not self, so the callback adds no reference cycle.
+        self._end_stream = _ending_stream(_end_once(handle), partial(_release_budget, self._budget))
+        self._ended = False
         _hook_response_close(inner, self._on_response_close)
 
     async def _aiterate(self) -> AsyncIterator[Any]:
@@ -847,7 +1035,15 @@ class _InstrumentedAsyncStream:
     def __getattr__(self, name: str) -> Any:
         return getattr(self._inner, name)
 
+    def _end(self, **fields: Any) -> None:
+        # The span has ended and the stream budget no longer counts bytes, so later events are
+        # not kept.
+        self._ended = True
+        self._end_stream(**fields)
+
     def _record(self, chunk: Any, received_at: float) -> bool:
+        if self._ended:
+            return True
         update = _record_chat_chunk(chunk, self._states, self._budget)
         if _chat_chunk_has_output(chunk):
             record_output_chunk = getattr(self._handle, "record_output_chunk", None)
@@ -867,6 +1063,37 @@ class _InstrumentedAsyncStream:
         return _chunk_error(chunk) is None
 
 
+def _write_fragment(target: dict[str, Any], key: str, value: str) -> None:
+    """Appends a delta to ``target[key]`` in a buffer, since repeated concatenation copies the
+    whole text for each delta. _joined_item reads the text back."""
+    fragments = target.get(key)
+    if not isinstance(fragments, _DeltaBuffer):
+        fragments = _DeltaBuffer()
+        fragments.write(f"{target.get(key, '')}")
+        target[key] = fragments
+    fragments.write(value)
+
+
+def _joined_value(value: Any) -> Any:
+    return value.getvalue() if isinstance(value, _DeltaBuffer) else value
+
+
+def _joined_item(item: Any) -> Any:
+    if not isinstance(item, dict):
+        return item
+    joined: dict[str, Any] = {}
+    for key, value in cast(dict[str, Any], item).items():
+        if key in ("content", "summary") and isinstance(value, list):
+            value = [
+                {name: _joined_value(field) for name, field in cast(dict[str, Any], part).items()}
+                if isinstance(part, dict)
+                else part
+                for part in cast(list[Any], value)
+            ]
+        joined[key] = _joined_value(value)
+    return joined
+
+
 class _ResponsesStreamState:
     def __init__(self) -> None:
         self.partial: dict[str, Any] = {}
@@ -895,7 +1122,10 @@ class _ResponsesStreamState:
 
     def _output_with_item(self, output_index: int, item: dict[str, Any]) -> list[dict[str, Any]]:
         items = {**self._items, output_index: item}
-        return [*[value for _, value in sorted(items.items())], *self._synthetic_events]
+        return [
+            *[_joined_item(value) for _, value in sorted(items.items())],
+            *self._synthetic_events,
+        ]
 
     @staticmethod
     def _can_accept(budget: telemetry_dev.CaptureBudget, value: Any) -> bool:
@@ -906,14 +1136,19 @@ class _ResponsesStreamState:
         return candidate.accept(value)
 
     def _replace_output(self, output: Any) -> bool:
-        replacement = _stream_capture_budget()
+        replacement = _measuring_budget(self._budget)
         if not replacement.accept(output):
             self._budget.truncated = True
             return False
         replacement.truncated = self._provider_events_truncated
-        self._budget = replacement
+        if not _adopt_budget(self._budget, replacement):
+            self._budget.truncated = True
+            return False
         return True
 
+    def release(self) -> None:
+        _release_budget(self._budget)
+
     def _sync_output(self) -> None:
         self.retained_output = self._output()
         self.partial["output"] = self.retained_output
@@ -999,7 +1234,7 @@ class _ResponsesStreamState:
         if event_type in {"response.output_item.added", "response.output_item.done"}:
             raw_item = _field(event, "item")
             replacement = event_type.endswith(".done")
-            preflight = _stream_capture_budget() if replacement else self._budget
+            preflight = _measuring_budget(self._budget) if replacement else self._budget
             if not self._can_accept(preflight, raw_item):
                 self._budget.truncated = True
                 return False
@@ -1017,7 +1252,7 @@ class _ResponsesStreamState:
         if event_type in {"response.content_part.added", "response.content_part.done"}:
             event_part = _field(event, "part")
             replacement = event_type.endswith(".done")
-            preflight = _stream_capture_budget() if replacement else self._budget
+            preflight = _measuring_budget(self._budget) if replacement else self._budget
             if not self._can_accept(preflight, event_part):
                 self._budget.truncated = True
                 return False
@@ -1119,7 +1354,7 @@ class _ResponsesStreamState:
             else:
                 if not self._budget.accept(value):
                     return False
-                item[field] = f"{item.get(field, '')}{value}"
+                _write_fragment(item, field, value)
                 name = _field(event, "name")
                 if name is not None:
                     item["name"] = name
@@ -1130,7 +1365,7 @@ class _ResponsesStreamState:
         }:
             event_part = _field(event, "part")
             replacement = event_type.endswith(".done")
-            preflight = _stream_capture_budget() if replacement else self._budget
+            preflight = _measuring_budget(self._budget) if replacement else self._budget
             if not self._can_accept(preflight, event_part):
                 self._budget.truncated = True
                 return False
@@ -1245,7 +1480,7 @@ class _ResponsesStreamState:
                 self._summary[summary_key] = part
                 self._sync_item(output_index, item)
             else:
-                summary["text"] = f"{summary.get('text', '')}{value}"
+                _write_fragment(summary, "text", value)
             return True
         content_index = self._event_index(event, "content_index", "contentIndex")
         content_key = (output_index, content_index)
@@ -1284,9 +1519,9 @@ class _ResponsesStreamState:
             self._content[content_key] = replacement
             self._sync_item(output_index, item)
         elif refusal:
-            part["refusal"] = f"{part.get('refusal', '')}{value}"
+            _write_fragment(part, "refusal", value)
         else:
-            part["text"] = f"{part.get('text', '')}{value}"
+            _write_fragment(part, "text", value)
         return True
 
     def record(self, event: Any) -> None:
@@ -1294,7 +1529,7 @@ class _ResponsesStreamState:
         response = _field(event, "response")
         if response is not None:
             fields = _responses_response(response, include_error=False, include_output=False)
-            response_budget = _stream_capture_budget()
+            response_budget = _measuring_budget(self._budget)
             raw_output = _field(response, "output")
             if raw_output is not None:
                 if not self._can_accept(response_budget, raw_output):
@@ -1306,7 +1541,11 @@ class _ResponsesStreamState:
                         self._budget.truncated = True
                     else:
                         response_artifact = [*response_items, *self._synthetic_events]
+                        adopted = False
                         if response_budget.accept(response_artifact):
+                            response_budget.truncated = self._provider_events_truncated
+                            adopted = _adopt_budget(self._budget, response_budget)
+                        if adopted:
                             self._items.clear()
                             self._content.clear()
                             self._summary.clear()
@@ -1314,8 +1553,6 @@ class _ResponsesStreamState:
                                 if isinstance(item, dict):
                                     self._hydrate_item(index, cast(dict[str, Any], item))
                             self.retained_output = response_artifact
-                            response_budget.truncated = self._provider_events_truncated
-                            self._budget = response_budget
                         else:
                             self._budget.truncated = True
             self.partial = fields
@@ -1329,6 +1566,9 @@ class _ResponsesStreamState:
 
     def fields(self, mask_output: bool, *, failed: bool = False) -> dict[str, Any]:
         fields = dict(self.partial)
+        output = fields.get("output")
+        if isinstance(output, list):
+            fields["output"] = [_joined_item(item) for item in cast(list[Any], output)]
         if failed or self._budget.truncated or not self.saw_terminal_snapshot:
             _mark_capture_incomplete(fields, mask_output)
         return fields
@@ -1338,10 +1578,12 @@ class _InstrumentedResponsesStream:
     def __init__(self, inner: Any, handle: telemetry_dev.SpanHandle, started_at: float) -> None:
         self._inner = inner
         self._handle = handle
-        self._end = _end_once(handle)
         self._started_at = started_at
         self._saw_first = False
         self._state = _ResponsesStreamState()
+        # Bound to the state, not self, so the callback adds no reference cycle.
+        self._end_stream = _ending_stream(_end_once(handle), self._state.release)
+        self._ended = False
         self._mask_output_when_incomplete = _capture_masked(handle)
         self._consume: Iterator[Any] | None = None
         self._in_next = False
@@ -1409,7 +1651,15 @@ class _InstrumentedResponsesStream:
     def __getattr__(self, name: str) -> Any:
         return getattr(self._inner, name)
 
+    def _end(self, **fields: Any) -> None:
+        # The span has ended and the stream budget no longer counts bytes, so later events are
+        # not kept.
+        self._ended = True
+        self._end_stream(**fields)
+
     def _record(self, event: Any, received_at: float) -> None:
+        if self._ended:
+            return
         if _response_event_has_output(event):
             record_output_chunk = getattr(self._handle, "record_output_chunk", None)
             if callable(record_output_chunk):
@@ -1436,10 +1686,12 @@ class _InstrumentedAsyncResponsesStream:
     def __init__(self, inner: Any, handle: telemetry_dev.SpanHandle, started_at: float) -> None:
         self._inner = inner
         self._handle = handle
-        self._end = _end_once(handle)
         self._started_at = started_at
         self._saw_first = False
         self._state = _ResponsesStreamState()
+        # Bound to the state, not self, so the callback adds no reference cycle.
+        self._end_stream = _ending_stream(_end_once(handle), self._state.release)
+        self._ended = False
         self._mask_output_when_incomplete = _capture_masked(handle)
         self._consume: AsyncIterator[Any] | None = None
         self._in_next = False
@@ -1510,7 +1762,15 @@ class _InstrumentedAsyncResponsesStream:
     def __getattr__(self, name: str) -> Any:
         return getattr(self._inner, name)
 
+    def _end(self, **fields: Any) -> None:
+        # The span has ended and the stream budget no longer counts bytes, so later events are
+        # not kept.
+        self._ended = True
+        self._end_stream(**fields)
+
     def _record(self, event: Any, received_at: float) -> None:
+        if self._ended:
+            return
         if _response_event_has_output(event):
             record_output_chunk = getattr(self._handle, "record_output_chunk", None)
             if callable(record_output_chunk):