pyagentic-core 2.2.1a1__tar.gz → 2.2.2__tar.gz

{pyagentic_core-2.2.1a1 → pyagentic_core-2.2.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: pyagentic-core
-Version: 2.2.1a1
+Version: 2.2.2
 Summary: Build LLM Agents in a Pythonic way
 Author-email: Ryan Mikulec <rmikulec.dev@gmail.com>
 License: MIT

{pyagentic_core-2.2.1a1 → pyagentic_core-2.2.2}/pyagentic/_base/_agent/_agent.py

@@ -1,5 +1,6 @@
 import inspect
 import json
+import asyncio
 from functools import wraps
 from typing import (
     Callable,
@@ -560,24 +561,43 @@ class BaseAgent(metaclass=AgentMeta):
                     self.state._messages.append(Message(role="assistant", content=response.text))
                     break
 
-                # Execute all tool/agent calls from this response
+                tasks = []
+
+                async def wrap(kind: str, tool_call, coro):
+                    """Run the coroutine and attach metadata."""
+                    result = await coro
+                    return kind, tool_call, result
+
                 for tool_call in response.tool_calls:
-                    # Skip if we've already processed this call (prevents duplicates)
                     if tool_call.id and tool_call.id in processed_call_ids:
                         continue
 
                     processed_call_ids.add(tool_call.id)
 
-                    # Route to either @tool methods or linked agents
                     if tool_call.name in self.__tool_defs__:
-                        result = await self._process_tool_call(tool_call, call_depth=depth)
-                        tool_responses.append(result)
-                        yield result
+                        coro = self._process_tool_call(tool_call, call_depth=depth)
+                        kind = "tool"
 
                     elif tool_call.name in self.__linked_agents__:
-                        result = await self._process_agent_call(tool_call)
+                        coro = self._process_agent_call(tool_call)
+                        kind = "agent"
+
+                    else:
+                        continue
+
+                    task = asyncio.create_task(wrap(kind, tool_call, coro))
+                    tasks.append(task)
+
+                # Process tasks as they *finish*, not in original order
+                for task in asyncio.as_completed(tasks):
+                    kind, tool_call, result = await task
+
+                    if kind == "tool":
+                        tool_responses.append(result)
+                    else:
                         agent_responses.append(result)
-                        yield result
+
+                    yield result
 
                 # Increment depth and continue loop (LLM will see tool results next iteration)
                 depth += 1

{pyagentic_core-2.2.1a1 → pyagentic_core-2.2.2}/pyagentic/_base/_agent/_agent_state.py

@@ -26,7 +26,6 @@ class _AgentState(BaseModel):
         ("on", EventKind.SET): "on_set",
         ("background", EventKind.SET): "background_set",
     }
-    _state_lock: ClassVar[threading.Lock] = PrivateAttr(default_factory=threading.Lock)
     __policies__: ClassVar[dict[str, list[Policy]]]
 
     instructions: str
@@ -61,15 +60,18 @@ class _AgentState(BaseModel):
         self._machine = machine
 
     def _update_state_machine(self, phases):
-        for to_, from_, condition in phases:
-            if condition(self):
-                trigger = f"{to_}_to_{from_}"
-                getattr(self._machine, trigger)()
+        for source, dest, condition in phases:
+            with self._state_lock:
+                if condition(self) and self.phase == source:
+                    trigger = f"{source}_to_{dest}"
+                    getattr(self._machine, trigger)()
 
     def model_post_init(self, state):
         self._instructions_template = Template(source=self.instructions)
         if self.input_template:
             self._input_template = Template(source=self.input_template)
+
+        self._state_lock = threading.Lock()
         return super().model_post_init(state)
 
     def get_policies(self, state_name: str) -> list[Policy]:
@@ -208,7 +210,8 @@ class _AgentState(BaseModel):
         event = SetEvent(name=name, previous=previous, value=value)
         final_value = self._run_policies(event, "on")
 
-        setattr(self, name, final_value)
+        with self._state_lock:
+            setattr(self, name, final_value)
         asyncio.create_task(self._dispatch_policies(event, "background"))
 
     @classmethod

{pyagentic_core-2.2.1a1 → pyagentic_core-2.2.2}/pyagentic_core.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: pyagentic-core
-Version: 2.2.1a1
+Version: 2.2.2
 Summary: Build LLM Agents in a Pythonic way
 Author-email: Ryan Mikulec <rmikulec.dev@gmail.com>
 License: MIT

{pyagentic_core-2.2.1a1 → pyagentic_core-2.2.2}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "pyagentic-core"
-version = "2.2.1-a.1"
+version = "2.2.2"
 description = "Build LLM Agents in a Pythonic way"
 readme = "README.md"
 requires-python = ">=3.13"