pyagentic-core 2.2.0a1__tar.gz → 2.2.0a2__tar.gz

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

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

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

@@ -1,5 +1,6 @@
 import inspect
 import json
+import asyncio
 from functools import wraps
 from typing import (
     Callable,
@@ -169,7 +170,6 @@ class BaseAgent(metaclass=AgentMeta):
     phases: ClassVar[list[tuple[str, str, Callable]]] = None
 
     # Generated Class Attributes (built by metaclass)
-    __machine__: Machine | None = None
     __response_model__: ClassVar[Type[AgentResponse]] = None  # Pydantic response model
     __state_class__: ClassVar[Type[_AgentState]] = None  # Generated state class
     __tool_response_models__: ClassVar[dict[str, Type[ToolResponse]]]  # Tool response models
@@ -232,34 +232,6 @@ class BaseAgent(metaclass=AgentMeta):
         if self.__tool_defs__ and not self.provider.__supports_tool_calls__:
             raise Exception("Tools are not supported with this provider")
 
-    def _build_phase_machine(self) -> Machine:
-        if not self.phases:
-            return None
-
-        states = []
-        for to_, from_, _ in self.phases:
-            if to_ not in states:
-                states.append(to_)
-            if from_ not in states:
-                states.append(from_)
-
-        machine = Machine(states=states, initial=states[0])
-
-        for to_, from_, _ in self.phases:
-            machine.add_transition(
-                trigger=f"{to_}_to_{from_}",
-                source=to_,
-                dest=from_,
-            )
-
-        return machine
-
-    def _update_state_machine(self):
-        for to_, from_, condition in self.phases:
-            if condition(self.state):
-                trigger = f"{to_}_to_{from_}"
-                getattr(self.__machine__, trigger)()
-
     def __post_init__(self):
         """
         Post-initialization hook called after agent instance is created.
@@ -281,7 +253,9 @@ class BaseAgent(metaclass=AgentMeta):
             ```
         """
         self._check_llm_provider()
-        self.__machine__ = self._build_phase_machine()
+
+        if self.phases:
+            self.state._build_phase_machine(self.phases)
 
         # Use BasicTracer as default if no tracer provided
         if not self.tracer:
@@ -347,7 +321,14 @@ class BaseAgent(metaclass=AgentMeta):
             self.state._messages.append(
                 Message(role="assistant", content="Failed to generate a response")
             )
-            return LLMResponse(text=f"The LLM failed to generate a response: {e}", tool_calls=[])
+            response = LLMResponse(
+                text=f"The LLM failed to generate a response: {e}", tool_calls=[]
+            )
+
+        if self.phases:
+            self.state._update_state_machine(phases=self.phases)
+
+        return response
 
     @traced(SpanKind.AGENT)
     async def _process_agent_call(self, tool_call: ToolCall) -> AgentResponse:
@@ -394,6 +375,8 @@ class BaseAgent(metaclass=AgentMeta):
         self.state._messages.append(
             self.provider.to_tool_call_result_message(result=stringified_result, id_=tool_call.id)
         )
+        if self.phases:
+            self.state._update_state_machine(phases=self.phases)
         return response
 
     @traced(SpanKind.TOOL)
@@ -458,6 +441,8 @@ class BaseAgent(metaclass=AgentMeta):
             self.provider.to_tool_call_result_message(result=stringified_result, id_=tool_call.id)
         )
 
+        if self.phases:
+            self.state._update_state_machine(phases=self.phases)
         # Build and return the structured tool response
         ToolResponseModel = self.__tool_response_models__[tool_call.name]
         return ToolResponseModel(
@@ -479,7 +464,12 @@ class BaseAgent(metaclass=AgentMeta):
         # Add all @tool decorated methods
         for tool_def in self.__tool_defs__.values():
             # Resolve StateRefs in parameters (e.g., ref.self.user_name -> actual value)
-            tool_defs.append(tool_def.resolve(self.agent_reference))
+
+            if self.phases and tool_def.phases:
+                if self.state.phase in tool_def.phases:
+                    tool_defs.append(tool_def.resolve(self.agent_reference))
+            else:
+                tool_defs.append(tool_def.resolve(self.agent_reference))
 
         # Add linked agents as tools
         for name, linked_def in self.__linked_agents__.items():
@@ -559,27 +549,45 @@ 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)
-                self._update_state_machine()
                 depth += 1
 
             # If we exhausted max_call_depth without final text, get one more response

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

@@ -1,7 +1,7 @@
 import asyncio
 import threading
 from typing import Any, Type, Self, Optional, ClassVar
-from pydantic import BaseModel, create_model, Field, PrivateAttr, ConfigDict
+from pydantic import BaseModel, create_model, Field, PrivateAttr, computed_field
 from jinja2 import Template
 from typing import Optional, Literal, Callable
 from transitions import Machine
@@ -26,21 +26,52 @@ 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
     input_template: Optional[str] = "{{ user_message }}"
+    _machine: Machine = PrivateAttr(default=None)
     _messages: list[Message] = PrivateAttr(default_factory=list)
     _instructions_template: Template = PrivateAttr(default_factory=lambda: Template(source=""))
     _input_template: Template = PrivateAttr(
         default_factory=lambda: Template(source="{{ user_message }}")
     )
 
+    def _build_phase_machine(self, phases: list[tuple[str, str, Callable]]) -> Machine:
+        if not phases:
+            return None
+
+        states = []
+        for source, dest, _ in phases:
+            if source not in states:
+                states.append(source)
+            if dest not in states:
+                states.append(dest)
+
+        machine = Machine(states=states, initial=states[0])
+
+        for source, dest, _ in phases:
+            machine.add_transition(
+                trigger=f"{source}_to_{dest}",
+                source=source,
+                dest=dest,
+            )
+
+        self._machine = machine
+
+    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)()
+
     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]:
@@ -179,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
@@ -222,6 +254,10 @@ class _AgentState(BaseModel):
         # now build the dataclass
         return create_model(f"AgentState[{name}]", __base__=cls, **pydantic_fields)
 
+    @property
+    def phase(self) -> str:
+        return self._machine.state if self._machine else None
+
     @property
     def recent_message(self) -> Message:
         """
@@ -243,7 +279,10 @@ class _AgentState(BaseModel):
         # start with all the normal dataclass fields
 
         # now format your instruction template
-        return self._instructions_template.render(**self.model_dump())
+        if self.phase:
+            return self._instructions_template.render(phase=self.phase, **self.model_dump())
+        else:
+            return self._instructions_template.render(**self.model_dump())
 
     @property
     def messages(self) -> list[Message]:
@@ -271,7 +310,10 @@ class _AgentState(BaseModel):
         if self.input_template:
             data = self.model_dump()
             data["user_message"] = message
-            content = self._input_template.render(**data)
+            if self.phase:
+                content = self._input_template.render(phase=self.phase, **self.model_dump())
+            else:
+                content = self._input_template.render(**self.model_dump())
         else:
             content = message
         self._messages.append(Message(role="user", content=content))

{pyagentic_core-2.2.0a1 → pyagentic_core-2.2.0a2}/pyagentic/_base/_tool.py

@@ -43,12 +43,14 @@ class _ToolDefinition:
         parameters: dict[str, tuple[TypeVar, ParamInfo]],
         return_type: Type[Any],
         condition: Callable[[Any], bool] = None,
+        phases: list[str] = None,
     ):
         self.name: str = name
         self.description: str = description
         self.parameters: dict[str, tuple[TypeVar, ParamInfo]] = parameters
         self.condition = condition
         self.return_type = return_type
+        self.phases = phases if phases else []
 
     def resolve(self, agent_reference: dict) -> Self:
         new_parameters = {}
@@ -67,6 +69,7 @@ class _ToolDefinition:
             parameters=new_parameters,
             condition=self.condition,
             return_type=self.return_type,
+            phases=self.phases,
         )
 
     def to_openai_spec(self) -> dict:
@@ -210,10 +213,7 @@ class _ToolDefinition:
         return compiled_args
 
 
-def tool(
-    description: str,
-    condition: Callable[[Any], bool] = None,
-):
+def tool(description: str, condition: Callable[[Any], bool] = None, phases: list[str] = None):
     """
     Decorator to mark an agent method as a tool that the LLM can call.
 
@@ -281,6 +281,7 @@ def tool(
             parameters=params,
             condition=condition,
             return_type=return_type,
+            phases=phases,
         )
         return fn
 

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

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

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

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