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

lionagi/core/flow/monoflow/followup.py

@@ -1,214 +0,0 @@
-"""
-This module contains the MonoFollowup class for performing followup chats with an LLM.
-
-The MonoFollowup class allows for conducting a series of followup chats with an LLM, with the ability to
-process instructions, system messages, and invoke tools during the conversation. It extends the MonoChat class.
-"""
-
-from typing import Callable
-from lionagi.core.messages import Instruction
-from lionagi.core.schema import Tool
-from .chat import MonoChat
-
-
-class MonoFollowup(MonoChat):
-    """
-    A class for performing followup chats with an LLM, processing instructions and system messages,
-    and optionally invoking tools.
-
-    Attributes:
-        FOLLOWUP_PROMPT (str): The default prompt for followup chats.
-        OUTPUT_PROMPT (str): The default prompt for presenting the final output to the user.
-
-    Methods:
-        async followup(self, instruction, context=None, sender=None, system=None, tools=None,
-                       max_followup=1, followup_prompt=None, output_prompt=None, **kwargs):
-            Performs a series of followup chats with an LLM, processing instructions and system messages,
-            and optionally invoking tools.
-
-        _get_prompt(prompt=None, default=None, num_followup=None, instruction=None) -> str:
-            Retrieves the appropriate prompt for the followup chat based on the provided parameters.
-
-        _create_followup_config(self, tools, tool_choice="auto", **kwargs) -> dict:
-            Creates the configuration for the followup chat based on the provided tools and parameters.
-
-        async _followup(self, instruction, context=None, sender=None, system=None, tools=None,
-                        max_followup=1, auto=False, followup_prompt=None, output_prompt=None,
-                        out=True, **kwargs) -> str:
-            Performs the actual followup chats with the LLM, processing instructions and system messages,
-            and optionally invoking tools.
-    """
-
-    FOLLOWUP_PROMPT = """
-    In the current task, you are allowed a maximum of another {num_followup} followup chats. 
-    If further actions are needed, invoke tool usage. 
-    If you are done, present the final result to the user without further tool usage.
-    """
-
-    OUTPUT_PROMPT = "Notice: Present the final output to the user. Original user instruction: {instruction}"
-
-    async def followup(
-        self,
-        instruction: Instruction | str | dict[str, dict | str],
-        context=None,
-        sender=None,
-        system=None,
-        tools=None,
-        max_followup: int = 1,
-        followup_prompt=None,
-        output_prompt=None,
-        **kwargs,
-    ):
-        """
-        Performs a series of followup chats with an LLM, processing instructions and system messages,
-        and optionally invoking tools.
-
-        Args:
-            instruction (Instruction | str | dict[str, dict | str]): The instruction for the followup chat.
-            context (Optional[Any]): Additional context for the followup chat.
-            sender (Optional[str]): The sender of the followup chat message.
-            system (Optional[Any]): System message to be processed during the followup chat.
-            tools (Optional[Any]): Specifies tools to be invoked during the followup chat.
-            max_followup (int): The maximum number of followup chats allowed (default: 1).
-            followup_prompt (Optional[str]): The prompt to use for followup chats.
-            output_prompt (Optional[str]): The prompt to use for presenting the final output to the user.
-            **kwargs: Additional keyword arguments for the followup chat.
-
-        Returns:
-            str: The result of the followup chat.
-        """
-        return await self._followup(
-            instruction=instruction,
-            context=context,
-            sender=sender,
-            system=system,
-            tools=tools,
-            max_followup=max_followup,
-            followup_prompt=followup_prompt,
-            output_prompt=output_prompt,
-            **kwargs,
-        )
-
-    @staticmethod
-    def _get_prompt(prompt=None, default=None, num_followup=None, instruction=None):
-        """
-        Retrieves the appropriate prompt for the followup chat based on the provided parameters.
-
-        Args:
-            prompt (Optional[str]): The prompt to use for the followup chat.
-            default (Optional[str]): The default prompt to use if no specific prompt is provided.
-            num_followup (Optional[int]): The number of remaining followup chats.
-            instruction (Optional[Any]): The original user instruction.
-
-        Returns:
-            str: The appropriate prompt for the followup chat.
-        """
-        if prompt is not None:
-            return prompt
-
-        try:
-            if num_followup is not None:
-                return default.format(num_followup=num_followup)
-            elif instruction is not None:
-                return default.format(instruction=instruction)
-        except (KeyError, ValueError):
-            pass
-
-        return default
-
-    def _create_followup_config(self, tools, tool_choice="auto", **kwargs):
-        """
-        Creates the configuration for the followup chat based on the provided tools and parameters.
-
-        Args:
-            tools (Optional[Any]): Specifies tools to be invoked during the followup chat.
-            tool_choice (str): The choice of tools to use (default: "auto").
-            **kwargs: Additional keyword arguments for the followup chat configuration.
-
-        Returns:
-            dict: The configuration for the followup chat.
-
-        Raises:
-            ValueError: If no tools are found and registered.
-        """
-        if tools and isinstance(tools, list) and isinstance(tools[0], (Callable, Tool)):
-            self.branch.tool_manager.register_tools(tools)
-
-        if not self.branch.tool_manager.has_tools:
-            raise ValueError("No tools found. You need to register tools.")
-
-        config = self.branch.tool_manager.parse_tool(tools=True, **kwargs)
-        config["tool_parsed"] = True
-        config["tool_choice"] = tool_choice
-        return config
-
-    async def _followup(
-        self,
-        instruction: Instruction | str | dict[str, dict | str],
-        context=None,
-        sender=None,
-        system=None,
-        tools=None,
-        max_followup: int = 1,
-        auto=False,
-        followup_prompt=None,
-        output_prompt=None,
-        out=True,
-        **kwargs,
-    ) -> None:
-        """
-        Performs the actual followup chats with the LLM, processing instructions and system messages,
-        and optionally invoking tools.
-
-        Args:
-            instruction (Instruction | str | dict[str, dict | str]): The instruction for the followup chat.
-            context (Optional[Any]): Additional context for the followup chat.
-            sender (Optional[str]): The sender of the followup chat message.
-            system (Optional[Any]): System message to be processed during the followup chat.
-            tools (Optional[Any]): Specifies tools to be invoked during the followup chat.
-            max_followup (int): The maximum number of followup chats allowed (default: 1).
-            auto (bool): Flag indicating whether to automatically determine if the chat is finished (default: False).
-            followup_prompt (Optional[str]): The prompt to use for followup chats.
-            output_prompt (Optional[str]): The prompt to use for presenting the final output to the user.
-            out (bool): Flag indicating whether to return the output of the followup chat (default: True).
-            **kwargs: Additional keyword arguments for the followup chat.
-
-        Returns:
-            Optional[str]: The result of the followup chat, if `out` is True.
-        """
-        config = self._create_followup_config(tools, **kwargs)
-
-        i = 0
-        _out = ""
-
-        while i < max_followup:
-            _prompt = self._get_prompt(
-                prompt=followup_prompt,
-                default=self.FOLLOWUP_PROMPT,
-                num_followup=max_followup - i,
-            )
-
-            if i == 0:
-                _prompt = {"NOTICE": _prompt, "TASK": instruction}
-                _out = await self.chat(
-                    _prompt, context=context, sender=sender, system=system, **config
-                )
-            else:
-                _out = await self.chat(_prompt, sender=sender, **config)
-
-            if auto and not self.branch._is_invoked():
-                return _out if out else None
-
-            i += 1
-
-        if auto:
-            if not self.branch._is_invoked():
-                return _out if out else None
-
-            _prompt = self._get_prompt(
-                prompt=output_prompt,
-                default=self.OUTPUT_PROMPT,
-                instruction=instruction,
-            )
-            _out = await self.chat(_prompt, sender=sender, **kwargs)
-            return _out if out else None

lionagi/core/flow/polyflow/__init__.py

@@ -1 +0,0 @@
-from .chat import PolyChat

lionagi/core/flow/polyflow/chat.py

@@ -1,248 +0,0 @@
-"""
-This module contains the PolyChat class for performing parallel chat conversations with multiple branches.
-
-The PolyChat class allows for conducting parallel chat conversations with multiple branches, each processing
-instructions and context independently. It provides methods for parallel chat execution and manages the
-created branches within the session.
-"""
-
-from typing import Any
-
-from lionagi.libs import ln_convert as convert
-from lionagi.libs.ln_async import AsyncUtil
-
-from lionagi.core.messages.schema import Instruction
-from lionagi.core.branch.branch import Branch
-
-from lionagi.core.flow.base.baseflow import BasePolyFlow
-
-
-class PolyChat(BasePolyFlow):
-    """
-    A class for performing parallel chat conversations with multiple branches.
-
-    Methods:
-        __init__(self, session) -> None:
-            Initializes the PolyChat instance.
-
-        async parallel_chat(self, instruction, num_instances=1, context=None, sender=None, branch_system=None,
-                             messages=None, tools=False, out=True, invoke=True, output_fields=None,
-                             persist_path=None, branch_config=None, explode=False, **kwargs) -> Any:
-            Performs parallel chat conversations with multiple branches.
-
-        async _parallel_chat(self, instruction, num_instances=1, context=None, sender=None, messages=None,
-                              tools=False, out=True, invoke=True, output_fields=None, persist_path=None,
-                              branch_config={}, explode=False, include_mapping=True, default_key="response",
-                              **kwargs) -> Any:
-            Internal method for performing parallel chat conversations with multiple branches.
-    """
-
-    def __init__(self, session) -> None:
-        """
-        Initializes the PolyChat instance.
-
-        Args:
-            session: The session object.
-        """
-        super().__init__(session)
-
-    async def parallel_chat(
-        self,
-        instruction: Instruction | str,
-        num_instances=1,
-        context=None,
-        sender=None,
-        branch_system=None,
-        messages=None,
-        tools=False,
-        out=True,
-        invoke: bool = True,
-        output_fields=None,
-        persist_path=None,
-        branch_config=None,
-        explode=False,
-        **kwargs,
-    ) -> Any:
-        """
-        Performs parallel chat conversations with multiple branches.
-
-        Args:
-            instruction (Instruction | str): The instruction for the chat conversation.
-            num_instances (int): The number of branch instances to create (default: 1).
-            context (Optional[Any]): Additional context for the chat conversation.
-            sender (Optional[str]): The sender of the chat message.
-            branch_system (Optional[Any]): The system configuration for the branches.
-            messages (Optional[Any]): Messages to initialize the branches with.
-            tools (bool): Flag indicating whether to use tools in the chat conversation (default: False).
-            out (bool): Flag indicating whether to return the output of the chat conversation (default: True).
-            invoke (bool): Flag indicating whether to invoke tools during the chat conversation (default: True).
-            output_fields (Optional[Any]): The output fields for the chat conversation.
-            persist_path (Optional[str]): The path to persist the branch data.
-            branch_config (Optional[dict]): Additional configuration for the branches.
-            explode (bool): Flag indicating whether to explode the instruction and context combinations (default: False).
-            **kwargs: Additional keyword arguments for the chat conversation.
-
-        Returns:
-            Any: The result of the parallel chat conversation.
-        """
-        if branch_config is None:
-            branch_config = {}
-        return await self._parallel_chat(
-            instruction,
-            num_instances=num_instances,
-            context=context,
-            sender=sender,
-            branch_system=branch_system,
-            messages=messages,
-            tools=tools,
-            out=out,
-            invoke=invoke,
-            output_fields=output_fields,
-            persist_path=persist_path,
-            branch_config=branch_config,
-            explode=explode,
-            **kwargs,
-        )
-
-    async def _parallel_chat(
-        self,
-        instruction: Instruction | str,
-        num_instances=1,
-        context=None,
-        sender=None,
-        messages=None,
-        tools=False,
-        out=True,
-        invoke: bool = True,
-        output_fields=None,
-        persist_path=None,
-        branch_config={},
-        explode=False,
-        include_mapping=True,
-        default_key="response",
-        **kwargs,
-    ) -> Any:
-        """
-        Internal method for performing parallel chat conversations with multiple branches.
-
-        Args:
-            instruction (Instruction | str): The instruction for the chat conversation.
-            num_instances (int): The number of branch instances to create (default: 1).
-            context (Optional[Any]): Additional context for the chat conversation.
-            sender (Optional[str]): The sender of the chat message.
-            messages (Optional[Any]): Messages to initialize the branches with.
-            tools (bool): Flag indicating whether to use tools in the chat conversation (default: False).
-            out (bool): Flag indicating whether to return the output of the chat conversation (default: True).
-            invoke (bool): Flag indicating whether to invoke tools during the chat conversation (default: True).
-            output_fields (Optional[Any]): The output fields for the chat conversation.
-            persist_path (Optional[str]): The path to persist the branch data.
-            branch_config (dict): Additional configuration for the branches (default: {}).
-            explode (bool): Flag indicating whether to explode the instruction and context combinations (default: False).
-            include_mapping (bool): Flag indicating whether to include mapping information in the output (default: True).
-            default_key (str): The default key for the output mapping (default: "response").
-            **kwargs: Additional keyword arguments for the chat conversation.
-
-        Returns:
-            Any: The result of the parallel chat conversation.
-        """
-
-        branches = {}
-
-        async def _inner(i, ins_, cxt_):
-
-            branch_ = Branch(
-                messages=messages,
-                service=self.session.default_branch.service,
-                llmconfig=self.session.default_branch.llmconfig,
-                persist_path=persist_path,
-                **branch_config,
-            )
-
-            branch_.branch_name = branch_.id_
-
-            if tools:
-                branch_.tool_manager = self.session.default_branch.tool_manager
-
-            res_ = await branch_.chat(
-                instruction=ins_ or instruction,
-                context=cxt_ or context,
-                sender=sender,
-                tools=tools,
-                invoke=invoke,
-                out=out,
-                output_fields=output_fields,
-                **kwargs,
-            )
-
-            branches[branch_.id_] = branch_
-            if include_mapping:
-                return {
-                    "instruction": ins_ or instruction,
-                    "context": cxt_ or context,
-                    "branch_id": branch_.id_,
-                    default_key: res_,
-                }
-
-            else:
-                return res_
-
-        async def _inner_2(i, ins_=None, cxt_=None):
-            """returns num_instances of branches performing for same task/context"""
-            tasks = [_inner(i, ins_, cxt_) for _ in range(num_instances)]
-            ress = await AsyncUtil.execute_tasks(*tasks)
-            return convert.to_list(ress)
-
-        async def _inner_3(i):
-            """different instructions but same context"""
-            tasks = [_inner_2(i, ins_=ins_) for ins_ in convert.to_list(instruction)]
-            ress = await AsyncUtil.execute_tasks(*tasks)
-            return convert.to_list(ress)
-
-        async def _inner_3_b(i):
-            """different context but same instruction"""
-            tasks = [_inner_2(i, cxt_=cxt_) for cxt_ in convert.to_list(context)]
-            ress = await AsyncUtil.execute_tasks(*tasks)
-            return convert.to_list(ress)
-
-        async def _inner_4(i):
-            """different instructions and different context"""
-
-            tasks = []
-            if explode:
-                tasks = [
-                    _inner_2(i, ins_=ins_, cxt_=cxt_)
-                    for ins_ in convert.to_list(instruction)
-                    for cxt_ in convert.to_list(context)
-                ]
-            else:
-                tasks = [
-                    _inner_2(i, ins_=ins_, cxt_=cxt_)
-                    for ins_, cxt_ in zip(
-                        convert.to_list(instruction), convert.to_list(context)
-                    )
-                ]
-
-            ress = await AsyncUtil.execute_tasks(*tasks)
-            return convert.to_list(ress)
-
-        if len(convert.to_list(instruction)) == 1:
-            if len(convert.to_list(context)) == 1:
-                out_ = await _inner_2(0)
-                self.session.branches.update(branches)
-                return out_
-
-            elif len(convert.to_list(context)) > 1:
-                out_ = await _inner_3_b(0)
-                self.session.branches.update(branches)
-                return out_
-
-        elif len(convert.to_list(instruction)) > 1:
-            if len(convert.to_list(context)) == 1:
-                out_ = await _inner_3(0)
-                self.session.branches.update(branches)
-                return out_
-
-            elif len(convert.to_list(context)) > 1:
-                out_ = await _inner_4(0)
-                self.session.branches.update(branches)
-                return out_

lionagi/core/mail/schema.py

@@ -1,56 +0,0 @@
-from collections import deque
-from enum import Enum
-
-from lionagi.core.schema.base_node import BaseRelatableNode
-
-
-class MailCategory(str, Enum):
-    MESSAGES = "messages"
-    TOOL = "tool"
-    SERVICE = "service"
-    MODEL = "model"
-    NODE = "node"
-    NODE_LIST = "node_list"
-    NODE_ID = "node_id"
-    START = "start"
-    END = "end"
-    CONDITION = "condition"
-
-
-class BaseMail:
-
-    def __init__(self, sender_id, recipient_id, category, package):
-        self.sender_id = sender_id
-        self.recipient_id = recipient_id
-        try:
-            if isinstance(category, str):
-                category = MailCategory(category)
-            if isinstance(category, MailCategory):
-                self.category = category
-            else:
-                raise ValueError(
-                    f"Invalid request title. Valid titles are" f" {list(MailCategory)}"
-                )
-        except Exception as e:
-            raise ValueError(
-                f"Invalid request title. Valid titles are "
-                f"{list(MailCategory)}, Error: {e}"
-            ) from e
-        self.package = package
-
-
-class StartMail(BaseRelatableNode):
-
-    def __init__(self, **kwargs):
-        super().__init__(**kwargs)
-        self.pending_outs = deque()
-
-    def trigger(self, context, structure_id, executable_id):
-        start_mail_content = {"context": context, "structure_id": structure_id}
-        start_mail = BaseMail(
-            sender_id=self.id_,
-            recipient_id=executable_id,
-            category="start",
-            package=start_mail_content,
-        )
-        self.pending_outs.append(start_mail)

lionagi/core/messages/__init__.py

@@ -1,3 +0,0 @@
-from .schema import System, Instruction, Response
-
-__all__ = ["System", "Instruction", "Response"]