openai-agents 0.4.1__tar.gz → 0.4.2__tar.gz

{openai_agents-0.4.1 → openai_agents-0.4.2}/.github/workflows/tests.yml

@@ -22,6 +22,8 @@ jobs:
           enable-cache: true
       - name: Install dependencies
         run: make sync
+      - name: Verify formatting
+        run: make format-check
       - name: Run lint
         run: make lint
 

{openai_agents-0.4.1 → openai_agents-0.4.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: openai-agents
-Version: 0.4.1
+Version: 0.4.2
 Summary: OpenAI Agents SDK
 Project-URL: Homepage, https://openai.github.io/openai-agents-python/
 Project-URL: Repository, https://github.com/openai/openai-agents-python
@@ -44,7 +44,7 @@ Requires-Dist: numpy<3,>=2.2.0; (python_version >= '3.10') and extra == 'voice'
 Requires-Dist: websockets<16,>=15.0; extra == 'voice'
 Description-Content-Type: text/markdown
 
-# OpenAI Agents SDK
+# OpenAI Agents SDK [![PyPI](https://img.shields.io/pypi/v/openai-agents?label=pypi%20package)](https://pypi.org/project/openai-agents/)
 
 The OpenAI Agents SDK is a lightweight yet powerful framework for building multi-agent workflows. It is provider-agnostic, supporting the OpenAI Responses and Chat Completions APIs, as well as 100+ other LLMs.
 

{openai_agents-0.4.1 → openai_agents-0.4.2}/README.md

@@ -1,4 +1,4 @@
-# OpenAI Agents SDK
+# OpenAI Agents SDK [![PyPI](https://img.shields.io/pypi/v/openai-agents?label=pypi%20package)](https://pypi.org/project/openai-agents/)
 
 The OpenAI Agents SDK is a lightweight yet powerful framework for building multi-agent workflows. It is provider-agnostic, supporting the OpenAI Responses and Chat Completions APIs, as well as 100+ other LLMs.
 

{openai_agents-0.4.1 → openai_agents-0.4.2}/examples/realtime/app/agent.py

@@ -1,3 +1,5 @@
+import asyncio
+
 from agents import function_tool
 from agents.extensions.handoff_prompt import RECOMMENDED_PROMPT_PREFIX
 from agents.realtime import RealtimeAgent, realtime_handoff
@@ -13,20 +15,26 @@ will use the agent returned from get_starting_agent() as the starting agent."""
     name_override="faq_lookup_tool", description_override="Lookup frequently asked questions."
 )
 async def faq_lookup_tool(question: str) -> str:
-    if "bag" in question or "baggage" in question:
+    print("faq_lookup_tool called with question:", question)
+
+    # Simulate a slow API call
+    await asyncio.sleep(3)
+
+    q = question.lower()
+    if "wifi" in q or "wi-fi" in q:
+        return "We have free wifi on the plane, join Airline-Wifi"
+    elif "bag" in q or "baggage" in q:
         return (
             "You are allowed to bring one bag on the plane. "
             "It must be under 50 pounds and 22 inches x 14 inches x 9 inches."
         )
-    elif "seats" in question or "plane" in question:
+    elif "seats" in q or "plane" in q:
         return (
             "There are 120 seats on the plane. "
             "There are 22 business class seats and 98 economy seats. "
             "Exit rows are rows 4 and 16. "
             "Rows 5-8 are Economy Plus, with extra legroom. "
         )
-    elif "wifi" in question:
-        return "We have free wifi on the plane, join Airline-Wifi"
     return "I'm sorry, I don't know the answer to that question."
 
 

{openai_agents-0.4.1 → openai_agents-0.4.2}/examples/realtime/app/server.py

@@ -47,6 +47,9 @@ class RealtimeWebSocketManager:
 
         agent = get_starting_agent()
         runner = RealtimeRunner(agent)
+        # If you want to customize the runner behavior, you can pass options:
+        # runner_config = RealtimeRunConfig(async_tool_calls=False)
+        # runner = RealtimeRunner(agent, config=runner_config)
         model_config: RealtimeModelConfig = {
             "initial_model_settings": {
                 "turn_detection": {

{openai_agents-0.4.1 → openai_agents-0.4.2}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "openai-agents"
-version = "0.4.1"
+version = "0.4.2"
 description = "OpenAI Agents SDK"
 readme = "README.md"
 requires-python = ">=3.9"

{openai_agents-0.4.1 → openai_agents-0.4.2}/src/agents/extensions/models/litellm_model.py

@@ -110,18 +110,26 @@ class LitellmModel(Model):
                 prompt=prompt,
             )
 
-            assert isinstance(response.choices[0], litellm.types.utils.Choices)
+            message: litellm.types.utils.Message | None = None
+            first_choice: litellm.types.utils.Choices | None = None
+            if response.choices and len(response.choices) > 0:
+                choice = response.choices[0]
+                if isinstance(choice, litellm.types.utils.Choices):
+                    first_choice = choice
+                    message = first_choice.message
 
             if _debug.DONT_LOG_MODEL_DATA:
                 logger.debug("Received model response")
             else:
-                logger.debug(
-                    f"""LLM resp:\n{
-                        json.dumps(
-                            response.choices[0].message.model_dump(), indent=2, ensure_ascii=False
-                        )
-                    }\n"""
-                )
+                if message is not None:
+                    logger.debug(
+                        f"""LLM resp:\n{
+                            json.dumps(message.model_dump(), indent=2, ensure_ascii=False)
+                        }\n"""
+                    )
+                else:
+                    finish_reason = first_choice.finish_reason if first_choice else "-"
+                    logger.debug(f"LLM resp had no message. finish_reason: {finish_reason}")
 
             if hasattr(response, "usage"):
                 response_usage = response.usage
@@ -152,14 +160,20 @@ class LitellmModel(Model):
                 logger.warning("No usage information returned from Litellm")
 
             if tracing.include_data():
-                span_generation.span_data.output = [response.choices[0].message.model_dump()]
+                span_generation.span_data.output = (
+                    [message.model_dump()] if message is not None else []
+                )
             span_generation.span_data.usage = {
                 "input_tokens": usage.input_tokens,
                 "output_tokens": usage.output_tokens,
             }
 
-            items = Converter.message_to_output_items(
-                LitellmConverter.convert_message_to_openai(response.choices[0].message)
+            items = (
+                Converter.message_to_output_items(
+                    LitellmConverter.convert_message_to_openai(message)
+                )
+                if message is not None
+                else []
             )
 
             return ModelResponse(
@@ -326,6 +340,23 @@ class LitellmModel(Model):
             )
 
         reasoning_effort = model_settings.reasoning.effort if model_settings.reasoning else None
+        # Enable developers to pass non-OpenAI compatible reasoning_effort data like "none"
+        # Priority order:
+        #  1. model_settings.reasoning.effort
+        #  2. model_settings.extra_body["reasoning_effort"]
+        #  3. model_settings.extra_args["reasoning_effort"]
+        if (
+            reasoning_effort is None  # Unset in model_settings
+            and isinstance(model_settings.extra_body, dict)
+            and "reasoning_effort" in model_settings.extra_body
+        ):
+            reasoning_effort = model_settings.extra_body["reasoning_effort"]
+        if (
+            reasoning_effort is None  # Unset in both model_settings and model_settings.extra_body
+            and model_settings.extra_args
+            and "reasoning_effort" in model_settings.extra_args
+        ):
+            reasoning_effort = model_settings.extra_args["reasoning_effort"]
 
         stream_options = None
         if stream and model_settings.include_usage is not None:
@@ -343,6 +374,9 @@ class LitellmModel(Model):
         if model_settings.extra_args:
             extra_kwargs.update(model_settings.extra_args)
 
+        # Prevent duplicate reasoning_effort kwargs when it was promoted to a top-level argument.
+        extra_kwargs.pop("reasoning_effort", None)
+
         ret = await litellm.acompletion(
             model=self.model,
             messages=converted_messages,

{openai_agents-0.4.1 → openai_agents-0.4.2}/src/agents/models/chatcmpl_stream_handler.py

@@ -150,6 +150,12 @@ class ChatCmplStreamHandler:
                     )
 
                 if reasoning_content and state.reasoning_content_index_and_output:
+                    # Ensure summary list has at least one element
+                    if not state.reasoning_content_index_and_output[1].summary:
+                        state.reasoning_content_index_and_output[1].summary = [
+                            Summary(text="", type="summary_text")
+                        ]
+
                     yield ResponseReasoningSummaryTextDeltaEvent(
                         delta=reasoning_content,
                         item_id=FAKE_RESPONSES_ID,
@@ -201,7 +207,7 @@ class ChatCmplStreamHandler:
                     )
 
                     # Create a new summary with updated text
-                    if state.reasoning_content_index_and_output[1].content is None:
+                    if not state.reasoning_content_index_and_output[1].content:
                         state.reasoning_content_index_and_output[1].content = [
                             Content(text="", type="reasoning_text")
                         ]

{openai_agents-0.4.1 → openai_agents-0.4.2}/src/agents/realtime/config.py

@@ -184,6 +184,9 @@ class RealtimeRunConfig(TypedDict):
     tracing_disabled: NotRequired[bool]
     """Whether tracing is disabled for this run."""
 
+    async_tool_calls: NotRequired[bool]
+    """Whether function tool calls should run asynchronously. Defaults to True."""
+
     # TODO (rm) Add history audio storage config
 
 

{openai_agents-0.4.1 → openai_agents-0.4.2}/src/agents/realtime/session.py

@@ -112,7 +112,7 @@ class RealtimeSession(RealtimeModelListener):
         }
         self._event_queue: asyncio.Queue[RealtimeSessionEvent] = asyncio.Queue()
         self._closed = False
-        self._stored_exception: Exception | None = None
+        self._stored_exception: BaseException | None = None
 
         # Guardrails state tracking
         self._interrupted_response_ids: set[str] = set()
@@ -123,6 +123,8 @@ class RealtimeSession(RealtimeModelListener):
         )
 
         self._guardrail_tasks: set[asyncio.Task[Any]] = set()
+        self._tool_call_tasks: set[asyncio.Task[Any]] = set()
+        self._async_tool_calls: bool = bool(self._run_config.get("async_tool_calls", True))
 
     @property
     def model(self) -> RealtimeModel:
@@ -216,7 +218,11 @@ class RealtimeSession(RealtimeModelListener):
         if event.type == "error":
             await self._put_event(RealtimeError(info=self._event_info, error=event.error))
         elif event.type == "function_call":
-            await self._handle_tool_call(event)
+            agent_snapshot = self._current_agent
+            if self._async_tool_calls:
+                self._enqueue_tool_call_task(event, agent_snapshot)
+            else:
+                await self._handle_tool_call(event, agent_snapshot=agent_snapshot)
         elif event.type == "audio":
             await self._put_event(
                 RealtimeAudio(
@@ -384,11 +390,17 @@ class RealtimeSession(RealtimeModelListener):
         """Put an event into the queue."""
         await self._event_queue.put(event)
 
-    async def _handle_tool_call(self, event: RealtimeModelToolCallEvent) -> None:
+    async def _handle_tool_call(
+        self,
+        event: RealtimeModelToolCallEvent,
+        *,
+        agent_snapshot: RealtimeAgent | None = None,
+    ) -> None:
         """Handle a tool call event."""
+        agent = agent_snapshot or self._current_agent
         tools, handoffs = await asyncio.gather(
-            self._current_agent.get_all_tools(self._context_wrapper),
-            self._get_handoffs(self._current_agent, self._context_wrapper),
+            agent.get_all_tools(self._context_wrapper),
+            self._get_handoffs(agent, self._context_wrapper),
         )
         function_map = {tool.name: tool for tool in tools if isinstance(tool, FunctionTool)}
         handoff_map = {handoff.tool_name: handoff for handoff in handoffs}
@@ -398,7 +410,7 @@ class RealtimeSession(RealtimeModelListener):
                 RealtimeToolStart(
                     info=self._event_info,
                     tool=function_map[event.name],
-                    agent=self._current_agent,
+                    agent=agent,
                 )
             )
 
@@ -423,7 +435,7 @@ class RealtimeSession(RealtimeModelListener):
                     info=self._event_info,
                     tool=func_tool,
                     output=result,
-                    agent=self._current_agent,
+                    agent=agent,
                 )
             )
         elif event.name in handoff_map:
@@ -444,7 +456,7 @@ class RealtimeSession(RealtimeModelListener):
                 )
 
             # Store previous agent for event
-            previous_agent = self._current_agent
+            previous_agent = agent
 
             # Update current agent
             self._current_agent = result
@@ -752,10 +764,49 @@ class RealtimeSession(RealtimeModelListener):
                 task.cancel()
         self._guardrail_tasks.clear()
 
+    def _enqueue_tool_call_task(
+        self, event: RealtimeModelToolCallEvent, agent_snapshot: RealtimeAgent
+    ) -> None:
+        """Run tool calls in the background to avoid blocking realtime transport."""
+        task = asyncio.create_task(self._handle_tool_call(event, agent_snapshot=agent_snapshot))
+        self._tool_call_tasks.add(task)
+        task.add_done_callback(self._on_tool_call_task_done)
+
+    def _on_tool_call_task_done(self, task: asyncio.Task[Any]) -> None:
+        self._tool_call_tasks.discard(task)
+
+        if task.cancelled():
+            return
+
+        exception = task.exception()
+        if exception is None:
+            return
+
+        logger.exception("Realtime tool call task failed", exc_info=exception)
+
+        if self._stored_exception is None:
+            self._stored_exception = exception
+
+        asyncio.create_task(
+            self._put_event(
+                RealtimeError(
+                    info=self._event_info,
+                    error={"message": f"Tool call task failed: {exception}"},
+                )
+            )
+        )
+
+    def _cleanup_tool_call_tasks(self) -> None:
+        for task in self._tool_call_tasks:
+            if not task.done():
+                task.cancel()
+        self._tool_call_tasks.clear()
+
     async def _cleanup(self) -> None:
         """Clean up all resources and mark session as closed."""
         # Cancel and cleanup guardrail tasks
         self._cleanup_guardrail_tasks()
+        self._cleanup_tool_call_tasks()
 
         # Remove ourselves as a listener
         self._model.remove_listener(self)

{openai_agents-0.4.1 → openai_agents-0.4.2}/tests/models/test_kwargs_functionality.py

@@ -176,3 +176,41 @@ async def test_empty_kwargs_handling(monkeypatch):
 
     # Should work without error and include regular parameters
     assert captured["temperature"] == 0.3
+
+
+@pytest.mark.allow_call_model_methods
+@pytest.mark.asyncio
+async def test_reasoning_effort_falls_back_to_extra_args(monkeypatch):
+    """
+    Ensure reasoning_effort from extra_args is promoted when reasoning settings are missing.
+    """
+    captured: dict[str, object] = {}
+
+    async def fake_acompletion(model, messages=None, **kwargs):
+        captured.update(kwargs)
+        msg = Message(role="assistant", content="test response")
+        choice = Choices(index=0, message=msg)
+        return ModelResponse(choices=[choice], usage=Usage(0, 0, 0))
+
+    monkeypatch.setattr(litellm, "acompletion", fake_acompletion)
+
+    # GitHub issue context: https://github.com/openai/openai-agents-python/issues/1764.
+    settings = ModelSettings(
+        extra_args={"reasoning_effort": "none", "custom_param": "custom_value"}
+    )
+    model = LitellmModel(model="test-model")
+
+    await model.get_response(
+        system_instructions=None,
+        input="test input",
+        model_settings=settings,
+        tools=[],
+        output_schema=None,
+        handoffs=[],
+        tracing=ModelTracing.DISABLED,
+        previous_response_id=None,
+    )
+
+    assert captured["reasoning_effort"] == "none"
+    assert captured["custom_param"] == "custom_value"
+    assert settings.extra_args == {"reasoning_effort": "none", "custom_param": "custom_value"}

openai_agents-0.4.2/tests/models/test_litellm_extra_body.py

@@ -0,0 +1,157 @@
+import litellm
+import pytest
+from litellm.types.utils import Choices, Message, ModelResponse, Usage
+
+from agents.extensions.models.litellm_model import LitellmModel
+from agents.model_settings import ModelSettings
+from agents.models.interface import ModelTracing
+
+
+@pytest.mark.allow_call_model_methods
+@pytest.mark.asyncio
+async def test_extra_body_is_forwarded(monkeypatch):
+    """
+    Forward `extra_body` entries into litellm.acompletion kwargs.
+
+    This ensures that user-provided parameters (e.g. cached_content)
+    arrive alongside default arguments.
+    """
+    captured: dict[str, object] = {}
+
+    async def fake_acompletion(model, messages=None, **kwargs):
+        captured.update(kwargs)
+        msg = Message(role="assistant", content="ok")
+        choice = Choices(index=0, message=msg)
+        return ModelResponse(choices=[choice], usage=Usage(0, 0, 0))
+
+    monkeypatch.setattr(litellm, "acompletion", fake_acompletion)
+    settings = ModelSettings(
+        temperature=0.1, extra_body={"cached_content": "some_cache", "foo": 123}
+    )
+    model = LitellmModel(model="test-model")
+
+    await model.get_response(
+        system_instructions=None,
+        input=[],
+        model_settings=settings,
+        tools=[],
+        output_schema=None,
+        handoffs=[],
+        tracing=ModelTracing.DISABLED,
+        previous_response_id=None,
+    )
+
+    assert {"cached_content": "some_cache", "foo": 123}.items() <= captured.items()
+
+
+@pytest.mark.allow_call_model_methods
+@pytest.mark.asyncio
+async def test_extra_body_reasoning_effort_is_promoted(monkeypatch):
+    """
+    Ensure reasoning_effort from extra_body is promoted to the top-level parameter.
+    """
+    captured: dict[str, object] = {}
+
+    async def fake_acompletion(model, messages=None, **kwargs):
+        captured.update(kwargs)
+        msg = Message(role="assistant", content="ok")
+        choice = Choices(index=0, message=msg)
+        return ModelResponse(choices=[choice], usage=Usage(0, 0, 0))
+
+    monkeypatch.setattr(litellm, "acompletion", fake_acompletion)
+    # GitHub issue context: https://github.com/openai/openai-agents-python/issues/1764.
+    settings = ModelSettings(
+        extra_body={"reasoning_effort": "none", "cached_content": "some_cache"}
+    )
+    model = LitellmModel(model="test-model")
+
+    await model.get_response(
+        system_instructions=None,
+        input=[],
+        model_settings=settings,
+        tools=[],
+        output_schema=None,
+        handoffs=[],
+        tracing=ModelTracing.DISABLED,
+        previous_response_id=None,
+    )
+
+    assert captured["reasoning_effort"] == "none"
+    assert captured["cached_content"] == "some_cache"
+    assert settings.extra_body == {"reasoning_effort": "none", "cached_content": "some_cache"}
+
+
+@pytest.mark.allow_call_model_methods
+@pytest.mark.asyncio
+async def test_reasoning_effort_prefers_model_settings(monkeypatch):
+    """
+    Verify explicit ModelSettings.reasoning takes precedence over extra_body entries.
+    """
+    from openai.types.shared import Reasoning
+
+    captured: dict[str, object] = {}
+
+    async def fake_acompletion(model, messages=None, **kwargs):
+        captured.update(kwargs)
+        msg = Message(role="assistant", content="ok")
+        choice = Choices(index=0, message=msg)
+        return ModelResponse(choices=[choice], usage=Usage(0, 0, 0))
+
+    monkeypatch.setattr(litellm, "acompletion", fake_acompletion)
+    settings = ModelSettings(
+        reasoning=Reasoning(effort="low"),
+        extra_body={"reasoning_effort": "high"},
+    )
+    model = LitellmModel(model="test-model")
+
+    await model.get_response(
+        system_instructions=None,
+        input=[],
+        model_settings=settings,
+        tools=[],
+        output_schema=None,
+        handoffs=[],
+        tracing=ModelTracing.DISABLED,
+        previous_response_id=None,
+    )
+
+    assert captured["reasoning_effort"] == "low"
+    assert settings.extra_body == {"reasoning_effort": "high"}
+
+
+@pytest.mark.allow_call_model_methods
+@pytest.mark.asyncio
+async def test_extra_body_reasoning_effort_overrides_extra_args(monkeypatch):
+    """
+    Ensure extra_body reasoning_effort wins over extra_args when both are provided.
+    """
+    captured: dict[str, object] = {}
+
+    async def fake_acompletion(model, messages=None, **kwargs):
+        captured.update(kwargs)
+        msg = Message(role="assistant", content="ok")
+        choice = Choices(index=0, message=msg)
+        return ModelResponse(choices=[choice], usage=Usage(0, 0, 0))
+
+    monkeypatch.setattr(litellm, "acompletion", fake_acompletion)
+    # GitHub issue context: https://github.com/openai/openai-agents-python/issues/1764.
+    settings = ModelSettings(
+        extra_body={"reasoning_effort": "none"},
+        extra_args={"reasoning_effort": "low", "custom_param": "custom"},
+    )
+    model = LitellmModel(model="test-model")
+
+    await model.get_response(
+        system_instructions=None,
+        input=[],
+        model_settings=settings,
+        tools=[],
+        output_schema=None,
+        handoffs=[],
+        tracing=ModelTracing.DISABLED,
+        previous_response_id=None,
+    )
+
+    assert captured["reasoning_effort"] == "none"
+    assert captured["custom_param"] == "custom"
+    assert settings.extra_args == {"reasoning_effort": "low", "custom_param": "custom"}

{openai_agents-0.4.1 → openai_agents-0.4.2}/tests/realtime/test_openai_realtime.py

@@ -518,9 +518,7 @@ class TestSendEventAndConfig(TestOpenAIRealtimeWebSocketModel):
         model._ongoing_response = True
         model._created_session = SimpleNamespace(
             audio=SimpleNamespace(
-                input=SimpleNamespace(
-                    turn_detection=SimpleNamespace(interrupt_response=True)
-                )
+                input=SimpleNamespace(turn_detection=SimpleNamespace(interrupt_response=True))
             )
         )
 
@@ -545,9 +543,7 @@ class TestSendEventAndConfig(TestOpenAIRealtimeWebSocketModel):
         model._ongoing_response = True
         model._created_session = SimpleNamespace(
             audio=SimpleNamespace(
-                input=SimpleNamespace(
-                    turn_detection=SimpleNamespace(interrupt_response=True)
-                )
+                input=SimpleNamespace(turn_detection=SimpleNamespace(interrupt_response=True))
             )
         )
 

{openai_agents-0.4.1 → openai_agents-0.4.2}/tests/realtime/test_session.py

@@ -561,8 +561,13 @@ class TestEventHandling:
 
     @pytest.mark.asyncio
     async def test_function_call_event_triggers_tool_handling(self, mock_model, mock_agent):
-        """Test that function_call events trigger tool call handling"""
-        session = RealtimeSession(mock_model, mock_agent, None)
+        """Test that function_call events trigger tool call handling synchronously when disabled"""
+        session = RealtimeSession(
+            mock_model,
+            mock_agent,
+            None,
+            run_config={"async_tool_calls": False},
+        )
 
         # Create function call event
         function_call_event = RealtimeModelToolCallEvent(
@@ -578,7 +583,9 @@ class TestEventHandling:
             await session.on_event(function_call_event)
 
             # Should have called the tool handler
-            handle_tool_call_mock.assert_called_once_with(function_call_event)
+            handle_tool_call_mock.assert_called_once_with(
+                function_call_event, agent_snapshot=mock_agent
+            )
 
             # Should still have raw event
             assert session._event_queue.qsize() == 1
@@ -586,6 +593,36 @@ class TestEventHandling:
             assert isinstance(raw_event, RealtimeRawModelEvent)
             assert raw_event.data == function_call_event
 
+    @pytest.mark.asyncio
+    async def test_function_call_event_runs_async_by_default(self, mock_model, mock_agent):
+        """Function call handling should be scheduled asynchronously by default"""
+        session = RealtimeSession(mock_model, mock_agent, None)
+
+        function_call_event = RealtimeModelToolCallEvent(
+            name="test_function",
+            call_id="call_async",
+            arguments='{"param": "value"}',
+        )
+
+        with pytest.MonkeyPatch().context() as m:
+            handle_tool_call_mock = AsyncMock()
+            m.setattr(session, "_handle_tool_call", handle_tool_call_mock)
+
+            await session.on_event(function_call_event)
+
+            # Let the background task run
+            await asyncio.sleep(0)
+
+            handle_tool_call_mock.assert_awaited_once_with(
+                function_call_event, agent_snapshot=mock_agent
+            )
+
+        # Raw event still enqueued
+        assert session._event_queue.qsize() == 1
+        raw_event = await session._event_queue.get()
+        assert isinstance(raw_event, RealtimeRawModelEvent)
+        assert raw_event.data == function_call_event
+
 
 class TestHistoryManagement:
     """Test suite for history management and audio transcription in

{openai_agents-0.4.1 → openai_agents-0.4.2}/uv.lock

@@ -1877,7 +1877,7 @@ wheels = [
 
 [[package]]
 name = "openai-agents"
-version = "0.4.1"
+version = "0.4.2"
 source = { editable = "." }
 dependencies = [
     { name = "griffe" },