lionagi 0.0.206__py3-none-any.whl → 0.0.208__py3-none-any.whl

lionagi/core/core_util.py

@@ -1,59 +0,0 @@
-import json
-from ..utils.sys_util import strip_lower
-
-
-def sign_message(messages, sender: str):
-    """
-    Sign messages with a sender identifier.
-
-    Args:
-        messages (pd.DataFrame): A DataFrame containing messages with columns 'node_id', 'role', 'sender', 'timestamp', and 'content'.
-        sender (str): The sender identifier to be added to the messages.
-
-    Returns:
-        pd.DataFrame: A new DataFrame with the sender identifier added to each message.
-
-    Raises:
-        ValueError: If the 'sender' is None or 'None'.
-    """
-    if sender is None or strip_lower(sender) == 'none':
-        raise ValueError("sender cannot be None")
-    df = messages.copy()
-
-    for i in df.index:
-        if not df.loc[i, 'content'].startswith('Sender'):
-            df.loc[i, 'content'] = f"Sender {sender}: {df.loc[i, 'content']}"
-        else:
-            content = df.loc[i, 'content'].split(':', 1)[1]
-            df.loc[i, 'content'] = f"Sender {sender}: {content}"
-    return df
-
-
-def validate_messages(messages):
-    """
-    Validate the structure and content of a messages DataFrame.
-
-    Args:
-        messages (pd.DataFrame): A DataFrame containing messages with columns 'node_id', 'role', 'sender', 'timestamp', and 'content'.
-
-    Returns:
-        bool: True if the messages DataFrame is valid; otherwise, raises a ValueError.
-
-    Raises:
-        ValueError: If the DataFrame structure is invalid or if it contains null values, roles other than ["system", "user", "assistant"],
-                    or content that cannot be parsed as JSON strings.
-    """
-    if list(messages.columns) != ['node_id', 'role', 'sender', 'timestamp', 'content']:
-        raise ValueError('Invalid messages dataframe. Unmatched columns.')
-    if messages.isnull().values.any():
-        raise ValueError('Invalid messages dataframe. Cannot have null.')
-    if not all(role in ['system', 'user', 'assistant'] for role in messages['role'].unique()):
-        raise ValueError('Invalid messages dataframe. Cannot have role other than ["system", "user", "assistant"].')
-    for cont in messages['content']:
-        if cont.startswith('Sender'):
-            cont = cont.split(':', 1)[1]
-        try:
-            json.loads(cont)
-        except:
-            raise ValueError('Invalid messages dataframe. Content expect json string.')
-    return True

lionagi/core/sessions/session.py

@@ -1,4 +1,5 @@
 import pandas as pd
+
 from typing import Any, List, Union, Dict, Optional, Callable, Tuple
 from dotenv import load_dotenv
 
@@ -8,30 +9,26 @@ from ..messages.messages import System, Instruction
 from ..branch.branch import Branch
 from ..branch.branch_manager import BranchManager
 
-
 load_dotenv()
 
 
 class Session:
     """
-    Represents a session with conversation branches, tool management, and logging.
+    Manages sessions with conversation branches, tool management, and interaction logging.
 
-    This class encapsulates the management of different conversation branches, each with its own
-    messages, instruction sets, and tools. It also handles logging and interactions with an external service.
+    This class orchestrates the handling of different conversation branches, enabling distinct conversational contexts to coexist within a single session. It facilitates the integration with external services for processing chat completions, tool management, and the logging of session activities.
 
     Attributes:
-        branches (Dict[str, Branch]): A dictionary of conversation branches.
-        default_branch (Branch): The default branch for the session.
-        default_branch_name (str): The name of the default branch.
-        llmconfig (Dict[str, Any]): Configuration settings for the language model.
-        logger_ (DataLogger): Logger for session data.
-        service (OpenAIService): Service used for handling chat completions and other operations.
+        branches (Dict[str, Branch]): Maps branch names to Branch instances.
+        default_branch (Branch): The primary branch for the session.
+        default_branch_name (str): Identifier for the default branch.
+        llmconfig (Dict[str, Any]): Configurations for language model interactions.
+        service (OpenAIService): Interface for external service interactions.
     """
     def __init__(
         self,
         system: Optional[Union[str, System]] = None,
         sender: Optional[str] = None,
-        dir: Optional[str] = None,
         llmconfig: Optional[Dict[str, Any]] = None,
         service: OpenAIService = None,
         branches: Optional[Dict[str, Branch]] = None,
@@ -39,36 +36,26 @@ class Session:
         default_branch_name: str = 'main',
     ):
         """
-        Initialize a Session object.
+        Initializes a session with optional settings for branches, service, and language model configurations.
 
         Args:
-            system (Union[str, System]): Initial system message or System object for the default branch.
-            dir (str, optional): Directory path for storing logs.
-            llmconfig (Dict[str, Any], optional): Configuration settings for the language model.
-            service (OpenAIService, optional): Service used for handling chat completions and other operations.
-            branches (Dict[str, Branch], optional): Pre-existing branches to initialize in the session.
-            default_branch (Branch, optional): Default branch for the session.
-            default_branch_name (str, optional): Name of the default branch, defaults to 'main'.
+            system (Optional[Union[str, System]]): Initial system message or configuration.
+            sender (Optional[str]): Identifier for the sender of the system message.
+            llmconfig (Optional[Dict[str, Any]]): Language model configuration settings.
+            service (OpenAIService): External service for chat completions and other operations.
+            branches (Optional[Dict[str, Branch]]): Predefined conversation branches.
+            default_branch (Optional[Branch]): Preselected default branch for the session.
+            default_branch_name (str): Name for the default branch, defaults to 'main'.
         """
 
         self.branches = branches if isinstance(branches, dict) else {}
         if service is None:
             service = OpenAIService()
-        
-        self.default_branch = default_branch if default_branch else Branch(name=default_branch_name, service=service, llmconfig=llmconfig)
-        self.default_branch_name = default_branch_name
-        if system:
-            self.default_branch.add_message(system=system, sender=sender)
-        if self.branches:
-            if self.default_branch_name not in self.branches.keys():
-                raise ValueError('default branch name is not in imported branches')
-            if self.default_branch is not self.branches[self.default_branch_name]:
-                raise ValueError(f'default branch does not match Branch object under {self.default_branch_name}')
-        if not self.branches:
-            self.branches[self.default_branch_name] = self.default_branch
-        if dir:
-            self.default_branch.dir = dir
 
+        self._setup_default_branch(
+            default_branch, default_branch_name, service, llmconfig, system, sender)
+        
+        self._verify_default_branch()
         self.branch_manager = BranchManager(self.branches)
         
     def new_branch(
@@ -83,20 +70,20 @@ class Session:
         llmconfig: Optional[Dict] = None,
     ) -> None:
         """
-        Create a new branch in the session.
+        Creates a new branch within the session.
 
         Args:
-            branch_name (str): Name of the new branch.
-            dir (str, optional): Directory path for storing logs.
-            messages (Optional[pd.DataFrame]): A DataFrame containing conversation messages.
-            system (Union[str, System], optional): Initial system message or System object for the new branch.
-            tools (Optional[Union[Tool, List[Tool]]], optional): Tools to register with the new branch.
-            sender (Optional[str], optional): Sender of the initial system message.
-            service (OpenAIService, optional): Service used for the new branch if different from the session's service.
-            llmconfig (Dict[str, Any], optional): Configuration settings for the language model.
+            branch_name (str): Name for the new branch.
+            dir (Optional[str]): Path for storing branch-related logs.
+            messages (Optional[pd.DataFrame]): Initial set of messages for the branch.
+            tools (Optional[Union[Tool, List[Tool]]]): Tools to register in the new branch.
+            system (Optional[Union[str, System]]): System message or configuration for the branch.
+            sender (Optional[str]): Identifier for the sender of the initial message.
+            service (Optional[OpenAIService]): Service interface specific to the branch.
+            llmconfig (Optional[Dict[str, Any]]): Language model configurations for the branch.
 
         Raises:
-            ValueError: If the branch name already exists in the session.
+            ValueError: If the branch name already exists within the session.
         """
         if branch_name in self.branches.keys():
             raise ValueError(f'Invalid new branch name {branch_name}. Already existed.')
@@ -116,18 +103,19 @@ class Session:
         get_name: bool = False
     ) -> Union[Branch, Tuple[Branch, str]]:
         """
-        Retrieve a branch from the session.
+        Retrieves a branch from the session by name or as a Branch object.
+
+        If no branch is specified, returns the default branch. Optionally, can also return the branch's name.
 
         Args:
-            branch (Optional[Union[Branch, str]], optional): The branch or its name to retrieve.
-                Defaults to the default branch if not specified.
-            get_name (bool, optional): If True, returns the name of the branch along with the branch object.
+            branch (Optional[Union[Branch, str]]): The branch name or Branch object to retrieve. Defaults to None, which refers to the default branch.
+            get_name (bool): If True, also returns the name of the branch alongside the Branch object.
 
         Returns:
-            Union[Branch, Tuple[Branch, str]]: The branch object or a tuple of the branch object and its name.
+            Union[Branch, Tuple[Branch, str]]: The requested Branch object, or a tuple of the Branch object and its name if `get_name` is True.
 
         Raises:
-            ValueError: If the branch does not exist in the session.
+            ValueError: If the specified branch does not exist within the session.
         """
         if isinstance(branch, str):
             if branch not in self.branches.keys():
@@ -152,10 +140,10 @@ class Session:
 
     def change_default(self, branch: Union[str, Branch]) -> None:
         """
-        Change the default branch of the session.
+        Changes the default branch of the session.
 
         Args:
-            branch (Union[str, Branch]): The branch or its name to set as the new default.
+            branch (Union[str, Branch]): The branch name or Branch object to set as the new default branch.
         """
         branch_, name_ = self.get_branch(branch, get_name=True)
         self.default_branch = branch_
@@ -265,6 +253,45 @@ class Session:
             instruction=instruction, system=system, context=context,
             out=out, sender=sender, invoke=invoke, tools=tools, **kwargs)
 
+    async def ReAct(
+        self,
+        instruction: Union[Instruction, str],
+        context = None,
+        sender = None,
+        to_ = None,
+        system = None,
+        tools = None, 
+        num_rounds: int = 1,
+        fallback: Optional[Callable] = None,
+        fallback_kwargs: Optional[Dict] = None,
+        out=True,
+        **kwargs  
+    ):
+        """
+        Performs a sequence of reasoning and action steps in a specified or default branch.
+
+        Args:
+            instruction (Union[Instruction, str]): Instruction to initiate the ReAct process.
+            context: Additional context for reasoning and action. Defaults to None.
+            sender: Identifier for the sender. Defaults to None.
+            to_: Target branch name or object for ReAct. Defaults to the default branch.
+            system: System message or configuration. Defaults to None.
+            tools: Tools to be used for actions. Defaults to None.
+            num_rounds (int): Number of reasoning-action cycles. Defaults to 1.
+            fallback (Optional[Callable]): Fallback function in case of an error. Defaults to None.
+            fallback_kwargs (Optional[Dict]): Arguments for the fallback function. Defaults to None.
+            out (bool): If True, outputs the result of the ReAct process. Defaults to True.
+            **kwargs: Arbitrary keyword arguments for additional customization.
+
+        Returns:
+            The outcome of the ReAct process, depending on the specified branch and instructions.
+        """
+        branch = self.get_branch(to_)
+        return await branch.ReAct(
+            instruction=instruction, context=context, sender=sender, system=system, tools=tools, 
+            num_rounds=num_rounds, fallback=fallback, fallback_kwargs=fallback_kwargs, 
+            out=out, **kwargs
+        )
 
     async def auto_followup(
         self,
@@ -293,16 +320,8 @@ class Session:
         """
         
         branch_ = self.get_branch(to_)
-        if fallback:
-            try:
-                return await branch_.auto_followup(
-                    instruction=instruction, num=num, tools=tools,**kwargs
-                )
-            except:
-                return fallback(**fallback_kwargs)
-        
         return await branch_.auto_followup(
-            instruction=instruction, num=num, tools=tools,**kwargs
+            instruction=instruction, num=num, tools=tools, fallback=fallback, fallback_kwargs=fallback_kwargs, **kwargs
         )
 
     def change_first_system_message(self, system: Union[System, str]) -> None:
@@ -369,7 +388,7 @@ class Session:
 
     def register_tools(self, tools: Union[Tool, List[Tool]]) -> None:
         """
-        Registers one or more tools to the current active branch.
+        Registers one or more tools to the current default branch.
 
         Args:
             tools (Union[Tool, List[Tool]]): The tool or list of tools to register.
@@ -378,7 +397,7 @@ class Session:
 
     def delete_tool(self, name: str) -> bool:
         """
-        Deletes a tool from the current active branch.
+        Deletes a tool from the current default branch.
 
         Args:
             name (str): The name of the tool to delete.
@@ -391,10 +410,10 @@ class Session:
     @property
     def describe(self) -> Dict[str, Any]:
         """
-        Generates a report of the current active branch.
+        Generates a report of the current default branch.
 
         Returns:
-            Dict[str, Any]: The report of the current active branch.
+            Dict[str, Any]: The report of the current default branch.
         """
         return self.default_branch.describe
 
@@ -408,6 +427,60 @@ class Session:
         """
         return self.default_branch.messages
 
+
+    @property
+    def first_system(self) -> pd.Series:
+        """
+        Get the first system message of the current default branch.
+
+        Returns:
+            System: The first system message of the current default branch.
+        """
+        return self.default_branch.first_system
+    
+    @property
+    def last_response(self) -> pd.Series:
+        """
+        Get the last response message of the current default branch.
+
+        Returns:
+            str: The last response message of the current default branch.
+        """
+        return self.default_branch.last_response
+
+
+    @property
+    def last_response_content(self) -> Dict:
+        """
+        Get the last response content of the current default branch.
+
+        Returns:
+            Dict: The last response content of the current default branch.
+        """
+        return self.default_branch.last_response_content
+
+
+    def _verify_default_branch(self):
+        if self.branches:
+            if self.default_branch_name not in self.branches.keys():
+                raise ValueError('default branch name is not in imported branches')
+            if self.default_branch is not self.branches[self.default_branch_name]:
+                raise ValueError(f'default branch does not match Branch object under {self.default_branch_name}')
+            
+        if not self.branches:
+            self.branches[self.default_branch_name] = self.default_branch
+
+    def _setup_default_branch(
+        self, default_branch, default_branch_name, service, llmconfig, system, sender
+    ):
+        self.default_branch = default_branch if default_branch else Branch(
+            name=default_branch_name, service=service, llmconfig=llmconfig
+        )
+        self.default_branch_name = default_branch_name
+        if system:
+            self.default_branch.add_message(system=system, sender=sender)
+
+        self.llmconfig = self.default_branch.llmconfig
     # def add_instruction_set(self, name: str, instruction_set: InstructionSet) -> None:
     #     """
     #     Adds an instruction set to the current active branch.

lionagi/tools/tool_manager.py

@@ -1,50 +1,44 @@
 import json
 import asyncio
 from typing import Dict, Union, List, Tuple, Any
-from lionagi.utils.call_util import lcall, is_coroutine_func, _call_handler
+from lionagi.utils.call_util import lcall, is_coroutine_func, _call_handler, alcall
 from lionagi.schema import BaseNode, Tool
 
 
 class ToolManager(BaseNode):
     """
-    A manager class to handle registration and invocation of tools that are subclasses of Tool.
+    A manager class for handling the registration and invocation of tools that are subclasses of Tool.
     
+    This class maintains a registry of tool instances, allowing for dynamic invocation based on
+    tool name and provided arguments. It supports both synchronous and asynchronous tool function
+    calls.
+
     Attributes:
-        registry (Dict[str, Tool]): A dictionary to hold registered tools, using their names as keys.
+        registry (Dict[str, Tool]): A dictionary to hold registered tools, keyed by their names.
     """
     registry: Dict = {}
 
     def name_existed(self, name: str) -> bool:
         """
-        Check if a tool name already exists in the registry.
+        Checks if a tool name already exists in the registry.
 
-        Parameters:
+        Args:
             name (str): The name of the tool to check.
 
         Returns:
             bool: True if the name exists, False otherwise.
-
-        Examples:
-            >>> tool_manager.name_existed('existing_tool')
-            True
-            >>> tool_manager.name_existed('nonexistent_tool')
-            False
         """
         return True if name in self.registry.keys() else False
             
     def _register_tool(self, tool: Tool) -> None:
         """
-        Register a new tool in the registry if it's an instance of Tool.
+        Registers a tool in the registry. Raises a TypeError if the object is not an instance of Tool.
 
-        Parameters:
+        Args:
             tool (Tool): The tool instance to register.
 
         Raises:
-            TypeError: If the provided tool is not an instance of Tool.
-
-        Examples:
-            >>> tool_manager._register_tool(Tool())
-            # Tool is registered without any output
+            TypeError: If the provided object is not an instance of Tool.
         """
         if not isinstance(tool, Tool):
             raise TypeError('Please register a Tool object.')
@@ -53,20 +47,16 @@ class ToolManager(BaseNode):
                 
     async def invoke(self, func_call: Tuple[str, Dict[str, Any]]) -> Any:
         """
-        Invoke a registered tool's function with the provided arguments.
+        Invokes a registered tool's function with the given arguments. Supports both coroutine and regular functions.
 
         Args:
-            func_call (Tuple[str, Dict[str, Any]]): A tuple containing the tool's function name and kwargs.
+            func_call (Tuple[str, Dict[str, Any]]): A tuple containing the function name and a dictionary of keyword arguments.
 
         Returns:
-            Any: The result of the tool's function invocation.
+            Any: The result of the function call.
 
         Raises:
-            ValueError: If the function is not registered or an error occurs during invocation.
-
-        Examples:
-            >>> await tool_manager.invoke(('registered_function', {'arg1': 'value1'}))
-            # Result of the registered_function with given arguments
+            ValueError: If the function name is not registered or if there's an error during function invocation.
         """
         name, kwargs = func_call
         if self.name_existed(name):
@@ -74,10 +64,13 @@ class ToolManager(BaseNode):
             func = tool.func
             parser = tool.parser
             try:
-                tasks = [await _call_handler(func, **kwargs)]
-                out = await asyncio.gather(*tasks)
-                return parser(out) if parser else out
-            
+                if is_coroutine_func(func):
+                    tasks = [_call_handler(func, **kwargs)]
+                    out = await asyncio.gather(*tasks)
+                    return parser(out[0]) if parser else out[0]
+                else:
+                    out = func(**kwargs)
+                    return parser(out) if parser else out
             except Exception as e:
                 raise ValueError(f"Error when invoking function {name} with arguments {kwargs} with error message {e}")
         else: 
@@ -86,20 +79,16 @@ class ToolManager(BaseNode):
     @staticmethod
     def get_function_call(response: Dict) -> Tuple[str, Dict]:
         """
-        Extract function name and arguments from a response JSON.
+        Extracts a function call and arguments from a response dictionary.
 
-        Parameters:
-            response (Dict): The JSON response containing function information.
+        Args:
+            response (Dict): The response dictionary containing the function call information.
 
         Returns:
-            Tuple[str, Dict]: The function name and its arguments.
+            Tuple[str, Dict]: A tuple containing the function name and a dictionary of arguments.
 
         Raises:
-            ValueError: If the response is not a valid function call.
-
-        Examples:
-            >>> ToolManager.get_function_call({"action": "execute_add", "arguments": '{"x":1, "y":2}'})
-            ('add', {'x': 1, 'y': 2})
+            ValueError: If the response does not contain valid function call information.
         """
         try:
             func = response['action'][7:]
@@ -115,27 +104,20 @@ class ToolManager(BaseNode):
     
     def register_tools(self, tools: List[Tool]) -> None:
         """
-        Register multiple tools using a given list.
+        Registers multiple tools in the registry.
 
-        Parameters:
-            tools (List[Tool]): A list of Tool instances to register.
-
-        Examples:
-            >>> tool_manager.register_tools([Tool(), Tool()])
-            # Multiple Tool instances registered
+        Args:
+            tools (List[Tool]): A list of tool instances to register.
         """
-        lcall(tools, self._register_tool) #, update=update, new=new, prefix=prefix, postfix=postfix)
+        lcall(tools, self._register_tool) 
 
     def to_tool_schema_list(self) -> List[Dict[str, Any]]:
         """
-        Convert the registry of tools to a list of their schemas.
+        Generates a list of schemas for all registered tools.
 
         Returns:
             List[Dict[str, Any]]: A list of tool schemas.
-
-        Examples:
-            >>> tool_manager.to_tool_schema_list()
-            # Returns a list of registered tool schemas
+        
         """
         schema_list = []
         for tool in self.registry.values():
@@ -144,21 +126,17 @@ class ToolManager(BaseNode):
 
     def _tool_parser(self, tools: Union[Dict, Tool, List[Tool], str, List[str], List[Dict]], **kwargs) -> Dict:
         """
-        Parse tools and additional keyword arguments to form a dictionary used for tool configuration.
+        Parses tool information and generates a dictionary for tool invocation.
 
-        Parameters:
-            tools: A single tool object, a list of tool objects, a tool name, a list of tool names, or a dictionary.
+        Args:
+            tools: Tool information which can be a single Tool instance, a list of Tool instances, a tool name, or a list of tool names.
             **kwargs: Additional keyword arguments.
 
         Returns:
-            Dict: A dictionary of tools and additional keyword arguments.
+            Dict: A dictionary containing tool schema information and any additional keyword arguments.
 
         Raises:
-            ValueError: If a tool name string does not correspond to a registered tool.
-
-        Examples:
-            >>> tool_manager._tool_parser('registered_tool')
-            # Returns a dictionary containing the schema of the registered tool
+            ValueError: If a tool name is provided that is not registered.
         """
         def tool_check(tool):
             if isinstance(tool, dict):
@@ -183,4 +161,3 @@ class ToolManager(BaseNode):
             kwargs = {**tool_kwarg, **kwargs}
             
         return kwargs
-    

lionagi/utils/__init__.py

@@ -1,7 +1,8 @@
 from .sys_util import (
     get_timestamp, create_copy, create_path, split_path, 
     get_bins, change_dict_key, str_to_num, create_id, 
-    as_dict, is_package_installed, install_import)
+    as_dict, is_package_installed, install_import, to_df
+    )
 
 from .nested_util import (
     to_readable_dict, nfilter, nset, nget, 
@@ -19,7 +20,7 @@ from .call_util import (
 
 
 __all__ = [
-    "is_package_installed", "install_import",
+    "is_package_installed", "install_import", "to_df",
     'get_timestamp', 'create_copy', 'create_path', 'split_path',
     'get_bins', 'change_dict_key', 'str_to_num', 'create_id',
     'as_dict', 'to_list', 'to_readable_dict', 'nfilter', 'nset',

lionagi/utils/call_util.py

@@ -92,7 +92,7 @@ def is_coroutine_func(func: Callable) -> bool:
     return asyncio.iscoroutinefunction(func)
 
 async def alcall(
-    input: Any, func: Callable, flatten: bool = False, **kwargs
+    input: Any = None, func: Callable = None, flatten: bool = False, **kwargs
 )-> List[Any]:
     """
     Asynchronously apply a function to each element in the input.
@@ -111,8 +111,12 @@ async def alcall(
         >>> asyncio.run(alcall([1, 2, 3], square))
         [1, 4, 9]
     """
-    lst = to_list(input=input)
-    tasks = [func(i, **kwargs) for i in lst]
+    if input:
+        lst = to_list(input=input)
+        tasks = [func(i, **kwargs) for i in lst]
+    else:
+        tasks = [func(**kwargs)]
+        
     outs = await asyncio.gather(*tasks)
     return to_list(outs, flatten=flatten)
 
@@ -833,16 +837,14 @@ async def _call_handler(
                 loop = asyncio.get_running_loop()
             except RuntimeError:  # No running event loop
                 loop = asyncio.new_event_loop()
-                asyncio.set_event_loop(loop)
-                # Running the coroutine in the new loop
                 result = loop.run_until_complete(func(*args, **kwargs))
+                
                 loop.close()
                 return result
 
             if loop.is_running():
-                return asyncio.ensure_future(func(*args, **kwargs))
-            else:
                 return await func(*args, **kwargs)
+
         else:
             return func(*args, **kwargs)