lionagi 0.0.316__py3-none-any.whl → 0.1.0__py3-none-any.whl

lionagi/core/execute/branch_executor.py

@@ -0,0 +1,233 @@
+import contextlib
+from lionagi.libs import convert, AsyncUtil, ParseUtil
+from lionagi.core.generic import ActionNode, Edge
+from lionagi.core.mail.schema import BaseMail
+from lionagi.core.messages.schema import System, Instruction
+
+from lionagi.core.branch.branch import Branch
+from lionagi.core.execute.base_executor import BaseExecutor
+
+
+class BranchExecutor(Branch, BaseExecutor):
+
+    async def forward(self) -> None:
+        for key in list(self.pending_ins.keys()):
+            while self.pending_ins[key]:
+                mail = self.pending_ins[key].popleft()
+                if mail.category == "start":
+                    self._process_start(mail)
+                elif mail.category == "node":
+                    await self._process_node(mail)
+                elif mail.category == "node_list":
+                    self._process_node_list(mail)
+                elif mail.category == "condition":
+                    self._process_condition(mail)
+                elif mail.category == "end":
+                    self._process_end(mail)
+
+    async def execute(self, refresh_time=1) -> None:
+        while not self.execute_stop:
+            await self.forward()
+            await AsyncUtil.sleep(refresh_time)
+
+    async def _process_node(self, mail: BaseMail):
+        if isinstance(mail.package["package"], System):
+            self._system_process(mail.package["package"], verbose=self.verbose)
+            self.send(
+                mail.sender_id,
+                "node_id",
+                {"request_source": self.id_, "package": mail.package["package"].id_},
+            )
+
+        elif isinstance(mail.package["package"], Instruction):
+            await self._instruction_process(
+                mail.package["package"], verbose=self.verbose
+            )
+            self.send(
+                mail.sender_id,
+                "node_id",
+                {"request_source": self.id_, "package": mail.package["package"].id_},
+            )
+
+        elif isinstance(mail.package["package"], ActionNode):
+            await self._action_process(mail.package["package"], verbose=self.verbose)
+            self.send(
+                mail.sender_id,
+                "node_id",
+                {
+                    "request_source": self.id_,
+                    "package": mail.package["package"].instruction.id_,
+                },
+            )
+        else:
+            try:
+                await self._agent_process(mail.package["package"], verbose=self.verbose)
+                self.send(
+                    mail.sender_id,
+                    "node_id",
+                    {
+                        "request_source": self.id_,
+                        "package": mail.package["package"].id_,
+                    },
+                )
+            except:
+                raise ValueError(f"Invalid mail to process. Mail:{mail}")
+
+    def _process_node_list(self, mail: BaseMail):
+        self.send(mail.sender_id, "end", {"request_source": self.id_, "package": "end"})
+        self.execute_stop = True
+        raise ValueError("Multiple path selection is currently not supported")
+
+    def _process_condition(self, mail: BaseMail):
+        relationship: Edge = mail.package["package"]
+        check_result = relationship.condition(self)
+        back_mail = {
+            "from": self.id_,
+            "edge_id": mail.package["package"].id_,
+            "check_result": check_result,
+        }
+        self.send(
+            mail.sender_id,
+            "condition",
+            {"request_source": self.id_, "package": back_mail},
+        )
+
+    def _system_process(self, system: System, verbose=True, context_verbose=False):
+        from lionagi.libs import SysUtil
+
+        SysUtil.check_import("IPython")
+        from IPython.display import Markdown, display
+
+        if verbose:
+            print(f"------------------Welcome: {system.sender}--------------------")
+            with contextlib.suppress(Exception):
+                system.content = ParseUtil.fuzzy_parse_json(system.content)
+            display(Markdown(f"system: {convert.to_str(system.system_info)}"))
+            if self.context and context_verbose:
+                display(Markdown(f"context: {convert.to_str(self.context)}"))
+
+        self.add_message(system=system)
+
+    async def _instruction_process(
+        self, instruction: Instruction, verbose=True, **kwargs
+    ):
+        from lionagi.libs import SysUtil
+
+        SysUtil.check_import("IPython")
+        from IPython.display import Markdown, display
+
+        if verbose:
+            with contextlib.suppress(Exception):
+                instruction.content = ParseUtil.fuzzy_parse_json(instruction.content)
+            display(
+                Markdown(
+                    f"{instruction.sender}: {convert.to_str(instruction.instruct)}"
+                )
+            )
+
+        if self.context:
+            instruction.content.update({"context": self.context})
+            self.context_log.append(self.context)
+            self.context = None
+
+        result = await self.chat(instruction, **kwargs)
+        with contextlib.suppress(Exception):
+            result = ParseUtil.fuzzy_parse_json(result)
+            if "response" in result.keys():
+                result = result["response"]
+        if verbose and len(self.assistant_responses) != 0:
+            display(
+                Markdown(
+                    f"{self.last_assistant_response.sender}: {convert.to_str(result)}"
+                )
+            )
+            print("-----------------------------------------------------")
+
+        self.execution_responses.append(result)
+
+    async def _action_process(self, action: ActionNode, verbose=True):
+        from lionagi.libs import SysUtil
+
+        SysUtil.check_import("IPython")
+        from IPython.display import Markdown, display
+
+        try:
+            func = getattr(self, action.action)
+        except:
+            raise ValueError(f"{action.action} is not a valid action")
+
+        if verbose:
+            display(
+                Markdown(
+                    f"{action.instruction.sender}: {convert.to_str(action.instruction.instruct)}"
+                )
+            )
+
+        if action.tools:
+            self.register_tools(action.tools)
+        if self.context:
+            result = await func(
+                action.instruction.content["instruction"],
+                context=self.context,
+                tools=action.tools,
+                **action.action_kwargs,
+            )
+            self.context = None
+        else:
+            result = await func(
+                action.instruction.content, tools=action.tools, **action.action_kwargs
+            )
+
+        if verbose and len(self.assistant_responses) != 0:
+            display(
+                Markdown(
+                    f"{self.last_assistant_response.sender}: {convert.to_str(result)}"
+                )
+            )
+            print("-----------------------------------------------------")
+
+        self.execution_responses.append(result)
+
+    async def _agent_process(self, agent, verbose=True):
+        """
+        Processes an agent.
+
+        Args:
+            agent: The agent to process.
+            verbose (bool): A flag indicating whether to provide verbose output (default: True).
+        """
+        context = self.responses
+        if verbose:
+            print("*****************************************************")
+        result = await agent.execute(context)
+
+        if verbose:
+            print("*****************************************************")
+
+        self.context = result
+        self.responses.append(result)
+
+    def _process_start(self, mail):
+        """
+        Processes a start mail.
+
+        Args:
+            mail (BaseMail): The start mail to process.
+        """
+        start_mail_content = mail.package
+        self.context = start_mail_content["context"]
+        self.send(
+            start_mail_content["structure_id"],
+            "start",
+            {"request_source": self.id_, "package": "start"},
+        )
+
+    def _process_end(self, mail: BaseMail):
+        """
+        Processes an end mail.
+
+        Args:
+            mail (BaseMail): The end mail to process.
+        """
+        self.execute_stop = True
+        self.send(mail.sender_id, "end", {"request_source": self.id_, "package": "end"})

lionagi/core/execute/instruction_map_executor.py

@@ -0,0 +1,131 @@
+import asyncio
+from pydantic import Field
+
+from lionagi.libs import AsyncUtil
+
+from lionagi.core.mail.schema import BaseMail, MailTransfer
+from lionagi.core.mail.mail_manager import MailManager
+from lionagi.core.execute.base_executor import BaseExecutor
+from lionagi.core.execute.branch_executor import BranchExecutor
+
+
+class InstructionMapExecutor(BaseExecutor):
+    branches: dict[str, BranchExecutor] = Field(
+        default_factory=dict, description="The branches of the instruction mapping."
+    )
+    structure_id: str = Field("", description="The ID of the executable structure.")
+    mail_transfer: MailTransfer = Field(
+        default_factory=MailTransfer, description="The mail transfer."
+    )
+    branch_kwargs: dict = Field(
+        default_factory=dict,
+        description="The keyword arguments for the initializing the branches.",
+    )
+    num_end_branches: int = Field(0, description="The number of end branches.")
+    mail_manager: MailManager = Field(
+        default_factory=MailManager, description="The mail manager."
+    )
+
+    def __init__(self, **kwargs):
+        super().__init__(**kwargs)
+        self.mail_manager = MailManager([self.mail_transfer])
+
+    def transfer_ins(self):
+        for key in list(self.pending_ins.keys()):
+            while self.pending_ins[key]:
+                mail: BaseMail = self.pending_ins[key].popleft()
+                if mail.category == "start":
+                    self._process_start(mail)
+                elif mail.category == "node_list":
+                    self._process_node_list(mail)
+                elif (
+                    (mail.category == "node")
+                    or (mail.category == "condition")
+                    or (mail.category == "end")
+                ):
+                    mail.sender_id = self.mail_transfer.id_
+                    mail.recipient_id = mail.package["request_source"]
+                    self.mail_transfer.pending_outs.append(mail)
+
+    def transfer_outs(self):
+        for key in list(self.mail_transfer.pending_ins.keys()):
+            while self.mail_transfer.pending_ins[key]:
+                mail: BaseMail = self.mail_transfer.pending_ins[key].popleft()
+                if mail.category == "end":
+                    self.num_end_branches += 1
+                    if self.num_end_branches == len(
+                        self.branches
+                    ):  # tell when structure should stop
+                        mail.sender_id = self.id_
+                        mail.recipient_id = self.structure_id
+                        self.pending_outs.append(mail)
+                        self.execute_stop = True
+                else:
+                    mail.sender_id = self.id_
+                    mail.recipient_id = self.structure_id
+                    self.pending_outs.append(mail)
+
+    def _process_start(self, start_mail: BaseMail):
+        branch = BranchExecutor(verbose=self.verbose, **self.branch_kwargs)
+        branch.context = start_mail.package["context"]
+        self.branches[branch.id_] = branch
+        self.mail_manager.add_sources([branch])
+        self.structure_id = start_mail.package["structure_id"]
+        mail = BaseMail(
+            sender_id=self.id_,
+            recipient_id=self.structure_id,
+            category="start",
+            package={"request_source": branch.id_, "package": "start"},
+        )
+        self.pending_outs.append(mail)
+
+    def _process_node_list(self, nl_mail: BaseMail):
+        source_branch_id = nl_mail.package["request_source"]
+        node_list = nl_mail.package["package"]
+        shared_context = self.branches[source_branch_id].context
+        shared_context_log = self.branches[source_branch_id].context_log
+        base_branch = self.branches[source_branch_id]
+
+        first_node_mail = BaseMail(
+            sender_id=self.mail_transfer.id_,
+            recipient_id=source_branch_id,
+            category="node",
+            package={"request_source": source_branch_id, "package": node_list[0]},
+        )
+        self.mail_transfer.pending_outs.append(first_node_mail)
+
+        for i in range(1, len(node_list)):
+            branch = BranchExecutor(
+                verbose=self.verbose,
+                messages=base_branch.messages.copy(),
+                service=base_branch.service,
+                llmconfig=base_branch.llmconfig,
+                datalogger=base_branch.datalogger,
+            )
+            branch.context = shared_context
+            branch.context_log = shared_context_log
+            self.branches[branch.id_] = branch
+            self.mail_manager.add_sources([branch])
+            node_mail = BaseMail(
+                sender_id=self.mail_transfer.id_,
+                recipient_id=branch.id_,
+                category="node",
+                package={"request_source": source_branch_id, "package": node_list[i]},
+            )
+            self.mail_transfer.pending_outs.append(node_mail)
+
+    async def forward(self):
+        self.transfer_ins()
+        self.transfer_outs()
+        self.mail_manager.collect_all()
+        self.mail_manager.send_all()
+        tasks = [
+            branch.forward() for branch in self.branches.values() if branch.pending_ins
+        ]
+        await asyncio.gather(*tasks)
+        return
+
+    async def execute(self, refresh_time=1):
+        while not self.execute_stop:
+            await self.forward()
+            await asyncio.sleep(refresh_time)

lionagi/core/execute/structure_executor.py

@@ -0,0 +1,218 @@
+from typing import overload
+
+from abc import ABC
+from collections import deque
+
+from lionagi.libs import AsyncUtil, convert
+
+from lionagi.core.generic import BaseNode, ActionNode, ActionSelection, Edge
+from lionagi.core.tool import Tool
+from lionagi.core.mail.schema import BaseMail
+from lionagi.core.execute.base_executor import BaseExecutor
+
+from lionagi.libs import AsyncUtil
+from lionagi.core.generic import Node, ActionSelection, Edge
+from lionagi.core.tool import Tool
+
+from lionagi.core.mail.schema import BaseMail
+from lionagi.core.graph.graph import Graph
+
+
+class StructureExecutor(BaseExecutor, Graph):
+
+    condition_check_result: bool | None = None
+
+    async def check_edge_condition(self, edge: Edge, executable_id, request_source):
+        if edge.condition.source_type == "structure":
+            return edge.condition(self)
+
+        elif edge.condition.source_type == "executable":
+            return await self._check_executable_condition(
+                edge, executable_id, request_source
+            )
+
+        else:
+            raise ValueError("Invalid source_type.")
+
+    def _process_edge_condition(self, edge_id):
+        """
+        Process the condition of a edge.
+
+        Args:
+            edge_id (str): The ID of the edge.
+        """
+        for key in list(self.pending_ins.keys()):
+            skipped_requests = deque()
+            while self.pending_ins[key]:
+                mail: BaseMail = self.pending_ins[key].popleft()
+                if (
+                    mail.category == "condition"
+                    and mail.package["package"]["edge_id"] == edge_id
+                ):
+                    self.condition_check_result = mail.package["package"][
+                        "check_result"
+                    ]
+                else:
+                    skipped_requests.append(mail)
+            self.pending_ins[key] = skipped_requests
+
+    async def _check_executable_condition(
+        self, edge: Edge, executable_id, request_source
+    ):
+        self.send(
+            recipient_id=executable_id,
+            category="condition",
+            package={"request_source": request_source, "package": edge},
+        )
+        while self.condition_check_result is None:
+            await AsyncUtil.sleep(0.1)
+            self._process_edge_condition(edge.id_)
+            continue
+        check_result = self.condition_check_result
+        self.condition_check_result = None
+        return check_result
+
+    async def _handle_node_id(self, mail: BaseMail):
+        if mail.package["package"] not in self.internal_nodes:
+            raise ValueError(
+                f"Node {mail.package} does not exist in the structure {self.id_}"
+            )
+        return await self._next_node(
+            self.internal_nodes[mail.package["package"]],
+            mail.sender_id,
+            mail.package["request_source"],
+        )
+
+    async def _handle_node(self, mail: BaseMail):
+        if not self.node_exist(mail.package["package"]):
+            raise ValueError(
+                f"Node {mail.package} does not exist in the structure {self.id_}"
+            )
+        return await self._next_node(
+            mail.package["package"], mail.sender_id, mail.package["request_source"]
+        )
+
+    async def _handle_mail(self, mail: BaseMail):
+
+        if mail.category == "start":
+            return self.get_heads()
+
+        elif mail.category == "end":
+            self.execute_stop = True
+            return None
+
+        elif mail.category == "node_id":
+            try:
+                return await self._handle_node_id(mail)
+            except Exception as e:
+                raise ValueError(f"Error handling node id: {e}") from e
+
+        elif mail.category == "node" and isinstance(mail.package["package"], BaseNode):
+            try:
+                return await self._handle_node(mail)
+            except Exception as e:
+                raise ValueError(f"Error handling node: {e}") from e
+
+        else:
+            raise ValueError(f"Invalid mail type for structure")
+
+    async def _next_node(self, current_node: BaseNode, executable_id, request_source):
+        """
+        Get the next step nodes based on the current node.
+
+        Args:
+            current_node (Node): The current node.
+            executable_id (str): The ID of the executable.
+
+        Returns:
+            list[Node]: The next step nodes.
+        """
+        next_nodes = []
+        next_edges: dict[Edge] = self.get_node_edges(current_node, node_as="out")
+        for edge in convert.to_list(list(next_edges.values())):
+            if edge.bundle:
+                continue
+            if edge.condition:
+                check = await self.check_edge_condition(
+                    edge, executable_id, request_source
+                )
+                if not check:
+                    continue
+            node = self.internal_nodes[edge.tail]
+            further_edges: dict[Edge] = self.get_node_edges(node, node_as="out")
+            bundled_nodes = deque()
+            for f_edge in convert.to_list(list(further_edges.values())):
+                if f_edge.bundle:
+                    bundled_nodes.append(self.internal_nodes[f_edge.tail])
+            if bundled_nodes:
+                node = self.parse_bundled_to_action(node, bundled_nodes)
+            next_nodes.append(node)
+        return next_nodes
+
+    def _send_mail(self, next_nodes: list | None, mail: BaseMail):
+        if not next_nodes:  # tail
+            self.send(
+                recipient_id=mail.sender_id,
+                category="end",
+                package={
+                    "request_source": mail.package["request_source"],
+                    "package": "end",
+                },
+            )
+        else:
+            if len(next_nodes) == 1:
+                self.send(
+                    recipient_id=mail.sender_id,
+                    category="node",
+                    package={
+                        "request_source": mail.package["request_source"],
+                        "package": next_nodes[0],
+                    },
+                )
+            else:
+                self.send(
+                    recipient_id=mail.sender_id,
+                    category="node_list",
+                    package={
+                        "request_source": mail.package["request_source"],
+                        "package": next_nodes,
+                    },
+                )
+
+    @staticmethod
+    def parse_bundled_to_action(instruction: Node, bundled_nodes: deque):
+        action_node = ActionNode(instruction=instruction)
+        while bundled_nodes:
+            node = bundled_nodes.popleft()
+            if isinstance(node, ActionSelection):
+                action_node.action = node.action
+                action_node.action_kwargs = node.action_kwargs
+            elif isinstance(node, Tool):
+                action_node.tools.append(node)
+            else:
+                raise ValueError("Invalid bundles nodes")
+        return action_node
+
+    async def forward(self) -> None:
+        """
+        Process the pending incoming mails and perform the corresponding actions.
+        """
+        for key in list(self.pending_ins.keys()):
+            while self.pending_ins[key]:
+                mail: BaseMail = self.pending_ins[key].popleft()
+                try:
+                    if mail == "end":
+                        self.execute_stop = True
+                        return
+                    next_nodes = await self._handle_mail(mail)
+                    self._send_mail(next_nodes, mail)
+                except Exception as e:
+                    raise ValueError(f"Error handling mail: {e}") from e
+
+    async def execute(self, refresh_time=1):
+        if not self.acyclic:
+            raise ValueError("Structure is not acyclic")
+
+        while not self.execute_stop:
+            await self.forward()
+            await AsyncUtil.sleep(refresh_time)

lionagi/core/flow/monoflow/ReAct.py

@@ -6,9 +6,9 @@ process instructions, system messages, and invoke tools during the conversation.
 """
 
 from typing import Callable
-from .chat import MonoChat
-from lionagi.core.schema import Tool
-from lionagi.core.messages import Instruction
+from lionagi.core.flow.monoflow.chat import MonoChat
+from lionagi.core.tool import Tool
+from lionagi.core.messages.schema import Instruction
 
 
 class MonoReAct(MonoChat):
@@ -235,4 +235,4 @@ class MonoReAct(MonoChat):
                 instruction=instruction,
             )
             _out = await self.chat(_prompt, sender=sender, **kwargs)
-            return _out if out else None
+            return _out if out else None

lionagi/core/flow/monoflow/chat.py

@@ -7,7 +7,7 @@ during the chat conversation. It extends the BaseMonoFlow and MonoChatMixin clas
 
 from typing import Any
 
-from lionagi.core.flow.base.baseflow import BaseMonoFlow
+from lionagi.core.flow.baseflow import BaseMonoFlow
 from lionagi.core.flow.monoflow.chat_mixin import MonoChatMixin
 
 
@@ -24,7 +24,7 @@ class MonoChat(BaseMonoFlow, MonoChatMixin):
             Initializes the MonoChat instance.
 
         async chat(self, instruction=None, context=None, sender=None, system=None, tools=False,
-                   out=True, invoke=True, output_fields=None, prompt_template=None, **kwargs) -> Any:
+                   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.
     """
@@ -48,7 +48,7 @@ class MonoChat(BaseMonoFlow, MonoChatMixin):
         out: bool = True,
         invoke: bool = True,
         output_fields=None,
-        prompt_template=None,
+        form=None,
         **kwargs,
     ) -> Any:
         """
@@ -64,7 +64,7 @@ class MonoChat(BaseMonoFlow, MonoChatMixin):
             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.
-            prompt_template (Optional[Any]): The prompt template for the chat.
+            form (Optional[Any]): The prompt template for the chat.
             **kwargs: Arbitrary keyword arguments for chat completion.
 
         Returns:
@@ -79,7 +79,7 @@ class MonoChat(BaseMonoFlow, MonoChatMixin):
             context=context,
             sender=sender,
             system=system,
-            prompt_template=prompt_template,
+            form=form,
             tools=tools,
             output_fields=output_fields,
             **kwargs,
@@ -91,5 +91,5 @@ class MonoChat(BaseMonoFlow, MonoChatMixin):
             invoke=invoke,
             out=out,
             output_fields=output_fields,
-            prompt_template=prompt_template,
+            form=form,
         )