pyagentic-core 1.2.1__tar.gz → 1.3.0a2__tar.gz

{pyagentic_core-1.2.1 → pyagentic_core-1.3.0a2}/PKG-INFO

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

{pyagentic_core-1.2.1 → pyagentic_core-1.3.0a2}/pyagentic/_base/_agent.py

@@ -1,10 +1,11 @@
 import inspect
 import json
 import openai
-from typing import Callable, Any, TypeVar, ClassVar, Type
+from typing import Callable, Any, TypeVar, ClassVar, Type, Self
 
 from pyagentic.logging import get_logger
-from pyagentic._base._tool import _ToolDefinition
+from pyagentic._base._params import ParamInfo
+from pyagentic._base._tool import _ToolDefinition, tool
 from pyagentic._base._context import ContextItem
 from pyagentic._base._metaclasses import AgentMeta
 
@@ -48,9 +49,12 @@ class Agent(metaclass=AgentMeta):
     __tool_defs__: ClassVar[dict[str, _ToolDefinition]]
     __context_attrs__: ClassVar[dict[str, tuple[TypeVar, ContextItem]]]
     __system_message__: ClassVar[str]
+    __description__: ClassVar[str]
     __input_template__: ClassVar[str] = None
     __response_model__: ClassVar[Type[AgentResponse]] = None
     __tool_response_models__: ClassVar[dict[str, Type[ToolResponse]]]
+    __linked_agents__: ClassVar[dict[str, Type[Self]]]
+    __call_params__: ClassVar[dict[str, tuple[TypeVar, ParamInfo]]]
 
     # Base Attributes
     model: str
@@ -60,9 +64,22 @@ class Agent(metaclass=AgentMeta):
     def __post_init__(self):
         self.client: openai.AsyncOpenAI = openai.AsyncOpenAI(api_key=self.api_key)
 
+    async def _process_agent_call(self, tool_call) -> AgentResponse:
+        logger.info(f"Calling {tool_call.name} with kwargs: {tool_call.arguments}")
+        self.context._messages.append(tool_call)
+        try:
+            agent = getattr(self, tool_call.name)
+            kwargs = json.loads(tool_call.arguments)
+            response = await agent(**kwargs)
+            result = f"Agent {tool_call.name}: {response.final_output}"
+        except Exception as e:
+            result = f"Agent `{tool_call.name}` failed: {e}. Please kindly state to the user that is failed, provide context, and ask if they want to try again."  # noqa E501
+        self.context._messages.append(
+            {"type": "function_call_output", "call_id": tool_call.call_id, "output": result}
+        )
+        return response
+
     async def _process_tool_call(self, tool_call) -> ToolResponse:
-        if tool_call.type != "function_call":
-            return False
         self.context._messages.append(tool_call)
         logger.info(f"Calling {tool_call.name} with kwargs: {tool_call.arguments}")
         # Lookup the bound method
@@ -98,8 +115,8 @@ class Agent(metaclass=AgentMeta):
         self.context._messages.append(
             {"type": "function_call_output", "call_id": tool_call.call_id, "output": result}
         )
-        ToolCalledModel = self.__tool_response_models__[tool_call.name]
-        return ToolCalledModel(
+        ToolResponseModel = self.__tool_response_models__[tool_call.name]
+        return ToolResponseModel(
             raw_kwargs=tool_call.arguments, call_depth=0, output=result, **compiled_args
         )
 
@@ -110,6 +127,9 @@ class Agent(metaclass=AgentMeta):
             # Check if any of the tool params use a ContextRef
             # convert to openai schema
             tool_defs.append(tool_def.to_openai(self.context))
+        for name, agent in self.__linked_agents__.items():
+            tool_def = agent.get_tool_definition(name)
+            tool_defs.append(tool_def.to_openai(self.context))
         return tool_defs
 
     async def run(self, input_: str) -> str:
@@ -168,9 +188,16 @@ class Agent(metaclass=AgentMeta):
 
         # Dispatch any tool calls
         tool_responses = []
+        agent_responses = []
         for tool_call in tool_calls:
-            tool_response = await self._process_tool_call(tool_call)
-            tool_responses.append(tool_response)
+            if tool_call.type != "function_call":
+                continue
+            elif tool_call.name in self.__tool_defs__:
+                tool_response = await self._process_tool_call(tool_call)
+                tool_responses.append(tool_response)
+            elif tool_call.name in self.__linked_agents__:
+                agent_response = await self._process_agent_call(tool_call)
+                agent_responses.append(agent_response)
 
         # If tools ran, re-invoke LLM for natural reply
         if tool_responses:
@@ -198,8 +225,20 @@ class Agent(metaclass=AgentMeta):
         if self.emitter:
             await _safe_run(self.emitter, AiUpdate(status=Status.SUCCEDED, message=ai_message))
 
-        return self.__response_model__(
-            response=response,
-            final_output=ai_message,
-            tool_responses=tool_responses,
-        )
+        response_fields = {"final_output": ai_message}
+        if self.__tool_defs__:
+            response_fields["tool_responses"] = tool_responses
+        if self.__linked_agents__:
+            response_fields["agent_responses"] = agent_responses
+
+        return self.__response_model__(**response_fields)
+
+    async def __call__(self, user_input: str):
+        return await self.run(input_=user_input)
+
+    @classmethod
+    def get_tool_definition(cls, name: str) -> _ToolDefinition:
+        tool_def = tool(cls.__description__)(cls.__call__).__tool_def__
+        # Override the name
+        tool_def.name = name
+        return tool_def

{pyagentic_core-1.2.1 → pyagentic_core-1.3.0a2}/pyagentic/_base/_metaclasses.py

@@ -9,6 +9,12 @@ from pyagentic._base._tool import _ToolDefinition
 
 from pyagentic.models.response import AgentResponse, ToolResponse
 
+from pyagentic._utils._typing import analyze_type
+
+
+class Agent:
+    pass
+
 
 @dataclass_transform(field_specifiers=(ContextItem,))
 class AgentMeta(type):
@@ -69,6 +75,21 @@ class AgentMeta(type):
                 context_attrs[name] = (computed_context, value)
         return context_attrs
 
+    @staticmethod
+    def _extract_linked_agents(annotations, Agent) -> dict[str, "Agent"]:
+        """
+        Extracts any class field from annotations and namespace where the value is that of
+            `ContextItem`, these will later be appeneded to the agents context. This will return
+            both the type and the user defined context item.
+        """
+        linked_agents = {}
+        for attr_name, attr_type in annotations.items():
+            type_info = analyze_type(attr_type, Agent)
+            if type_info.is_subclass:
+                linked_agents[attr_name] = attr_type
+
+        return linked_agents
+
     @staticmethod
     def _build_init_signature(cls) -> inspect.Signature:
         """
@@ -80,6 +101,8 @@ class AgentMeta(type):
         for field_name, field_type in cls.__annotations__.items():
             if field_name in cls.__context_attrs__:
                 default_val = cls.__context_attrs__[field_name][1].get_default_value()
+            elif field_name in cls.__linked_agents__:
+                default_val = None
             else:
                 default_val = getattr(cls, field_name, inspect._empty)
             param = inspect.Parameter(
@@ -106,7 +129,7 @@ class AgentMeta(type):
                 name=self.__class__.__name__, ctx_map=self.__context_attrs__
             )
 
-            context_kwargs = {}
+            compiled = {}
             for attr_name, (attr_type, attr_default) in self.__context_attrs__.items():
                 # Skip compted contexts, this validaiton will happen with the validator
                 #   using a dry run with supplied default values
@@ -121,15 +144,25 @@ class AgentMeta(type):
                         raise UnexpectedContextItemType(
                             name=attr_name, expected=attr_type, recieved=type(val)
                         )
-                    context_kwargs[attr_name] = val
+                    compiled[attr_name] = val
                 else:
-                    context_kwargs[attr_name] = attr_default.get_default_value()
+                    compiled[attr_name] = attr_default.get_default_value()
 
             self.context = ContextClass(
                 instructions=self.__system_message__,
                 input_template=self.__input_template__,
-                **context_kwargs,
+                **compiled,
             )
+            # ------------- Retrieve Linked Agents -------------------
+            for agent_name in self.__linked_agents__.keys():
+                agent_instance = kwargs.get(agent_name, None)
+
+                # Not sure if there is a better way, but setting model = "validation"
+                #   bypasses checking agent in args. This is so the Validator is able to create
+                #   a dummy agent wihout having to worry about creating a chain of linked agents
+                if not agent_instance and kwargs["model"] != "validation":
+                    raise AttributeError(f"Linked Agent {agent_name} not found")
+                compiled[agent_name] = agent_instance
 
             bound = sig.bind(self, *args, **kwargs)
 
@@ -164,16 +197,22 @@ class AgentMeta(type):
             tool_name: ToolResponse.from_tool_def(tool_def)
             for tool_name, tool_def in cls.__tool_defs__.items()
         }
+        # Attach linked agents
+        cls.__linked_agents__ = mcs._extract_linked_agents(cls.__annotations__, cls.__bases__[0])
         # Create final Agent response model, using the tool response models
+        tool_response_models = list(cls.__tool_response_models__.values())
+        linked_agent_response_models = [
+            agent.__response_model__ for agent in cls.__linked_agents__.values()
+        ]
         cls.__response_model__ = AgentResponse.from_tool_defs(
-            cls.__name__, list(cls.__tool_response_models__.values())
+            agent_name=cls.__name__,
+            tool_response_models=tool_response_models,
+            linked_agents_response_models=linked_agent_response_models,
         )
-
         # Build the new init
         sig = mcs._build_init_signature(cls)
         cls.__init__ = mcs._build_init(sig)
 
         # Validate agent
         _AgentConstructionValidator(cls).validate()
-
         return cls

{pyagentic_core-1.2.1 → pyagentic_core-1.3.0a2}/pyagentic/_base/_params.py

@@ -103,7 +103,7 @@ class Param:
                 case TypeCategory.LIST_PRIMITIVE:
                     setattr(self, field_name, value)
                 case TypeCategory.SUBCLASS:
-                    value = field_type(**value) if type(value) == dict else value
+                    value = field_type(**value) if type(value) is dict else value
                     setattr(self, field_name, value)
                 case TypeCategory.LIST_SUBCLASS:
                     listed_value = (

{pyagentic_core-1.2.1 → pyagentic_core-1.3.0a2}/pyagentic/_base/_tool.py

@@ -142,7 +142,7 @@ def tool(
         # Check return type
         types = get_type_hints(fn)
         return_type = types.pop("return", None)
-        if return_type != str:
+        if return_type != str and fn.__name__ != "__call__":
             raise ToolDeclarationFailed(
                 tool_name=fn.__name__, message="Method must have a return type of `str`"
             )

{pyagentic_core-1.2.1 → pyagentic_core-1.3.0a2}/pyagentic/_base/_validation.py

@@ -27,10 +27,7 @@ class _AgentConstructionValidator:
     def __init__(self, AgentClass: Type["Agent"]):
         self.problems = []
         self.AgentClass = AgentClass
-        self.sample_agent = self.AgentClass(
-            model="testing",
-            api_key="validation",
-        )
+        self.sample_agent = self.AgentClass(model="validation", api_key="validation")
 
     def validate(self):
         """

{pyagentic_core-1.2.1 → pyagentic_core-1.3.0a2}/pyagentic/_utils/_typing.py

@@ -54,20 +54,23 @@ def analyze_type(type_: type, base_class: type) -> TypeInfo:
     """
     origin = get_origin(type_)
 
-    if origin == list:
-        inner_type = get_args(type_)[0]
-        if is_primitive(inner_type):
-            return TypeInfo(TypeCategory.LIST_PRIMITIVE, type_, inner_type)
-        elif issubclass(inner_type, base_class):
-            return TypeInfo(TypeCategory.LIST_SUBCLASS, type_, inner_type)
-        else:
-            return TypeInfo(TypeCategory.UNSUPPORTED, type_, inner_type)
-
-    elif is_primitive(type_):
-        return TypeInfo(TypeCategory.PRIMITIVE, type_)
+    try:
+        if origin == list:
+            inner_type = get_args(type_)[0]
+            if is_primitive(inner_type):
+                return TypeInfo(TypeCategory.LIST_PRIMITIVE, type_, inner_type)
+            elif issubclass(inner_type, base_class):
+                return TypeInfo(TypeCategory.LIST_SUBCLASS, type_, inner_type)
+            else:
+                return TypeInfo(TypeCategory.UNSUPPORTED, type_, inner_type)
+
+        elif is_primitive(type_):
+            return TypeInfo(TypeCategory.PRIMITIVE, type_)
+
+        elif issubclass(type_, base_class):
+            return TypeInfo(TypeCategory.SUBCLASS, type_)
 
-    elif issubclass(type_, base_class):
-        return TypeInfo(TypeCategory.SUBCLASS, type_)
-
-    else:
+        else:
+            return TypeInfo(TypeCategory.UNSUPPORTED, type_)
+    except TypeError:
         return TypeInfo(TypeCategory.UNSUPPORTED, type_)

{pyagentic_core-1.2.1 → pyagentic_core-1.3.0a2}/pyagentic/models/response.py

@@ -1,8 +1,6 @@
 from pydantic import BaseModel, Field, create_model
 from typing import Type, Self, Union
 
-from openai.types.responses import Response
-
 from pyagentic._base._tool import _ToolDefinition
 from pyagentic._base._params import Param
 
@@ -114,24 +112,24 @@ class AgentResponse(BaseModel):
         a fastapi app. This is done by calling `from_tool_defs`.
     """
 
-    response: Response
     final_output: str
 
     @classmethod
     def from_tool_defs(
-        cls, agent_name: str, tool_response_models: list[Type[ToolResponse]]
+        cls,
+        agent_name: str,
+        tool_response_models: list[Type[ToolResponse]],
+        linked_agents_response_models: list[Type[Self]],
     ) -> Type[Self]:
         """
         Creates a subclass of `AgentResponse`, using Tool Definitions to create a predetermined
             schema of what the response will look like.
         """
+        fields = {}
         if tool_response_models:
             ToolResult = Union[tuple(tool_response_models)]
-            return create_model(
-                f"{agent_name}Response", __base__=cls, tool_responses=(list[ToolResult], ...)
-            )
-        else:
-            return create_model(
-                f"{agent_name}Response",
-                __base__=cls,
-            )
+            fields["tool_responses"] = (list[ToolResult], ...)
+        if linked_agents_response_models:
+            AgentResult = Union[tuple(linked_agents_response_models)]
+            fields["agent_responses"] = (list[AgentResult], ...)
+        return create_model(f"{agent_name}Response", __base__=cls, **fields)

{pyagentic_core-1.2.1 → pyagentic_core-1.3.0a2}/pyagentic_core.egg-info/PKG-INFO

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

{pyagentic_core-1.2.1 → pyagentic_core-1.3.0a2}/pyproject.toml

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