fix(uagents): support event loop init on Python 3.14

python/src/uagents/agent.py

@@ -94,6 +94,41 @@
 from uagents.utils import get_logger, set_global_log_level
 
 
+def _default_event_loop(
+    loop: asyncio.AbstractEventLoop | None,
+) -> asyncio.AbstractEventLoop:
+    """Resolve the event loop for Agent/Bureau construction.
+
+    Agent and Bureau need a loop during synchronous __init__ (ASGIServer, create_task).
+    Historically, asyncio.get_event_loop() implicitly created a main-thread loop when none
+    existed (Python 3.10-3.13). Python 3.14+ raises RuntimeError instead.
+
+    Order: honor explicit loop=, reuse the thread's loop if set and open, else create one
+    and register it via set_event_loop() so later get_event_loop() calls on this thread work.
+    If the thread default exists but is closed (e.g. after Agent.run()), create a new loop.
+    """
+    if loop is not None:
+        return loop
+    try:
+        existing = asyncio.get_event_loop()
+    except RuntimeError:
+        existing = None
+    if existing is None or existing.is_closed():
+        new_loop = asyncio.new_event_loop()
+        asyncio.set_event_loop(new_loop)
+        return new_loop
+    return existing
+
+
+def _clear_thread_loop_default(closed_loop: asyncio.AbstractEventLoop) -> None:
+    """Clear the thread default if it still references a loop we just closed."""
+    try:
+        if asyncio.get_event_loop() is closed_loop:
+            asyncio.set_event_loop(None)
+    except RuntimeError:
+        pass
+
+
 async def _run_interval(
     func: IntervalCallback,
     logger: logging.Logger,
@@ -355,7 +390,8 @@ def __init__(
         self._name = name
         self._port = port or 8000
 
-        self._loop = loop or asyncio.get_event_loop_policy().get_event_loop()
+        # See _default_event_loop: required at init time, not only in run() (Python 3.14+).
+        self._loop = _default_event_loop(loop)
 
         # initialize wallet and identity
         self._initialize_wallet_and_identity(seed, name, wallet_key_derivation_index)
@@ -1338,6 +1374,7 @@ def run(self):
             if not self._loop.is_closed():
                 self._loop.stop()
                 self._loop.close()
+            _clear_thread_loop_default(self._loop)
 
     def get_message_protocol(
         self, message_schema_digest
@@ -1572,7 +1609,8 @@ def __init__(
             log_level (int | str): The logging level for the bureau.
             shutdown_timeout (int): The timeout for shutting down the bureau.
         """
-        self._loop = loop or asyncio.get_event_loop_policy().get_event_loop()
+        # See _default_event_loop: same Python 3.14+ loop resolution as Agent.
+        self._loop = _default_event_loop(loop)
         self._agents: list[Agent] = []
         self._port = port or 8000
         self._queries: dict[str, asyncio.Future] = {}
@@ -1836,3 +1874,4 @@ def run(self):
             if not self._loop.is_closed():
                 self._loop.stop()
                 self._loop.close()
+            _clear_thread_loop_default(self._loop)

python/tests/test_agent.py

@@ -1,8 +1,10 @@
 # pylint: disable=protected-access
+import asyncio
 import unittest
 from collections.abc import Callable
 
 from uagents import Agent, Context, Model
+from uagents.agent import _default_event_loop
 from uagents.resolver import GlobalResolver
 from uagents.types import RestHandlerDetails
 
@@ -28,6 +30,44 @@ class Response(Model):
 )
 
 
+class TestDefaultEventLoop(unittest.TestCase):
+    def setUp(self) -> None:
+        try:
+            self._previous_loop = asyncio.get_event_loop()
+        except RuntimeError:
+            self._previous_loop = None
+        self._test_loop: asyncio.AbstractEventLoop | None = None
+
+    def tearDown(self) -> None:
+        if self._test_loop is not None and not self._test_loop.is_closed():
+            self._test_loop.close()
+        if self._previous_loop is not None and not self._previous_loop.is_closed():
+            asyncio.set_event_loop(self._previous_loop)
+        else:
+            asyncio.set_event_loop(None)
+
+    def test_returns_explicit_loop(self) -> None:
+        explicit = asyncio.new_event_loop()
+        self.assertIs(_default_event_loop(explicit), explicit)
+        explicit.close()
+
+    def test_creates_loop_when_thread_has_none(self) -> None:
+        asyncio.set_event_loop(None)
+        result = _default_event_loop(None)
+        self._test_loop = result
+        self.assertFalse(result.is_closed())
+        self.assertIs(asyncio.get_event_loop(), result)
+
+    def test_replaces_closed_thread_loop(self) -> None:
+        closed = asyncio.new_event_loop()
+        closed.close()
+        asyncio.set_event_loop(closed)
+        result = _default_event_loop(None)
+        self._test_loop = result
+        self.assertFalse(result.is_closed())
+        self.assertIsNot(result, closed)
+
+
 class TestAgent(unittest.TestCase):
     def setUp(self) -> None:
         self.agent = alice

python/tests/test_bureau.py

@@ -1,9 +1,10 @@
-import asyncio
+# pylint: disable=protected-access
 import unittest
 
 from cosmpy.aerial.wallet import LocalWallet
 
 from uagents import Agent, Bureau
+from uagents.agent import _default_event_loop
 from uagents.registration import (
     AgentEndpoint,
     BatchLedgerRegistrationPolicy,
@@ -22,8 +23,11 @@
 
 class TestBureau(unittest.IsolatedAsyncioTestCase):
     def setUp(self) -> None:
-        self.loop = asyncio.get_event_loop()
-        return super().setUp()
+        # Obtain a loop before super().setUp() so agents can use loop=self.loop.
+        # Use production helper (3.14-safe, replaces closed thread loops after run()).
+        # Do not use get_running_loop(): IsolatedAsyncioTestCase has not started yet.
+        self.loop = _default_event_loop(None)
+        super().setUp()
 
     def test_bureau_updates_agents_no_ledger_batch(self):
         alice = Agent(name="alice", endpoint=ALICE_ENDPOINT.url, loop=self.loop)