Merge branch 'master' into py-2071-get-driver-type-from-broker-url

Author: ericapisani

.github/workflows/test-integrations-flags.yml

@@ -32,7 +32,7 @@ jobs:
     strategy:
       fail-fast: false
       matrix:
-        python-version: ["3.7","3.8","3.9","3.12","3.13","3.14","3.14t"]
+        python-version: ["3.7","3.8","3.9","3.10","3.12","3.13","3.14","3.14t"]
         # python3.6 reached EOL and is no longer being supported on
         # new versions of hosted runners on Github Actions
         # ubuntu-20.04 is the last version that supported python3.6

.gitignore

@@ -29,6 +29,7 @@ pip-wheel-metadata
 .mypy_cache
 .vscode/
 .claude/
+.serena
 .tool-versions
 
 # for running AWS Lambda tests using AWS SAM

CHANGELOG.md

@@ -1,5 +1,40 @@
 # Changelog
 
+## 2.53.0
+
+### Bug Fixes 🐛
+
+#### Openai Agents
+
+- Patch `execute_final_output()` functions following library refactor by @alexander-alderman-webb in [#5453](https://github.com/getsentry/sentry-python/pull/5453)
+- Patch `execute_handoffs()` functions following library refactor by @alexander-alderman-webb in [#5452](https://github.com/getsentry/sentry-python/pull/5452)
+- Patch `run_single_turn_streamed()` functions following library refactor by @alexander-alderman-webb in [#5451](https://github.com/getsentry/sentry-python/pull/5451)
+- Patch `run_single_turn()` functions following library refactor by @alexander-alderman-webb in [#5450](https://github.com/getsentry/sentry-python/pull/5450)
+- Patch models functions following library refactor by @alexander-alderman-webb in [#5449](https://github.com/getsentry/sentry-python/pull/5449)
+- Patch tool functions following library refactor by @alexander-alderman-webb in [#5445](https://github.com/getsentry/sentry-python/pull/5445)
+
+#### Other
+
+- Close the connection we're reading driver_type from by @sentrivana in [#5427](https://github.com/getsentry/sentry-python/pull/5427)
+
+### Documentation 📚
+
+- Document `openai-agents` control-flow by @alexander-alderman-webb in [#5447](https://github.com/getsentry/sentry-python/pull/5447)
+
+### Internal Changes 🔧
+
+#### Openai Agents
+
+- New tool field and library error log by @alexander-alderman-webb in [#5454](https://github.com/getsentry/sentry-python/pull/5454)
+- Avoid calling SDK-internal functions by @alexander-alderman-webb in [#5437](https://github.com/getsentry/sentry-python/pull/5437)
+
+#### Other
+
+- Improve Craft config with title stripping and artifact filtering by @BYK in [#5444](https://github.com/getsentry/sentry-python/pull/5444)
+- Use fixed clickhouse action, remove aws-sam-cli dependency by @sentrivana in [#5457](https://github.com/getsentry/sentry-python/pull/5457)
+- Remove references to unsupported attribute types by @alexander-alderman-webb in [#5425](https://github.com/getsentry/sentry-python/pull/5425)
+- Pin setuptools for linting and chalice tests by @alexander-alderman-webb in [#5438](https://github.com/getsentry/sentry-python/pull/5438)
+
 ## 2.52.0
 
 ### New Features ✨

docs/conf.py

@@ -31,7 +31,7 @@
 copyright = "2019-{}, Sentry Team and Contributors".format(datetime.now().year)
 author = "Sentry Team and Contributors"
 
-release = "2.52.0"
+release = "2.53.0"
 version = ".".join(release.split(".")[:2])  # The short X.Y version.
 
 

scripts/populate_tox/package_dependencies.jsonl

@@ -1490,4 +1490,4 @@ def _get_default_options() -> "dict[str, Any]":
 del _get_default_options
 
 
-VERSION = "2.52.0"
+VERSION = "2.53.0"

scripts/populate_tox/releases.jsonl

@@ -4,11 +4,14 @@
 from functools import wraps
 
 from .patches import (
-    _create_get_model_wrapper,
+    _get_model,
     _get_all_tools,
+    _run_single_turn,
+    _run_single_turn_streamed,
+    _execute_handoffs,
     _create_run_wrapper,
     _create_run_streamed_wrapper,
-    _patch_agent_run,
+    _execute_final_output,
     _patch_error_tracing,
 )
 
@@ -30,9 +33,18 @@
 try:
     # AgentRunner methods moved in v0.8
     # https://github.com/openai/openai-agents-python/commit/3ce7c24d349b77bb750062b7e0e856d9ff48a5d5#diff-7470b3a5c5cbe2fcbb2703dc24f326f45a5819d853be2b1f395d122d278cd911
-    from agents.run_internal import run_loop
+    from agents.run_internal import run_loop, turn_preparation, turn_resolution
 except ImportError:
     run_loop = None
+    turn_preparation = None
+    turn_resolution = None
+
+from typing import TYPE_CHECKING
+
+if TYPE_CHECKING:
+    from typing import Any
+
+    from agents.run_internal.run_steps import SingleStepResult
 
 
 def _patch_runner() -> None:
@@ -48,15 +60,6 @@ def _patch_runner() -> None:
         agents.run.DEFAULT_AGENT_RUNNER.run_streamed
     )
 
-    # Creating the actual spans for each agent run (works for both streaming and non-streaming).
-    _patch_agent_run()
-
-
-def _patch_model() -> None:
-    agents.run.AgentRunner._get_model = classmethod(
-        _create_get_model_wrapper(agents.run.AgentRunner._get_model),
-    )
-
 
 class OpenAIAgentsIntegration(Integration):
     """
@@ -73,24 +76,23 @@ class OpenAIAgentsIntegration(Integration):
         - `Runner.run()` and `Runner.run_streamed()` are thin wrappers for `DEFAULT_AGENT_RUNNER.run()` and `DEFAULT_AGENT_RUNNER.run_streamed()`.
         - `DEFAULT_AGENT_RUNNER.run()` and `DEFAULT_AGENT_RUNNER.run_streamed()` are patched in `_patch_runner()` with `_create_run_wrapper()` and `_create_run_streamed_wrapper()`, respectively.
     3. In a loop, the agent repeatedly calls the Responses API, maintaining a conversation history that includes previous messages and tool results, which is passed to each call.
-        - A Model instance is created at the start of the loop by calling the `Runner._get_model()`. We patch the Model instance using `_create_get_model_wrapper()` in `_patch_model()`.
+        - A Model instance is created at the start of the loop by calling the `Runner._get_model()`. We patch the Model instance using `patches._get_model()`.
         - Available tools are also deteremined at the start of the loop, with `Runner._get_all_tools()`. We patch Tool instances by iterating through the returned tools in `patches._get_all_tools()`.
-        - In each loop iteration, `run_single_turn()` or `run_single_turn_streamed()` is responsible for calling the Responses API, patched with `patched_run_single_turn()` and `patched_run_single_turn_streamed()`.
-    4. On loop termination, `RunImpl.execute_final_output()` is called. The function is patched with `patched_execute_final_output()`.
+        - In each loop iteration, `run_single_turn()` or `run_single_turn_streamed()` is responsible for calling the Responses API, patched with `patches._run_single_turn()` and `patches._run_single_turn_streamed()`.
+    4. On loop termination, `RunImpl.execute_final_output()` is called. The function is patched with `patches._execute_final_output()`.
 
     Local tools are run based on the return value from the Responses API as a post-API call step in the above loop.
     Hosted MCP Tools are run as part of the Responses API call, and involve OpenAI reaching out to an external MCP server.
     An agent can handoff to another agent, also directed by the return value of the Responses API and run post-API call in the loop.
     Handoffs are a way to switch agent-wide configuration.
-    - Handoffs are executed by calling `RunImpl.execute_handoffs()`. The method is patched in `patched_execute_handoffs()`
+    - Handoffs are executed by calling `RunImpl.execute_handoffs()`. The method is patched with `patches._execute_handoffs()`
     """
 
     identifier = "openai_agents"
 
     @staticmethod
     def setup_once() -> None:
         _patch_error_tracing()
-        _patch_model()
         _patch_runner()
 
         library_version = parse_version(OPENAI_AGENTS_VERSION)
@@ -109,6 +111,61 @@ async def new_wrapped_get_all_tools(
                 )
 
             agents.run.get_all_tools = new_wrapped_get_all_tools
+
+            @wraps(turn_preparation.get_model)
+            def new_wrapped_get_model(
+                agent: "agents.Agent", run_config: "agents.RunConfig"
+            ) -> "agents.Model":
+                return _get_model(turn_preparation.get_model, agent, run_config)
+
+            agents.run_internal.run_loop.get_model = new_wrapped_get_model
+
+            @wraps(run_loop.run_single_turn)
+            async def new_wrapped_run_single_turn(
+                *args: "Any", **kwargs: "Any"
+            ) -> "SingleStepResult":
+                return await _run_single_turn(run_loop.run_single_turn, *args, **kwargs)
+
+            agents.run.run_single_turn = new_wrapped_run_single_turn
+
+            @wraps(run_loop.run_single_turn_streamed)
+            async def new_wrapped_run_single_turn_streamed(
+                *args: "Any", **kwargs: "Any"
+            ) -> "SingleStepResult":
+                return await _run_single_turn_streamed(
+                    run_loop.run_single_turn_streamed, *args, **kwargs
+                )
+
+            agents.run.run_single_turn_streamed = new_wrapped_run_single_turn_streamed
+
+            original_execute_handoffs = turn_resolution.execute_handoffs
+
+            @wraps(original_execute_handoffs)
+            async def new_wrapped_execute_handoffs(
+                *args: "Any", **kwargs: "Any"
+            ) -> "SingleStepResult":
+                return await _execute_handoffs(
+                    original_execute_handoffs, *args, **kwargs
+                )
+
+            agents.run_internal.turn_resolution.execute_handoffs = (
+                new_wrapped_execute_handoffs
+            )
+
+            original_execute_final_output = turn_resolution.execute_final_output
+
+            @wraps(turn_resolution.execute_final_output)
+            async def new_wrapped_final_output(
+                *args: "Any", **kwargs: "Any"
+            ) -> "SingleStepResult":
+                return await _execute_final_output(
+                    original_execute_final_output, *args, **kwargs
+                )
+
+            agents.run_internal.turn_resolution.execute_final_output = (
+                new_wrapped_final_output
+            )
+
             return
 
         original_get_all_tools = AgentRunner._get_all_tools
@@ -122,3 +179,65 @@ async def old_wrapped_get_all_tools(
             return await _get_all_tools(original_get_all_tools, agent, context_wrapper)
 
         agents.run.AgentRunner._get_all_tools = classmethod(old_wrapped_get_all_tools)
+
+        original_get_model = AgentRunner._get_model
+
+        @wraps(AgentRunner._get_model.__func__)
+        def old_wrapped_get_model(
+            cls: "agents.Runner", agent: "agents.Agent", run_config: "agents.RunConfig"
+        ) -> "agents.Model":
+            return _get_model(original_get_model, agent, run_config)
+
+        agents.run.AgentRunner._get_model = classmethod(old_wrapped_get_model)
+
+        original_run_single_turn = AgentRunner._run_single_turn
+
+        @wraps(AgentRunner._run_single_turn.__func__)
+        async def old_wrapped_run_single_turn(
+            cls: "agents.Runner", *args: "Any", **kwargs: "Any"
+        ) -> "SingleStepResult":
+            return await _run_single_turn(original_run_single_turn, *args, **kwargs)
+
+        agents.run.AgentRunner._run_single_turn = classmethod(
+            old_wrapped_run_single_turn
+        )
+
+        original_run_single_turn_streamed = AgentRunner._run_single_turn_streamed
+
+        @wraps(AgentRunner._run_single_turn_streamed.__func__)
+        async def old_wrapped_run_single_turn_streamed(
+            cls: "agents.Runner", *args: "Any", **kwargs: "Any"
+        ) -> "SingleStepResult":
+            return await _run_single_turn_streamed(
+                original_run_single_turn_streamed, *args, **kwargs
+            )
+
+        agents.run.AgentRunner._run_single_turn_streamed = classmethod(
+            old_wrapped_run_single_turn_streamed
+        )
+
+        original_execute_handoffs = agents._run_impl.RunImpl.execute_handoffs
+
+        @wraps(agents._run_impl.RunImpl.execute_handoffs.__func__)
+        async def old_wrapped_execute_handoffs(
+            cls: "agents.Runner", *args: "Any", **kwargs: "Any"
+        ) -> "SingleStepResult":
+            return await _execute_handoffs(original_execute_handoffs, *args, **kwargs)
+
+        agents._run_impl.RunImpl.execute_handoffs = classmethod(
+            old_wrapped_execute_handoffs
+        )
+
+        original_execute_final_output = agents._run_impl.RunImpl.execute_final_output
+
+        @wraps(agents._run_impl.RunImpl.execute_final_output.__func__)
+        async def old_wrapped_final_output(
+            cls: "agents.Runner", *args: "Any", **kwargs: "Any"
+        ) -> "SingleStepResult":
+            return await _execute_final_output(
+                original_execute_final_output, *args, **kwargs
+            )
+
+        agents._run_impl.RunImpl.execute_final_output = classmethod(
+            old_wrapped_final_output
+        )

sentry_sdk/consts.py

@@ -1,5 +1,10 @@
-from .models import _create_get_model_wrapper  # noqa: F401
+from .models import _get_model  # noqa: F401
 from .tools import _get_all_tools  # noqa: F401
 from .runner import _create_run_wrapper, _create_run_streamed_wrapper  # noqa: F401
-from .agent_run import _patch_agent_run  # noqa: F401
+from .agent_run import (
+    _run_single_turn,
+    _run_single_turn_streamed,
+    _execute_handoffs,
+    _execute_final_output,
+)  # noqa: F401
 from .error_tracing import _patch_error_tracing  # noqa: F401