Merge branch 'master' into feat/span-first-2

Author: sentrivana

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

@@ -66,7 +66,7 @@ jobs:
           python-version: ${{ matrix.python-version }}
           allow-prereleases: true
       - name: "Setup ClickHouse Server"
-        uses: getsentry/action-clickhouse-in-ci@v1.6
+        uses: getsentry/action-clickhouse-in-ci@v1.7
       - name: Setup Test Env
         run: |
           pip install "coverage[toml]" tox

CHANGELOG.md

@@ -2,19 +2,42 @@
 
 ## 2.52.0a5
 
+This is an alpha release for internal testing of span streaming.
+
+## 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 🔧
 
-- (ci) Improve Craft config with title stripping and artifact filtering by @BYK in [#5444](https://github.com/getsentry/sentry-python/pull/5444)
-- (openai-agents) Avoid calling SDK-internal functions by @alexander-alderman-webb in [#5437](https://github.com/getsentry/sentry-python/pull/5437)
-- Remove references to unsupported attribute types by @alexander-alderman-webb in [#5425](https://github.com/getsentry/sentry-python/pull/5425)
+#### Openai Agents
 
-### Other
+- 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)
 
-- [do not merge] feat: Span streaming & new span API by @sentrivana in [#5317](https://github.com/getsentry/sentry-python/pull/5317)
+#### 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.0a4
 

scripts/populate_tox/package_dependencies.jsonl

@@ -112,7 +112,6 @@ deps =
 
     # AWS Lambda
     aws_lambda: aws-cdk-lib
-    aws_lambda: aws-sam-cli
     aws_lambda: boto3
     aws_lambda: fastapi
     aws_lambda: requests

scripts/populate_tox/releases.jsonl

@@ -51,7 +51,7 @@
 
       {% if needs_clickhouse %}
       - name: "Setup ClickHouse Server"
-        uses: getsentry/action-clickhouse-in-ci@v1.6
+        uses: getsentry/action-clickhouse-in-ci@v1.7
       {% endif %}
 
       {% if needs_redis %}

scripts/populate_tox/tox.jinja

@@ -1,11 +1,17 @@
 from sentry_sdk.integrations import DidNotEnable, Integration
+from sentry_sdk.utils import parse_version
+
+from functools import wraps
 
 from .patches import (
-    _create_get_model_wrapper,
-    _create_get_all_tools_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,
 )
 
@@ -17,11 +23,30 @@
     # after it, even if we don't use it.
     import agents
     from agents.run import DEFAULT_AGENT_RUNNER
+    from agents.run import AgentRunner
+    from agents.version import __version__ as OPENAI_AGENTS_VERSION
 
 except ImportError:
     raise DidNotEnable("OpenAI Agents not installed")
 
 
+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, 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:
     # Create the root span for one full agent run (including eventual handoffs)
     # Note agents.run.DEFAULT_AGENT_RUNNER.run_sync is a wrapper around
@@ -35,21 +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),
-    )
-
-
-def _patch_tools() -> None:
-    agents.run.AgentRunner._get_all_tools = classmethod(
-        _create_get_all_tools_wrapper(agents.run.AgentRunner._get_all_tools),
-    )
-
 
 class OpenAIAgentsIntegration(Integration):
     """
@@ -66,23 +76,168 @@ 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()`.
-        - 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 `_create_get_all_tools_wrapper()` called via `_patch_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()`.
+        - 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 `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_tools()
-        _patch_model()
         _patch_runner()
+
+        library_version = parse_version(OPENAI_AGENTS_VERSION)
+        if library_version is not None and library_version >= (
+            0,
+            8,
+        ):
+
+            @wraps(run_loop.get_all_tools)
+            async def new_wrapped_get_all_tools(
+                agent: "agents.Agent",
+                context_wrapper: "agents.RunContextWrapper",
+            ) -> "list[agents.Tool]":
+                return await _get_all_tools(
+                    run_loop.get_all_tools, agent, context_wrapper
+                )
+
+            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
+
+        @wraps(AgentRunner._get_all_tools.__func__)
+        async def old_wrapped_get_all_tools(
+            cls: "agents.Runner",
+            agent: "agents.Agent",
+            context_wrapper: "agents.RunContextWrapper",
+        ) -> "list[agents.Tool]":
+            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
+        )

scripts/split_tox_gh_actions/templates/test_group.jinja

@@ -1,5 +1,10 @@
-from .models import _create_get_model_wrapper  # noqa: F401
-from .tools import _create_get_all_tools_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