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

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: pyagentic-core
-Version: 2.2.0a1
+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.0a1 → pyagentic_core-2.2.1}/pyagentic/_base/_agent/_agent.py

@@ -169,7 +169,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 +231,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 +252,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 +320,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 +374,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 +440,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(
@@ -478,13 +462,30 @@ 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)
-            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():
-            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
 
@@ -579,7 +580,6 @@ class BaseAgent(metaclass=AgentMeta):
                         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.1}/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
@@ -31,12 +31,41 @@ class _AgentState(BaseModel):
 
     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:
+            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:
@@ -222,6 +251,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 +276,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 +307,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.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.0a1 → 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.0a1 → pyagentic_core-2.2.1}/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.1}/pyagentic_core.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: pyagentic-core
-Version: 2.2.0a1
+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.0a1 → pyagentic_core-2.2.1}/pyproject.toml

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