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

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

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

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

@@ -169,6 +169,7 @@ 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
@@ -231,6 +232,34 @@ 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.
@@ -252,9 +281,7 @@ class BaseAgent(metaclass=AgentMeta):
             ```
         """
         self._check_llm_provider()
-
-        if self.phases:
-            self.state._build_phase_machine(self.phases)
+        self.__machine__ = self._build_phase_machine()
 
         # Use BasicTracer as default if no tracer provided
         if not self.tracer:
@@ -320,14 +347,7 @@ class BaseAgent(metaclass=AgentMeta):
             self.state._messages.append(
                 Message(role="assistant", content="Failed to generate a response")
             )
-            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
+            return LLMResponse(text=f"The LLM failed to generate a response: {e}", tool_calls=[])
 
     @traced(SpanKind.AGENT)
     async def _process_agent_call(self, tool_call: ToolCall) -> AgentResponse:
@@ -374,8 +394,6 @@ 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)
@@ -440,8 +458,6 @@ 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(
@@ -463,12 +479,7 @@ 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)
-
-            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))
+            tool_defs.append(tool_def.resolve(self.agent_reference))
 
         # Add linked agents as tools
         for name, linked_def in self.__linked_agents__.items():
@@ -568,6 +579,7 @@ 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.0 → pyagentic_core-2.2.0a1}/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, computed_field
+from pydantic import BaseModel, create_model, Field, PrivateAttr, ConfigDict
 from jinja2 import Template
 from typing import Optional, Literal, Callable
 from transitions import Machine
@@ -31,41 +31,12 @@ 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:
@@ -251,10 +222,6 @@ 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:
         """
@@ -276,10 +243,7 @@ class _AgentState(BaseModel):
         # start with all the normal dataclass fields
 
         # now format your instruction template
-        if self.phase:
-            return self._instructions_template.render(phase=self.phase, **self.model_dump())
-        else:
-            return self._instructions_template.render(**self.model_dump())
+        return self._instructions_template.render(**self.model_dump())
 
     @property
     def messages(self) -> list[Message]:
@@ -307,10 +271,7 @@ class _AgentState(BaseModel):
         if self.input_template:
             data = self.model_dump()
             data["user_message"] = message
-            if self.phase:
-                content = self._input_template.render(phase=self.phase, **self.model_dump())
-            else:
-                content = self._input_template.render(**self.model_dump())
+            content = self._input_template.render(**data)
         else:
             content = message
         self._messages.append(Message(role="user", content=content))

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

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

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

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

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

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