fix(anthropic): capture time_to_first_token when using .text_stream

[Abhijeet Prasad (AbhiPrasad)]

TracedMessageStream.text_stream was falling through via Wrapper.getattr to the unwrapped Anthropic stream, so __process_message was never called and time_to_first_token was not recorded on the span.

Override text_stream to route iteration through the traced stream's own next/anext, ensuring __process_message is called for every event.

Fixes https://linear.app/braintrustdata/issue/BT-4702/python-anthropic-time-to-first-token-not-captured-when-using-text

[starfolkai]

Drop into this review session: sfk devbox session 73

Code Review: #234

Fix is correct. Two test gaps worth addressing before merge.

---

Root cause analysis

TracedMessageStream extends Wrapper, which delegates unknown attribute access via __getattr__. Before this change, .text_stream fell through to __getattr__, returning self.__msg_stream.text_stream — a generator over the raw underlying stream. That iterator bypassed __process_message entirely, so __time_to_first_token was never set.

The fix is the right approach: add an explicit text_stream property that routes through self (the wrapper's own __iter__/__aiter__), ensuring every event hits __process_message.

---

Issues

1. Tests don't assert span output or token counts (minor gap)

The new tests only call _assert_metrics_are_valid, which checks timing and the presence of time_to_first_token. They don't verify that log["output"] is populated or that token counts are present. The span output (content, stop_reason) comes from accumulate_event running on events consumed by text_stream. If that accumulation ever breaks for the text_stream path, these tests won't catch it.

The existing test_anthropic_messages_streaming_sync and _async tests assert both. A few lines in each new test would close the gap:

assertlog["output"]["role"] =="assistant"assertlog["output"]["content"]
assertlog["metrics"]["prompt_tokens"] >0assertlog["metrics"]["completion_tokens"] >0

2. Sync test is missing the initial assert not memory_logger.pop() guard

test_anthropic_messages_streaming_async_text_stream has it on line 610, but test_anthropic_messages_streaming_sync_text_stream skips it. Minor inconsistency, but it means span leakage from a prior test won't be caught.

3. Async/sync dispatch heuristic in text_stream (worth a comment)

# tracing.py:336ifhasattr(self.__msg_stream, "__aiter__"):
returnself.__async_text_stream()
returnself.__sync_text_stream()

This works today because Anthropic's sync MessageStream doesn't implement __aiter__, while AsyncMessageStream does. It's not immediately obvious why this check is sufficient. A one-line comment would make the intent clear and reduce future confusion:

# Async streams expose __aiter__; sync streams do not.

---

What's good

• The mechanics are correct: __sync_text_stream and __async_text_stream both iterate via self, so __process_message is called on every raw event (including message_start, content_block_delta, etc.), TTFT is captured on the first event, and accumulate_event builds the full snapshot as before.
• VCR cassettes are properly checked in for both sync and async paths.
• No changes to the existing streaming behavior for callers who use __iter__/__aiter__ directly.

Tests confirmed passing locally:

5 passed (test_anthropic_messages_streaming_async, _sync, _sync_text_stream, _async_text_stream, test_anthropic_beta_messages_streaming_async)

[Abhijeet Prasad (AbhiPrasad)]

TracedMessageStream.text_stream was falling through via Wrapper.getattr to the unwrapped Anthropic stream, so __process_message was never called and time_to_first_token was not recorded on the span.

Override text_stream to route iteration through the traced stream's own next/anext, ensuring __process_message is called for every event.

Fixes https://linear.app/braintrustdata/issue/BT-4702/python-anthropic-time-to-first-token-not-captured-when-using-text

[starfolkai]

Drop into this review session: sfk devbox session 73

Code Review: #234

Fix is correct. Two test gaps worth addressing before merge.

---

Root cause analysis

TracedMessageStream extends Wrapper, which delegates unknown attribute access via __getattr__. Before this change, .text_stream fell through to __getattr__, returning self.__msg_stream.text_stream — a generator over the raw underlying stream. That iterator bypassed __process_message entirely, so __time_to_first_token was never set.

The fix is the right approach: add an explicit text_stream property that routes through self (the wrapper's own __iter__/__aiter__), ensuring every event hits __process_message.

---

Issues

1. Tests don't assert span output or token counts (minor gap)

The new tests only call _assert_metrics_are_valid, which checks timing and the presence of time_to_first_token. They don't verify that log["output"] is populated or that token counts are present. The span output (content, stop_reason) comes from accumulate_event running on events consumed by text_stream. If that accumulation ever breaks for the text_stream path, these tests won't catch it.

The existing test_anthropic_messages_streaming_sync and _async tests assert both. A few lines in each new test would close the gap:

assertlog["output"]["role"] =="assistant"assertlog["output"]["content"]
assertlog["metrics"]["prompt_tokens"] >0assertlog["metrics"]["completion_tokens"] >0

2. Sync test is missing the initial assert not memory_logger.pop() guard

test_anthropic_messages_streaming_async_text_stream has it on line 610, but test_anthropic_messages_streaming_sync_text_stream skips it. Minor inconsistency, but it means span leakage from a prior test won't be caught.

3. Async/sync dispatch heuristic in text_stream (worth a comment)

# tracing.py:336ifhasattr(self.__msg_stream, "__aiter__"):
returnself.__async_text_stream()
returnself.__sync_text_stream()

This works today because Anthropic's sync MessageStream doesn't implement __aiter__, while AsyncMessageStream does. It's not immediately obvious why this check is sufficient. A one-line comment would make the intent clear and reduce future confusion:

# Async streams expose __aiter__; sync streams do not.

---

What's good

• The mechanics are correct: __sync_text_stream and __async_text_stream both iterate via self, so __process_message is called on every raw event (including message_start, content_block_delta, etc.), TTFT is captured on the first event, and accumulate_event builds the full snapshot as before.
• VCR cassettes are properly checked in for both sync and async paths.
• No changes to the existing streaming behavior for callers who use __iter__/__aiter__ directly.

Tests confirmed passing locally:

5 passed (test_anthropic_messages_streaming_async, _sync, _sync_text_stream, _async_text_stream, test_anthropic_beta_messages_streaming_async)

[Abhijeet Prasad (AbhiPrasad)]

TracedMessageStream.text_stream was falling through via Wrapper.getattr to the unwrapped Anthropic stream, so __process_message was never called and time_to_first_token was not recorded on the span.

Override text_stream to route iteration through the traced stream's own next/anext, ensuring __process_message is called for every event.

Fixes https://linear.app/braintrustdata/issue/BT-4702/python-anthropic-time-to-first-token-not-captured-when-using-text

[starfolkai]

Drop into this review session: sfk devbox session 73

Code Review: #234

Fix is correct. Two test gaps worth addressing before merge.

---

Root cause analysis

TracedMessageStream extends Wrapper, which delegates unknown attribute access via __getattr__. Before this change, .text_stream fell through to __getattr__, returning self.__msg_stream.text_stream — a generator over the raw underlying stream. That iterator bypassed __process_message entirely, so __time_to_first_token was never set.

The fix is the right approach: add an explicit text_stream property that routes through self (the wrapper's own __iter__/__aiter__), ensuring every event hits __process_message.

---

Issues

1. Tests don't assert span output or token counts (minor gap)

The new tests only call _assert_metrics_are_valid, which checks timing and the presence of time_to_first_token. They don't verify that log["output"] is populated or that token counts are present. The span output (content, stop_reason) comes from accumulate_event running on events consumed by text_stream. If that accumulation ever breaks for the text_stream path, these tests won't catch it.

The existing test_anthropic_messages_streaming_sync and _async tests assert both. A few lines in each new test would close the gap:

assertlog["output"]["role"] =="assistant"assertlog["output"]["content"]
assertlog["metrics"]["prompt_tokens"] >0assertlog["metrics"]["completion_tokens"] >0

2. Sync test is missing the initial assert not memory_logger.pop() guard

test_anthropic_messages_streaming_async_text_stream has it on line 610, but test_anthropic_messages_streaming_sync_text_stream skips it. Minor inconsistency, but it means span leakage from a prior test won't be caught.

3. Async/sync dispatch heuristic in text_stream (worth a comment)

# tracing.py:336ifhasattr(self.__msg_stream, "__aiter__"):
returnself.__async_text_stream()
returnself.__sync_text_stream()

This works today because Anthropic's sync MessageStream doesn't implement __aiter__, while AsyncMessageStream does. It's not immediately obvious why this check is sufficient. A one-line comment would make the intent clear and reduce future confusion:

# Async streams expose __aiter__; sync streams do not.

---

What's good

• The mechanics are correct: __sync_text_stream and __async_text_stream both iterate via self, so __process_message is called on every raw event (including message_start, content_block_delta, etc.), TTFT is captured on the first event, and accumulate_event builds the full snapshot as before.
• VCR cassettes are properly checked in for both sync and async paths.
• No changes to the existing streaming behavior for callers who use __iter__/__aiter__ directly.

Tests confirmed passing locally:

5 passed (test_anthropic_messages_streaming_async, _sync, _sync_text_stream, _async_text_stream, test_anthropic_beta_messages_streaming_async)

[Abhijeet Prasad (AbhiPrasad)]

TracedMessageStream.text_stream was falling through via Wrapper.getattr to the unwrapped Anthropic stream, so __process_message was never called and time_to_first_token was not recorded on the span.

Override text_stream to route iteration through the traced stream's own next/anext, ensuring __process_message is called for every event.

Fixes https://linear.app/braintrustdata/issue/BT-4702/python-anthropic-time-to-first-token-not-captured-when-using-text

[starfolkai]

Drop into this review session: sfk devbox session 73

Code Review: #234

Fix is correct. Two test gaps worth addressing before merge.

---

Root cause analysis

TracedMessageStream extends Wrapper, which delegates unknown attribute access via __getattr__. Before this change, .text_stream fell through to __getattr__, returning self.__msg_stream.text_stream — a generator over the raw underlying stream. That iterator bypassed __process_message entirely, so __time_to_first_token was never set.

The fix is the right approach: add an explicit text_stream property that routes through self (the wrapper's own __iter__/__aiter__), ensuring every event hits __process_message.

---

Issues

1. Tests don't assert span output or token counts (minor gap)

The new tests only call _assert_metrics_are_valid, which checks timing and the presence of time_to_first_token. They don't verify that log["output"] is populated or that token counts are present. The span output (content, stop_reason) comes from accumulate_event running on events consumed by text_stream. If that accumulation ever breaks for the text_stream path, these tests won't catch it.

The existing test_anthropic_messages_streaming_sync and _async tests assert both. A few lines in each new test would close the gap:

assertlog["output"]["role"] =="assistant"assertlog["output"]["content"]
assertlog["metrics"]["prompt_tokens"] >0assertlog["metrics"]["completion_tokens"] >0

2. Sync test is missing the initial assert not memory_logger.pop() guard

test_anthropic_messages_streaming_async_text_stream has it on line 610, but test_anthropic_messages_streaming_sync_text_stream skips it. Minor inconsistency, but it means span leakage from a prior test won't be caught.

3. Async/sync dispatch heuristic in text_stream (worth a comment)

# tracing.py:336ifhasattr(self.__msg_stream, "__aiter__"):
returnself.__async_text_stream()
returnself.__sync_text_stream()

This works today because Anthropic's sync MessageStream doesn't implement __aiter__, while AsyncMessageStream does. It's not immediately obvious why this check is sufficient. A one-line comment would make the intent clear and reduce future confusion:

# Async streams expose __aiter__; sync streams do not.

---

What's good

• The mechanics are correct: __sync_text_stream and __async_text_stream both iterate via self, so __process_message is called on every raw event (including message_start, content_block_delta, etc.), TTFT is captured on the first event, and accumulate_event builds the full snapshot as before.
• VCR cassettes are properly checked in for both sync and async paths.
• No changes to the existing streaming behavior for callers who use __iter__/__aiter__ directly.

Tests confirmed passing locally:

5 passed (test_anthropic_messages_streaming_async, _sync, _sync_text_stream, _async_text_stream, test_anthropic_beta_messages_streaming_async)

[Abhijeet Prasad (AbhiPrasad)]

TracedMessageStream.text_stream was falling through via Wrapper.getattr to the unwrapped Anthropic stream, so __process_message was never called and time_to_first_token was not recorded on the span.

Override text_stream to route iteration through the traced stream's own next/anext, ensuring __process_message is called for every event.

Fixes https://linear.app/braintrustdata/issue/BT-4702/python-anthropic-time-to-first-token-not-captured-when-using-text

[starfolkai]

Drop into this review session: sfk devbox session 73

Code Review: #234

Fix is correct. Two test gaps worth addressing before merge.

---

Root cause analysis

TracedMessageStream extends Wrapper, which delegates unknown attribute access via __getattr__. Before this change, .text_stream fell through to __getattr__, returning self.__msg_stream.text_stream — a generator over the raw underlying stream. That iterator bypassed __process_message entirely, so __time_to_first_token was never set.

The fix is the right approach: add an explicit text_stream property that routes through self (the wrapper's own __iter__/__aiter__), ensuring every event hits __process_message.

---

Issues

1. Tests don't assert span output or token counts (minor gap)

The new tests only call _assert_metrics_are_valid, which checks timing and the presence of time_to_first_token. They don't verify that log["output"] is populated or that token counts are present. The span output (content, stop_reason) comes from accumulate_event running on events consumed by text_stream. If that accumulation ever breaks for the text_stream path, these tests won't catch it.

The existing test_anthropic_messages_streaming_sync and _async tests assert both. A few lines in each new test would close the gap:

assertlog["output"]["role"] =="assistant"assertlog["output"]["content"]
assertlog["metrics"]["prompt_tokens"] >0assertlog["metrics"]["completion_tokens"] >0

2. Sync test is missing the initial assert not memory_logger.pop() guard

test_anthropic_messages_streaming_async_text_stream has it on line 610, but test_anthropic_messages_streaming_sync_text_stream skips it. Minor inconsistency, but it means span leakage from a prior test won't be caught.

3. Async/sync dispatch heuristic in text_stream (worth a comment)

# tracing.py:336ifhasattr(self.__msg_stream, "__aiter__"):
returnself.__async_text_stream()
returnself.__sync_text_stream()

This works today because Anthropic's sync MessageStream doesn't implement __aiter__, while AsyncMessageStream does. It's not immediately obvious why this check is sufficient. A one-line comment would make the intent clear and reduce future confusion:

# Async streams expose __aiter__; sync streams do not.

---

What's good

• The mechanics are correct: __sync_text_stream and __async_text_stream both iterate via self, so __process_message is called on every raw event (including message_start, content_block_delta, etc.), TTFT is captured on the first event, and accumulate_event builds the full snapshot as before.
• VCR cassettes are properly checked in for both sync and async paths.
• No changes to the existing streaming behavior for callers who use __iter__/__aiter__ directly.

Tests confirmed passing locally:

5 passed (test_anthropic_messages_streaming_async, _sync, _sync_text_stream, _async_text_stream, test_anthropic_beta_messages_streaming_async)

[Abhijeet Prasad (AbhiPrasad)]

TracedMessageStream.text_stream was falling through via Wrapper.getattr to the unwrapped Anthropic stream, so __process_message was never called and time_to_first_token was not recorded on the span.

Override text_stream to route iteration through the traced stream's own next/anext, ensuring __process_message is called for every event.

Fixes https://linear.app/braintrustdata/issue/BT-4702/python-anthropic-time-to-first-token-not-captured-when-using-text

[starfolkai]

Drop into this review session: sfk devbox session 73

Code Review: #234

Fix is correct. Two test gaps worth addressing before merge.

---

Root cause analysis

TracedMessageStream extends Wrapper, which delegates unknown attribute access via __getattr__. Before this change, .text_stream fell through to __getattr__, returning self.__msg_stream.text_stream — a generator over the raw underlying stream. That iterator bypassed __process_message entirely, so __time_to_first_token was never set.

The fix is the right approach: add an explicit text_stream property that routes through self (the wrapper's own __iter__/__aiter__), ensuring every event hits __process_message.

---

Issues

1. Tests don't assert span output or token counts (minor gap)

The new tests only call _assert_metrics_are_valid, which checks timing and the presence of time_to_first_token. They don't verify that log["output"] is populated or that token counts are present. The span output (content, stop_reason) comes from accumulate_event running on events consumed by text_stream. If that accumulation ever breaks for the text_stream path, these tests won't catch it.

The existing test_anthropic_messages_streaming_sync and _async tests assert both. A few lines in each new test would close the gap:

assertlog["output"]["role"] =="assistant"assertlog["output"]["content"]
assertlog["metrics"]["prompt_tokens"] >0assertlog["metrics"]["completion_tokens"] >0

2. Sync test is missing the initial assert not memory_logger.pop() guard

test_anthropic_messages_streaming_async_text_stream has it on line 610, but test_anthropic_messages_streaming_sync_text_stream skips it. Minor inconsistency, but it means span leakage from a prior test won't be caught.

3. Async/sync dispatch heuristic in text_stream (worth a comment)

# tracing.py:336ifhasattr(self.__msg_stream, "__aiter__"):
returnself.__async_text_stream()
returnself.__sync_text_stream()

This works today because Anthropic's sync MessageStream doesn't implement __aiter__, while AsyncMessageStream does. It's not immediately obvious why this check is sufficient. A one-line comment would make the intent clear and reduce future confusion:

# Async streams expose __aiter__; sync streams do not.

---

What's good

• The mechanics are correct: __sync_text_stream and __async_text_stream both iterate via self, so __process_message is called on every raw event (including message_start, content_block_delta, etc.), TTFT is captured on the first event, and accumulate_event builds the full snapshot as before.
• VCR cassettes are properly checked in for both sync and async paths.
• No changes to the existing streaming behavior for callers who use __iter__/__aiter__ directly.

Tests confirmed passing locally:

5 passed (test_anthropic_messages_streaming_async, _sync, _sync_text_stream, _async_text_stream, test_anthropic_beta_messages_streaming_async)

[Abhijeet Prasad (AbhiPrasad)]

TracedMessageStream.text_stream was falling through via Wrapper.getattr to the unwrapped Anthropic stream, so __process_message was never called and time_to_first_token was not recorded on the span.

Override text_stream to route iteration through the traced stream's own next/anext, ensuring __process_message is called for every event.

Fixes https://linear.app/braintrustdata/issue/BT-4702/python-anthropic-time-to-first-token-not-captured-when-using-text

[starfolkai]

Drop into this review session: sfk devbox session 73

Code Review: #234

Fix is correct. Two test gaps worth addressing before merge.

---

Root cause analysis

TracedMessageStream extends Wrapper, which delegates unknown attribute access via __getattr__. Before this change, .text_stream fell through to __getattr__, returning self.__msg_stream.text_stream — a generator over the raw underlying stream. That iterator bypassed __process_message entirely, so __time_to_first_token was never set.

The fix is the right approach: add an explicit text_stream property that routes through self (the wrapper's own __iter__/__aiter__), ensuring every event hits __process_message.

---

Issues

1. Tests don't assert span output or token counts (minor gap)

The new tests only call _assert_metrics_are_valid, which checks timing and the presence of time_to_first_token. They don't verify that log["output"] is populated or that token counts are present. The span output (content, stop_reason) comes from accumulate_event running on events consumed by text_stream. If that accumulation ever breaks for the text_stream path, these tests won't catch it.

The existing test_anthropic_messages_streaming_sync and _async tests assert both. A few lines in each new test would close the gap:

assertlog["output"]["role"] =="assistant"assertlog["output"]["content"]
assertlog["metrics"]["prompt_tokens"] >0assertlog["metrics"]["completion_tokens"] >0

2. Sync test is missing the initial assert not memory_logger.pop() guard

test_anthropic_messages_streaming_async_text_stream has it on line 610, but test_anthropic_messages_streaming_sync_text_stream skips it. Minor inconsistency, but it means span leakage from a prior test won't be caught.

3. Async/sync dispatch heuristic in text_stream (worth a comment)

# tracing.py:336ifhasattr(self.__msg_stream, "__aiter__"):
returnself.__async_text_stream()
returnself.__sync_text_stream()

This works today because Anthropic's sync MessageStream doesn't implement __aiter__, while AsyncMessageStream does. It's not immediately obvious why this check is sufficient. A one-line comment would make the intent clear and reduce future confusion:

# Async streams expose __aiter__; sync streams do not.

---

What's good

• The mechanics are correct: __sync_text_stream and __async_text_stream both iterate via self, so __process_message is called on every raw event (including message_start, content_block_delta, etc.), TTFT is captured on the first event, and accumulate_event builds the full snapshot as before.
• VCR cassettes are properly checked in for both sync and async paths.
• No changes to the existing streaming behavior for callers who use __iter__/__aiter__ directly.

Tests confirmed passing locally:

5 passed (test_anthropic_messages_streaming_async, _sync, _sync_text_stream, _async_text_stream, test_anthropic_beta_messages_streaming_async)

[Abhijeet Prasad (AbhiPrasad)]

TracedMessageStream.text_stream was falling through via Wrapper.getattr to the unwrapped Anthropic stream, so __process_message was never called and time_to_first_token was not recorded on the span.

Override text_stream to route iteration through the traced stream's own next/anext, ensuring __process_message is called for every event.

Fixes https://linear.app/braintrustdata/issue/BT-4702/python-anthropic-time-to-first-token-not-captured-when-using-text

[starfolkai]

Drop into this review session: sfk devbox session 73

Code Review: #234

Fix is correct. Two test gaps worth addressing before merge.

---

Root cause analysis

TracedMessageStream extends Wrapper, which delegates unknown attribute access via __getattr__. Before this change, .text_stream fell through to __getattr__, returning self.__msg_stream.text_stream — a generator over the raw underlying stream. That iterator bypassed __process_message entirely, so __time_to_first_token was never set.

The fix is the right approach: add an explicit text_stream property that routes through self (the wrapper's own __iter__/__aiter__), ensuring every event hits __process_message.

---

Issues

1. Tests don't assert span output or token counts (minor gap)

The new tests only call _assert_metrics_are_valid, which checks timing and the presence of time_to_first_token. They don't verify that log["output"] is populated or that token counts are present. The span output (content, stop_reason) comes from accumulate_event running on events consumed by text_stream. If that accumulation ever breaks for the text_stream path, these tests won't catch it.

The existing test_anthropic_messages_streaming_sync and _async tests assert both. A few lines in each new test would close the gap:

assertlog["output"]["role"] =="assistant"assertlog["output"]["content"]
assertlog["metrics"]["prompt_tokens"] >0assertlog["metrics"]["completion_tokens"] >0

2. Sync test is missing the initial assert not memory_logger.pop() guard

test_anthropic_messages_streaming_async_text_stream has it on line 610, but test_anthropic_messages_streaming_sync_text_stream skips it. Minor inconsistency, but it means span leakage from a prior test won't be caught.

3. Async/sync dispatch heuristic in text_stream (worth a comment)

# tracing.py:336ifhasattr(self.__msg_stream, "__aiter__"):
returnself.__async_text_stream()
returnself.__sync_text_stream()

This works today because Anthropic's sync MessageStream doesn't implement __aiter__, while AsyncMessageStream does. It's not immediately obvious why this check is sufficient. A one-line comment would make the intent clear and reduce future confusion:

# Async streams expose __aiter__; sync streams do not.

---

What's good

• The mechanics are correct: __sync_text_stream and __async_text_stream both iterate via self, so __process_message is called on every raw event (including message_start, content_block_delta, etc.), TTFT is captured on the first event, and accumulate_event builds the full snapshot as before.
• VCR cassettes are properly checked in for both sync and async paths.
• No changes to the existing streaming behavior for callers who use __iter__/__aiter__ directly.

Tests confirmed passing locally:

5 passed (test_anthropic_messages_streaming_async, _sync, _sync_text_stream, _async_text_stream, test_anthropic_beta_messages_streaming_async)