lionagi 0.1.2__py3-none-any.whl → 0.2.0__py3-none-any.whl

lionagi/core/flow/monoflow/chat.py

@@ -1,95 +0,0 @@
-"""
-This module contains the MonoChat class for performing chat conversations with an LLM.
-
-The MonoChat class allows for processing instructions and system messages, and optionally invoking tools
-during the chat conversation. It extends the BaseMonoFlow and MonoChatMixin classes.
-"""
-
-from typing import Any
-
-from lionagi.core.flow.baseflow import BaseMonoFlow
-from lionagi.core.flow.monoflow.chat_mixin import MonoChatMixin
-
-
-class MonoChat(BaseMonoFlow, MonoChatMixin):
-    """
-    A class for performing a chat conversation with an LLM, processing instructions and system messages,
-    and optionally invoking tools.
-
-    Attributes:
-        branch: The Branch instance to perform chat operations.
-
-    Methods:
-        __init__(self, branch) -> None:
-            Initializes the MonoChat instance.
-
-        async chat(self, instruction=None, context=None, sender=None, system=None, tools=False,
-                   out=True, invoke=True, output_fields=None, form=None, **kwargs) -> Any:
-            Performs a chat conversation with an LLM, processing instructions and system messages,
-            and optionally invoking tools.
-    """
-
-    def __init__(self, branch) -> None:
-        """
-        Initializes the MonoChat instance.
-
-        Args:
-            branch: The Branch instance to perform chat operations.
-        """
-        super().__init__(branch)
-
-    async def chat(
-        self,
-        instruction=None,
-        context=None,
-        sender=None,
-        system=None,
-        tools=False,
-        out: bool = True,
-        invoke: bool = True,
-        output_fields=None,
-        form=None,
-        **kwargs,
-    ) -> Any:
-        """
-        Performs a chat conversation with an LLM, processing instructions and system messages,
-        and optionally invoking tools.
-
-        Args:
-            instruction (Union[Instruction, str]): The instruction for the chat.
-            context (Optional[Any]): Additional context for the chat.
-            sender (Optional[str]): The sender of the chat message.
-            system (Optional[Union[System, str, Dict[str, Any]]]): System message to be processed.
-            tools (Union[bool, Tool, List[Tool], str, List[str]]): Specifies tools to be invoked.
-            out (bool): If True, outputs the chat response.
-            invoke (bool): If True, invokes tools as part of the chat.
-            output_fields (Optional[Any]): The output fields for the chat.
-            form (Optional[Any]): The prompt template for the chat.
-            **kwargs: Arbitrary keyword arguments for chat completion.
-
-        Returns:
-            Any: The result of the chat conversation.
-
-        Examples:
-            >>> await MonoChat.chat(branch, "Ask about user preferences")
-        """
-
-        config = self._create_chat_config(
-            instruction=instruction,
-            context=context,
-            sender=sender,
-            system=system,
-            form=form,
-            tools=tools,
-            output_fields=output_fields,
-            **kwargs,
-        )
-
-        await self._call_chatcompletion(**config)
-
-        return await self._output(
-            invoke=invoke,
-            out=out,
-            output_fields=output_fields,
-            form=form,
-        )

lionagi/core/flow/monoflow/chat_mixin.py

@@ -1,253 +0,0 @@
-"""
-This module contains mixins for configuring and invoking chatbots.
-"""
-
-from abc import ABC
-from typing import Any
-
-import re
-from lionagi.libs import nested, func_call, convert, StringMatch, ParseUtil
-from lionagi.core.tool.tool import TOOL_TYPE
-from lionagi.core.messages.schema import Instruction
-
-
-class MonoChatConfigMixin(ABC):
-    """
-    Mixin class for configuring chatbots.
-
-    Methods:
-        _create_chat_config(self, instruction=None, context=None, sender=None, system=None,
-        output_fields=None, form=None, tools=False, **kwargs) -> Any:
-        Creates a chat configuration based on the provided parameters.
-    """
-
-    def _create_chat_config(
-        self,
-        instruction: Instruction | str | dict[str, Any] = None,
-        context: Any | None = None,
-        sender: str | None = None,
-        system: str | dict[str, Any] | None = None,
-        output_fields=None,
-        form=None,
-        tools: TOOL_TYPE = False,
-        **kwargs,
-    ) -> Any:
-        """
-        Creates a chat configuration based on the provided parameters.
-
-        Args:
-            instruction (Instruction | str | dict[str, Any]): The instruction for the chatbot (optional).
-            context (Any): The context for the chatbot (optional).
-            sender (str): The sender of the message (optional).
-            system (str | dict[str, Any]): The system message for the chatbot (optional).
-            output_fields: The output fields for the chatbot (optional).
-            form: The prompt template for the chatbot (optional).
-            tools (TOOL_TYPE): The tools for the chatbot (default: False).
-            **kwargs: Additional keyword arguments for the chat configuration.
-
-        Returns:
-            Any: The chat configuration.
-        """
-        if system:
-            self.branch.change_first_system_message(system)
-
-        if not form:
-            self.branch.add_message(
-                instruction=instruction,
-                context=context,
-                sender=sender,
-                output_fields=output_fields,
-            )
-        else:
-            instruct_ = Instruction.from_form(form)
-            self.branch.add_message(instruction=instruct_)
-
-        if "tool_parsed" in kwargs:
-            kwargs.pop("tool_parsed")
-            tool_kwarg = {"tools": tools}
-            kwargs = tool_kwarg | kwargs
-        elif tools and self.branch.has_tools:
-            kwargs = self.branch.tool_manager.parse_tool(tools=tools, **kwargs)
-
-        config = {**self.branch.llmconfig, **kwargs}
-        if sender is not None:
-            config["sender"] = sender
-
-        return config
-
-
-class MonoChatInvokeMixin(ABC):
-    """
-    Mixin class for invoking chatbots.
-
-    Methods:
-        async _output(self, invoke, out, output_fields, func_calls_=None, form=None,
-                    return_template=True):
-            Processes the output of the chatbot.
-
-        _return_response(content_, output_fields) -> Any:
-            Returns the response from the chatbot.
-
-        async _invoke_tools(self, content_=None, func_calls_=None):
-            Invokes the tools associated with the chatbot.
-
-        _process_chatcompletion(self, payload, completion, sender):
-            Processes the chat completion.
-
-        async _call_chatcompletion(self, sender=None, with_sender=False, **kwargs):
-            Calls the chat completion API.
-    """
-
-    async def _output(
-        self,
-        invoke,
-        out,
-        output_fields,
-        func_calls_=None,
-        form=None,
-        return_template=True,
-    ):
-        """
-        Processes the output of the chatbot.
-
-        Args:
-            invoke: Flag indicating whether to invoke the tools.
-            out: Flag indicating whether to return the output.
-            output_fields: The output fields for the chatbot.
-            func_calls_: The function calls for invoking the tools (optional).
-            form: The prompt template for the chatbot (optional).
-            return_template (bool): Flag indicating whether to return the prompt template (default: True).
-        """
-
-        content_ = self.branch.last_message_content
-
-        if invoke:
-            try:
-                await self._invoke_tools(content_, func_calls_=func_calls_)
-            except Exception:
-                pass
-
-        response_ = self._return_response(content_, output_fields)
-
-        if form:
-            form._process_response(response_)
-            return form if return_template else form.outputs
-
-        if out:
-            return response_
-
-    @staticmethod
-    def _return_response(content_, output_fields):
-        """
-        Returns the response from the chatbot.
-
-        Args:
-            content_: The content of the last message.
-            output_fields: The output fields for the chatbot.
-
-        Returns:
-            Any: The response from the chatbot.
-        """
-        out_ = ""
-
-        if len(content_.items()) == 1 and len(nested.get_flattened_keys(content_)) == 1:
-            key = nested.get_flattened_keys(content_)[0]
-            out_ = content_[key]
-
-        if output_fields:
-            try:
-                return StringMatch.force_validate_dict(
-                    out_, keys=list(output_fields.keys())
-                )
-            except Exception:
-                pass
-
-        if isinstance(out_, str):
-            try:
-                match = re.search(r"```json\n({.*?})\n```", out_, re.DOTALL)
-                if match:
-                    out_ = ParseUtil.fuzzy_parse_json(match.group(1))
-            except Exception:
-                pass
-
-        return out_
-
-    async def _invoke_tools(self, content_=None, func_calls_=None):
-        """
-        Invokes the tools associated with the chatbot.
-
-        Args:
-            content_: The content of the last message (optional).
-            func_calls_: The function calls for invoking the tools (optional).
-
-        Returns:
-            list: The results of invoking the tools.
-        """
-        if func_calls_ is None and content_ is not None:
-            tool_uses = content_
-            func_calls_ = func_call.lcall(
-                [convert.to_dict(i) for i in tool_uses["action_request"]],
-                self.branch.tool_manager.get_function_call,
-            )
-
-        outs = await func_call.alcall(func_calls_, self.branch.tool_manager.invoke)
-        outs = convert.to_list(outs, flatten=True)
-
-        a = []
-        for out_, f in zip(outs, func_calls_):
-            res = {
-                "function": f[0],
-                "arguments": f[1],
-                "output": out_,
-            }
-            self.branch.add_message(response=res)
-            a.append(res)
-
-        return a
-
-    def _process_chatcompletion(self, payload, completion, sender):
-        """
-        Processes the chat completion.
-
-        Args:
-            payload: The payload for the chat completion.
-            completion: The completed chat response.
-            sender: The sender of the message.
-        """
-        if "choices" in completion:
-            add_msg_config = {"response": completion["choices"][0]}
-            if sender is not None:
-                add_msg_config["sender"] = sender
-
-            self.branch.datalogger.append(input_data=payload, output_data=completion)
-            self.branch.add_message(**add_msg_config)
-            self.branch.status_tracker.num_tasks_succeeded += 1
-        else:
-            self.branch.status_tracker.num_tasks_failed += 1
-
-    async def _call_chatcompletion(self, sender=None, with_sender=False, **kwargs):
-        """
-        Calls the chat completion API.
-
-        Args:
-            sender: The sender of the message (optional).
-            with_sender (bool): Flag indicating whether to include the sender in the chat messages (default: False).
-            **kwargs: Additional keyword arguments for the chat completion API.
-        """
-        messages = (
-            self.branch.chat_messages_with_sender
-            if with_sender
-            else self.branch.chat_messages
-        )
-        payload, completion = await self.branch.service.serve_chat(
-            messages=messages, **kwargs
-        )
-        self._process_chatcompletion(payload, completion, sender)
-
-
-class MonoChatMixin(MonoChatConfigMixin, MonoChatInvokeMixin, ABC):
-    """
-    Mixin class that combines MonoChatConfigMixin and MonoChatInvokeMixin.
-    """
-
-    pass

lionagi/core/flow/monoflow/followup.py

@@ -1,215 +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.schema import Instruction
-from lionagi.core.tool.tool import Tool
-from lionagi.core.flow.monoflow.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.")
-
-        if tools is None:
-            tools = True
-        config = self.branch.tool_manager.parse_tool(tools=tools, **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=True,
-        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 not self.branch._is_invoked():
-                return _out if out else None
-
-            i += 1
-
-        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