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

lionagi/core/branch/branch.py

@@ -1,17 +1,17 @@
 import json
-
 import pandas as pd
 
 from typing import Any, Callable, Dict, List, Optional, Union
 from collections import deque
-import asyncio
 from dotenv import load_dotenv
 
-from lionagi.utils import as_dict, get_flattened_keys, alcall, lcall, mcall, to_list
+from lionagi.utils import as_dict, get_flattened_keys, alcall, lcall, to_list
+from lionagi.utils.sys_util import is_same_dtype
 from lionagi.schema import Tool
 from lionagi._services.base_service import StatusTracker, BaseService
 from lionagi._services.oai import OpenAIService
 from lionagi._services.openrouter import OpenRouterService
+
 from lionagi.configs.oai_configs import oai_schema
 from lionagi.configs.openrouter_configs import openrouter_schema
 from lionagi.tools.tool_manager import ToolManager
@@ -19,63 +19,91 @@ from lionagi.tools.tool_manager import ToolManager
 from ..messages.messages import Instruction, System
 from ..instruction_set.instruction_set import InstructionSet
 
-from .conversation import Conversation
+from .conversation import Conversation, validate_messages
 from .branch_manager import Request
-from ..core_util import validate_messages
 
 load_dotenv()
 
-oai_service = OpenAIService()
 
 class Branch(Conversation):
     """
-    Represents a conversation branch with messages, instruction sets, and tool management.
-
-    A `Branch` is a type of conversation that can have messages, system instructions, and registered tools
-    for interacting with external services or tools.
+    Manages a conversation branch within the application, handling messages, instruction sets, 
+    tool registrations, and service interactions for a single conversation flow. Extends the 
+    Conversation class to provide specialized functionalities like message handling, tool 
+    management, and integration with external services.
 
     Attributes:
-        dir (str): The directory path for storing logs.
-        messages (pd.DataFrame): A DataFrame containing conversation messages.
-        instruction_sets (Dict[str, InstructionSet]): A dictionary of instruction sets mapped by their names.
-        tool_manager (ToolManager): An instance of ToolManager for managing tools.
-        service (OpenAIService): An instance of OpenAIService to interact with OpenAI API.
-        status_tracker (StatusTracker): An instance of StatusTracker to keep track of the status.
-        llmconfig (Dict): Configuration for the language model.
-
-    Examples:
-        >>> branch = Branch(dir="path/to/log")
-        >>> branch.add_instruction_set("greet", InstructionSet(instructions=["Hello", "Hi"]))
-        >>> branch.remove_instruction_set("greet")
-        True
-        >>> tool = Tool(name="calculator")
-        >>> branch.register_tools(tool)
-        >>> branch.messages_describe()  # doctest: +SKIP
-        {'total_messages': 0, 'summary_by_role': ..., 'summary_by_sender': ..., 'instruction_sets': {}, 'registered_tools': {'calculator': ...}, 'messages': []}
+        messages (pd.DataFrame): Dataframe storing conversation messages.
+        instruction_sets (Dict[str, InstructionSet]): Dictionary mapping instruction set names to their instances.
+        tool_manager (ToolManager): Manages tools available within the conversation.
+        status_tracker (StatusTracker): Tracks the status of various tasks within the conversation.
+        name (Optional[str]): Identifier for the branch.
+        pending_ins (Dict): Dictionary storing incoming requests.
+        pending_outs (deque): Queue for outgoing requests.
+        service (BaseService): Service instance for interaction with external services.
+        llmconfig (Dict): Configuration for language model interactions.
+
+    Methods:
+        __init__(self, name=None, messages=None, instruction_sets=None, tool_manager=None, 
+                 service=None, llmconfig=None):
+            Initializes a new Branch instance with optional configurations.
+
+        clone(self) -> 'Branch':
+            Creates a deep copy of the current Branch instance.
+
+        merge_branch(self, branch: 'Branch', update: True):
+            Merges another branch into the current Branch instance.
+
+        send(self, to_name: str, title: str, package: Any):
+            Sends a request package to a specified recipient.
+
+        receive(self, from_name: str, messages=True, tool=True, service=True, llmconfig=True):
+            Processes and integrates received request packages based on their titles.
+
+        receive_all(self):
+            Processes all pending incoming requests from all senders.
+
+        call_chatcompletion(self, sender=None, with_sender=False, **kwargs):
+            Asynchronously calls the chat completion service with the current message queue.
+
+        chat(self, instruction: Union[Instruction, str], context=None, sender=None, system=None, 
+             tools=False, out=True, invoke=True, **kwargs) -> Any:
+            Asynchronously handles a chat interaction within the branch.
+
+        ReAct(self, instruction: Union[Instruction, str], context=None, sender=None, system=None, 
+              tools=None, num_rounds=1, **kwargs):
+            Performs a sequence of reasoning and action based on the given instruction over multiple rounds.
+
+        auto_followup(self, instruction: Union[Instruction, str], context=None, sender=None, 
+                      system=None, tools=False, max_followup=3, out=True, **kwargs) -> None:
+            Automatically performs follow-up actions until a specified condition is met or the maximum number of follow-ups is reached.
+    
+    Note:
+        This class is designed to be used within an asynchronous environment, where methods like
+        `chat`, `ReAct`, and `auto_followup` are particularly useful for handling complex conversation flows.
     """
-
+    
     def __init__(
         self,
         name: Optional[str] = None,
-        dir: Optional[str] = None,
         messages: Optional[pd.DataFrame] = None,
         instruction_sets: Optional[Dict[str, InstructionSet]] = None,
         tool_manager: Optional[ToolManager] = None,
-        service: OpenAIService = oai_service,
+        service : Optional[BaseService] = None,
         llmconfig: Optional[Dict] = None,
     ):
         """
         Initializes a new Branch instance.
 
         Args:
-            dir (Optional[str]): The directory path for storing logs.
-            messages (Optional[pd.DataFrame]): A DataFrame containing conversation messages.
-            instruction_sets (Optional[Dict[str, InstructionSet]]): A dictionary of instruction sets.
-            tool_manager (Optional[ToolManager]): An instance of ToolManager for managing tools.
-            service (OpenAIService): The OpenAI service instance.
-            llmconfig (Optional[Dict]): Configuration for the language model.
-        """
-        super().__init__(dir)
+            name (Optional[str]): Name of the branch, providing an identifier within the conversational system. Defaults to None.
+            messages (Optional[pd.DataFrame]): A pandas DataFrame containing the conversation's messages. Initializes with an empty DataFrame if None. Defaults to None.
+            instruction_sets (Optional[Dict[str, InstructionSet]]): Dictionary mapping instruction set names to InstructionSet objects for conversation flow management. Defaults to {}.
+            tool_manager (Optional[ToolManager]): Manages tools within the branch. Creates a new instance if None. Defaults to None.
+            service (Optional[BaseService]): Interacts with external services. Initializes a default service based on branch configuration if None. Defaults to None.
+            llmconfig (Optional[Dict]): Configuration for language model interactions. Sets up default configuration based on the service type if None. Defaults to None.
+        """
+        super().__init__()
         self.messages = (
             messages
             if messages is not None
@@ -85,101 +113,108 @@ class Branch(Conversation):
         )
         self.instruction_sets = instruction_sets if instruction_sets else {}
         self.tool_manager = tool_manager if tool_manager else ToolManager()
-
-        self.service = service if service else oai_service
         self.status_tracker = StatusTracker()
-        if llmconfig:
-            self.llmconfig = llmconfig
-        else:
-            if isinstance(service, OpenAIService):
-                self.llmconfig = oai_schema["chat/completions"]["config"]
-            elif isinstance(service, OpenRouterService):
-                self.llmconfig = openrouter_schema["chat/completions"]["config"]
-            else:
-                self.llmconfig = {}
-
+        self._add_service(service, llmconfig)
         self.name = name
         self.pending_ins = {}
         self.pending_outs = deque()
 
-    def change_first_system_message(
-        self, system: Union[str, Dict[str, Any], System], sender: Optional[str] = None
-    ):
-        """
-        Change the system message of the conversation.
+    @property
+    def chat_messages(self):
+        return self._to_chatcompletion_message()
 
-        Args:
-            system (Union[str, Dict[str, Any], System]): The new system message.
-            sender (Optional[str]): The sender of the system message.
+    @property
+    def chat_messages_with_sender(self):
+        return self._to_chatcompletion_message(with_sender=True) 
 
-        Raises:
-            ValueError: If the input cannot be converted into a system message.
+    @property
+    def messages_describe(self) -> Dict[str, Any]:
+        return {
+            "total_messages": len(self.messages),
+            "summary_by_role": self._info(),
+            "summary_by_sender": self._info(use_sender=True),
+            "instruction_sets": self.instruction_sets,
+            "registered_tools": self.tool_manager.registry,
+            "messages": [
+                msg.to_dict() for _, msg in self.messages.iterrows()
+            ],
+        }
 
-        Examples:
-            >>> branch.change_first_system_message("System update", sender="admin")
-            >>> branch.change_first_system_message({"text": "System reboot", "type": "update"})
-        """
-        if len(self.messages[self.messages.role == 'system']) == 0:
-            raise ValueError("There is no system message in the messages.")
-        if isinstance(system, (str, Dict)):
-            system = System(system, sender=sender)
-        if isinstance(system, System):
-            message_dict = system.to_dict()
-            if sender:
-                message_dict['sender'] = sender
-            message_dict['timestamp'] = str(pd.Timestamp.now())
-            sys_index = self.messages[self.messages.role == 'system'].index
-            self.messages.loc[sys_index[0]] = message_dict
+    @property
+    def has_tools(self) -> bool:
+        return self.tool_manager.registry != {}
 
-        else:
-            raise ValueError("Input cannot be converted into a system message.")
+# ----- tool manager methods ----- #
 
     def register_tools(self, tools: Union[Tool, List[Tool]]):
         """
-        Register one or more tools with the conversation's tool manager.
+        Registers a tool or a list of tools with the branch's tool manager.
+
+        This makes the tools available for use within the conversation.
 
         Args:
-            tools (Union[Tool, List[Tool]]): The tools to register.
+            tools (Union[Tool, List[Tool]]): A single Tool instance or a list of Tool instances to be registered.
 
         Examples:
-            >>> tool = Tool(name="calculator")
             >>> branch.register_tools(tool)
+            >>> branch.register_tools([tool1, tool2])
         """
         if not isinstance(tools, list):
             tools = [tools]
         self.tool_manager.register_tools(tools=tools)
 
-    def delete_tool(self, name: str) -> bool:
+    def delete_tool(self, tools: Union[Tool, List[Tool], str, List[str]], verbose=True) -> bool:
         """
-        Delete a tool from the conversation's tool manager.
+        Deletes one or more tools from the branch's tool manager registry.
+
+        This can be done using either tool instances or their names.
 
         Args:
-            name (str): The name of the tool to delete.
+            tools (Union[Tool, List[Tool], str, List[str]]): A single Tool instance, a list of Tool instances, a tool name, or a list of tool names to be deleted.
+            verbose (bool): If True, prints a success message upon successful deletion. Defaults to True.
 
         Returns:
-            bool: True if the tool was deleted, False otherwise.
+            bool: True if the tool(s) were successfully deleted, False otherwise.
 
         Examples:
-            >>> branch.delete_tool("calculator")
-            True
-        """
-        if name in self.tool_manager.registry:
-            self.tool_manager.registry.pop(name)
-            return True
+            >>> branch.delete_tool("tool_name")
+            >>> branch.delete_tool(["tool_name1", "tool_name2"])
+            >>> branch.delete_tool(tool_instance)
+            >>> branch.delete_tool([tool_instance1, tool_instance2])
+        """
+        if isinstance(tools, list):
+            if is_same_dtype(tools, str):
+                for tool in tools:
+                    if tool in self.tool_manager.registry:
+                        self.tool_manager.registry.pop(tool)
+                if verbose:
+                    print("tools successfully deleted")
+                return True
+            elif is_same_dtype(tools, Tool):
+                for tool in tools:
+                    if tool.name in self.tool_manager.registry:
+                        self.tool_manager.registry.pop(tool.name)
+                if verbose:
+                    print("tools successfully deleted")
+                return True
+        if verbose:
+            print("tools deletion failed")
         return False
 
+# ----- branch manipulation ----- #
     def clone(self) -> 'Branch':
         """
-        Create a clone of the conversation.
+        Creates a deep copy of the current Branch instance.
+
+        This method duplicates the Branch's state, including its messages, instruction sets, and tool registrations, but creates a new ToolManager instance for the cloned branch.
 
         Returns:
-            Branch: A new Branch object that is a clone of the current conversation.
+            Branch: A new Branch instance that is a deep copy of the current instance.
 
         Examples:
             >>> cloned_branch = branch.clone()
         """
         cloned = Branch(
-            dir = self.logger.dir,
             messages=self.messages.copy(), 
             instruction_sets=self.instruction_sets.copy(),
             tool_manager=ToolManager()
@@ -193,14 +228,18 @@ class Branch(Conversation):
 
     def merge_branch(self, branch: 'Branch', update: bool = True):
         """
-        Merge another Branch into this Branch.
+        Merges another branch into the current Branch instance.
+
+        Incorporates messages, instruction sets, and tool registrations from the specified branch. Optionally updates existing instruction sets and tools if duplicates are found.
 
         Args:
-            branch (Branch): The Branch to merge into this one.
-            update (bool): If True, update existing instruction sets and tools, 
-                otherwise only add non-existing ones.
+            branch (Branch): The branch to merge into the current branch.
+            update (bool): If True, existing instruction sets and tools are updated with those from the merged branch. Defaults to True.
 
+        Examples:
+            >>> branch.merge_branch(another_branch)
         """
+
         message_copy = branch.messages.copy()
         self.messages = self.messages.merge(message_copy, how='outer')
 
@@ -218,136 +257,153 @@ class Branch(Conversation):
                 if key not in self.tool_manager.registry:
                     self.tool_manager.registry[key] = value
 
-    @property
-    def messages_describe(self) -> Dict[str, Any]:
+
+# ----- intra-branch communication methods ----- #
+    def send(self, to_name, title, package):
         """
-        Describe the conversation and its messages.
+        Sends a request package to a specified recipient.
 
-        Returns:
-            Dict[str, Any]: A dictionary containing information about the conversation and its messages.
+        Packages are queued in `pending_outs` for dispatch. The function doesn't immediately send the package but prepares it for delivery.
+
+        Args:
+            to_name (str): The name of the recipient branch.
+            title (str): The title or category of the request (e.g., 'messages', 'tool', 'service', 'llmconfig').
+            package (Any): The actual data or object to be sent, its expected type depends on the title.
 
         Examples:
-            >>> description = branch.messages_describe()
-            >>> print(description["total_messages"])
-            0
+            >>> branch.send("another_branch", "messages", message_dataframe)
+            >>> branch.send("service_branch", "service", service_config)
         """
-        return {
-            "total_messages": len(self.messages),
-            "summary_by_role": self.info(),
-            "summary_by_sender": self.info(use_sender=True),
-            "instruction_sets": self.instruction_sets,
-            "registered_tools": self.tool_manager.registry,
-            "messages": [
-                msg.to_dict() for _, msg in self.messages.iterrows()
-            ],
-        }
+        request = Request(from_name=self.name, to_name=to_name, title=title, request=package)
+        self.pending_outs.append(request)
 
-    def to_chatcompletion_message(self) -> List[Dict[str, Any]]:
+    def receive(self, from_name, messages=True, tool=True, service=True, llmconfig=True):
         """
-        Convert the conversation into a chat completion message format suitable for the OpenAI API.
+        Processes and integrates received request packages based on their titles.
 
-        Returns:
-            List[Dict[str, Any]]: A list of messages in chat completion message format.
+        Handles incoming requests by updating the branch's state with the received data. It can selectively process requests based on the type specified by the `title` of the request.
+
+        Args:
+            from_name (str): The name of the sender whose packages are to be processed.
+            messages (bool): If True, processes 'messages' requests. Defaults to True.
+            tool (bool): If True, processes 'tool' requests. Defaults to True.
+            service (bool): If True, processes 'service' requests. Defaults to True.
+            llmconfig (bool): If True, processes 'llmconfig' requests. Defaults to True.
+
+        Raises:
+            ValueError: If no package is found from the specified sender, or if any of the packages have an invalid format.
 
         Examples:
-            >>> chat_completion_message = branch.to_chatcompletion_message()
+            >>> branch.receive("another_branch")
         """
-        message = []
-        for _, row in self.messages.iterrows():
-            content_ = row['content']
-            if content_.startswith('Sender'):
-                content_ = content_.split(':', 1)[1]
-            if isinstance(content_, str):
-                try:
-                    content_ = json.dumps(as_dict(content_))
-                except Exception as e:
-                    raise ValueError(f"Error in serealizing, {row['node_id']} {content_}: {e}")
-                
-            out = {"role": row['role'], "content": content_}
-            message.append(out)
-        return message
+        skipped_requests = deque()
+        if from_name not in self.pending_ins:
+            raise ValueError(f'No package from {from_name}')
+        while self.pending_ins[from_name]:
+            request = self.pending_ins[from_name].popleft()
 
-    def _is_invoked(self) -> bool:
+            if request.title == 'messages' and messages:
+                if not isinstance(request.request, pd.DataFrame):
+                    raise ValueError('Invalid messages format')
+                validate_messages(request.request)
+                self.messages = self.messages.merge(request.request, how='outer')
+                continue
+
+            elif request.title == 'tool' and tool:
+                if not isinstance(request.request, Tool):
+                    raise ValueError('Invalid tool format')
+                self.tool_manager.register_tools([request.request])
+
+            elif request.title == 'service' and service:
+                if not isinstance(request.request, BaseService):
+                    raise ValueError('Invalid service format')
+                self.service = request.request
+
+            elif request.title == 'llmconfig' and llmconfig:
+                if not isinstance(request.request, dict):
+                    raise ValueError('Invalid llmconfig format')
+                self.llmconfig.update(request.request)
+
+            else:
+                skipped_requests.append(request)
+
+        self.pending_ins[from_name] = skipped_requests
+
+    def receive_all(self):
         """
-        Check if the conversation has been invoked with an action response.
+        Processes all pending incoming requests from all senders.
 
-        Returns:
-            bool: True if the conversation has been invoked, False otherwise.
+        This method iterates through all senders with pending requests and processes each using the `receive` method. It ensures that all queued incoming data is integrated into the branch's state.
 
+        Examples:
+            >>> branch.receive_all()
         """
-        content = self.messages.iloc[-1]['content']
-        try:
-            if (
-                as_dict(content)['action_response'].keys() >= {'function', 'arguments', 'output'}
-            ):
-                return True
-        except:
-            return False
-    
-    async def call_chatcompletion(self, **kwargs):
+        for key in list(self.pending_ins.keys()):
+            self.receive(key)
+       
+
+# ----- service methods ----- #
+
+    async def call_chatcompletion(self, sender=None, with_sender=False, **kwargs):
         """
-        Call the chat completion service with the current conversation messages.
+        Asynchronously calls the chat completion service with the current message queue.
 
-        This method asynchronously sends the messages to the OpenAI service and updates the conversation
-        with the response.
+        This method prepares the messages for chat completion, sends the request to the configured service, and handles the response. The method supports additional keyword arguments that are passed directly to the service.
 
         Args:
-            **kwargs: Additional keyword arguments to pass to the chat completion service.
+            sender (Optional[str]): The name of the sender to be included in the chat completion request. Defaults to None.
+            with_sender (bool): If True, includes the sender's name in the messages. Defaults to False.
+            **kwargs: Arbitrary keyword arguments passed directly to the chat completion service.
 
+        Examples:
+            >>> await branch.call_chatcompletion()
         """
-        messages = self.to_chatcompletion_message()
-        payload, completion = await self.service.serve_chat(messages=messages, **kwargs)
+        messages = self.chat_messages if not with_sender else self.chat_messages_with_sender
+        payload, completion = await self.service.serve_chat(
+            messages=messages, **kwargs)
         if "choices" in completion:
-            self.logger.add_entry({"input": payload, "output": completion})
-            self.add_message(response=completion['choices'][0])
+            add_msg_config = {"response":completion['choices'][0]}
+            if sender is not None:
+                add_msg_config["sender"] = sender
+                
+            self.add_message(**add_msg_config)
             self.status_tracker.num_tasks_succeeded += 1
         else:
             self.status_tracker.num_tasks_failed += 1
 
-    @property
-    def has_tools(self) -> bool:
-        """
-        Check if there are any tools registered in the tool manager.
-
-        Returns:
-            bool: True if there are tools registered, False otherwise.
-
-        """
-        return self.tool_manager.registry != {}
+# ----- chat methods ----- #
 
     async def chat(
         self,
         instruction: Union[Instruction, str],
-        system: Optional[Union[System, str, Dict[str, Any]]] = None,
         context: Optional[Any] = None,
-        out: bool = True,
         sender: Optional[str] = None,
-        invoke: bool = True,
+        system: Optional[Union[System, str, Dict[str, Any]]] = None,
         tools: Union[bool, Tool, List[Tool], str, List[str]] = False,
+        out: bool = True,
+        invoke: bool = True,
         **kwargs
     ) -> Any:
         """
-        Conduct a chat with the conversation, processing instructions and potentially using tools.
+        Asynchronously handles a chat interaction within the branch.
 
-        This method asynchronously handles a chat instruction, updates the conversation with the response,
-        and performs tool invocations if specified.
+        This method adds a new message based on the provided instruction, optionally using specified tools, and processes the chat completion.
 
         Args:
-            instruction (Union[Instruction, str]): The chat instruction to process.
-            system (Optional[Union[System, str, Dict[str, Any]]]): The system message to include in the chat.
-            context (Optional[Any]): Additional context to include in the chat.
-            out (bool): If True, return the output of the chat.
-            sender (Optional[str]): The sender of the chat instruction.
-            invoke (bool): If True, invoke tools based on the chat response.
-            tools (Union[bool, Tool, List[Tool], str, List[str]]): Tools to potentially use during the chat.
-            **kwargs: Additional keyword arguments to pass to the chat completion service.
+            instruction (Union[Instruction, str]): The instruction or query to process.
+            context (Optional[Any]): Additional context for the chat completion request. Defaults to None.
+            sender (Optional[str]): The name of the sender. Defaults to None.
+            system (Optional[Union[System, str, Dict[str, Any]]]): System message or configuration. Defaults to None.
+            tools (Union[bool, Tool, List[Tool], str, List[str]]): Specifies if and which tools to use in the chat. Defaults to False.
+            out (bool): If True, the output of the chat completion is returned. Defaults to True.
+            invoke (bool): If True, invokes any action as determined by the chat completion. Defaults to True.
+            **kwargs: Arbitrary keyword arguments for further customization.
 
         Returns:
-            Any: The output of the chat, if out is True.
+            Any: The result of the chat interaction, which could be varied based on the input and configuration.
 
         Examples:
-            >>> result = await branch.chat("What is the weather today?")
-            >>> print(result)
+            >>> result = await branch.chat("How's the weather?")
         """
         
         if system:
@@ -363,6 +419,9 @@ class Branch(Conversation):
                 kwargs = self.tool_manager._tool_parser(tools=tools, **kwargs)
 
         config = {**self.llmconfig, **kwargs}
+        if sender is not None: 
+            config.update({"sender": sender})
+        
         await self.call_chatcompletion(**config)
         
         async def _output():
@@ -376,7 +435,6 @@ class Branch(Conversation):
                     )
                     
                     outs = await alcall(func_calls, self.tool_manager.invoke)
-                    
                     outs = to_list(outs, flatten=True)
 
                     for out_, f in zip(outs, func_calls):
@@ -400,116 +458,310 @@ class Branch(Conversation):
         
         return await _output()
 
+    async def ReAct(
+        self,
+        instruction: Union[Instruction, str],
+        context = None,
+        sender = None,
+        system = None,
+        tools = None, 
+        num_rounds: int = 1,
+        **kwargs 
+    ):
+        """
+        Performs a sequence of reasoning and action based on the given instruction over multiple rounds.
+
+        In each round, the method reflects on the task, devises an action plan using available tools, and invokes the necessary tool usage to execute the plan.
+
+        Args:
+            instruction (Union[Instruction, str]): The initial task or question to start the reasoning and action process.
+            context: Optional context to influence the reasoning process. Defaults to None.
+            sender (Optional[str]): The name of the sender initiating the ReAct process. Defaults to None.
+            system: Optional system message or configuration to be considered during the process. Defaults to None.
+            tools: Specifies the tools to be considered for action plans. Defaults to None.
+            num_rounds (int): The number of reasoning-action rounds to be performed. Defaults to 1.
+            **kwargs: Arbitrary keyword arguments for further customization.
+
+        Returns:
+            The final output after completing the specified number of reasoning-action rounds.
+
+        Examples:
+            >>> await branch.ReAct("Prepare a report on recent sales trends.", num_rounds=2)
+        """
+        if tools is not None:
+            if isinstance(tools, list) and isinstance(tools[0], Tool):
+                self.register_tools(tools)
+        
+        if self.tool_manager.registry == {}:
+            raise ValueError("No tools found, You need to register tools for ReAct (reason-action)")
+        
+        else:
+            kwargs = self.tool_manager._tool_parser(tools=True, **kwargs)
+
+        out = ''
+        i = 0
+        while i < num_rounds:
+            prompt = f"""you have {(num_rounds-i)*2} step left in current task. if available, integrate previous tool responses. perform reasoning and prepare action plan according to available tools only, apply divide and conquer technique.
+            """ 
+            instruct = {"Notice": prompt}
+            
+            if i == 0:
+                instruct["Task"] = instruction
+                out = await self.chat(
+                    instruction=instruct, context=context, 
+                    system=system, sender=sender, **kwargs
+                )
+        
+            elif i >0:
+                out = await self.chat(
+                    instruction=instruct, sender=sender, **kwargs
+                )
+                
+            prompt = f"""
+                you have {(num_rounds-i)*2-1} step left in current task, invoke tool usage to perform actions
+            """
+            out = await self.chat(prompt, tool_choice="auto", tool_parsed=True, sender=sender, **kwargs)
+
+            i += 1
+            if not self._is_invoked():
+                return out
+            
+
+        if self._is_invoked():
+            prompt = """
+                present the final result to user
+            """
+            return await self.chat(prompt, sender=sender, tool_parsed=True, **kwargs)
+        else:
+            return out
+
+    # async def auto_ReAct(
+    #     self,
+    #     instruction: Union[Instruction, str],
+    #     context = None,
+    #     sender = None,
+    #     system = None,
+    #     tools = None, 
+    #     max_rounds: int = 1,
+        
+    #     fallback: Optional[Callable] = None,
+    #     fallback_kwargs: Optional[Dict] = None,
+    #     **kwargs 
+    # ):
+    #     if tools is not None:
+    #         if isinstance(tools, list) and isinstance(tools[0], Tool):
+    #             self.register_tools(tools)
+        
+    #     if self.tool_manager.registry == {}:
+    #         raise ValueError("No tools found, You need to register tools for ReAct (reason-action)")
+        
+    #     else:
+    #         kwargs = self.tool_manager._tool_parser(tools=True, **kwargs)
+
+    #     i = 0
+    #     while i < max_rounds:
+    #         prompt = f"""
+    #             you have {(max_rounds-i)*2} step left in current task. reflect, perform 
+    #             reason for action plan according to available tools only, apply divide and conquer technique, retain from invoking functions
+    #         """ 
+    #         instruct = {"Notice": prompt}
+            
+    #         if i == 0:
+    #             instruct["Task"] = instruction
+    #             await self.chat(
+    #                 instruction=instruct, context=context, 
+    #                 system=system, out=False, sender=sender, **kwargs
+    #             )
+        
+    #         elif i >0:
+    #             await self.chat(
+    #                 instruction=instruct, out=False, sender=sender, **kwargs
+    #             )
+                
+    #         prompt = f"""
+    #             you have {(max_rounds-i)*2-1} step left in current task, invoke tool usage to perform the action
+    #         """
+    #         await self.chat(prompt, tool_choice="auto", tool_parsed=True, out=False,sender=sender, **kwargs)
+
+    #         i += 1
+
+    #     if self._is_invoked():
+    #         if fallback is not None:
+    #             if asyncio.iscoroutinefunction(fallback):
+    #                 return await fallback(**fallback_kwargs)
+    #             else:
+    #                 return fallback(**fallback_kwargs)
+    #         prompt = """
+    #             present the final result to user
+    #         """
+    #         return await self.chat(prompt, sender=sender, tool_parsed=True, **kwargs)
+
     async def auto_followup(
         self,
         instruction: Union[Instruction, str],
-        num: int = 3,
+        context = None,
+        sender = None,
+        system = None,
         tools: Union[bool, Tool, List[Tool], str, List[str], List[Dict]] = False,
-        fallback: Optional[Callable] = None,
-        fallback_kwargs: Optional[Dict] = None,
+        max_followup: int = 3,
+        out=True, 
         **kwargs
     ) -> None:
+
         """
-        Automatically perform follow-up chats based on the conversation state.
+        Automatically performs follow-up actions until a specified condition is met or the maximum number of follow-ups is reached.
 
-        This method asynchronously conducts follow-up chats based on the conversation state and tool invocations,
-        with an optional fallback if the maximum number of follow-ups is reached.
+        This method allows for iterative refinement and follow-up based on the instruction, using available tools and considering feedback from each step.
 
         Args:
-            instruction (Union[Instruction, str]): The chat instruction to process.
-            num (int): The maximum number of follow-up chats to perform.
-            tools (Union[bool, Tool, List[Tool], str, List[str], List[Dict]]): Tools to potentially use during the chats.
-            fallback (Optional[Callable]): A fallback function to call if the maximum number of follow-ups is reached.
-            fallback_kwargs (Optional[Dict]): Keyword arguments to pass to the fallback function.
-            **kwargs: Additional keyword arguments to pass to the chat completion service.
+            instruction (Union[Instruction, str]): The instruction to initiate the follow-up process.
+            context: Optional context relevant to the follow-up actions. Defaults to None.
+            sender (Optional[str]): The name of the sender. Defaults to None.
+            system: Optional system configuration affecting the follow-up process. Defaults to None.
+            tools (Union[bool, Tool, List[Tool], str, List[str], List[Dict]]): Specifies the tools to be used during follow-up actions. Defaults to False.
+            max_followup (int): The maximum number of follow-up iterations. Defaults to 3.
+            out (bool): If True, the final result is returned. Defaults to True.
+            **kwargs: Arbitrary keyword arguments for additional customization.
+
+        Returns:
+            The final result after all follow-up actions are completed, if `out` is True.
 
         Examples:
-            >>> await branch.auto_followup("Could you elaborate on that?")
+            >>> await branch.auto_followup("Update the database with new entries.", max_followup=2)
         """
+
         if self.tool_manager.registry != {} and tools:
             kwargs = self.tool_manager._tool_parser(tools=tools, **kwargs)
 
-        cont_ = True
-        while num > 0 and cont_ is True:
-            if tools:
-                await self.chat(instruction, tool_choice="auto", tool_parsed=True, out=False, **kwargs)
-            else:
-                await self.chat(instruction, tool_parsed=True,  out=False, **kwargs)
-            num -= 1
-            cont_ = True if self._is_invoked() else False
-        if num == 0:
-            if fallback is not None:
-                if asyncio.iscoroutinefunction(fallback):
-                    return await fallback(**fallback_kwargs)
-                else:
-                    return fallback(**fallback_kwargs)
-            return await self.chat(instruction, tool_parsed=True, **kwargs)
+        n_tries = 0
+        while (max_followup - n_tries) > 0:
+            prompt = f"""
+                In the current task you are allowed a maximum of another {max_followup-n_tries} followup chats. 
+                if further actions are needed, invoke tools usage. If you are done, present the final result 
+                to user without further tool usage
+            """
+            if n_tries > 0:
+                _out = await self.chat(prompt, sender=sender, tool_choice="auto", tool_parsed=True, **kwargs)
+                n_tries += 1
+                
+                if not self._is_invoked():
+                    return _out if out else None
+                                
+            elif n_tries == 0:
+                instruct = {"notice": prompt, "task": instruction}
+                out = await self.chat(
+                    instruct, context=context, system=system, sender=sender, tool_choice="auto", 
+                    tool_parsed=True, **kwargs
+                )
+                n_tries += 1
+                
+                if not self._is_invoked():
+                    return _out if out else None
 
-    def send(self, to_name, title, package):
-        """
-        Send a request package to a specified recipient.
+        if self._is_invoked():
+            """
+            In the current task, you are at your last step, present the final result to user
+            """
+            return await self.chat(instruction, sender=sender, tool_parsed=True, **kwargs)
 
-        Args:
-            to_name (str): The name of the recipient.
-            title (str): The title or category of the request (e.g., 'messages', 'tool', 'service', 'llmconfig').
-            package (Any): The actual data or object to be sent. Its expected type depends on the title.
-        """
-        request = Request(from_name=self.name, to_name=to_name, title=title, request=package)
-        self.pending_outs.append(request)
+    # async def followup(
+    #     self,
+    #     instruction: Union[Instruction, str],
+    #     context = None,
+    #     sender = None,
+    #     system = None,
+    #     tools: Union[bool, Tool, List[Tool], str, List[str], List[Dict]] = False,
+    #     max_followup: int = 3,
+    #     out=True, 
+    #     **kwargs
+    # ) -> None:
 
-    def receive(self, from_name, messages=True, tool=True, service=True, llmconfig=True):
-        """
-        Process and integrate received request packages based on their titles.
+    #     """
+    #     auto tool usages until LLM decides done. Then presents final results. 
+    #     """
 
-        Args:
-            from_name (str): The name of the sender whose packages are to be processed.
-            messages (bool, optional): If True, processes 'messages' requests.
-            tool (bool, optional): If True, processes 'tool' requests.
-            service (bool, optional): If True, processes 'service' requests.
-            llmconfig (bool, optional): If True, processes 'llmconfig' requests.
+    #     if self.tool_manager.registry != {} and tools:
+    #         kwargs = self.tool_manager._tool_parser(tools=tools, **kwargs)
+
+    #     n_tries = 0
+    #     while (max_followup - n_tries) > 0:
+    #         prompt = f"""
+    #             In the current task you are allowed a maximum of another {max_followup-n_tries} followup chats. 
+    #             if further actions are needed, invoke tools usage. If you are done, present the final result 
+    #             to user without further tool usage.
+    #         """
+    #         if n_tries > 0:
+    #             _out = await self.chat(prompt, sender=sender, tool_choice="auto", tool_parsed=True, **kwargs)
+    #             n_tries += 1
+                
+    #             if not self._is_invoked():
+    #                 return _out if out else None
+                                
+    #         elif n_tries == 0:
+    #             instruct = {"notice": prompt, "task": instruction}
+    #             out = await self.chat(
+    #                 instruct, context=context, system=system, sender=sender, tool_choice="auto", 
+    #                 tool_parsed=True, **kwargs
+    #             )
+    #             n_tries += 1
+                
+    #             if not self._is_invoked():
+    #                 return _out if out else None
 
-        Raises:
-            ValueError: If no package is found from the specified sender, or if any of the packages have an invalid format.
-        """
-        skipped_requests = deque()
-        if from_name not in self.pending_ins:
-            raise ValueError(f'No package from {from_name}')
-        while self.pending_ins[from_name]:
-            request = self.pending_ins[from_name].popleft()
+    def _add_service(self, service, llmconfig):
+        service = service or OpenAIService()
+        self.service=service
+        if llmconfig:
+            self.llmconfig = llmconfig
+        else:
+            if isinstance(service, OpenAIService):
+                self.llmconfig = oai_schema["chat/completions"]["config"]
+            elif isinstance(service, OpenRouterService):
+                self.llmconfig = openrouter_schema["chat/completions"]["config"]
+            else:
+                self.llmconfig = {}
 
-            if request.title == 'messages' and messages:
-                if not isinstance(request.request, pd.DataFrame):
-                    raise ValueError('Invalid messages format')
-                validate_messages(request.request)
-                self.messages = self.messages.merge(request.request, how='outer')
-                continue
 
-            elif request.title == 'tool' and tool:
-                if not isinstance(request.request, Tool):
-                    raise ValueError('Invalid tool format')
-                self.tool_manager.register_tools([request.request])
+    def _to_chatcompletion_message(self, with_sender=False) -> List[Dict[str, Any]]:
+        message = []
 
-            elif request.title == 'service' and service:
-                if not isinstance(request.request, BaseService):
-                    raise ValueError('Invalid service format')
-                self.service = request.request
+        for _, row in self.messages.iterrows():
+            content_ = row['content']
+            if content_.startswith('Sender'):
+                content_ = content_.split(':', 1)[1]
+                
+            if isinstance(content_, str):
+                try:
+                    content_ = json.dumps(as_dict(content_))
+                except Exception as e:
+                    raise ValueError(f"Error in serealizing, {row['node_id']} {content_}: {e}")
+                
+            out = {"role": row['role'], "content": content_}
+            if with_sender:
+                out['content'] = f"Sender {row['sender']}: {content_}"
+            
+            message.append(out)
+        return message
 
-            elif request.title == 'llmconfig' and llmconfig:
-                if not isinstance(request.request, dict):
-                    raise ValueError('Invalid llmconfig format')
-                self.llmconfig.update(request.request)
 
-            else:
-                skipped_requests.append(request)
+    def _is_invoked(self) -> bool:
+        """
+        Check if the conversation has been invoked with an action response.
 
-        self.pending_ins[from_name] = skipped_requests
+        Returns:
+            bool: True if the conversation has been invoked, False otherwise.
 
-    def receive_all(self):
-        """
-        Process all pending incoming requests from all senders.
         """
-        for key in list(self.pending_ins.keys()):
-            self.receive(key)
+        content = self.messages.iloc[-1]['content']
+        try:
+            if (
+                as_dict(content)['action_response'].keys() >= {'function', 'arguments', 'output'}
+            ):
+                return True
+        except:
+            return False
+
+
 
 
     # def add_instruction_set(self, name: str, instruction_set: InstructionSet):