fix: OpenAI Types Normalized with Cast

There were a few assumptions being made about openai types
in the tests and the openai wrappers that raised linting errors.
Some of these errors were rightly raised, especially around streaming
types, and have been patched.

Author: iamemilio

instrumentation-genai/opentelemetry-instrumentation-openai-v2/src/opentelemetry/instrumentation/openai_v2/patch.py

@@ -15,10 +15,9 @@
 
 import asyncio
 import inspect
+from collections.abc import AsyncIterator, Iterator
 from timeit import default_timer
-from typing import Any, Optional
-
-from openai import Stream
+from typing import Any, Optional, cast
 
 from opentelemetry._logs import Logger, LogRecord
 from opentelemetry.context import get_current
@@ -537,7 +536,7 @@ class StreamWrapper:
 
     def __init__(
         self,
-        stream: Stream,
+        stream: Iterator[Any] | AsyncIterator[Any],
         span: Span,
         logger: Logger,
         capture_content: bool,
@@ -663,14 +662,18 @@ async def __aexit__(self, exc_type, exc_val, exc_tb):
 
     def close(self):
         try:
-            close_result = self.stream.close()
+            close_fn = getattr(self.stream, "close", None)
+            if not callable(close_fn):
+                return
+
+            close_result = close_fn()
             if inspect.isawaitable(close_result):
                 try:
                     loop = asyncio.get_running_loop()
                 except RuntimeError:
-                    asyncio.run(close_result)
+                    asyncio.run(cast(Any, close_result))
                 else:
-                    loop.create_task(close_result)
+                    loop.create_task(cast(Any, close_result))
         finally:
             self.cleanup()
 
@@ -682,7 +685,7 @@ def __aiter__(self):
 
     def __next__(self):
         try:
-            chunk = next(self.stream)
+            chunk = next(cast(Iterator[Any], self.stream))
             self.process_chunk(chunk)
             return chunk
         except StopIteration:
@@ -695,7 +698,7 @@ def __next__(self):
 
     async def __anext__(self):
         try:
-            chunk = await self.stream.__anext__()  # type: ignore[attr-defined]
+            chunk = await anext(cast(AsyncIterator[Any], self.stream))
             self.process_chunk(chunk)
             return chunk
         except StopAsyncIteration:

instrumentation-genai/opentelemetry-instrumentation-openai-v2/src/opentelemetry/instrumentation/openai_v2/responses.py

@@ -107,7 +107,7 @@ def _create_log_record(
     event_name: str, body: Mapping[str, Any] | None
 ) -> LogRecord:
     return LogRecord(
-        event_name=event_name,  # type: ignore[call-arg]
+        event_name=event_name,
         attributes=_GEN_AI_SYSTEM_ATTRIBUTES,
         body=dict(body) if body else None,
     )

instrumentation-genai/opentelemetry-instrumentation-openai-v2/src/opentelemetry/instrumentation/openai_v2/responses_patch.py

@@ -276,7 +276,7 @@ def _emit_output_log(self) -> None:
         context = set_span_in_context(self.span, get_current())
         self.logger.emit(
             LogRecord(
-                event_name="gen_ai.output",  # type: ignore[call-arg]
+                event_name="gen_ai.output",
                 attributes={
                     GenAIAttributes.GEN_AI_SYSTEM: GenAIAttributes.GenAiSystemValues.OPENAI.value
                 },
@@ -340,7 +340,7 @@ def __aiter__(self):
 
     async def __anext__(self):
         try:
-            event = await self.stream.__anext__()  # type: ignore[attr-defined]
+            event = await self.stream.__anext__()
             self._process_event(event)
             return event
         except StopAsyncIteration:

instrumentation-genai/opentelemetry-instrumentation-openai-v2/src/opentelemetry/instrumentation/openai_v2/utils.py

@@ -173,7 +173,7 @@ def set_span_attributes(span, attributes):
     but tests may pass dicts or other lightweight objects.
     """
     if hasattr(attributes, "model_dump"):
-        for field, value in attributes.model_dump(by_alias=True).items():  # type: ignore[attr-defined]
+        for field, value in attributes.model_dump(by_alias=True).items():
             set_span_attribute(span, field, value)
         return
 

instrumentation-genai/opentelemetry-instrumentation-openai-v2/tests/test_responses.py

@@ -74,7 +74,7 @@ def test_responses_basic_with_content(
     # First log should be the input message
     input_log = logs[0]
     assert input_log.log_record.event_name == "gen_ai.user.input"
-    assert input_log.log_record.body["content"] == input_text  # type: ignore[index]
+    assert input_log.log_record.body["content"] == input_text
     assert_log_parent(input_log, span)
 
     output_logs = [

instrumentation-genai/opentelemetry-instrumentation-openai-v2/tests/test_responses_handlers.py

@@ -15,9 +15,11 @@
 """Resilience tests for Responses input/output conversion helpers."""
 
 from dataclasses import dataclass
-from typing import Any, Optional
+from typing import Any, Optional, cast
 
 import pytest
+from openai.types.responses import ResponseOutputItem
+from openai.types.responses import ResponseInputItemParam
 
 from opentelemetry.instrumentation.openai_v2.responses import (
     output_to_event,
@@ -26,6 +28,7 @@
 from opentelemetry.instrumentation.openai_v2.responses_patch import (
     _log_responses_inputs,
 )
+from opentelemetry._logs import Logger
 
 
 @dataclass
@@ -49,6 +52,13 @@ def emit(self, record: Any) -> None:
         self.emitted.append(record)
 
 
+def _as_output_item(value: Any) -> ResponseOutputItem:
+    # These tests intentionally pass minimal "shape-only" objects to exercise
+    # resilience for new/unknown output types. Cast keeps type-checkers happy
+    # without weakening the production signature.
+    return cast(ResponseOutputItem, value)
+
+
 @pytest.mark.parametrize(
     "input_data",
     [
@@ -145,10 +155,16 @@ def emit(self, record: Any) -> None:
 def test_input_type_handler_does_not_crash(input_data):
     """Each known input type should be processed without exceptions."""
     assert (
-        responses_input_to_event(input_data, capture_content=True) is not None
+        responses_input_to_event(
+            cast(ResponseInputItemParam, input_data), capture_content=True
+        )
+        is not None
     )
     assert (
-        responses_input_to_event(input_data, capture_content=False) is not None
+        responses_input_to_event(
+            cast(ResponseInputItemParam, input_data), capture_content=False
+        )
+        is not None
     )
 
 
@@ -166,19 +182,19 @@ def test_string_input_does_not_crash():
 def test_responses_create_input_none_is_noop_for_logging():
     logger = _CapturingLogger()
 
-    _log_responses_inputs(logger, {"input": None}, capture_content=True)
-    _log_responses_inputs(logger, {"input": None}, capture_content=False)
+    _log_responses_inputs(cast(Logger, logger), {"input": None}, capture_content=True)
+    _log_responses_inputs(cast(Logger, logger), {"input": None}, capture_content=False)
 
-    assert logger.emitted == []
+    assert not logger.emitted
 
 
 def test_responses_create_input_omitted_is_noop_for_logging():
     logger = _CapturingLogger()
 
-    _log_responses_inputs(logger, {}, capture_content=True)
-    _log_responses_inputs(logger, {}, capture_content=False)
+    _log_responses_inputs(cast(Logger, logger), {}, capture_content=True)
+    _log_responses_inputs(cast(Logger, logger), {}, capture_content=False)
 
-    assert logger.emitted == []
+    assert not logger.emitted
 
 
 @pytest.mark.parametrize(
@@ -204,7 +220,9 @@ def test_responses_create_input_omitted_is_noop_for_logging():
 )
 def test_unexpected_input_does_not_crash(unexpected_input):
     # Should not raise
-    responses_input_to_event(unexpected_input, capture_content=True)
+    responses_input_to_event(
+        cast(ResponseInputItemParam, unexpected_input), capture_content=True
+    )
 
 
 def test_deeply_nested_content_does_not_crash():
@@ -222,7 +240,9 @@ def test_deeply_nested_content_does_not_crash():
         ],
     }
     assert (
-        responses_input_to_event(nested_input, capture_content=True)
+        responses_input_to_event(
+            cast(ResponseInputItemParam, nested_input), capture_content=True
+        )
         is not None
     )
 
@@ -240,29 +260,37 @@ def test_future_union_types_are_best_effort():
         "name": "some_tool",
         "arguments": {"x": 1},
     }
-    event = responses_input_to_event(future_call, capture_content=True)
+    event = responses_input_to_event(
+        cast(ResponseInputItemParam, future_call), capture_content=True
+    )
     assert event is not None
     assert event.event_name == "gen_ai.assistant.input"
-    assert event.body and event.body.get("type") == "future_provider_tool_call"
+    body: Any = event.body
+    assert body and body.get("type") == "future_provider_tool_call"
 
     # New tool call output (tool -> model): routed by `*_call_output`
     future_call_output = {
         "type": "future_provider_tool_call_output",
         "call_id": "call_123",
         "output": "ok",
     }
-    event = responses_input_to_event(future_call_output, capture_content=True)
+    event = responses_input_to_event(
+        cast(ResponseInputItemParam, future_call_output), capture_content=True
+    )
     assert event is not None
     assert event.event_name == "gen_ai.tool.input"
-    assert event.body and event.body.get("id") == "call_123"
+    body = event.body
+    assert body and body.get("id") == "call_123"
 
     # Another output naming style: routed by `*_output`
     future_output_alt = {
         "type": "future_provider_tool_output",
         "id": "id_999",
         "output": [{"type": "text", "text": "ok"}],
     }
-    event = responses_input_to_event(future_output_alt, capture_content=True)
+    event = responses_input_to_event(
+        cast(ResponseInputItemParam, future_output_alt), capture_content=True
+    )
     assert event is not None
     assert event.event_name == "gen_ai.tool.input"
 
@@ -279,8 +307,14 @@ class MockOutput:
         content = [ContentPart()]
         index = 0
 
-    assert output_to_event(MockOutput(), capture_content=True) is not None  # type: ignore[arg-type]
-    assert output_to_event(MockOutput(), capture_content=False) is not None  # type: ignore[arg-type]
+    assert (
+        output_to_event(_as_output_item(MockOutput()), capture_content=True)
+        is not None
+    )
+    assert (
+        output_to_event(_as_output_item(MockOutput()), capture_content=False)
+        is not None
+    )
 
 
 def test_function_call_output_does_not_crash():
@@ -292,7 +326,10 @@ class MockOutput:
         status = "completed"
         index = 0
 
-    assert output_to_event(MockOutput(), capture_content=True) is not None  # type: ignore[arg-type]
+    assert (
+        output_to_event(_as_output_item(MockOutput()), capture_content=True)
+        is not None
+    )
 
 
 def test_reasoning_output_does_not_crash():
@@ -306,7 +343,10 @@ class MockOutput:
         status = "completed"
         summary = [Part()]
 
-    assert output_to_event(MockOutput(), capture_content=True) is not None  # type: ignore[arg-type]
+    assert (
+        output_to_event(_as_output_item(MockOutput()), capture_content=True)
+        is not None
+    )
 
 
 @pytest.mark.parametrize(
@@ -328,7 +368,7 @@ def test_tool_call_outputs_do_not_crash(output_type):
         name="tool_name",
         status="completed",
     )
-    assert output_to_event(mock, capture_content=True) is not None  # type: ignore[arg-type]
+    assert output_to_event(_as_output_item(mock), capture_content=True) is not None
 
 
 def test_unknown_output_type_does_not_crash():
@@ -337,14 +377,20 @@ class MockOutput:
         id = "id_123"
         status = "completed"
 
-    assert output_to_event(MockOutput(), capture_content=True) is not None  # type: ignore[arg-type]
+    assert (
+        output_to_event(_as_output_item(MockOutput()), capture_content=True)
+        is not None
+    )
 
 
 def test_minimal_output_does_not_crash():
     class MockOutput:
         type = "message"
 
-    assert output_to_event(MockOutput(), capture_content=True) is not None  # type: ignore[arg-type]
+    assert (
+        output_to_event(_as_output_item(MockOutput()), capture_content=True)
+        is not None
+    )
 
 
 def test_output_with_none_values_does_not_crash():
@@ -355,4 +401,7 @@ class MockOutput:
         content = None
         index = None
 
-    assert output_to_event(MockOutput(), capture_content=True) is not None  # type: ignore[arg-type]
+    assert (
+        output_to_event(_as_output_item(MockOutput()), capture_content=True)
+        is not None
+    )