lionagi 0.0.312__py3-none-any.whl → 0.2.1__py3-none-any.whl

lionagi/core/action/tool_manager.py

@@ -0,0 +1,356 @@
+"""
+Copyright 2024 HaiyangLi
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+"""
+
+"""
+This module contains the ToolManager class, which manages tools in the system.
+It allows registering, invoking, and retrieving schemas of tools. Tools can be
+registered individually or in batches, and invoked using function names, JSON
+strings, or specialized objects.
+"""
+
+import inspect
+from functools import singledispatchmethod
+from typing import Any, Callable, List, Union, Tuple
+from lionagi.libs import ParseUtil
+from lionagi.libs.ln_convert import to_list, to_dict
+from lionagi.libs.ln_func_call import lcall
+from lionagi.core.collections.abc import Actionable
+from lionagi.core.action.function_calling import FunctionCalling
+from lionagi.core.action.tool import Tool, TOOL_TYPE
+
+
+class ToolManager(Actionable):
+    """
+    Manages tools in the system. Provides functionality to register tools,
+    invoke them based on various input formats, and retrieve tool schemas.
+    """
+
+    def __init__(self, registry: dict[str, Tool] = None) -> None:
+        """
+        Initializes a new instance of ToolManager.
+
+        Args:
+            registry (dict[str, Tool], optional): A dictionary to store registered tools.
+                Defaults to an empty dictionary.
+        """
+        self.registry = registry or {}
+
+    def __contains__(self, tool) -> bool:
+        if isinstance(tool, Tool):
+            return tool.name in self.registry
+
+        elif isinstance(tool, str):
+            return tool in self.registry
+
+        elif inspect.isfunction(tool):
+            return tool.__name__ in self.registry
+
+        return False
+
+    def _register_tool(self, tool: Tool | Callable, update: bool = False) -> bool:
+        """
+        Registers a single tool or multiple tools based on the input type.
+
+        Args:
+            tool (Any): Can be a single Tool, a list of Tools, a callable, or other forms.
+
+        Raises:
+            TypeError: If the tools argument type is unsupported.
+        """
+        if not update and tool in self:
+            raise ValueError(f"Function {tool.name} is already registered.")
+        if isinstance(tool, Callable):
+            tool = func_to_tool(tool)
+            tool = tool[0] if isinstance(tool, list) and len(tool) == 1 else tool
+        if not isinstance(tool, Tool):
+            raise TypeError("Please register a Tool object.")
+        self.registry[tool.name] = tool
+        return True
+
+    def update_tools(self, tools: list | Tool | Callable):
+        if isinstance(tools, Tool) or isinstance(tools, Callable):
+            return self._register_tool(tools, update=True)
+        else:
+            return all(lcall(tools, self._register_tool, update=True))
+
+    def register_tools(self, tools: list | Tool | Callable):
+        """
+        Registers multiple Tools.
+
+        Args:
+            tools (list): The list of Tools to register.
+
+        Returns:
+            bool: True if all tools are successfully registered.
+        """
+        if isinstance(tools, Tool) or isinstance(tools, Callable):
+            return self._register_tool(tools)
+        else:
+            return all(lcall(tools, self._register_tool))
+
+    async def invoke(self, func_calling=None):
+        """
+        Invokes a function based on the provided function calling description.
+
+        Args:
+            func_calling (Any, optional): The function calling description, which can be:
+                - tuple: (name, kwargs)
+                - dict: {"function": name, "arguments": kwargs}
+                - str: JSON string of dict format
+                - ActionRequest object
+                - FunctionCalling object
+
+        Returns:
+            Any: The result of the function call.
+
+        Raises:
+            ValueError: If func_calling is None or the function is not registered.
+        """
+        if not func_calling:
+            raise ValueError("func_calling is required.")
+
+        if not isinstance(func_calling, FunctionCalling):
+            func_calling = FunctionCalling.create(func_calling)
+
+        if func_calling.func_name in self.registry:
+            return await self.registry[func_calling.func_name].invoke(
+                func_calling=func_calling
+            )
+
+        raise ValueError(f"Function {func_calling.func_name} is not registered.")
+
+    @property
+    def _schema_list(self) -> list[dict[str, Any]]:
+        """
+        Lists all tool schemas currently registered in the ToolManager.
+
+        Returns:
+            list[dict[str, Any]]: A list of tool schemas.
+        """
+        return [tool.schema_ for tool in self.registry.values()]
+
+    def get_tool_schema(self, tools: TOOL_TYPE, **kwargs) -> dict:
+        """
+        Retrieves the schema for a specific tool or all tools based on the input.
+
+        Args:
+            tools (TOOL_TYPE): Can be a boolean, specific tool name, Tool, or list of tools.
+            **kwargs: Additional keyword arguments to be merged with tool schema.
+
+        Returns:
+            dict: Combined tool schema and kwargs.
+        """
+        if isinstance(tools, bool):
+            tool_kwarg = {"tools": self._schema_list}
+            return tool_kwarg | kwargs
+
+        else:
+            tool_kwarg = {"tools": self._get_tool_schema(tools)}
+            return tool_kwarg | kwargs
+
+    @singledispatchmethod
+    def _get_tool_schema(self, tool: Any) -> dict:
+        """
+        Retrieves the schema for a specific tool based on its type.
+
+        Args:
+            tool (Any): The tool descriptor, can be a dict, Tool, str, or list.
+
+        Raises:
+            TypeError: If the tool type is unsupported.
+        """
+        raise TypeError(f"Unsupported type {type(tool)}")
+
+    @_get_tool_schema.register(dict)
+    def _(self, tool):
+        """
+        Assumes that the tool is a schema and returns it.
+
+        Args:
+            tool (dict): The tool schema.
+
+        Returns:
+            dict: The tool schema.
+        """
+        return tool
+
+    @_get_tool_schema.register(Tool)
+    def _(self, tool):
+        """
+        Retrieves the schema for a Tool object.
+
+        Args:
+            tool (Tool): The Tool object.
+
+        Returns:
+            dict: The tool schema.
+
+        Raises:
+            ValueError: If the Tool is not registered.
+        """
+        if tool.name in self.registry:
+            return self.registry[tool.name].schema_
+        else:
+            err_msg = f"Function {tool.name} is not registered."
+            raise ValueError(err_msg)
+
+    @_get_tool_schema.register(str)
+    def _(self, tool):
+        """
+        Assumes that the tool is a name and retrieves its schema.
+
+        Args:
+            tool (str): The tool name.
+
+        Returns:
+            dict: The tool schema.
+
+        Raises:
+            ValueError: If the tool name is not registered.
+        """
+        if tool in self.registry:
+            return self.registry[tool].schema_
+        else:
+            err_msg = f"Function {tool} is not registered."
+            raise ValueError(err_msg)
+
+    @_get_tool_schema.register(list)
+    def _(self, tools):
+        """
+        Retrieves the schema for a list of tools.
+
+        Args:
+            tools (list): The list of tools.
+
+        Returns:
+            list: A list of tool schemas.
+        """
+        return lcall(tools, self._get_tool_schema)
+
+    def parse_tool(self, tools: TOOL_TYPE, **kwargs) -> dict:
+        """
+        Parses and merges tool schemas based on the provided tool descriptors.
+
+        Args:
+            tools (TOOL_TYPE): The tools to parse, can be a single tool or list.
+            **kwargs: Additional keyword arguments to be merged with the tool schema.
+
+        Returns:
+            dict: The merged tool schema and additional arguments.
+        """
+        if tools:
+            if isinstance(tools, bool):
+                tool_kwarg = {"tools": self._schema_list}
+                kwargs = tool_kwarg | kwargs
+            else:
+                tools = to_list(tools) if not isinstance(tools, list) else [tools]
+                tool_kwarg = {"tools": lcall(tools, self._get_tool_schema)}
+                kwargs = tool_kwarg | kwargs
+
+        return kwargs
+
+    @staticmethod
+    def parse_tool_request(response: dict) -> Tuple[str, dict]:
+        """
+        Parses a tool request from a given response dictionary.
+
+        Args:
+            response (dict): The response data containing the tool request.
+
+        Returns:
+            Tuple[str, dict]: The function name and its arguments.
+
+        Raises:
+            ValueError: If the response is not a valid function call.
+        """
+        try:
+            func = response["action"][7:]
+            args = to_dict(response["arguments"])
+            return func, args
+        except Exception:
+            try:
+                func = response["recipient_name"].split(".")[-1]
+                args = response["parameters"]
+                return func, args
+            except:
+                raise ValueError("response is not a valid function call")
+
+
+def func_to_tool(
+    func_: Union[Callable, List[Callable]],
+    parser: Union[Callable, List[Callable]] = None,
+    docstring_style: str = "google",
+    **kwargs,
+) -> List[Tool]:
+    """
+    Converts functions to Tool objects, optionally associating parsers with each function
+    and applying a specified docstring parsing style to generate tool schemas.
+
+    Args:
+        func_ (Callable | list[Callable]): The function(s) to convert into tool(s).
+        parser (Callable | list[Callable], optional): Parser(s) to associate with
+            the function(s). If a list is provided, it should match the length of func_.
+        docstring_style (str, optional): The style of the docstring parser to use when
+            generating tool schemas. Defaults to "google".
+
+    Returns:
+        list[Tool]: A list of Tool objects created from the provided function(s).
+
+    Raises:
+        ValueError: If the length of the parsers does not match the length of the
+            functions when both are provided as lists.
+
+    Examples:
+        # Convert a single function with a custom parser
+        tools = func_to_tool(my_function, my_parser)
+
+        # Convert multiple functions without parsers
+        tools = func_to_tool([func_one, func_two])
+
+        # Convert multiple functions with multiple parsers
+        tools = func_to_tool([func_one, func_two], [parser_one, parser_two])
+    """
+    fs = []
+    funcs = to_list(func_, flatten=True, dropna=True)
+    parsers = to_list(parser, flatten=True, dropna=True)
+
+    if parser:
+        if len(funcs) != len(parsers) != 1:
+            raise ValueError(
+                "Length of parser must match length of func. Except if you only pass one"
+            )
+
+        for idx in range(len(funcs)):
+            f_ = lambda _f: Tool(
+                function=_f,
+                schema_=ParseUtil._func_to_schema(_f, style=docstring_style),
+                parser=parsers[idx] if len(parsers) > 1 else parsers[0],
+                **kwargs,
+            )
+
+            fs.append(f_)
+
+    else:
+        fs = lcall(
+            funcs,
+            lambda _f: Tool(
+                function=_f,
+                schema_=ParseUtil._func_to_schema(_f, style=docstring_style),
+                **kwargs,
+            ),
+        )
+
+    return fs

lionagi/core/agent/__init__.py

@@ -1,3 +0,0 @@
-from .base_agent import BaseAgent
-
-__all__ = ["BaseAgent"]

lionagi/core/agent/base_agent.py

@@ -1,38 +1,45 @@
+"""
+Copyright 2024 HaiyangLi
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+"""
+
 """
 This module contains the BaseAgent class, which serves as a base class for agents.
 """
 
-from lionagi.core.mail.schema import StartMail
-from lionagi.core.schema.base_node import BaseRelatableNode
-from lionagi.core.mail.mail_manager import MailManager
+from pydantic import Field
+from typing import Any, Callable
 
 from lionagi.libs import func_call, AsyncUtil
 
 
-class BaseAgent(BaseRelatableNode):
-    """
-    A base class for agents.
-
-    Attributes:
-        structure: The structure of the agent.
-        executable: The executable object of the agent.
-        start: The StartMail object for triggering the agent.
-        mailManager: The MailManager object for managing agent communication.
-        output_parser: A function for parsing the agent's output (optional).
-        start_context: The initial context for the agent (optional).
-
-    Methods:
-        __init__(self, structure, executable_obj, output_parser=None) -> None:
-            Initializes the BaseAgent instance.
+from lionagi.core.mail.start_mail import StartMail
+from lionagi.core.generic.node import Node
+from lionagi.core.mail.mail_manager import MailManager
+from lionagi.core.executor.base_executor import BaseExecutor
+from lionagi.core.executor.graph_executor import GraphExecutor
 
-        async mail_manager_control(self, refresh_time=1) -> None:
-            Controls the mail manager execution based on the structure and executable states.
 
-        async execute(self, context=None) -> Any:
-            Executes the agent with the given context and returns the parsed output (if available).
-    """
+class BaseAgent(Node):
 
-    def __init__(self, structure, executable_obj, output_parser=None) -> None:
+    def __init__(
+        self,
+        structure: BaseExecutor,
+        executable: BaseExecutor,
+        output_parser=None,
+        **kwargs,
+    ) -> None:
         """
         Initializes the BaseAgent instance.
 
@@ -41,13 +48,15 @@ class BaseAgent(BaseRelatableNode):
             executable_obj: The executable object of the agent.
             output_parser: A function for parsing the agent's output (optional).
         """
-        super().__init__()
-        self.structure = structure
-        self.executable = executable_obj
-        self.start = StartMail()
-        self.mailManager = MailManager([self.structure, self.executable, self.start])
-        self.output_parser = output_parser
-        self.start_context = None
+        super().__init__(**kwargs)
+        self.structure: BaseExecutor = structure
+        self.executable: BaseExecutor = executable
+        self.start: StartMail = StartMail()
+        self.mail_manager: MailManager = MailManager(
+            [self.structure, self.executable, self.start]
+        )
+        self.output_parser: Callable | None = output_parser
+        self.start_context: Any | None = None
 
     async def mail_manager_control(self, refresh_time=1):
         """
@@ -58,7 +67,7 @@ class BaseAgent(BaseRelatableNode):
         """
         while not self.structure.execute_stop or not self.executable.execute_stop:
             await AsyncUtil.sleep(refresh_time)
-        self.mailManager.execute_stop = True
+        self.mail_manager.execute_stop = True
 
     async def execute(self, context=None):
         """
@@ -73,22 +82,22 @@ class BaseAgent(BaseRelatableNode):
         self.start_context = context
         self.start.trigger(
             context=context,
-            structure_id=self.structure.id_,
-            executable_id=self.executable.id_,
+            structure_id=self.structure.ln_id,
+            executable_id=self.executable.ln_id,
         )
         await func_call.mcall(
             [0.1, 0.1, 0.1, 0.1],
             [
                 self.structure.execute,
                 self.executable.execute,
-                self.mailManager.execute,
+                self.mail_manager.execute,
                 self.mail_manager_control,
             ],
         )
 
         self.structure.execute_stop = False
         self.executable.execute_stop = False
-        self.mailManager.execute_stop = False
+        self.mail_manager.execute_stop = False
 
         if self.output_parser:
             return self.output_parser(self)

lionagi/core/agent/eval/evaluator.py

@@ -0,0 +1 @@
+# TODO

lionagi/core/agent/eval/vote.py

@@ -0,0 +1,40 @@
+# TODO
+
+# from lionagi.libs import func_call
+# import numpy as np
+# from lionagi.core.form.predict import predict
+# from lionagi.core.form.score import score
+
+
+# async def vote(
+#     sentence,
+#     directive=predict,
+#     num_generations=5,
+#     num_output=1,
+#     num_scorer=5,
+#     score_range=(0, 100),
+#     num_digit=2,
+#     scorer_instruction=None,
+#     **kwargs,
+# ):
+#     async def _inner(i):
+#         out_ = await directive(sentence, **kwargs)
+#         score_ = await score(
+#             out_.answer,
+#             context=sentence,
+#             instruction=scorer_instruction,
+#             score_range=score_range,
+#             num_digit=num_digit,
+#             num_instances=num_scorer,
+#             return_template=False,
+#         )
+
+#         out_.__setattr__("score", score_)
+#         return out_
+
+#     _outs = await func_call.alcall(list(range(num_generations)), _inner)
+
+#     top_index = np.argsort([i.score for i in _outs])[-num_output:]
+#     final_output = list(np.array(_outs)[top_index])
+
+#     return final_output[0] if len(final_output) == 1 else final_output

lionagi/core/agent/learn/learner.py

@@ -0,0 +1,59 @@
+# class LearningFramework:
+#     def __init__(self, learning_model: Any, learning_service: Any):
+#         self.learning_model = learning_model
+#         self.learning_service = learning_service
+
+#     async def learn_from_interaction(self, interaction_data: Dict[str, Any]) -> None:
+#         """
+#         Update the learning model based on interaction data.
+#         """
+#         # Update the embedded model
+#         self.learning_model.update(interaction_data)
+
+#         # Optionally send data to an external learning provider
+#         await self.learning_service.send_data_for_learning(interaction_data)
+
+#     async def adapt_response_strategy(self, context: Dict[str, Any]) -> Dict[str, Any]:
+#         """
+#         Adapt the assistant_response strategy based on learned patterns and context.
+#         """
+#         # Use the learning model to determine the adaptation strategy
+#         adaptation_strategy = self.learning_model.determine_strategy(context)
+#         return adaptation_strategy
+
+
+# class LearningAgent(TaskAgent):
+#     def __init__(
+#         self, name: Optional[str] = None, learning_model: Optional[Any] = None
+#     ):
+#         super().__init__(name)
+#         self.learning_model = learning_model
+
+#     async def learn_from_interaction(self, interaction_data: Any):
+#         """
+#         Update the learning model based on interaction data.
+#         This method should be implemented to integrate specific learning algorithms.
+#         """
+#         if self.learning_model:
+#             # Placeholder for learning logic. Implement learning model updates based on interaction data.
+#             print("Learning from interaction...")
+
+#     async def adapt_response_strategy(self, instruction: Any) -> Any:
+#         """
+#         Adapt the assistant_response strategy based on what has been learned.
+#         Override this method to implement adaptive assistant_response strategies.
+#         """
+#         # Example implementation. Use the learning model to adapt the assistant_response strategy.
+#         print("Adapting assistant_response strategy based on learned patterns...")
+#         # Placeholder for demonstration. Implement adaptive assistant_response generation based on the learning model.
+#         return "Adapted assistant_response based on learning."
+
+#     async def process_instruction(self, instruction: Any) -> Any:
+#         """
+#         Process instruction with learning and adaptation.
+#         """
+#         # Incorporate learning into the instruction processing.
+#         response = await super().process_instruction(instruction)
+#         await self.learn_from_interaction(instruction)
+#         adapted_response = await self.adapt_response_strategy(instruction)
+#         return adapted_response

lionagi/core/agent/plan/unit_template.py

@@ -0,0 +1 @@
+# TODO

lionagi/core/collections/__init__.py

@@ -0,0 +1,17 @@
+from .model import iModel
+from .pile import Pile, pile
+from .progression import Progression, progression
+from .flow import Flow, flow
+from .exchange import Exchange
+
+
+__all__ = [
+    "iModel",
+    "Pile",
+    "pile",
+    "Progression",
+    "progression",
+    "Flow",
+    "flow",
+    "Exchange",
+]