lionagi 0.0.104__py3-none-any.whl → 0.0.105__py3-none-any.whl

lionagi/session/conversation.py

@@ -2,87 +2,91 @@ from .message import Message
 
 class Conversation:
     """
-    A class modeling conversations and managing messages within the conversation.
+    A class representing a conversation between users and the assistant.
 
-    This class facilitates the organization and manipulation of messages in a conversation.
-    It includes methods for initiating a conversation, adding messages, changing the system message,
-    appending the last response, and keeping the last N exchanges.
+    This class manages the exchange of messages within a conversation, including system settings,
+    user instructions, and assistant responses.
 
     Attributes:
-        response_counts: A class-level attribute to track the number of responses.
-        messages: A list containing messages in the conversation.
-        msg: An instance of the Message class for creating and processing messages.
-        responses: A list containing response messages.
+        response_counts (int): The count of assistant responses in the conversation.
+        messages (list): A list to store messages in the conversation.
+        msg (Message): An instance of the Message class for creating messages.
+        responses (list): A list to store assistant responses in the conversation.
 
     Methods:
-        initiate_conversation: Start a new conversation with system and user instructions.
-        add_messages: Add messages to the conversation.
-        change_system: Change the system message in the conversation.
-        append_last_response: Append the last response to the conversation.
-        keep_last_n_exchanges: Keep only the last N exchanges in the conversation.
+        initiate_conversation(system, instruction, context=None, name=None):
+            Initiate a conversation with a system setting and user instruction.
+
+        add_messages(system, instruction, context=None, response=None, tool=None, name=None):
+            Add messages to the conversation, including system setting, user instruction, and assistant response.
+
+        change_system(system):
+            Change the system setting in the conversation.
+
+        keep_last_n_exchanges(n: int):
+            Keep the last n exchanges in the conversation.
     """
-    
     response_counts = 0
     
     def __init__(self, messages=None) -> None:
         """
         Initialize a Conversation object.
 
-        Args:
-            messages: A list of messages to initialize the conversation.
+        Parameters:
+            messages (list): A list of messages to initialize the conversation. Default is None.
+
         """
         self.messages = messages or []
         self.msg = Message()
         self.responses = []
 
-    def initiate_conversation(self, system, instruction, context=None):
+    def initiate_conversation(self, system, instruction, context=None, name=None):
         """
-        Start a new conversation with a system message and an instruction.
+        Initiate a conversation with a system setting and user instruction.
 
-        Args:
-            system: The content of the system message.
-            instruction: The content of the user instruction.
-            context: Additional context for the user instruction.
+        Parameters:
+            system (str): The system setting for the conversation.
+            instruction (str): The user instruction to initiate the conversation.
+            context (dict): Additional context for the conversation. Default is None.
+            name (str): The name associated with the user. Default is None.
         """
         self.messages, self.responses = [], []
         self.add_messages(system=system)
-        self.add_messages(instruction=instruction, context=context)
+        self.add_messages(instruction=instruction, context=context, name=name)
 
-    def add_messages(self, system=None, instruction=None, context=None, response=None):
+    # modify the message adding to accomodate tools
+    def add_messages(self, system=None, instruction=None, context=None, response=None, tool=None, name=None):
         """
-        Add messages to the conversation.
+        Add messages to the conversation, including system setting, user instruction, and assistant response.
 
-        Args:
-            system: The content of the system message.
-            instruction: The content of the user instruction.
-            context: Additional context for the user instruction.
-            response: The content of the assistant's response.
+        Parameters:
+            system (str): The system setting for the message. Default is None.
+            instruction (str): The instruction content for the message. Default is None.
+            context (dict): Additional context for the message. Default is None.
+            response (dict): The response content for the message. Default is None.
+            tool (dict): The tool information for the message. Default is None.
+            name (str): The name associated with the message. Default is None.
         """
-        msg = self.msg(system=system, instruction=instruction, response=response, context=context)
+        msg = self.msg(system=system, instruction=instruction, context=context, response=response, tool=tool, name=name)
         self.messages.append(msg)
 
     def change_system(self, system):
         """
-        Change the system message in the conversation.
+        Change the system setting in the conversation.
 
-        Args:
-            system: The new content for the system message.
+        Parameters:
+            system (str): The new system setting for the conversation.
         """
         self.messages[0] = self.msg(system=system)
 
-    def append_last_response(self):
-        """
-        Append the last response to the conversation.
-        """
-        self.add_messages(response=self.responses[-1])
-
     def keep_last_n_exchanges(self, n: int):
         """
-        Keep only the last N exchanges in the conversation.
+        Keep the last n exchanges in the conversation.
 
-        Args:
-            n: The number of exchanges to keep.
+        Parameters:
+            n (int): The number of exchanges to keep.
         """
+        # keep last n_exchanges, one exchange is marked by one assistant response
         response_indices = [
             index for index, message in enumerate(self.messages[1:]) if message["role"] == "assistant"
         ]

lionagi/session/message.py

@@ -1,76 +1,139 @@
 from datetime import datetime
 import json
-from ..utils.sys_util import create_id
+from ..utils.sys_util import create_id, l_call
 from ..utils.log_util import DataLogger
 
 
 class Message:
     """
-    A class modeling messages in conversations.
+    A class representing a message in a conversation.
 
-    This class is designed to encapsulate messages exchanged between different roles
-    (user, assistant, or system) in a conversation. It includes functionality to process,
-    log, and manage messages.
+    This class encapsulates messages from users, the assistant, systems, and external tools.
 
     Attributes:
-        role: The role of the message (user, assistant, or system).
-        content: The content of the message.
-        sender: The sender of the message.
-        logger: An instance of DataLogger for logging message information.
+        role (str): The role of the message, indicating if it's from the user, assistant, system, or tool.
+        content: The content of the message, which can be an instruction, response, system setting, or tool information.
+        name (str): The name associated with the message, specifying the source (user, assistant, system, or tool).
+        metadata (dict): Additional metadata including id, timestamp, and name.
+        _logger (DataLogger): An instance of the DataLogger class for logging message details.
 
     Methods:
-        __call__: Process and log a message based on its role.
+        create_message(system, instruction, context, response, tool, name):
+            Create a message based on the provided information.
+
+        to_json() -> dict:
+            Convert the message to a JSON format.
+
+        __call__(system, instruction, context, response, name, tool) -> dict:
+            Create and return a message in JSON format.
+
+        to_csv(dir, filename, verbose, timestamp, dir_exist_ok, file_exist_ok):
+            Save the message to a CSV file.
     """
     def __init__(self) -> None:
         """
-        Initialize a Message object with attributes for role, content, sender, and a DataLogger.
+        Initialize a Message object.
         """
         self.role = None
         self.content = None
-        self.sender = None
-        self.logger = DataLogger()
-
-    def __call__(self, system=None, instruction=None, response=None, context=None, sender=None):
+        self.name = None
+        self.metadata = None
+        self._logger = DataLogger()
+    
+    def create_message(self, system=None, instruction=None, context=None, response=None, tool=None, name=None):
         """
-        Process and log a message based on the specified role (system, instruction, or response).
+        Create a message based on the provided information.
 
-        Args:
-            system: The content of the message in the system role.
-            instruction: The content of the message in the user role.
-            response: The content of the message in the assistant role.
-            context: Additional context for the user instruction.
-            sender: The sender of the message.
+        Parameters:
+            system (str): The system setting for the message. Default is None.
+            instruction (str): The instruction content for the message. Default is None.
+            context (dict): Additional context for the message. Default is None.
+            response (dict): The response content for the message. Default is None.
+            tool (dict): The tool information for the message. Default is None.
+            name (str): The name associated with the message. Default is None.
         """
+        if sum(l_call([system, instruction, response, tool], bool)) > 1:
+            raise ValueError("Error: Message cannot have more than one role.")
         
-        if sum(map(bool, [system, instruction, response])) > 1:
-            raise ValueError("Message cannot have more than one role.")
-        else:
+        else: 
             if response:
                 self.role = "assistant"
-                self.sender = sender or "assistant"
-                self.content = response['content']
+                response = response["message"]
+                if str(response['content']) == "None":
+                    try:
+                        # currently can only support a single function response
+                        if response['tool_calls'][0]['type'] == 'function':
+                            self.name = name or ("func_" + response['tool_calls'][0]['function']['name'])
+                            content = response['tool_calls'][0]['function']['arguments']
+                            self.content = {"function":self.name, "arguments": content}
+                    except:
+                        raise ValueError("Response message must be one of regular response or function calling")
+                else:
+                    self.content = response['content']
+                    self.name = name or "assistant"
             elif instruction:
                 self.role = "user"
-                self.sender = sender or "user"
                 self.content = {"instruction": instruction}
+                self.name = name or "user"
                 if context:
-                    self.content.update(context)
+                    self.content.update({"context": context})
             elif system:
                 self.role = "system"
-                self.sender = sender or "system"
                 self.content = system
+                self.name = name or "system"
+            elif tool:
+                self.role = "tool"
+                self.content = tool
+                self.name = name or "tool"
+    
+    def to_json(self):
+        """
+        Convert the message to a JSON format.
+
+        Returns:
+        - dict: The message in JSON format.
+        """
         out = {
             "role": self.role,
             "content": json.dumps(self.content) if isinstance(self.content, dict) else self.content
             }
-        
-        a = {**{
+    
+        self.metadata = {
             "id": create_id(),
             "timestamp": datetime.now().isoformat(),
-            "sender": self.sender
-        }, **out}
-        self.logger(a)
+            "name": self.name}
+        
+        self._logger({**self.metadata, **out})
         return out
+        
+    def __call__(self, system=None, instruction=None, context=None, response=None, name=None, tool=None):
+        """
+        Create and return a message in JSON format.
+
+        Parameters:
+            system (str): The system setting for the message. Default is None.
+            instruction (str): The instruction content for the message. Default is None.
+            context (dict): Additional context for the message. Default is None.
+            response (dict): The response content for the message. Default is None.
+            name (str): The name associated with the message. Default is None.
+            tool (dict): The tool information for the message. Default is None.
+
+        Returns:
+            dict: The message in JSON format.
+        """
+        self.create_message(system, instruction, context, response, tool, name)
+        return self.to_json()
     
-    def _to_csv(self, dir, filename, verbose=True, timestamp=True, dir_exist_ok=True, file_exist_ok=False):
-        self.logger.to_csv(dir, filename, verbose, timestamp, dir_exist_ok, file_exist_ok)
+    def to_csv(self, dir=None, filename=None, verbose=True, timestamp=True, dir_exist_ok=True, file_exist_ok=False):
+        """
+        Save the message to a CSV file.
+
+        Parameters:
+            dir (str): The directory path for saving the CSV file. Default is None.
+            filename (str): The filename for the CSV file. Default is None.
+            verbose (bool): Whether to include verbose information in the CSV. Default is True.
+            timestamp (bool): Whether to include timestamps in the CSV. Default is True.
+            dir_exist_ok (bool): Whether to allow the directory to exist. Default is True.
+            file_exist_ok (bool): Whether to allow the file to exist. Default is False.
+        """
+        self._logger.to_csv(dir, filename, verbose, timestamp, dir_exist_ok, file_exist_ok)

lionagi/session/session.py

@@ -3,108 +3,222 @@ import asyncio
 from typing import Any
 
 from .conversation import Conversation
-from ..api.oai_config import oai_llmconfig
+from ..utils.sys_util import to_list
 from ..utils.log_util import DataLogger
 from ..utils.api_util import StatusTracker
+from ..utils.tool_util import ToolManager
 from ..api.oai_service import OpenAIService
 
+from ..api.oai_config import oai_llmconfig
+
 
 status_tracker = StatusTracker()
 OAIService = OpenAIService()
 
 class Session():
     """
-    A class representing a conversation session with chat completion capabilities.
+    A class representing a conversation session with a conversational AI system.
 
-    This class manages conversations, interacts with chat completion services (currently OpenAI),
-    and logs the interactions using a DataLogger.
+    This class manages the flow of conversation, system settings, and interactions with external tools.
 
     Attributes:
-        conversation: An instance of the Conversation class for managing messages.
-        system: The system identifier for the conversation session.
-        llmconfig: Configuration parameters for language models.
-        logger: An instance of DataLogger for logging conversation interactions.
-        api_service: An instance of the API service for making asynchronous API calls.
+        conversation (Conversation): An instance of the Conversation class to manage messages.
+        system (str): The current system setting for the conversation.
+        llmconfig (dict): Configuration settings for the language model.
+        _logger (DataLogger): An instance of the DataLogger class for logging conversation details.
+        api_service: An instance of the API service for making calls to the conversational AI model.
+        toolmanager (ToolManager): An instance of the ToolManager class for managing external tools.
 
     Methods:
-        initiate: Initiate a conversation session with the given instruction.
-        followup: Continue the conversation session with a follow-up instruction.
-        create_payload_chatcompletion: Create a payload for chat completion API calls.
-        call_chatcompletion: Make an asynchronous call to the chat completion API.
+        set_dir(dir):
+            Set the directory for logging.
+
+        set_system(system):
+            Set the system for the conversation.
+
+        set_llmconfig(llmconfig):
+            Set the language model configuration.
+
+        set_api_service(api_service):
+            Set the API service for making model calls.
+
+        _output(output, invoke=True, out=True) -> Any:
+            Process the output, invoke tools if needed, and optionally return the output.
+
+        register_tools(tools, funcs, update=False, new=False, prefix=None, postfix=None):
+            Register tools and their corresponding functions.
+
+        initiate(instruction, system=None, context=None, out=True, name=None, invoke=True, **kwargs) -> Any:
+            Start a new conversation session with the provided instruction.
+
+        followup(instruction, system=None, context=None, out=True, name=None, invoke=True, **kwargs) -> Any:
+            Continue the conversation with the provided instruction.
+
+        create_payload_chatcompletion(**kwargs) -> dict:
+            Create a payload for chat completion based on the conversation state and configuration.
+
+        call_chatcompletion(sleep=0.1, **kwargs) -> None:
+            Make a call to the chat completion API and process the response.
+
+        messages_to_csv(dir=None, filename="_messages.csv", **kwargs) -> None:
+            Save conversation messages to a CSV file.
+
+        log_to_csv(dir=None, filename="_llmlog.csv", **kwargs) -> None:
+            Save conversation logs to a CSV file.
     """
     
     def __init__(self, system, dir=None, llmconfig=oai_llmconfig, api_service=OAIService):
         """
-        Initialize a Session object.
+        Initialize a Session object with default or provided settings.
 
-        Args:
-            system: The system identifier for the conversation session.
-            dir: The directory for logging interactions.
-            llmconfig: Configuration parameters for language models.
-            api_service: An instance of the API service for making asynchronous API calls.
+        Parameters:
+            system (str): The initial system setting for the conversation.
+            dir (Optional[str]): The directory for logging. Default is None.
+            llmconfig (Optional[dict]): Configuration settings for the language model. Default is oai_llmconfig.
+            api_service: An instance of the API service for making calls to the conversational AI model.
         """
         self.conversation = Conversation()
         self.system = system
         self.llmconfig = llmconfig
-        self.logger = DataLogger(dir=dir)
+        self._logger = DataLogger(dir=dir)
+        self.api_service = api_service
+        self.toolmanager = ToolManager()
+    
+    def set_dir(self, dir):
+        """
+        Set the directory for logging.
+
+        Parameters:
+            dir (str): The directory path.
+        """
+        self._logger.dir = dir
+    
+    def set_system(self, system):
+        """
+        Set the system for the conversation.
+
+        Parameters:
+            system (str): The system setting.
+        """
+        self.conversation.change_system(system)
+    
+    def set_llmconfig(self, llmconfig):
+        """
+        Set the language model configuration.
+
+        Parameters:
+            llmconfig (dict): Configuration settings for the language model.
+        """
+        self.llmconfig = llmconfig
+    
+    def set_api_service(self, api_service):
+        """
+        Set the API service for making model calls.
+
+        Parameters:
+            api_service: An instance of the API service.
+        """
         self.api_service = api_service
     
-    async def initiate(self, instruction, system=None, context=None, out=True, **kwargs) -> Any:
+    async def _output(self, output, invoke=True, out=True):
         """
-        Initiate a conversation session with the given instruction.
+        Process the output, invoke tools if needed, and optionally return the output.
 
-        Args:
-            instruction: The user's instruction to initiate the conversation.
-            system: The content of the system message.
-            context: Additional context for the user instruction.
-            out: Whether to return the output content.
+        Parameters:
+            output: The output to process.
+            invoke (bool): Whether to invoke tools based on the output. Default is True.
+            out (bool): Whether to return the output. Default is True.
 
         Returns:
-            Any: The output content if 'out' is True, otherwise None.
+            Any: The processed output.
+        """
+        if invoke:
+            try: 
+                func, args = self.toolmanager._get_function_call(output)
+                outs = await self.toolmanager.ainvoke(func, args)
+                self.conversation.add_messages(tool=outs)
+            except:
+                pass
+        if out:
+            return output
+        
+    def register_tools(self, tools, funcs, update=False, new=False, prefix=None, postfix=None):
+        """
+        Register tools and their corresponding functions.
+
+        Parameters:
+            tools (list): The list of tool information dictionaries.
+            funcs (list): The list of corresponding functions.
+            update (bool): Whether to update existing functions.
+            new (bool): Whether to create new registries for existing functions.
+            prefix (Optional[str]): A prefix to add to the function names.
+            postfix (Optional[str]): A postfix to add to the function names.
+        """
+        funcs = to_list(funcs)
+        self.toolmanager.register_tools(tools, funcs, update, new, prefix, postfix)
+    
+    async def initiate(self, instruction, system=None, context=None, out=True, name=None, invoke=True, **kwargs) -> Any:
+        """
+        Start a new conversation session with the provided instruction.
+
+        Parameters:
+            instruction (str): The instruction to initiate the conversation.
+            system (Optional[str]): The system setting for the conversation. Default is None.
+            context (Optional[dict]): Additional context for the instruction. Default is None.
+            out (bool): Whether to return the output. Default is True.
+            name (Optional[str]): The name associated with the instruction. Default is None.
+            invoke (bool): Whether to invoke tools based on the output. Default is True.
+            kwargs: Additional keyword arguments for configuration.
+
+        Returns:
+            Any: The processed output.
         """
         config = {**self.llmconfig, **kwargs}
         system = system or self.system
-        self.conversation.initiate_conversation(system=system, instruction=instruction, context=context)
-        
+        self.conversation.initiate_conversation(system=system, instruction=instruction, context=context, name=name)
         await self.call_chatcompletion(**config)
-        if out:
-            return self.conversation.responses[-1]['content']        
+        output = self.conversation.responses[-1]['content']
+        
+        return await self._output(output, invoke, out)
 
-    async def followup(self, instruction, system=None, context=None, out=True, **kwargs) -> Any:
+    async def followup(self, instruction, system=None, context=None, out=True, name=None, invoke=True, **kwargs) -> Any:
         """
-        Continue the conversation session with a follow-up instruction.
+        Continue the conversation with the provided instruction.
 
-        Args:
-            instruction: The user's follow-up instruction.
-            system: The content of the system message.
-            context: Additional context for the user instruction.
-            out: Whether to return the output content.
+        Parameters:
+            instruction (str): The instruction to continue the conversation.
+            system (Optional[str]): The system setting for the conversation. Default is None.
+            context (Optional[dict]): Additional context for the instruction. Default is None.
+            out (bool): Whether to return the output. Default is True.
+            name (Optional[str]): The name associated with the instruction. Default is None.
+            invoke (bool): Whether to invoke tools based on the output. Default is True.
+            kwargs: Additional keyword arguments for configuration.
 
         Returns:
-            Any: The output content if 'out' is True, otherwise None.
+            Any: The processed output.
         """
-        self.conversation.append_last_response()
         if system:
             self.conversation.change_system(system)
-        self.conversation.add_messages(instruction=instruction, context=context)
-        
+        self.conversation.add_messages(instruction=instruction, context=context, name=name)
         config = {**self.llmconfig, **kwargs}
         await self.call_chatcompletion(**config)
-        if out:
-            return self.conversation.responses[-1]['content']
+        output = self.conversation.responses[-1]['content']
+        
+        return await self._output(output, invoke, out)
     
     def create_payload_chatcompletion(self, **kwargs):
         """
-        Create a payload for chat completion API calls.
+        Create a payload for chat completion based on the conversation state and configuration.
+
+        Parameters:
+            kwargs: Additional keyword arguments for configuration.
 
-        Args:
-            kwargs: Additional keyword arguments for customization.
+        Returns:
+            dict: The payload for chat completion.
         """
         # currently only openai chat completions are supported
         messages = self.conversation.messages
-        
         config = {**self.llmconfig, **kwargs}
-        
         payload = {
             "messages": messages,
             "model": config.get('model'),
@@ -117,34 +231,30 @@ class Session():
             }
         
         for key in ["seed", "stop", "stream", "tools", "tool_choice", "user", "max_tokens"]:
-            if config[key] is True:
+            if bool(config[key]) is True and str(config[key]) != "none":
                 payload.update({key: config[key]})
-    
         return payload
-    
-    async def call_chatcompletion(self, delay=1, **kwargs):
+
+    async def call_chatcompletion(self, sleep=0.1,  **kwargs):
         """
-        Make an asynchronous call to the chat completion API.
+        Make a call to the chat completion API and process the response.
 
-        Args:
-            delay: The delay (in seconds) between API calls.
-            kwargs: Additional keyword arguments for customization.
+        Parameters:
+            sleep (float): The sleep duration after making the API call. Default is 0.1.
+            kwargs: Additional keyword arguments for configuration.
         """
-        # currently only openai chat completions are supported
-        
         endpoint = f"chat/completions"
         try:
             async with aiohttp.ClientSession() as session:
+                payload = self.create_payload_chatcompletion(**kwargs)
                 completion = await self.api_service.call_api(
-                                session, endpoint,
-                                self.create_payload_chatcompletion(**kwargs))
+                                session, endpoint, payload)
                 if "choices" in completion:
-                    completion = completion['choices'][0]       # currently can only call one completion at a time, n has to be 1
-                    self.logger({"input":self.conversation.messages, "output": completion})
-                    response = {"role": "assistant", "content": completion['message']["content"]}
-                    self.conversation.responses.append(response)
+                    self._logger({"input":payload, "output": completion})
+                    self.conversation.add_messages(response=completion['choices'][0])
+                    self.conversation.responses.append(self.conversation.messages[-1])
                     self.conversation.response_counts += 1
-                    await asyncio.sleep(delay=delay)
+                    await asyncio.sleep(sleep)
                     status_tracker.num_tasks_succeeded += 1
                 else:
                     status_tracker.num_tasks_failed += 1
@@ -153,13 +263,29 @@ class Session():
             raise e
     
     def messages_to_csv(self, dir=None, filename="_messages.csv", **kwags):
-        dir = dir or self.logger.dir
+        """
+        Save conversation messages to a CSV file.
+
+        Parameters:
+            dir (Optional[str]): The directory path for saving the CSV file. Default is None.
+            filename (Optional[str]): The filename for the CSV file. Default is "_messages.csv".
+            kwargs: Additional keyword arguments for CSV file settings.
+        """
+        dir = dir or self._logger.dir
         if dir is None:
             raise ValueError("No directory specified.")
-        self.conversation.msg._to_csv(dir=dir, filename=filename, **kwags)
+        self.conversation.msg.to_csv(dir=dir, filename=filename, **kwags)
         
     def log_to_csv(self, dir=None, filename="_llmlog.csv", **kwags):
-        dir = dir or self.logger.dir
+        """
+        Save conversation logs to a CSV file.
+
+        Parameters:
+            dir (Optional[str]): The directory path for saving the CSV file. Default is None.
+            filename (Optional[str]): The filename for the CSV file. Default is "_llmlog.csv".
+            kwargs: Additional keyword arguments for CSV file settings.
+        """
+        dir = dir or self._logger.dir
         if dir is None:
             raise ValueError("No directory specified.")
-        self.logger.to_csv(dir=dir, filename=filename, **kwags)
+        self._logger.to_csv(dir=dir, filename=filename, **kwags)

lionagi/utils/__init__.py

@@ -1,9 +1,10 @@
 from .sys_util import to_flat_dict, append_to_jsonl, to_list, str_to_num, make_copy, to_temp, to_csv, hold_call, ahold_call, l_call, al_call, m_call, am_call, e_call, ae_call, get_timestamp, create_path
 from .doc_util import dir_to_path, read_text, dir_to_files, chunk_text, file_to_chunks, file_to_chunks, get_bins
 from .log_util import DataLogger
+from .tool_util import ToolManager
 
 __all__ = [
     "to_list", "str_to_num", "make_copy", "to_temp", "to_csv", "hold_call", "ahold_call", "l_call", "al_call", "m_call", "am_call", "e_call", "ae_call", "get_timestamp", "create_path", "to_flat_dict", "append_to_jsonl",
     "dir_to_path", "read_text", "dir_to_files", "chunk_text", "file_to_chunks", "file_to_chunks", "get_bins",
-    "DataLogger"
+    "DataLogger", "ToolManager"
 ]

lionagi/utils/doc_util.py

@@ -26,7 +26,7 @@ def dir_to_path(dir: str, ext, recursive: bool = False, flat: bool = True):
     def _dir_to_path(ext, recursive=recursive):
         tem = '**/*' if recursive else '*'
         return list(Path(dir).glob(tem + ext))
-    
+
     return to_list(l_call(ext, _dir_to_path, flat=True), flat=flat)
 
 def read_text(filepath: str, clean: bool = True) -> str:
@@ -48,15 +48,15 @@ def read_text(filepath: str, clean: bool = True) -> str:
         content = f.read()
         if clean:
             # Define characters to replace and their replacements
-            replacements = {'\\': ' ', '\\\n': ' ', '\\\t': ' ', '  ': ' ', '\'': ' '}
+            replacements = {'\\': ' ', '\n': ' ', '\t': ' ', '  ': ' ', '\'': ' '}
             for old, new in replacements.items():
                 content = content.replace(old, new)
         return content
 
-def dir_to_files(dir: str, ext: str, recursive: bool = False, 
-                 reader: Callable = read_text, clean: bool = True, 
+def dir_to_files(dir: str, ext: str, recursive: bool = False,
+                 reader: Callable = read_text, clean: bool = True,
                  to_csv: bool = False, project: str = 'project',
-                 output_dir: str = 'data/logs/sources/', filename: Optional[str] = None, 
+                 output_dir: str = 'data/logs/sources/', filename: Optional[str] = None,
                  verbose: bool = True, timestamp: bool = True, logger: Optional[DataLogger] = None):
     """
     Reads and processes files in a specified directory with the given extension.
@@ -81,9 +81,9 @@ def dir_to_files(dir: str, ext: str, recursive: bool = False,
     Examples:
         >>> logs = dir_to_files(dir='my_directory', ext='.txt', to_csv=True)
     """
-    
+
     sources = dir_to_path(dir, ext, recursive)
-    
+
     def split_path(path: Path) -> tuple:
         folder_name = path.parent.name
         file_name = path.name
@@ -99,9 +99,9 @@ def dir_to_files(dir: str, ext: str, recursive: bool = False,
             "file_size": len(str(content)),
             'content': content
         } if content else None
-    
+
     logs = to_list(l_call(sources, to_dict, flat=True), dropna=True)
-    
+
     if to_csv:
         filename = filename or f"{project}_sources.csv"
         logger = DataLogger(dir=output_dir, log=logs) if not logger else logger
@@ -109,7 +109,7 @@ def dir_to_files(dir: str, ext: str, recursive: bool = False,
 
     return logs
 
-def chunk_text(input: str, chunk_size: int, overlap: float, 
+def chunk_text(input: str, chunk_size: int, overlap: float,
                threshold: int) -> List[Union[str, None]]:
     """
     Splits a string into chunks of a specified size, allowing for optional overlap between chunks.
@@ -127,19 +127,19 @@ def chunk_text(input: str, chunk_size: int, overlap: float,
     Returns:
         List[Union[str, None]]: List of text chunks.
     """
-    
+
     try:
         # Ensure text is a string
         if not isinstance(input, str):
             input = str(input)
-        
+
         chunks = []
         n_chunks = math.ceil(len(input) / chunk_size)
         overlap_size = int(chunk_size * overlap / 2)
-        
+
         if n_chunks == 1:
             return [input]
-        
+
         elif n_chunks == 2:
             chunks.append(input[:chunk_size + overlap_size])
             if len(input) - chunk_size > threshold:
@@ -147,28 +147,28 @@ def chunk_text(input: str, chunk_size: int, overlap: float,
             else:
                 return [input]
             return chunks
-        
+
         elif n_chunks > 2:
             chunks.append(input[:chunk_size + overlap_size])
             for i in range(1, n_chunks - 1):
                 start_idx = chunk_size * i - overlap_size
                 end_idx = chunk_size * (i + 1) + overlap_size
                 chunks.append(input[start_idx:end_idx])
-            
+
             if len(input) - chunk_size * (n_chunks - 1) > threshold:
                 chunks.append(input[chunk_size * (n_chunks - 1) - overlap_size:])
             else:
-                chunks[-1] += input[chunk_size * (n_chunks - 1):]
-            
+                chunks[-1] += input[chunk_size * (n_chunks - 1) + overlap_size:]
+
             return chunks
-        
+
     except Exception as e:
         raise ValueError(f"An error occurred while chunking the text. {e}")
 
-def _file_to_chunks(input: Dict[str, Any], 
-                   field: str = 'content', 
-                   chunk_size: int = 1500, 
-                   overlap: float = 0.2, 
+def _file_to_chunks(input: Dict[str, Any],
+                   field: str = 'content',
+                   chunk_size: int = 1500,
+                   overlap: float = 0.2,
                    threshold: int = 200) -> List[Dict[str, Any]]:
     """
     Splits text from a specified dictionary field into chunks and returns a list of dictionaries.
@@ -195,7 +195,7 @@ def _file_to_chunks(input: Dict[str, Any],
     try:
         out = {key: value for key, value in input.items() if key != field}
         out.update({"chunk_overlap": overlap, "chunk_threshold": threshold})
-        
+
         chunks = chunk_text(input[field], chunk_size=chunk_size, overlap=overlap, threshold=threshold)
         logs = []
         for i, chunk in enumerate(chunks):
@@ -209,22 +209,22 @@ def _file_to_chunks(input: Dict[str, Any],
             logs.append(chunk_dict)
 
         return logs
-        
+
     except Exception as e:
         raise ValueError(f"An error occurred while chunking the file. {e}")
-    
-def file_to_chunks(input, 
-                   field: str = 'content', 
-                   chunk_size: int = 1500, 
-                   overlap: float = 0.2, 
-                   threshold: int = 200, 
-                   to_csv=False, 
+
+def file_to_chunks(input,
+                   field: str = 'content',
+                   chunk_size: int = 1500,
+                   overlap: float = 0.2,
+                   threshold: int = 200,
+                   to_csv=False,
                    project='project',
-                   output_dir='data/logs/sources/', 
+                   output_dir='data/logs/sources/',
                    chunk_func = _file_to_chunks,
-                   filename=None, 
-                   verbose=True, 
-                   timestamp=True, 
+                   filename=None,
+                   verbose=True,
+                   timestamp=True,
                    logger=None):
     """
         Splits text from a specified dictionary field into chunks and returns a list of dictionaries.
@@ -243,10 +243,10 @@ def file_to_chunks(input,
         timestamp: If True, include a timestamp in the exported file name.
         logger: An optional DataLogger instance for logging.
     """
-    
+
     f = lambda x: chunk_func(x, field=field, chunk_size=chunk_size, overlap=overlap, threshold=threshold)
     logs = to_list(l_call(input, f), flat=True)
-    
+
     if to_csv:
         filename = filename if filename else f"{project}_sources.csv"
         logger = DataLogger(log=logs) if not logger else logger

lionagi/utils/sys_util.py

@@ -670,7 +670,7 @@ def create_id() -> str:
     random_bytes = os.urandom(16)
     return hashlib.sha256(current_time + random_bytes).hexdigest()[:16]
 
-def create_path(dir: str, filename: str, timestamp: bool = True, dir_exist_ok: bool = True) -> str:
+def create_path(dir: str, filename: str, timestamp: bool = True, dir_exist_ok: bool = True, time_prefix=False) -> str:
     """
     Creates a file path by optionally appending a timestamp to the filename.
 
@@ -690,10 +690,14 @@ def create_path(dir: str, filename: str, timestamp: bool = True, dir_exist_ok: b
         >>> create_path('/tmp/', 'log.txt', timestamp=False)
         '/tmp/log.txt'
     """
+    
+    dir = dir + '/' if str(dir)[-1] != '/' else dir
+    filename, ext = filename.split('.')
     os.makedirs(dir, exist_ok=dir_exist_ok)
+    
     if timestamp:
         timestamp = get_timestamp()
-        return f"{dir}{timestamp}{filename}"
+        return f"{dir}{timestamp}_{filename}.{ext}" if time_prefix else f"{dir}{filename}_{timestamp}.{ext}"
     else:
         return f"{dir}{filename}"
     

lionagi/utils/tool_util.py

@@ -0,0 +1,194 @@
+import json
+import asyncio
+from .sys_util import l_call
+    
+
+class ToolManager:
+    """
+    A manager class for handling and invoking registered tools and functions.
+
+    This class allows the registration of tools and functions, enabling their invocation.
+
+    Attributes:
+        registry (dict): A dictionary storing the registered tools and their corresponding functions.
+
+    Methods:
+        _to_dict(name, function, content=None) -> dict:
+            Convert tool information to a dictionary entry.
+
+        _name_existed(name) -> bool:
+            Check if a given name exists in the registry.
+
+        _register_function(name, function, content=None, update=False, new=False, prefix=None, postfix=None) -> None:
+            Register a function with a specified name in the registry.
+
+        invoke(name, args) -> Any:
+            Invoke a registered function with the provided arguments.
+
+        ainvoke(name, args) -> Any:
+            Asynchronously invoke a registered function with the provided arguments.
+
+        _get_function_call(response) -> Tuple[str, dict]:
+            Extract function name and arguments from a response JSON.
+
+        _from_tool(tool, func) -> Tuple[str, callable, list]:
+            Convert tool information to function registration parameters.
+
+        register_tools(tools, functions, update=False, new=False, prefix=None, postfix=None) -> None:
+            Register multiple tools and their corresponding functions.
+    """
+    def __init__(self):
+        """
+        Initialize a ToolManager object with an empty registry.
+        """
+        self.registry = {}
+        
+    @staticmethod
+    def _to_dict(name, function, content=None):
+        """
+        Convert tool information to a dictionary entry.
+
+        Parameters:
+            name (str): The name of the tool.
+            function (callable): The function associated with the tool.
+            content (Optional[str]): Additional content for the tool.
+
+        Returns:
+            dict: A dictionary entry representing the tool.
+        """
+        return {name: {"function": function, "content": content or "none"}}
+
+    def _name_existed(self, name):
+        """
+        Check if a given name exists in the registry.
+
+        Parameters:
+            name (str): The name to check.
+
+        Returns:
+            bool: True if the name exists in the registry, False otherwise.
+
+        """
+        return True if name in self.registry.keys() else False
+            
+    def _register_function(self, name, function, content=None, update=False, new=False, prefix=None, postfix=None):
+        """
+        Register a function with a specified name in the registry.
+
+        Parameters:
+            name (str): The name of the function.
+            function (callable): The function to register.
+            content (Optional[str]): Additional content for the function.
+            update (bool): Whether to update an existing function with the same name.
+            new (bool): Whether to create a new registry for an existing function.
+            prefix (Optional[str]): A prefix to add to the function name.
+            postfix (Optional[str]): A postfix to add to the function name.
+
+        """
+        if self._name_existed(name):
+            if update and new:
+                raise ValueError(f"Cannot both update and create new registry for existing function {name} at the same time")
+            
+        name = f"{prefix or ''}{name}{postfix or '1'}" if new else name                
+        self.registry.update(self._to_dict(name, function, content)) 
+                
+    def invoke(self, name, args):
+        """
+        Invoke a registered function with the provided arguments.
+
+        Parameters:
+            name (str): The name of the function to invoke.
+            args (dict): The arguments to pass to the function.
+
+        Returns:
+            Any: The result of invoking the function.
+        """
+        if self._name_existed(name):
+            try:
+                return self.registry[name](**args)
+            except Exception as e:
+                raise ValueError(f"Error when invoking function {name} with arguments {args} with error message {e}")
+        else: 
+            raise ValueError(f"Function {name} is not registered.")
+    
+    async def ainvoke(self, name, args):
+        """
+        Asynchronously invoke a registered function with the provided arguments.
+
+        Parameters:
+            name (str): The name of the function to invoke.
+            args (dict): The arguments to pass to the function.
+
+        Returns:
+            Any: The result of invoking the function asynchronously.
+
+        """
+        if self._name_existed(name):
+            function = self.registry[name]["function"]
+            try:
+                if asyncio.iscoroutinefunction(function):
+                    return await function(**args)
+                else:
+                    return function(**args)
+            except Exception as e:
+                raise ValueError(f"Error when invoking function {name} with arguments {args} with error message {e}")
+        else: 
+            raise ValueError(f"Function {name} is not registered.")
+    
+    @staticmethod
+    def _get_function_call(response):
+        """
+        Extract function name and arguments from a response JSON.
+
+        Parameters:
+            response (str): The JSON response containing function information.
+
+        Returns:
+            Tuple[str, dict]: The function name and its arguments.
+        """
+        try: 
+            out = json.loads(response)
+            func = out['function'][5:]
+            args = json.loads(out['arguments'])
+            return (func, args)
+        except:
+            try:
+                out = json.loads(response)
+                out = out['tool_uses'][0]
+                func = out['recipient_name'].split('.')[-1]
+                args = out['parameters']
+                return (func, args)
+            except:
+                raise ValueError('response is not a valid function call')
+    
+    @staticmethod
+    def _from_tool(tool, func):
+        """
+        Convert tool information to function registration parameters.
+
+        Parameters:
+            tool (dict): The tool information.
+            func (callable): The function associated with the tool.
+
+        Returns:
+            Tuple[str, callable, list]: The function name, the function, and the list of function parameters.
+
+        """
+        return (tool['function']['name'], func, 
+                tool['function']['parameters']['properties'].keys())
+        
+    def register_tools(self, tools, functions, update=False, new=False, prefix=None, postfix=None):
+        """
+        Register multiple tools and their corresponding functions.
+
+        Parameters:
+            tools (list): The list of tool information dictionaries.
+            functions (list): The list of corresponding functions.
+            update (bool): Whether to update existing functions.
+            new (bool): Whether to create new registries for existing functions.
+            prefix (Optional[str]): A prefix to add to the function names.
+            postfix (Optional[str]): A postfix to add to the function names.
+
+        """
+        funcs = l_call(range(len(tools)), lambda i: self._from_tool(tools[i], functions[i]))
+        l_call(range(len(tools)), lambda i: self._register_function(funcs[i][0], funcs[i][1], update=update, new=new, prefix=prefix, postfix=postfix))

lionagi/version.py

@@ -1 +1 @@
-__version__ = "0.0.104"
+__version__ = "0.0.105"

{lionagi-0.0.104.dist-info → lionagi-0.0.105.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: lionagi
-Version: 0.0.104
+Version: 0.0.105
 Summary: Towards automated general intelligence.
 Author: HaiyangLi
 Author-email: Haiyang Li <ocean@lionagi.ai>
@@ -227,7 +227,8 @@ Requires-Dist: httpx ==0.25.1
 - PyPI: https://pypi.org/project/lionagi/
 - Documentation: https://lionagi.readthedocs.io/en/latest/  （still a lot TODO）
 - Website: TODO
-- Discord: [Join Our Discord](https://discord.gg/ACnynvvPjt)
+- Discord: [Join Our Discord](https://discord.gg/7RGWqpSxze)
+
   
 # LionAGI
 **Towards Automated General Intelligence**
@@ -286,7 +287,7 @@ Visit our notebooks for our examples.
 
 ### Community
 
-We encourage contributions to LionAGI and invite you to enrich its features and capabilities. Engage with us and other community members on [Discord](https://discord.gg/ACnynvvPjt)
+We encourage contributions to LionAGI and invite you to enrich its features and capabilities. Engage with us and other community members [Join Our Discord](https://discord.gg/7RGWqpSxze)
 
 ### Citation
 

lionagi-0.0.105.dist-info/RECORD

@@ -0,0 +1,21 @@
+lionagi/__init__.py,sha256=2Rko3tw94ZFVN_GSvcxAY1O77FxswcaMxNHKH5Bj7jc,788
+lionagi/version.py,sha256=WyIu1E1JGmXY5vMstqMyTqow6kk_Dcs2wEzR6Z1x6Ts,24
+lionagi/api/__init__.py,sha256=RcmOxPnbaj5R6JYqQzQZ67KyVByJfyUw6QSw22KSo8g,134
+lionagi/api/oai_config.py,sha256=yhyZ4aEaF6r3XBbhxI47r8CL2-amc-4IKJhbXv2W9CM,356
+lionagi/api/oai_service.py,sha256=ctX4k3du_sl52n2LilSxXGHdce-igHXtEfpB6RrKbwQ,11209
+lionagi/session/__init__.py,sha256=hbM6VwWz0Oh-Vld79JDFo5eYaCIqAn_OswmLiT0z4UA,58
+lionagi/session/conversation.py,sha256=ZeaNJgmhA6aMG8cZMagRSF4gfsJNQKsNWAFxY6M2Y34,4057
+lionagi/session/message.py,sha256=rjNeOSDgweW_eQfmsgsWTJ30slnfMEv0Tn4LHeAOgxo,6147
+lionagi/session/session.py,sha256=007xhhUUbn60LpOqLsGlvRcio7t_77bx3z_GFir0rOk,12194
+lionagi/tools/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+lionagi/utils/__init__.py,sha256=jTZigmOboszESjWr9dP8PKtZ8XF_RqVd4Ni8s-GkaVs,760
+lionagi/utils/api_util.py,sha256=WE51kMpKzmBwRqD0dkzxAMWzK04_k_5dth2kiOjVkMA,14837
+lionagi/utils/doc_util.py,sha256=uT2paXguEs26kkW7oe2rR3CozQmpP2P9eJJdnZ9uM_E,12338
+lionagi/utils/log_util.py,sha256=qbmaZxiX_bKY-LLaZcpMbTwi3aeBcK9-Lc93vkLIBuk,3103
+lionagi/utils/sys_util.py,sha256=K4dumJ0th082RITpoz_F_eUw-OwkaLOz-BHoezuxwlU,28045
+lionagi/utils/tool_util.py,sha256=OWQsGqAxiyxz2Q7cVE_JmnF19GKN2D9BNvJ09c98DlM,7461
+lionagi-0.0.105.dist-info/LICENSE,sha256=TBnSyG8fs_tMRtK805GzA1cIyExleKyzoN_kuVxT9IY,11358
+lionagi-0.0.105.dist-info/METADATA,sha256=SACNHjsB9hpR-d3Y5kfIhUsox3cdMTe_dLPHHFl08YU,17370
+lionagi-0.0.105.dist-info/WHEEL,sha256=oiQVh_5PnQM0E3gPdiz09WCNmwiHDMaGer_elqB3coM,92
+lionagi-0.0.105.dist-info/top_level.txt,sha256=szvch_d2jE1Lu9ZIKsl26Ll6BGfYfbOgt5lm-UpFSo4,8
+lionagi-0.0.105.dist-info/RECORD,,

lionagi-0.0.104.dist-info/RECORD

@@ -1,19 +0,0 @@
-lionagi/__init__.py,sha256=2Rko3tw94ZFVN_GSvcxAY1O77FxswcaMxNHKH5Bj7jc,788
-lionagi/version.py,sha256=m9tOf0gVCkqN3dmK4Ruh3l4dO8KbQ-WtCnvEBME8wSU,24
-lionagi/api/__init__.py,sha256=RcmOxPnbaj5R6JYqQzQZ67KyVByJfyUw6QSw22KSo8g,134
-lionagi/api/oai_config.py,sha256=yhyZ4aEaF6r3XBbhxI47r8CL2-amc-4IKJhbXv2W9CM,356
-lionagi/api/oai_service.py,sha256=ctX4k3du_sl52n2LilSxXGHdce-igHXtEfpB6RrKbwQ,11209
-lionagi/session/__init__.py,sha256=hbM6VwWz0Oh-Vld79JDFo5eYaCIqAn_OswmLiT0z4UA,58
-lionagi/session/conversation.py,sha256=dedqlGEfIT26WfTJhBOlYWpz_-BFad1BkzIya2mkFwA,3436
-lionagi/session/message.py,sha256=bxvJbR0z9z97suz4sMKbNYIuJYsHuAXuTDgj3CI0qnM,2851
-lionagi/session/session.py,sha256=zTRMNaV8R3DKD10hm-wOAW8dSRVobu_aa7_lAT8I9kg,6812
-lionagi/utils/__init__.py,sha256=-9k5ILJjZ9bTq6U4NA3vNURG2HS7wsUdE1fEWItTGqM,710
-lionagi/utils/api_util.py,sha256=WE51kMpKzmBwRqD0dkzxAMWzK04_k_5dth2kiOjVkMA,14837
-lionagi/utils/doc_util.py,sha256=kZ3qRIKc5kAXFjeR8Z6oDzM4vRQVDw6rG5YDavme2zQ,12461
-lionagi/utils/log_util.py,sha256=qbmaZxiX_bKY-LLaZcpMbTwi3aeBcK9-Lc93vkLIBuk,3103
-lionagi/utils/sys_util.py,sha256=8S1S7V3Sk_Yyp2pfqrGyO_9w-wDHQ3Kzpez4yGvpZuM,27860
-lionagi-0.0.104.dist-info/LICENSE,sha256=TBnSyG8fs_tMRtK805GzA1cIyExleKyzoN_kuVxT9IY,11358
-lionagi-0.0.104.dist-info/METADATA,sha256=640tGgNFlJ91RYqHBU2B4VLx1dcGVlMztLmbXBPXeEs,17363
-lionagi-0.0.104.dist-info/WHEEL,sha256=oiQVh_5PnQM0E3gPdiz09WCNmwiHDMaGer_elqB3coM,92
-lionagi-0.0.104.dist-info/top_level.txt,sha256=szvch_d2jE1Lu9ZIKsl26Ll6BGfYfbOgt5lm-UpFSo4,8
-lionagi-0.0.104.dist-info/RECORD,,