[opentelemetry-instrumentation-genai-anthropic] Freeze a one-shot tools iterator

tools is typed as an iterable, so a caller may pass a generator. Reading tool
definitions drained it before the SDK serialized the request, and the request
went out with an empty tool list.

Materialize it in the wrappers, ahead of both readers. The SDK materializes the
value itself when it builds the request body, so the request is unchanged.

Placement matters and differs between the two entry points: create reads the
request after the wrapper runs, but stream serializes it while building the
manager, before the invocation is created. Doing this while building the
invocation would leave stream recording no tools.

Assisted-by: Claude Opus 5

Author: sfc-gh-zeningchen

instrumentation/opentelemetry-instrumentation-genai-anthropic/src/opentelemetry/instrumentation/genai/anthropic/patch.py

@@ -6,7 +6,7 @@
 from __future__ import annotations
 
 import logging
-from collections.abc import Awaitable, Callable
+from collections.abc import Awaitable, Callable, Iterator
 from typing import TYPE_CHECKING, Any, cast
 
 from anthropic.types import Message as AnthropicMessage
@@ -96,6 +96,19 @@ def _fail_context_manager_response(
         )
 
 
+def _materialize_tools(kwargs: dict[str, Any]) -> None:
+    """Replace a one-shot ``tools`` iterator with a list.
+
+    ``tools`` is typed as an iterable, so it may be a generator, and both the
+    SDK and the tool definitions read it. Call this before either of them does:
+    ``create`` reads the request after this wrapper, but ``stream`` serializes
+    it while building the manager, before the invocation is created.
+    """
+    tools = kwargs.get("tools")
+    if isinstance(tools, Iterator):
+        kwargs["tools"] = list(cast("Iterator[Any]", tools))
+
+
 def _is_raw_response(result: object) -> bool:
     """Whether ``result`` is a raw-response object to route through the proxy.
 
@@ -131,6 +144,7 @@ def traced_method(
         | AnthropicStream[RawMessageStreamEvent]
         | MessagesStreamWrapper[None]
     ):
+        _materialize_tools(kwargs)
         invocation = _create_invocation(
             handler, instance, args, kwargs, capture_content
         )
@@ -189,6 +203,7 @@ async def traced_method(
         | AnthropicAsyncStream[RawMessageStreamEvent]
         | AsyncMessagesStreamWrapper[None]
     ):
+        _materialize_tools(kwargs)
         invocation = _create_invocation(
             handler, instance, args, kwargs, capture_content
         )
@@ -269,6 +284,7 @@ def traced_method(
         args: tuple[Any, ...],
         kwargs: dict[str, Any],
     ) -> MessagesStreamManagerWrapper[Any]:
+        _materialize_tools(kwargs)
         return MessagesStreamManagerWrapper(
             wrapped(*args, **kwargs),
             lambda: _create_invocation(
@@ -294,6 +310,7 @@ def traced_method(
         args: tuple[Any, ...],
         kwargs: dict[str, Any],
     ) -> AsyncMessagesStreamManagerWrapper[Any]:
+        _materialize_tools(kwargs)
         return AsyncMessagesStreamManagerWrapper(
             wrapped(*args, **kwargs),
             lambda: _create_invocation(

instrumentation/opentelemetry-instrumentation-genai-anthropic/tests/test_async_messages.py

@@ -815,6 +815,58 @@ async def test_async_messages_create_captures_tool_use_content(
     _assert_weather_tool_definitions(span)
 
 
+@pytest.mark.asyncio
+async def test_async_messages_create_tools_generator_reaches_the_sdk(
+    span_exporter, instrument_with_content
+):
+    """Async counterpart: a one-shot ``tools`` iterator must reach the SDK.
+
+    Served by a mock transport rather than a cassette, because the assertion is
+    about the request body the SDK sends.
+    """
+    seen = {}
+
+    def respond(request):
+        seen["body"] = json.loads(request.content)
+        return _http_lib.Response(
+            200,
+            json={
+                "id": "msg_generator",
+                "type": "message",
+                "role": "assistant",
+                "model": "claude-sonnet-4-20250514",
+                "content": [{"type": "text", "text": "ok"}],
+                "stop_reason": "end_turn",
+                "stop_sequence": None,
+                "usage": {"input_tokens": 1, "output_tokens": 1},
+            },
+        )
+
+    client = AsyncAnthropic(
+        api_key="test_anthropic_api_key",
+        base_url="http://anthropic.test",
+        http_client=_http_lib.AsyncClient(
+            transport=_http_lib.MockTransport(respond)
+        ),
+    )
+    try:
+        await client.messages.create(
+            model="claude-sonnet-4-20250514",
+            max_tokens=256,
+            messages=[
+                {"role": "user", "content": "What is the weather in SF?"}
+            ],
+            tools=(tool for tool in [_WEATHER_TOOL]),
+        )
+    finally:
+        await client.close()
+
+    assert seen["body"]["tools"] == [_WEATHER_TOOL]
+    spans = span_exporter.get_finished_spans()
+    assert len(spans) == 1
+    _assert_weather_tool_definitions(spans[0])
+
+
 @pytest.mark.asyncio
 @pytest.mark.vcr()
 @pytest.mark.cassette("test_async_messages_create_captures_tool_use_content")

instrumentation/opentelemetry-instrumentation-genai-anthropic/tests/test_sync_messages.py

@@ -176,6 +176,55 @@ def _load_span_messages(span, attribute):
 }
 
 
+_STREAM_SSE_BODY = b"".join(
+    f"event: {name}\ndata: {json.dumps(payload)}\n\n".encode()
+    for name, payload in (
+        (
+            "message_start",
+            {
+                "type": "message_start",
+                "message": {
+                    "id": "msg_generator",
+                    "type": "message",
+                    "role": "assistant",
+                    "model": "claude-sonnet-4-20250514",
+                    "content": [],
+                    "stop_reason": None,
+                    "stop_sequence": None,
+                    "usage": {"input_tokens": 1, "output_tokens": 1},
+                },
+            },
+        ),
+        (
+            "content_block_start",
+            {
+                "type": "content_block_start",
+                "index": 0,
+                "content_block": {"type": "text", "text": ""},
+            },
+        ),
+        (
+            "content_block_delta",
+            {
+                "type": "content_block_delta",
+                "index": 0,
+                "delta": {"type": "text_delta", "text": "ok"},
+            },
+        ),
+        ("content_block_stop", {"type": "content_block_stop", "index": 0}),
+        (
+            "message_delta",
+            {
+                "type": "message_delta",
+                "delta": {"stop_reason": "end_turn", "stop_sequence": None},
+                "usage": {"output_tokens": 2},
+            },
+        ),
+        ("message_stop", {"type": "message_stop"}),
+    )
+)
+
+
 def _assert_weather_tool_definitions(span):
     assert _load_span_messages(
         span, GenAIAttributes.GEN_AI_TOOL_DEFINITIONS
@@ -1151,6 +1200,87 @@ def test_sync_messages_create_captures_tool_use_content(
     _assert_weather_tool_definitions(span)
 
 
+def test_sync_messages_create_tools_generator_reaches_the_sdk(
+    span_exporter, instrument_with_content
+):
+    """A one-shot ``tools`` iterator must still reach the SDK.
+
+    Served by a mock transport rather than a cassette, because the assertion is
+    about the request body the SDK sends.
+    """
+    seen = {}
+
+    def respond(request):
+        seen["body"] = json.loads(request.content)
+        return httpx.Response(
+            200,
+            json={
+                "id": "msg_generator",
+                "type": "message",
+                "role": "assistant",
+                "model": "claude-sonnet-4-20250514",
+                "content": [{"type": "text", "text": "ok"}],
+                "stop_reason": "end_turn",
+                "stop_sequence": None,
+                "usage": {"input_tokens": 1, "output_tokens": 1},
+            },
+        )
+
+    client = Anthropic(
+        api_key="test_anthropic_api_key",
+        base_url="http://anthropic.test",
+        http_client=httpx.Client(transport=httpx.MockTransport(respond)),
+    )
+    client.messages.create(
+        model="claude-sonnet-4-20250514",
+        max_tokens=256,
+        messages=[{"role": "user", "content": "What is the weather in SF?"}],
+        tools=(tool for tool in [_WEATHER_TOOL]),
+    )
+
+    assert seen["body"]["tools"] == [_WEATHER_TOOL]
+    spans = span_exporter.get_finished_spans()
+    assert len(spans) == 1
+    _assert_weather_tool_definitions(spans[0])
+
+
+def test_sync_messages_stream_tools_generator_is_recorded(
+    span_exporter, instrument_with_content
+):
+    """``stream`` serializes the request before the invocation exists.
+
+    The generator has to be frozen in the wrapper, not while the invocation is
+    built, or the SDK drains it first and the span records no tools.
+    """
+    seen = {}
+
+    def respond(request):
+        seen["body"] = json.loads(request.content)
+        return httpx.Response(
+            200,
+            headers={"content-type": "text/event-stream"},
+            content=_STREAM_SSE_BODY,
+        )
+
+    client = Anthropic(
+        api_key="test_anthropic_api_key",
+        base_url="http://anthropic.test",
+        http_client=httpx.Client(transport=httpx.MockTransport(respond)),
+    )
+    with client.messages.stream(
+        model="claude-sonnet-4-20250514",
+        max_tokens=256,
+        messages=[{"role": "user", "content": "What is the weather in SF?"}],
+        tools=(tool for tool in [_WEATHER_TOOL]),
+    ) as stream:
+        stream.until_done()
+
+    assert seen["body"]["tools"] == [_WEATHER_TOOL]
+    spans = span_exporter.get_finished_spans()
+    assert len(spans) == 1
+    _assert_weather_tool_definitions(spans[0])
+
+
 @pytest.mark.vcr()
 @pytest.mark.cassette("test_sync_messages_create_captures_tool_use_content")
 @pytest.mark.skipif(