pyagentic-core 2.2.0a2__tar.gz → 2.2.1__tar.gz

{pyagentic_core-2.2.0a2 → pyagentic_core-2.2.1}/PKG-INFO

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

{pyagentic_core-2.2.0a2 → pyagentic_core-2.2.1}/pyagentic/_base/_agent/_agent.py

@@ -1,6 +1,5 @@
 import inspect
 import json
-import asyncio
 from functools import wraps
 from typing import (
     Callable,
@@ -463,8 +462,10 @@ class BaseAgent(metaclass=AgentMeta):
 
         # Add all @tool decorated methods
         for tool_def in self.__tool_defs__.values():
+            if tool_def.condition:
+                if not tool_def.condition(self.state):
+                    continue
             # Resolve StateRefs in parameters (e.g., ref.self.user_name -> actual value)
-
             if self.phases and tool_def.phases:
                 if self.state.phase in tool_def.phases:
                     tool_defs.append(tool_def.resolve(self.agent_reference))
@@ -473,8 +474,18 @@ class BaseAgent(metaclass=AgentMeta):
 
         # Add linked agents as tools
         for name, linked_def in self.__linked_agents__.items():
-            tool_def = linked_def.agent.get_tool_definition(name)
-            tool_defs.append(tool_def.resolve(self.agent_reference))
+
+            if linked_def.info.condition:
+                if not linked_def.info.condition(self.state):
+                    continue
+
+            if self.phases and linked_def.info.phases:
+                if self.state.phase in linked_def.info.phases:
+                    tool_def = linked_def.agent.get_tool_definition(name)
+                    tool_defs.append(tool_def.resolve(self.agent_reference))
+            else:
+                tool_def = linked_def.agent.get_tool_definition(name)
+                tool_defs.append(tool_def.resolve(self.agent_reference))
 
         return tool_defs
 
@@ -549,43 +560,24 @@ class BaseAgent(metaclass=AgentMeta):
                     self.state._messages.append(Message(role="assistant", content=response.text))
                     break
 
-                tasks = []
-
-                async def wrap(kind: str, tool_call, coro):
-                    """Run the coroutine and attach metadata."""
-                    result = await coro
-                    return kind, tool_call, result
-
+                # Execute all tool/agent calls from this response
                 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__:
-                        coro = self._process_tool_call(tool_call, call_depth=depth)
-                        kind = "tool"
+                        result = await self._process_tool_call(tool_call, call_depth=depth)
+                        tool_responses.append(result)
+                        yield result
 
                     elif tool_call.name in self.__linked_agents__:
-                        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:
+                        result = await self._process_agent_call(tool_call)
                         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.0a2 → pyagentic_core-2.2.1}/pyagentic/_base/_agent/_agent_state.py

@@ -26,6 +26,7 @@ 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,17 +62,14 @@ class _AgentState(BaseModel):
 
     def _update_state_machine(self, phases):
         for to_, from_, condition in phases:
-            with self._state_lock:
-                if condition(self) and self.phase == from_:
-                    trigger = f"{to_}_to_{from_}"
-                    getattr(self._machine, trigger)()
+            if condition(self):
+                trigger = f"{to_}_to_{from_}"
+                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]:
@@ -210,8 +208,7 @@ class _AgentState(BaseModel):
         event = SetEvent(name=name, previous=previous, value=value)
         final_value = self._run_policies(event, "on")
 
-        with self._state_lock:
-            setattr(self, name, final_value)
+        setattr(self, name, final_value)
         asyncio.create_task(self._dispatch_policies(event, "background"))
 
     @classmethod

{pyagentic_core-2.2.0a2 → pyagentic_core-2.2.1}/pyagentic/_base/_info.py

@@ -45,6 +45,7 @@ class AgentInfo(_SpecInfo):
     """
 
     condition: MaybeRef[Callable] | None = None
+    phases: list[str] | None = None
 
 
 @dataclass

{pyagentic_core-2.2.0a2 → pyagentic_core-2.2.1}/pyagentic/_base/_spec.py

@@ -117,7 +117,10 @@ class spec:
 
     @staticmethod
     def AgentLink(
-        default: Any = None, default_factory: Callable = None, condition: Callable = None
+        default: Any = None,
+        default_factory: Callable = None,
+        condition: Callable = None,
+        phases: list[str] | None = None,
     ) -> AgentInfo:
         """
         Creates an AgentInfo descriptor for configuring linked agent fields.
@@ -126,8 +129,12 @@ class spec:
             default (Any, optional): The default agent instance
             default_factory (Callable, optional): A factory function to generate the default agent
             condition (Callable, optional): A callable determining when this agent link is active
+            phases (list[str], optional): A list of phases of when this agent will be available.
+                When None, will show for all phases. Defaults to None.
 
         Returns:
             AgentInfo: A configured AgentInfo descriptor
         """
-        return AgentInfo(default=default, default_factory=default_factory, condition=condition)
+        return AgentInfo(
+            default=default, default_factory=default_factory, condition=condition, phases=phases
+        )

{pyagentic_core-2.2.0a2 → pyagentic_core-2.2.1}/pyagentic_core.egg-info/PKG-INFO

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

{pyagentic_core-2.2.0a2 → pyagentic_core-2.2.1}/pyproject.toml

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