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

lionagi/api/oai_service.py

@@ -19,20 +19,25 @@ class OpenAIRateLimiter(RateLimiter):
     and replenishing these limits at regular intervals.
 
     Attributes:
-        max_requests_per_minute (int): Maximum number of requests allowed per minute.
-        max_tokens_per_minute (int): Maximum number of tokens allowed per minute.
+        max_requests_per_minute (int):
+            Maximum number of requests allowed per minute.
+        max_tokens_per_minute (int):
+            Maximum number of tokens allowed per minute.
 
     Methods:
-        rate_limit_replenisher: Coroutine to replenish rate limits over time.
-        calculate_num_token: Calculates the required tokens for a request.
+        rate_limit_replenisher:
+            Coroutine to replenish rate limits over time.
+        calculate_num_token:
+            Calculates the required tokens for a request.
     """
 
     def __init__(self, max_requests_per_minute: int, max_tokens_per_minute: int) -> None:
         """
         Initializes the rate limiter with specific limits for OpenAI API.
 
-        Args:
+        Parameters:
             max_requests_per_minute (int): The maximum number of requests allowed per minute.
+
             max_tokens_per_minute (int): The maximum number of tokens that can accumulate per minute.
         """
         super().__init__(max_requests_per_minute, max_tokens_per_minute)
@@ -66,8 +71,9 @@ class OpenAIRateLimiter(RateLimiter):
         This method should be implemented in a subclass to provide the specific calculation logic
         for the OpenAI API.
 
-        Args:
+        Parameters:
             payload (Dict[str, Any]): The payload of the request.
+
             api_endpoint (str): The specific API endpoint for the request.
 
         Returns:
@@ -160,12 +166,17 @@ class OpenAIService(BaseAPIService):
         """
         Initializes the OpenAI service with configuration for API interaction.
 
-        Args:
+        Parameters:
             api_key (str): The API key for authenticating with OpenAI.
+
             token_encoding_name (str): The name of the text encoding used by OpenAI.
+
             max_attempts (int): The maximum number of attempts for calling an API endpoint.
+
             status_tracker (Optional[StatusTracker]): Tracker for API call outcomes.
-            rate_limiter (Optional[OpenAIRateLimiter]): Rate limiter for OpenAI's limits.
+
+            ratelimiter (Optional[OpenAIRateLimiter]): Rate limiter for OpenAI's limits.
+
             queue (Optional[AsyncQueue]): Queue for managing asynchronous API calls.
 
         Example:
@@ -183,15 +194,16 @@ class OpenAIService(BaseAPIService):
         super().__init__(api_key, token_encoding_name, max_attempts, 
                          max_requests_per_minute, max_tokens_per_minute,
                          ratelimiter, status_tracker, queue)
-        
 
-    async def call_api(self, http_session, endpoint, payload: Dict[str, any] =None) -> Optional[Dict[str, any]]:
+    async def call_api(self, http_session, endpoint, payload: Dict[str, any] = None) -> Optional[Dict[str, any]]:
         """
         Call an OpenAI API endpoint with a specific payload and handle the response.
 
-        Args:
-            session: The session object for making HTTP requests.
-            request_url (str): The full URL of the OpenAI API endpoint to be called.
+        Parameters:
+            http_session: The session object for making HTTP requests.
+
+            endpoint (str): The full URL of the OpenAI API endpoint to be called.
+
             payload (Dict[str, any]): The payload to send with the API request.
 
         Returns:

lionagi/session/conversation.py

@@ -1,5 +1,6 @@
 from .message import Message
 
+
 class Conversation:
     """
     A class representing a conversation between users and the assistant.
@@ -8,21 +9,22 @@ class Conversation:
     user instructions, and assistant responses.
 
     Attributes:
-        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.
+        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(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.
     """
@@ -40,14 +42,17 @@ class Conversation:
         self.msg = Message()
         self.responses = []
 
-    def initiate_conversation(self, system, instruction, context=None, name=None):
+    def initiate_conversation(self, system=None, instruction=None, context=None, name=None):
         """
         Initiate a conversation with a system setting and 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 = [], []
@@ -55,19 +60,23 @@ class Conversation:
         self.add_messages(instruction=instruction, context=context, name=name)
 
     # modify the message adding to accomodate tools
-    def add_messages(self, system=None, instruction=None, context=None, response=None, tool=None, name=None):
+    def add_messages(self, system=None, instruction=None, context=None, response=None, name=None):
         """
         Add messages to the conversation, including system setting, user instruction, and assistant 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, context=context, response=response, tool=tool, name=name)
+        msg = self.msg(system=system, instruction=instruction, context=context, 
+                       response=response, name=name)
         self.messages.append(msg)
 
     def change_system(self, system):
@@ -92,4 +101,5 @@ class Conversation:
         ]
         if len(response_indices) >= n:
             first_index_to_keep = response_indices[-n] + 1
-            self.messages = [self.system] + self.messages[first_index_to_keep:]
+            self.messages = self.messages[0] + self.messages[first_index_to_keep:]
+            

lionagi/session/message.py

@@ -11,11 +11,16 @@ class Message:
     This class encapsulates messages from users, the assistant, systems, and external tools.
 
     Attributes:
-        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.
+        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:
         create_message(system, instruction, context, response, tool, name):
@@ -40,37 +45,52 @@ class Message:
         self.metadata = None
         self._logger = DataLogger()
     
-    def create_message(self, system=None, instruction=None, context=None, response=None, tool=None, name=None):
+    def create_message(self, system=None, instruction=None, context=None, response=None, name=None):
+
         """
         Create a message based on the provided information.
 
         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:
+        if sum(l_call([system, instruction, response], bool)) > 1:
             raise ValueError("Error: Message cannot have more than one role.")
         
         else: 
             if response:
                 self.role = "assistant"
-                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"
+                try:
+                    response = response["message"]
+                    if str(response['content']) == "None":
+                        try:
+                            tool_count = 0
+                            func_list = []
+                            while tool_count < len(response['tool_calls']):
+                                if response['tool_calls'][tool_count]['type'] == 'function':
+                                    func_content = {"function": ("func_" + response['tool_calls'][tool_count]['function']['name']),
+                                                    "arguments": response['tool_calls'][tool_count]['function']['arguments']}
+                                    func_list.append(func_content)
+                                tool_count += 1
+
+                            self.name = name or "func_request"
+                            self.content = {'function_list': func_list}
+                        except:
+                            raise ValueError("Response message must be one of regular response or function calling")
+                    else:
+                        self.content = response['content']
+                        self.name = name or "assistant"
+                except:
+                    self.name = name or "func_call"
+                    self.content = response
+                
             elif instruction:
                 self.role = "user"
                 self.content = {"instruction": instruction}
@@ -81,17 +101,13 @@ class Message:
                 self.role = "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.
+            dict: The message in JSON format.
         """
         out = {
             "role": self.role,
@@ -106,22 +122,27 @@ class Message:
         self._logger({**self.metadata, **out})
         return out
         
-    def __call__(self, system=None, instruction=None, context=None, response=None, name=None, tool=None):
+    def __call__(self, system=None, instruction=None, context=None, 
+                 response=None, name=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)
+        self.create_message(system=system, instruction=instruction, 
+                            context=context, response=response, name=name)
         return self.to_json()
     
     def to_csv(self, dir=None, filename=None, verbose=True, timestamp=True, dir_exist_ok=True, file_exist_ok=False):
@@ -130,10 +151,16 @@ class Message:
 
         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)
+        self._logger.to_csv(dir, filename, verbose, timestamp, dir_exist_ok, file_exist_ok)
+        

lionagi/session/session.py

@@ -1,20 +1,21 @@
 import aiohttp
 import asyncio
+import json
 from typing import Any
 
+import lionagi
 from .conversation import Conversation
-from ..utils.sys_util import to_list
+from ..utils.sys_util import to_list, l_call, al_call
 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 a conversational AI system.
@@ -22,12 +23,18 @@ class Session():
     This class manages the flow of conversation, system settings, and interactions with external tools.
 
     Attributes:
-        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.
+        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:
         set_dir(dir):
@@ -54,6 +61,9 @@ class Session():
         followup(instruction, system=None, context=None, out=True, name=None, invoke=True, **kwargs) -> Any:
             Continue the conversation with the provided instruction.
 
+        auto_followup(self, instruct, num=3, tool_parser=None, **kwags):
+            Automates the follow-up process for a specified number of times or until the session concludes.
+
         create_payload_chatcompletion(**kwargs) -> dict:
             Create a payload for chat completion based on the conversation state and configuration.
 
@@ -73,8 +83,11 @@ class Session():
 
         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()
@@ -82,7 +95,7 @@ class Session():
         self.llmconfig = llmconfig
         self._logger = DataLogger(dir=dir)
         self.api_service = api_service
-        self.toolmanager = ToolManager()
+        self._toolmanager = ToolManager()
     
     def set_dir(self, dir):
         """
@@ -120,55 +133,94 @@ class Session():
         """
         self.api_service = api_service
     
-    async def _output(self, output, invoke=True, out=True):
+    async def _output(self, invoke=True, out=True, tool_parser=None):
         """
         Process the output, invoke tools if needed, and optionally return the output.
 
         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 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)
+            try:
+                tool_uses = json.loads(self.conversation.responses[-1]['content'])
+                if 'function_list' in tool_uses.keys():
+                    func_calls = l_call(tool_uses['function_list'], self._toolmanager._get_function_call)
+
+                else:
+                    func_calls = l_call(tool_uses['tool_uses'], self._toolmanager._get_function_call)
+
+                outs = await al_call(func_calls, self._toolmanager.ainvoke)
+                if tool_parser:
+                    outs = l_call(outs, tool_parser)
+                for out, f in zip(outs, func_calls):
+                    response = {"function": f[0], "arguments": f[1], "output": out}
+                    self.conversation.add_messages(response=response)
+
             except:
                 pass
+
         if out:
-            return output
-        
+            return self.conversation.responses[-1]['content']
+    
+    def _is_invoked(self):
+        """
+        Checks if the current message indicates the invocation of a function call.
+
+        Returns:
+            bool: True if a function call is detected in the content of the last message, False otherwise.
+        """
+        msg = self.conversation.messages[-1]
+        try: 
+            if json.loads(msg['content']).keys() >= {'function', 'arguments', 'output'}:
+                return True
+        except: 
+            return False    
+
     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)
+        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:
+    async def initiate(self, instruction, system=None, context=None, name=None, invoke=True, out=True, tool_parser=None, **kwargs) -> Any:
         """
         Start a new conversation session with the provided instruction.
 
         Parameters:
-            instruction (str): The instruction to initiate the conversation.
+            instruction (Union[str, dict]): 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.
+
+            tool_parser (Optional[callable]): A custom tool parser function. Default is None.
+
+            **kwargs: Additional keyword arguments for configuration.
 
         Returns:
             Any: The processed output.
@@ -176,23 +228,30 @@ class Session():
         config = {**self.llmconfig, **kwargs}
         system = system or self.system
         self.conversation.initiate_conversation(system=system, instruction=instruction, context=context, name=name)
-        await self.call_chatcompletion(**config)
-        output = self.conversation.responses[-1]['content']
+        await self._call_chatcompletion(**config)
         
-        return await self._output(output, invoke, out)
+        return await self._output(invoke, out, tool_parser)
 
-    async def followup(self, instruction, system=None, context=None, out=True, name=None, invoke=True, **kwargs) -> Any:
+    async def followup(self, instruction, system=None, context=None, out=True, name=None, invoke=True, tool_parser=None, **kwargs) -> Any:
         """
         Continue the conversation with the provided instruction.
 
         Parameters:
-            instruction (str): The instruction to continue the conversation.
+            instruction (Union[str, dict]): 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.
+
+            tool_parser (Optional[callable]): A custom tool parser function. Default is None.
+
+            **kwargs: Additional keyword arguments for configuration.
 
         Returns:
             Any: The processed output.
@@ -201,17 +260,38 @@ class Session():
             self.conversation.change_system(system)
         self.conversation.add_messages(instruction=instruction, context=context, name=name)
         config = {**self.llmconfig, **kwargs}
-        await self.call_chatcompletion(**config)
-        output = self.conversation.responses[-1]['content']
-        
-        return await self._output(output, invoke, out)
-    
-    def create_payload_chatcompletion(self, **kwargs):
+        await self._call_chatcompletion(**config)
+
+        return await self._output(invoke, out, tool_parser)
+
+    async def auto_followup(self, instruct, num=3, tool_parser=None, **kwargs):
+        """
+        Automates the follow-up process for a specified number of times or until the session concludes.
+
+        Parameters:
+            instruct (Union[str, dict]): The instruction for the follow-up.
+
+            num (int, optional): The number of times to automatically follow up. Defaults to 3.
+
+            tool_parser (callable, optional): A custom tool parser function. Defaults to None.
+
+            **kwargs: Additional keyword arguments passed to the underlying `followup` method.
+
+        """
+        cont_ = True
+        while num > 0 and cont_ is True:
+            await self.followup(instruct, tool_parser=tool_parser, tool_choice="auto", **kwargs)
+            num -= 1
+            cont_ = True if self._is_invoked() else False
+        if num == 0:
+            await self.followup(instruct, **kwargs)
+
+    def _create_payload_chatcompletion(self, **kwargs):
         """
         Create a payload for chat completion based on the conversation state and configuration.
 
         Parameters:
-            kwargs: Additional keyword arguments for configuration.
+            **kwargs: Additional keyword arguments for configuration.
 
         Returns:
             dict: The payload for chat completion.
@@ -235,22 +315,23 @@ class Session():
                 payload.update({key: config[key]})
         return payload
 
-    async def call_chatcompletion(self, sleep=0.1,  **kwargs):
+    async def _call_chatcompletion(self, sleep=0.1,  **kwargs):
         """
         Make a call to the chat completion API and process the response.
 
         Parameters:
             sleep (float): The sleep duration after making the API call. Default is 0.1.
-            kwargs: Additional keyword arguments for configuration.
+
+            **kwargs: Additional keyword arguments for configuration.
         """
         endpoint = f"chat/completions"
         try:
             async with aiohttp.ClientSession() as session:
-                payload = self.create_payload_chatcompletion(**kwargs)
+                payload = self._create_payload_chatcompletion(**kwargs)
                 completion = await self.api_service.call_api(
                                 session, endpoint, payload)
                 if "choices" in completion:
-                    self._logger({"input":payload, "output": completion})
+                    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
@@ -262,30 +343,34 @@ class Session():
             status_tracker.num_tasks_failed += 1
             raise e
     
-    def messages_to_csv(self, dir=None, filename="_messages.csv", **kwags):
+    def messages_to_csv(self, dir=None, filename="_messages.csv", **kwargs):
         """
         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.
+
+            **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, **kwargs)
         
-    def log_to_csv(self, dir=None, filename="_llmlog.csv", **kwags):
+    def log_to_csv(self, dir=None, filename="_llmlog.csv", **kwargs):
         """
         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.
+
+            **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, **kwargs)