lionagi 0.5.4__py3-none-any.whl → 0.6.0__py3-none-any.whl

lionagi/operatives/action/manager.py

@@ -0,0 +1,239 @@
+# Copyright (c) 2023 - 2024, HaiyangLi <quantocean.li at gmail dot com>
+#
+# SPDX-License-Identifier: Apache-2.0
+
+from typing import Any
+
+from lionagi.protocols.types import (
+    ActionRequest,
+    EventStatus,
+    Execution,
+    Log,
+    Manager,
+)
+from lionagi.utils import to_list
+
+from .function_calling import FunctionCalling
+from .request_response_model import ActionRequestModel
+from .tool import FuncTool, FuncToolRef, Tool, ToolRef
+
+__all__ = ("ActionManager",)
+
+
+class ActionManager(Manager):
+
+    def __init__(self, *args: FuncTool, **kwargs) -> None:
+
+        super().__init__()
+        self.registry: dict[str, Tool] = {}
+
+        tools = []
+        if args:
+            tools.extend(to_list(args, dropna=True, flatten=True))
+        if kwargs:
+            tools.extend(
+                to_list(kwargs, dropna=True, flatten=True, use_values=True)
+            )
+        self.register_tools(tools, update=True)
+
+    def __contains__(self, tool: FuncToolRef) -> bool:
+        """Check if a tool is registered in the registry.
+
+        Supports checking by:
+        - Tool object
+        - Tool name (string)
+        - Callable function
+
+        Args:
+            tool: The tool to check for registration.
+
+        Returns:
+            bool: True if tool is registered, False otherwise.
+        """
+        if isinstance(tool, Tool):
+            return tool.function in self.registry
+        elif isinstance(tool, str):
+            return tool in self.registry
+        elif callable(tool):
+            return tool.__name__ in self.registry
+        return False
+
+    def register_tool(
+        self,
+        tool: FuncTool,
+        update: bool = False,
+    ) -> None:
+        """Register a single tool in the registry.
+
+        If the tool is a callable function, it is automatically converted
+        to a Tool object. Existing tools can be updated if update=True.
+
+        Args:
+            tool: The tool to register (Tool object or callable).
+            update: If True, update existing tool; if False, raise error.
+
+        Raises:
+            ValueError: If tool already registered and update=False.
+            TypeError: If tool is not a Tool object or callable.
+        """
+        if not update and tool in self:
+            name = None
+            if isinstance(tool, Tool):
+                name = tool.function
+            elif callable(tool):
+                name = tool.__name__
+            raise ValueError(f"Tool {name} is already registered.")
+
+        if callable(tool):
+            tool = Tool(func_callable=tool)
+        if not isinstance(tool, Tool):
+            raise TypeError("Please register a Tool object or callable.")
+
+        self.registry[tool.function] = tool
+
+    def register_tools(
+        self,
+        tools: list[FuncTool] | FuncTool,
+        update: bool = False,
+    ) -> None:
+        """Register multiple tools in the registry.
+
+        Handles both single tools and lists of tools. Each tool can be
+        either a Tool object or a callable function.
+
+        Args:
+            tools: Single tool or list of tools to register.
+            update: If True, update existing tools; if False, raise error.
+
+        Raises:
+            ValueError: If any tool is already registered.
+            TypeError: If any tool is not a Tool object or callable.
+        """
+        tools_list = tools if isinstance(tools, list) else [tools]
+        [
+            self.register_tool(tool, update=update)
+            for tool in to_list(tools_list, dropna=True, flatten=True)
+        ]
+
+    def match_tool(
+        self, action_request: ActionRequest | ActionRequestModel
+    ) -> FunctionCalling:
+        if not isinstance(action_request, ActionRequest | ActionRequestModel):
+            raise TypeError(f"Unsupported type {type(action_request)}")
+
+        tool = self.registry.get(action_request.function, None)
+        if not isinstance(tool, Tool):
+            raise ValueError(
+                f"Function {action_request.function} is not registered."
+            )
+        return FunctionCalling(
+            func_tool=tool, arguments=action_request.arguments
+        )
+
+    async def invoke(
+        self, func_call: ActionRequestModel | ActionRequest
+    ) -> FunctionCalling | Execution | None:
+        """Invoke a tool based on the provided function call.
+
+        1. Matches function call to registered tool
+        2. Creates FunctionCalling instance
+        3. Invokes function with arguments
+        4. Logs execution details
+        5. Returns result
+
+        Args:
+            func_call: Function call specification in supported format.
+            log_manager: Optional logger for execution tracking.
+
+        Returns:
+            Result of tool invocation after processing pipeline.
+
+        Raises:
+            ValueError: If function not registered or call format invalid.
+        """
+        try:
+            function_calling = self.match_tool(func_call)
+        except ValueError as e:
+            return Log(
+                content={
+                    "event_type": "function_call",
+                    "status": EventStatus.FAILED,
+                    "error": str(e),
+                }
+            )
+        await function_calling.invoke()
+        return function_calling
+
+    @property
+    def schema_list(self) -> list[dict[str, Any]]:
+        """List all tool schemas currently registered.
+
+        Returns:
+            List of OpenAI function schemas for all registered tools.
+        """
+        return [tool.tool_schema for tool in self.registry.values()]
+
+    def get_tool_schema(
+        self,
+        tools: ToolRef = False,
+        auto_register: bool = True,
+        update: bool = False,
+    ) -> dict:
+        """Retrieve the schema for specific tools or all tools.
+
+        Args:
+            tools: Specification of which tools to retrieve schemas for.
+                If True, return all tools. If False, return empty dict.
+                Can also be a specific tool or list of tools.
+            **kwargs: Additional keyword arguments to include in output.
+
+        Returns:
+            Dictionary containing tool schemas and additional kwargs.
+
+        Raises:
+            ValueError: If a specified tool is not registered.
+            TypeError: If an unsupported tool type is provided.
+        """
+        if isinstance(tools, list | tuple) and len(tools) == 1:
+            tools = tools[0]
+        if isinstance(tools, bool):
+            if tools is True:
+                return {"tools": self.schema_list}
+            return []
+        else:
+            schemas = self._get_tool_schema(
+                tools, auto_register=auto_register, update=update
+            )
+            return {"tools": schemas}
+
+    def _get_tool_schema(
+        self,
+        tool: Any,
+        auto_register: bool = True,
+        update: bool = False,
+    ) -> dict[str, Any] | list[dict[str, Any]]:
+        if isinstance(tool, dict):
+            return tool
+        if callable(tool):
+            name = tool.__name__
+            if name not in self.registry:
+                if auto_register:
+                    self.register_tool(tool, update=update)
+                else:
+                    raise ValueError(f"Tool {name} is not registered.")
+            return self.registry[name].tool_schema
+
+        elif isinstance(tool, Tool) or isinstance(tool, str):
+            name = tool.function if isinstance(tool, Tool) else tool
+            if name in self.registry:
+                return self.registry[name].tool_schema
+            raise ValueError(f"Tool {name} is not registered.")
+        elif isinstance(tool, list):
+            return [
+                self._get_tool_schema(t, auto_register=auto_register)
+                for t in tool
+            ]
+        raise TypeError(f"Unsupported type {type(tool)}")
+
+
+__all__ = ["ActionManager"]

lionagi/operatives/action/request_response_model.py

@@ -0,0 +1,90 @@
+# Copyright (c) 2023 - 2024, HaiyangLi <quantocean.li at gmail dot com>
+#
+# SPDX-License-Identifier: Apache-2.0
+
+from typing import Any
+
+from pydantic import Field, field_validator
+
+from lionagi.libs.validate.common_field_validators import (
+    validate_nullable_string_field,
+)
+from lionagi.utils import HashableModel, to_dict
+
+from ..models.field_model import FieldModel
+from .utils import (
+    action_requests_field_description,
+    arguments_field_description,
+    function_field_description,
+    parse_action_request,
+)
+
+__all__ = (
+    "ActionRequestModel",
+    "ACTION_REQUESTS_FIELD",
+    "ActionResponseModel",
+    "ACTION_RESPONSES_FIELD",
+)
+
+
+class ActionRequestModel(HashableModel):
+
+    function: str | None = Field(
+        None,
+        title="Function",
+        description=function_field_description,
+        examples=["multiply", "create_user"],
+    )
+    arguments: dict[str, Any] | None = Field(
+        None,
+        title="Arguments",
+        description=arguments_field_description,
+    )
+
+    @field_validator("arguments", mode="before")
+    def validate_arguments(cls, value: Any) -> dict[str, Any]:
+        return to_dict(
+            value,
+            fuzzy_parse=True,
+            recursive=True,
+            recursive_python_only=False,
+        )
+
+    @field_validator("function", mode="before")
+    def validate_function(cls, value: str) -> str:
+        return validate_nullable_string_field(cls, value, "function", False)
+
+    @classmethod
+    def create(cls, content: str):
+        try:
+            content = parse_action_request(content)
+            if content:
+                return [cls.model_validate(i) for i in content]
+            return []
+        except Exception:
+            return []
+
+
+ACTION_REQUESTS_FIELD = FieldModel(
+    name="action_requests",
+    annotation=list[ActionRequestModel],
+    default_factory=list,
+    title="Actions",
+    description=action_requests_field_description,
+)
+
+
+class ActionResponseModel(HashableModel):
+
+    function: str = Field(default_factory=str, title="Function")
+    arguments: dict[str, Any] = Field(default_factory=dict)
+    output: Any = None
+
+
+ACTION_RESPONSES_FIELD = FieldModel(
+    name="action_responses",
+    annotation=list[ActionResponseModel],
+    default_factory=list,
+    title="Actions",
+    description="**do not fill**",
+)

lionagi/operatives/action/tool.py

@@ -0,0 +1,141 @@
+# Copyright (c) 2023 - 2024, HaiyangLi <quantocean.li at gmail dot com>
+#
+# SPDX-License-Identifier: Apache-2.0
+
+import inspect
+from collections.abc import Callable
+from typing import Any, Self, TypeAlias
+
+from pydantic import Field, field_validator, model_validator
+
+from lionagi.libs.schema.function_to_schema import function_to_schema
+from lionagi.libs.validate.common_field_validators import validate_callable
+from lionagi.protocols.types import Element
+
+__all__ = (
+    "Tool",
+    "func_to_tool",
+    "FuncTool",
+    "FuncToolRef",
+    "ToolRef",
+)
+
+
+class Tool(Element):
+    """A class for handling function calls with schema validation and processing.
+
+    This class wraps callable objects with optional pre and post processing,
+    schema validation, and provides utility methods for function inspection.
+    """
+
+    func_callable: Callable[..., Any] = Field(
+        ...,  # ... indicates required field
+        description="The callable function to be wrapped by the tool",
+        exclude=True,
+    )
+
+    tool_schema: dict[str, Any] | None = Field(
+        default=None,
+        description="Schema describing the function's parameters and structure",
+    )
+
+    preprocessor: Callable[[Any], Any] | None = Field(
+        default=None,
+        description="Optional function for preprocessing inputs before execution",
+        exclude=True,
+    )
+
+    preprocessor_kwargs: dict[str, Any] = Field(
+        default_factory=dict,
+        description="Keyword arguments passed to the preprocessor function",
+        exclude=True,
+    )
+
+    postprocessor: Callable[[Any], Any] | None = Field(
+        default=None,
+        description="Optional function for postprocessing outputs after execution",
+        exclude=True,
+    )
+
+    postprocessor_kwargs: dict[str, Any] = Field(
+        default_factory=dict,
+        description="Keyword arguments passed to the postprocessor function",
+        exclude=True,
+    )
+
+    strict_func_call: bool = Field(
+        default=False,
+        description="Whether to enforce strict validation of function parameters",
+    )
+
+    @field_validator("func_callable", mode="before")
+    def _validate_func_callable(cls, value: Any) -> Callable[..., Any]:
+        return validate_callable(
+            cls, value, undefind_able=False, check_name=True
+        )
+
+    @model_validator(mode="after")
+    def _validate_tool_schema(self) -> Self:
+        if self.tool_schema is None:
+            self.tool_schema = function_to_schema(self.func_callable)
+        return self
+
+    @property
+    def function(self) -> str:
+        """Get the name of the function from the schema.
+
+        Returns:
+            str: The name of the function as defined in the schema.
+        """
+        return self.tool_schema["function"]["name"]
+
+    @property
+    def required_fields(self) -> set[str]:
+        """Get the required fields from the schema.
+
+        Returns:
+            set[str]: Set of required field names.
+        """
+        return set(self.tool_schema["function"]["parameters"]["required"])
+
+    @property
+    def minimum_acceptable_fields(self) -> set[str]:
+        """Get the minimum required fields from function signature.
+
+        Returns:
+            set[str]: Set of minimum required field names.
+        """
+        try:
+            a = {
+                k
+                for k, v in inspect.signature(
+                    self.func_callable
+                ).parameters.items()
+                if v.default == inspect.Parameter.empty
+            }
+            if "kwargs" in a:
+                a.remove("kwargs")
+            if "args" in a:
+                a.remove("args")
+            return a
+        except Exception:
+            return set()
+
+    @classmethod
+    def from_dict(cls, data: dict[str, Any]):
+        raise NotImplementedError("Tool.from_dict is not implemented.")
+
+    def to_dict(self) -> dict[str, Any]:
+        """Convert Tool instance to dictionary.
+
+        Returns:
+            dict[str, Any]: Dictionary representation of the Tool.
+        """
+        dict_ = super().to_dict()
+        dict_["function"] = self.function
+        return dict_
+
+
+FuncTool: TypeAlias = Tool | Callable[..., Any]
+FuncToolRef: TypeAlias = FuncTool | str
+ToolRef: TypeAlias = FuncToolRef | list[FuncToolRef] | bool

lionagi/{protocols/operatives/action.py → operatives/action/utils.py}

@@ -3,21 +3,49 @@
 # SPDX-License-Identifier: Apache-2.0
 
 import re
+from typing import Any
 
-from lionagi.core.typing import (
-    Any,
-    BaseModel,
-    Field,
-    FieldModel,
-    field_validator,
+from pydantic import BaseModel
+
+from lionagi.libs.validate.common_field_validators import (
+    validate_boolean_field,
+    validate_nullable_string_field,
+)
+from lionagi.utils import to_dict, to_json, to_list
+
+from ..models.field_model import FieldModel
+
+function_field_description = (
+    "Name of the function to call from the provided `tool_schemas`. "
+    "If no `tool_schemas` exist, set to None or leave blank. "
+    "Never invent new function names outside what's given."
+)
+
+arguments_field_description = (
+    "Dictionary of arguments for the chosen function. "
+    "Use only argument names/types defined in `tool_schemas`. "
+    "Never introduce extra argument names."
+)
+
+action_required_field_description = (
+    "Whether this step strictly requires performing actions. "
+    "If true, the requests in `action_requests` must be fulfilled, "
+    "assuming `tool_schemas` are available. "
+    "If false or no `tool_schemas` exist, actions are optional."
 )
-from lionagi.libs.parse import to_dict, to_json, validate_boolean
 
-from .prompts import (
-    action_requests_field_description,
-    action_required_field_description,
-    arguments_field_description,
-    function_field_description,
+action_requests_field_description = (
+    "List of actions to be executed when `action_required` is true. "
+    "Each action must align with the available `tool_schemas`. "
+    "Leave empty if no actions are needed."
+)
+
+
+__all__ = (
+    "FUNCTION_FIELD",
+    "ARGUMENTS_FIELD",
+    "ACTION_REQUIRED_FIELD",
+    "parse_action_request",
 )
 
 
@@ -30,12 +58,13 @@ def parse_action_request(content: str | dict) -> list[dict]:
 
     elif isinstance(content, str):
         json_blocks = to_json(content, fuzzy_parse=True)
-        print(json_blocks)
         if not json_blocks:
             pattern2 = r"```python\s*(.*?)\s*```"
             _d = re.findall(pattern2, content, re.DOTALL)
-            json_blocks = [to_dict(match, fuzzy_parse=True) for match in _d]
-            json_blocks = [i for i in json_blocks if i]
+            json_blocks = [to_json(match, fuzzy_parse=True) for match in _d]
+            json_blocks = to_list(json_blocks, dropna=True)
+
+        print(json_blocks)
 
     elif content and isinstance(content, dict):
         json_blocks = [content]
@@ -46,12 +75,11 @@ def parse_action_request(content: str | dict) -> list[dict]:
     out = []
 
     for i in json_blocks:
-        print(i)
         j = {}
         if isinstance(i, dict):
             if "function" in i and isinstance(i["function"], dict):
                 if "name" in i["function"]:
-                    i = i["function"]
+                    i["function"] = i["function"]["name"]
             for k, v in i.items():
                 k = (
                     k.replace("action_", "")
@@ -60,7 +88,7 @@ def parse_action_request(content: str | dict) -> list[dict]:
                 )
                 if k in ["name", "function", "recipient"]:
                     j["function"] = v
-                elif k in ["parameter", "argument", "arg"]:
+                elif k in ["parameter", "argument", "arg", "param"]:
                     j["arguments"] = to_dict(
                         v, str_type="json", fuzzy_parse=True, suppress=True
                     )
@@ -74,20 +102,11 @@ def parse_action_request(content: str | dict) -> list[dict]:
     return out
 
 
-def _validate_function_name(cls, value: Any) -> str | None:
-    if not isinstance(value, str):
-        return None
-    return value
-
-
-def _validate_action_required(cls, value) -> bool:
-    try:
-        return validate_boolean(value)
-    except Exception:
-        return False
+def validate_function_name(cls, value: Any) -> str | None:
+    return validate_nullable_string_field(cls, value, strict=False)
 
 
-def _validate_arguments(cls, value: Any) -> dict:
+def validate_arguments(cls, value: Any) -> dict:
     return to_dict(
         value,
         fuzzy_parse=True,
@@ -103,7 +122,7 @@ FUNCTION_FIELD = FieldModel(
     title="Function",
     description=function_field_description,
     examples=["add", "multiply", "divide"],
-    validator=_validate_function_name,
+    validator=validate_function_name,
 )
 
 ARGUMENTS_FIELD = FieldModel(
@@ -113,7 +132,7 @@ ARGUMENTS_FIELD = FieldModel(
     title="Action Arguments",
     description=arguments_field_description,
     examples=[{"num1": 1, "num2": 2}, {"x": "hello", "y": "world"}],
-    validator=_validate_arguments,
+    validator=validate_arguments,
     validator_kwargs={"mode": "before"},
 )
 
@@ -123,63 +142,6 @@ ACTION_REQUIRED_FIELD = FieldModel(
     default=False,
     title="Action Required",
     description=action_required_field_description,
-    validator=_validate_action_required,
+    validator=lambda cls, v: validate_boolean_field(cls, v, False),
     validator_kwargs={"mode": "before"},
 )
-
-
-class ActionRequestModel(BaseModel):
-
-    function: str | None = FUNCTION_FIELD.field_info
-    arguments: dict[str, Any] | None = ARGUMENTS_FIELD.field_info
-
-    @field_validator("arguments", mode="before")
-    def validate_arguments(cls, value: Any) -> dict[str, Any]:
-        return to_dict(
-            value,
-            fuzzy_parse=True,
-            recursive=True,
-            recursive_python_only=False,
-        )
-
-    @classmethod
-    def create(cls, content: str):
-        try:
-            content = parse_action_request(content)
-            if content:
-                return [cls.model_validate(i) for i in content]
-            return []
-        except Exception:
-            return []
-
-
-class ActionResponseModel(BaseModel):
-
-    function: str = Field(default_factory=str)
-    arguments: dict[str, Any] = Field(default_factory=dict)
-    output: Any = None
-
-
-ACTION_REQUESTS_FIELD = FieldModel(
-    name="action_requests",
-    annotation=list[ActionRequestModel],
-    default_factory=list,
-    title="Actions",
-    description=action_requests_field_description,
-)
-
-
-ACTION_RESPONSES_FIELD = FieldModel(
-    name="action_responses",
-    annotation=list[ActionResponseModel],
-    default_factory=list,
-    title="Actions",
-    description="**do not fill**",
-)
-
-__all__ = [
-    "ActionRequestModel",
-    "ActionResponseModel",
-    "ACTION_REQUESTS_FIELD",
-    "ACTION_RESPONSES_FIELD",
-]

lionagi/{core → operatives}/forms/base.py

@@ -2,13 +2,18 @@
 #
 # SPDX-License-Identifier: Apache-2.0
 
-from pydantic import field_validator
+from typing import Any, Literal
 
-from ..generic.types import Component
-from ..typing import UNDEFINED, Any, Field, Literal, PydanticUndefined
+from pydantic import Field, field_validator
+from pydantic_core import PydanticUndefined
 
+from lionagi.protocols.types import Node
+from lionagi.utils import UNDEFINED
 
-class BaseForm(Component):
+from ..models.operable_model import OperableModel
+
+
+class BaseForm(Node, OperableModel):
     """Base form class providing core functionality for form handling.
 
     This class serves as a foundation for creating custom forms within the