lionagi 0.0.305__py3-none-any.whl → 0.0.307__py3-none-any.whl

lionagi/core/direct/utils.py

@@ -0,0 +1,83 @@
+import contextlib
+from lionagi.libs import ParseUtil, StringMatch, convert, func_call
+
+
+def _parse_out(out_):
+    if isinstance(out_, str):
+        try:
+            out_ = ParseUtil.md_to_json(out_)
+        except Exception:
+            with contextlib.suppress(Exception):
+                out_ = ParseUtil.fuzzy_parse_json(out_.strip("```json").strip("```"))
+    return out_
+
+
+def _handle_single_out(
+    out_,
+    default_key,
+    choices=None,
+    to_type="dict",
+    to_type_kwargs=None,
+    to_default=True,
+):
+
+    if to_type_kwargs is None:
+        to_type_kwargs = {}
+    out_ = _parse_out(out_)
+
+    if default_key not in out_:
+        raise ValueError(f"Key {default_key} not found in output")
+
+    answer = out_[default_key]
+
+    if (
+        choices is not None
+        and answer not in choices
+        and convert.strip_lower(out_) in ["", "none", "null", "na", "n/a"]
+    ):
+        raise ValueError(f"Answer {answer} not in choices {choices}")
+
+    if to_type == "str":
+        out_[default_key] = convert.to_str(answer, **to_type_kwargs)
+
+    elif to_type == "num":
+        out_[default_key] = convert.to_num(answer, **to_type_kwargs)
+
+    return out_[default_key] if to_default and len(out_.keys()) == 1 else out_
+
+
+def _handle_multi_out(
+    out_,
+    default_key,
+    choices=None,
+    to_type="dict",
+    to_type_kwargs=None,
+    to_default=True,
+    include_mapping=False,
+):
+    if to_type_kwargs is None:
+        to_type_kwargs = {}
+    if include_mapping:
+        for i in out_:
+            i[default_key] = _handle_single_out(
+                i[default_key],
+                choices=choices,
+                default_key=default_key,
+                to_type=to_type,
+                to_type_kwargs=to_type_kwargs,
+                to_default=to_default,
+            )
+    else:
+        _out = []
+        for i in out_:
+            i = _handle_single_out(
+                i,
+                choices=choices,
+                default_key=default_key,
+                to_type=to_type,
+                to_type_kwargs=to_type_kwargs,
+                to_default=to_default,
+            )
+            _out.append(i)
+
+    return out_ if len(out_) > 1 else out_[0]

lionagi/core/flow/__init__.py

@@ -1,3 +0,0 @@
-from .monoflow.mono_chat import MonoChat
-
-__all__ = ["MonoChat"]

lionagi/core/flow/monoflow/{mono_react.py → ReAct.py}

@@ -1,4 +1,7 @@
-from .mono_chat import MonoChat
+from lionagi.core.tool.tool_manager import func_to_tool
+from typing import Callable
+import lionagi.libs.ln_convert as convert
+from .chat import MonoChat
 from lionagi.core.schema.base_node import Tool
 from lionagi.core.messages.schema import Instruction
 
@@ -39,23 +42,25 @@ class MonoReAct(MonoChat):
         try:
             try:
                 return default.format(num_steps=num_steps)
-            except:
+            except Exception:
                 return default.format(instruction=instruction)
-        except:
+        except Exception:
             return default
 
-    def _create_followup_config(self, tools, **kwargs):
+    def _create_followup_config(self, tools, auto=True, **kwargs):
 
-        if tools is not None:
-            if isinstance(tools, list) and isinstance(tools[0], Tool):
-                self.branch.tool_manager.register_tools(tools)
+        if tools is not None and (
+            isinstance(tools, list) and isinstance(tools[0], 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"] = "auto"
+        if auto:
+            config["tool_choice"] = "auto"
         return config
 
     async def _handle_auto(
@@ -85,7 +90,7 @@ class MonoReAct(MonoChat):
         prompt_ = self._get_prompt(
             output_prompt, _output_prompt, instruction=instruction
         )
-        return await self.chat(prompt_, sender=sender, **config)
+        return await self.chat(prompt_, sender=sender, out=out, **config)
 
     async def _ReAct(
         self,
@@ -152,6 +157,44 @@ class MonoReAct(MonoChat):
             if a:
                 return a
 
+    async def _react(
+        self,
+        instruction=None,
+        context=None,
+        output_fields=None,
+        tools=None,
+        reason_prompt=None,
+        action_prompt=None,
+        **kwargs,
+    ):
+
+        config = self._create_followup_config(tools=tools, auto=False, **kwargs)
+
+        instruct = {
+            "requirement": "think step by step, perform reasoning and prepare action plan according to available tools only",
+            "task": convert.to_str(instruction),
+        }
+
+        extra_fields = output_fields or {}
+        output_fields = {
+            "reason": reason_prompt or "reasoning",
+            "action": action_prompt
+            or "the action(s) to take, in function call format. If no actions are needed return none",
+        }
+        output_fields = {**output_fields, **extra_fields}
+
+        out_ = await self.chat(
+            instruct, context=context, output_fields=output_fields, **config
+        )
+        print(out_)
+
+        if convert.strip_lower(out_["action"]) not in ["none", "no", "na", "nan"]:
+            res = await self._invoke_tools(content_={"action_request": out_["action"]})
+            for idx, item in enumerate(res):
+                out_[f"action_response_{idx}"] = item
+
+        return out_
+
     # TODO: auto_ReAct
 
 

lionagi/core/flow/monoflow/__init__.py

@@ -0,0 +1,9 @@
+from .chat import MonoChat
+from .followup import MonoFollowup
+from .ReAct import MonoReAct
+
+__all__ = [
+    "MonoChat",
+    "MonoFollowup",
+    "MonoReAct",
+]

lionagi/core/flow/monoflow/{mono_chat.py → chat.py}

@@ -1,7 +1,7 @@
 from typing import Any
 
 from lionagi.core.flow.base.baseflow import BaseMonoFlow
-from lionagi.core.flow.monoflow.mono_chat_mixin import MonoChatMixin
+from lionagi.core.flow.monoflow.chat_mixin import MonoChatMixin
 
 
 class MonoChat(BaseMonoFlow, MonoChatMixin):
@@ -25,18 +25,18 @@ class MonoChat(BaseMonoFlow, MonoChatMixin):
         a chat conversation with LLM, processing instructions and system messages, optionally invoking tools.
 
         Args:
-            branch: The Branch instance to perform chat operations.
-            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.
-            **kwargs: Arbitrary keyword arguments for chat completion.
+                branch: The Branch instance to perform chat operations.
+                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.
+                **kwargs: Arbitrary keyword arguments for chat completion.
 
         Examples:
-            >>> await ChatFlow.chat(branch, "Ask about user preferences")
+                >>> await ChatFlow.chat(branch, "Ask about user preferences")
         """
 
         config = self._create_chat_config(

lionagi/core/flow/monoflow/{mono_chat_mixin.py → chat_mixin.py}

@@ -36,32 +36,33 @@ class MonoChatConfigMixin(ABC):
         if "tool_parsed" in kwargs:
             kwargs.pop("tool_parsed")
             tool_kwarg = {"tools": tools}
-            kwargs = {**tool_kwarg, **kwargs}
-        else:
-            if tools and self.branch.has_tools:
-                kwargs = self.branch.tool_manager.parse_tool(tools=tools, **kwargs)
+            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.update({"sender": sender})
+            config["sender"] = sender
 
         return config
 
 
 class MonoChatInvokeMixin(ABC):
-    async def _output(self, invoke, out, output_fields):
+    async def _output(self, invoke, out, output_fields, func_calls_=None):
+        # sourcery skip: use-contextlib-suppress
         content_ = self.branch.last_message_content
 
         if invoke:
             try:
-                await self._invoke_tools(content_)
-            except:
+                await self._invoke_tools(content_, func_calls_=func_calls_)
+            except Exception:
                 pass
         if out:
             return self._return_response(content_, output_fields)
 
     @staticmethod
     def _return_response(content_, output_fields):
+        # sourcery skip: assign-if-exp, use-contextlib-suppress
         out_ = ""
 
         if len(content_.items()) == 1 and len(nested.get_flattened_keys(content_)) == 1:
@@ -75,29 +76,34 @@ class MonoChatInvokeMixin(ABC):
                 else:
                     out_ = ParseUtil.md_to_json(out_)
                 out_ = StringMatch.correct_keys(output_fields=output_fields, out_=out_)
-            except:
+            except Exception:
                 pass
 
         return out_
 
-    async def _invoke_tools(self, content_):
-        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,
-        )
+    async def _invoke_tools(self, content_=None, func_calls_=None):
+
+        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 = await func_call.alcall(func_calls_, self.branch.tool_manager.invoke)
         outs = convert.to_list(outs, flatten=True)
 
-        for out_, f in zip(outs, func_calls):
-            self.branch.add_message(
-                response={
-                    "function": f[0],
-                    "arguments": f[1],
-                    "output": out_,
-                }
-            )
+        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):
         if "choices" in completion:
@@ -113,9 +119,9 @@ class MonoChatInvokeMixin(ABC):
 
     async def _call_chatcompletion(self, sender=None, with_sender=False, **kwargs):
         messages = (
-            self.branch.chat_messages
-            if not with_sender
-            else self.branch.chat_messages_with_sender
+            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

lionagi/core/flow/monoflow/{mono_followup.py → followup.py}

@@ -1,6 +1,6 @@
 from lionagi.core.messages.schema import Instruction
 from lionagi.core.schema.base_node import Tool
-from .mono_chat import MonoChat
+from .chat import MonoChat
 
 
 class MonoFollowup(MonoChat):
@@ -41,16 +41,17 @@ class MonoFollowup(MonoChat):
         try:
             try:
                 return default.format(num_followup=num_followup)
-            except:
+            except Exception:
                 return default.format(instruction=instruction)
-        except:
+        except Exception:
             return default
 
     def _create_followup_config(self, tools, **kwargs):
 
-        if tools is not None:
-            if isinstance(tools, list) and isinstance(tools[0], Tool):
-                self.branch.tool_manager.register_tools(tools)
+        if tools is not None and (
+            isinstance(tools, list) and isinstance(tools[0], 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")

lionagi/core/flow/polyflow/__init__.py

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

lionagi/core/flow/polyflow/{polychat.py → chat.py}

@@ -6,7 +6,6 @@ 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
 
 
@@ -28,7 +27,7 @@ class PolyChat(BasePolyFlow):
         invoke: bool = True,
         output_fields=None,
         persist_path=None,
-        branch_config={},
+        branch_config=None,
         explode=False,
         **kwargs,
     ) -> Any:
@@ -36,6 +35,8 @@ class PolyChat(BasePolyFlow):
         parallel chat
         """
 
+        if branch_config is None:
+            branch_config = {}
         return await self._parallel_chat(
             instruction,
             num_instances=num_instances,
@@ -67,6 +68,8 @@ class PolyChat(BasePolyFlow):
         persist_path=None,
         branch_config={},
         explode=False,
+        include_mapping=True,
+        default_key="response",
         **kwargs,
     ) -> Any:
         """
@@ -102,7 +105,16 @@ class PolyChat(BasePolyFlow):
             )
 
             branches[branch_.id_] = branch_
-            return res_
+            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"""

lionagi/core/mail/__init__.py

@@ -0,0 +1,8 @@
+from .schema import BaseMail, StartMail
+from .mail_manager import MailManager
+
+__all__ = [
+    "BaseMail",
+    "StartMail",
+    "MailManager",
+]

lionagi/core/mail/mail_manager.py

@@ -1,49 +1,97 @@
-from typing import Dict, Any
 from collections import deque
-from lionagi.core.mail.schema import BaseMail
+from lionagi.libs import AsyncUtil
+from ..schema import BaseNode
+from .schema import BaseMail
 
 
 class MailManager:
+    """
+    Manages the sending, receiving, and storage of mail items between various sources.
 
-    def __init__(self, sources: Dict[str, Any]):
-        self.sources = sources
+    This class acts as a central hub for managing mail transactions within a system. It allows for the addition
+    and deletion of sources, and it handles the collection and dispatch of mails to and from these sources.
+
+    Attributes:
+            sources (Dict[str, Any]): A dictionary mapping source identifiers to their attributes.
+            mails (Dict[str, Dict[str, deque]]): A nested dictionary storing queued mail items, organized by recipient
+                    and sender.
+    """
+
+    def __init__(self, sources):
+        self.sources = {}
         self.mails = {}
-        for key in self.sources.keys():
-            self.mails[key] = {}
+        self.add_sources(sources)
+        self.execute_stop = False
+
+    def add_sources(self, sources):
+        if isinstance(sources, dict):
+            for _, v in sources.items():
+                if v.id_ not in self.sources:
+                    self.sources[v.id_] = v
+                    self.mails[v.id_] = {}
+        elif isinstance(sources, list):
+            for v in sources:
+                if v.id_ not in self.sources:
+                    self.sources[v.id_] = v
+                    self.mails[v.id_] = {}
 
     @staticmethod
-    def create_mail(sender, recipient, category, package):
-        return BaseMail(sender, recipient, category, package)
-
-    def add_source(self, sources: Dict[str, Any]):
-        for key in sources.keys():
-            if key in self.sources:
-                raise ValueError(f"{key} exists, please input a different name.")
-            self.sources[key] = {}
-
-    def delete_source(self, source_name):
-        if source_name not in self.sources:
-            raise ValueError(f"{source_name} does not exist.")
-        self.sources.pop(source_name)
-
-    def collect(self, sender):
-        if sender not in self.sources:
-            raise ValueError(f"{sender} does not exist.")
-        while self.sources[sender].pending_outs:
-            mail_ = self.sources[sender].pending_outs.popleft()
-            if mail_.sender not in self.mails[mail_.recipient]:
-                self.mails[mail_.recipient] = {mail_.sender: deque()}
-            self.mails[mail_.recipient][mail_.sender].append(mail_)
-
-    def send(self, to_name):
-        if to_name not in self.sources:
-            raise ValueError(f"{to_name} does not exist.")
-        if not self.mails[to_name]:
+    def create_mail(sender_id, recipient_id, category, package):
+        return BaseMail(sender_id, recipient_id, category, package)
+
+    def add_source(self, sources: list[BaseNode]):
+        for source in sources:
+            if source.id_ in self.sources:
+                # raise ValueError(f"Source {source.id_} exists, please input a different name.")
+                continue
+            self.sources[source.id_] = source
+            self.mails[source.id_] = {}
+
+    def delete_source(self, source_id):
+        if source_id not in self.sources:
+            raise ValueError(f"Source {source_id} does not exist.")
+        # if self.mails[source_id]:
+        #     raise ValueError(f"None empty pending mails in source {source_id}")
+        self.sources.pop(source_id)
+        self.mails.pop(source_id)
+
+    def collect(self, sender_id):
+        if sender_id not in self.sources:
+            raise ValueError(f"Sender source {sender_id} does not exist.")
+        while self.sources[sender_id].pending_outs:
+            mail_ = self.sources[sender_id].pending_outs.popleft()
+            if mail_.recipient_id not in self.sources:
+                raise ValueError(
+                    f"Recipient source {mail_.recipient_id} does not exist"
+                )
+            if mail_.sender_id not in self.mails[mail_.recipient_id]:
+                self.mails[mail_.recipient_id] = {mail_.sender_id: deque()}
+            self.mails[mail_.recipient_id][mail_.sender_id].append(mail_)
+
+    def send(self, recipient_id):
+        if recipient_id not in self.sources:
+            raise ValueError(f"Recipient source {recipient_id} does not exist.")
+        if not self.mails[recipient_id]:
             return
-        else:
-            for key in list(self.mails[to_name].keys()):
-                request = self.mails[to_name].pop(key)
-                if key not in self.sources[to_name].pending_ins:
-                    self.sources[to_name].pending_ins[key] = request
-                else:
-                    self.sources[to_name].pending_ins[key].append(request)
+        for key in list(self.mails[recipient_id].keys()):
+            mails_deque = self.mails[recipient_id].pop(key)
+            if key not in self.sources[recipient_id].pending_ins:
+                self.sources[recipient_id].pending_ins[key] = mails_deque
+            else:
+                while mails_deque:
+                    mail_ = mails_deque.popleft()
+                    self.sources[recipient_id].pending_ins[key].append(mail_)
+
+    def collect_all(self):
+        for ids in self.sources:
+            self.collect(ids)
+
+    def send_all(self):
+        for ids in self.sources:
+            self.send(ids)
+
+    async def execute(self, refresh_time=1):
+        while not self.execute_stop:
+            self.collect_all()
+            self.send_all()
+            await AsyncUtil.sleep(refresh_time)

lionagi/core/mail/schema.py

@@ -1,18 +1,27 @@
+from collections import deque
 from enum import Enum
 
+from lionagi.core.schema.base_node import BaseRelatableNode
+
 
 class MailCategory(str, Enum):
     MESSAGES = "messages"
-    TOOL = "tools"
-    SERVICE = "provider"
+    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, recipient, category, package):
-        self.sender = sender
-        self.recipient = recipient
+    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)
@@ -26,5 +35,22 @@ class BaseMail:
             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

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