fix: improve run_sync's python 3.14 compatibility

src/agents/run.py

@@ -3,6 +3,7 @@
 import asyncio
 import inspect
 import os
+import warnings
 from dataclasses import dataclass, field
 from typing import Any, Callable, Generic, cast, get_args
 
@@ -720,19 +721,37 @@ def run_sync(
         conversation_id = kwargs.get("conversation_id")
         session = kwargs.get("session")
 
-        # Python 3.14 no longer creates a default loop implicitly, so we inspect the running loop.
+        # Python 3.14 stopped implicitly wiring up a default event loop
+        # when synchronous code touches asyncio APIs for the first time.
+        # Several of our synchronous entry points (for example the Redis/SQLAlchemy session helpers)
+        # construct asyncio primitives like asyncio.Lock during __init__,
+        # which binds them to whatever loop happens to be the thread's default at that moment.
+        # To keep those locks usable we must ensure that run_sync reuses that same default loop
+        # instead of hopping over to a brand-new asyncio.run() loop.
         try:
-            loop = asyncio.get_running_loop()
+            already_running_loop = asyncio.get_running_loop()
         except RuntimeError:
-            loop = None
+            already_running_loop = None
 
-        if loop is not None:
+        if already_running_loop is not None:
             # This method is only expected to run when no loop is already active.
             raise RuntimeError(
                 "AgentRunner.run_sync() cannot be called when an event loop is already running."
             )
 
-        return asyncio.run(
+        policy = asyncio.get_event_loop_policy()
+        with warnings.catch_warnings():
+            warnings.simplefilter("ignore", DeprecationWarning)
+            try:
+                default_loop = policy.get_event_loop()
+            except RuntimeError:
+                default_loop = policy.new_event_loop()
+                policy.set_event_loop(default_loop)
+
+        # We intentionally leave the default loop open even if we had to create one above. Session
+        # instances and other helpers stash loop-bound primitives between calls and expect to find
+        # the same default loop every time run_sync is invoked on this thread.
+        return default_loop.run_until_complete(
             self.run(
                 starting_agent,
                 input,

tests/test_agent_runner_sync.py

@@ -0,0 +1,73 @@
+import asyncio
+from collections.abc import Generator
+
+import pytest
+
+from agents.run import AgentRunner
+
+
+@pytest.fixture
+def fresh_event_loop_policy() -> Generator[asyncio.AbstractEventLoopPolicy, None, None]:
+    policy_before = asyncio.get_event_loop_policy()
+    new_policy = asyncio.DefaultEventLoopPolicy()
+    asyncio.set_event_loop_policy(new_policy)
+    try:
+        yield new_policy
+    finally:
+        asyncio.set_event_loop_policy(policy_before)
+
+
+def test_run_sync_reuses_existing_default_loop(monkeypatch, fresh_event_loop_policy):
+    runner = AgentRunner()
+    observed_loops: list[asyncio.AbstractEventLoop] = []
+
+    async def fake_run(self, *_args, **_kwargs):
+        observed_loops.append(asyncio.get_running_loop())
+        return object()
+
+    monkeypatch.setattr(AgentRunner, "run", fake_run, raising=False)
+
+    test_loop = asyncio.new_event_loop()
+    fresh_event_loop_policy.set_event_loop(test_loop)
+
+    try:
+        runner.run_sync(object(), "input")
+        assert observed_loops and observed_loops[0] is test_loop
+    finally:
+        fresh_event_loop_policy.set_event_loop(None)
+        test_loop.close()
+
+
+def test_run_sync_creates_default_loop_when_missing(monkeypatch, fresh_event_loop_policy):
+    runner = AgentRunner()
+    observed_loops: list[asyncio.AbstractEventLoop] = []
+
+    async def fake_run(self, *_args, **_kwargs):
+        observed_loops.append(asyncio.get_running_loop())
+        return object()
+
+    monkeypatch.setattr(AgentRunner, "run", fake_run, raising=False)
+
+    fresh_event_loop_policy.set_event_loop(None)
+
+    runner.run_sync(object(), "input")
+    created_loop = observed_loops[0]
+    assert created_loop is fresh_event_loop_policy.get_event_loop()
+
+    fresh_event_loop_policy.set_event_loop(None)
+    created_loop.close()
+
+
+def test_run_sync_errors_when_loop_already_running(monkeypatch, fresh_event_loop_policy):
+    runner = AgentRunner()
+
+    async def fake_run(self, *_args, **_kwargs):
+        return object()
+
+    monkeypatch.setattr(AgentRunner, "run", fake_run, raising=False)
+
+    async def invoke():
+        with pytest.raises(RuntimeError):
+            runner.run_sync(object(), "input")
+
+    asyncio.run(invoke())