lionagi 0.0.315__tar.gz → 0.1.0__tar.gz

{lionagi-0.0.315/lionagi.egg-info → lionagi-0.1.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: lionagi
-Version: 0.0.315
+Version: 0.1.0
 Summary: Towards automated general intelligence.
 Author: HaiyangLi
 Author-email: Haiyang Li <ocean@lionagi.ai>

lionagi-0.1.0/lionagi/core/__init__.py

@@ -0,0 +1,26 @@
+from . import *
+
+from .branch.branch import Branch
+from .session.session import Session
+from .generic import (
+    ActionNode,
+    ActionSelection,
+    Condition,
+)
+from .agent.base_agent import BaseAgent
+from .messages.schema import Instruction, System, Response
+from .tool import func_to_tool
+
+
+__all__ = [
+    "ActionNode",
+    "ActionSelection",
+    "Branch",
+    "Condition",
+    "Session",
+    "System",
+    "Instruction",
+    "Response",
+    "BaseAgent",
+    "func_to_tool",
+]

{lionagi-0.0.315 → lionagi-0.1.0}/lionagi/core/agent/base_agent.py

@@ -2,37 +2,28 @@
 This module contains the BaseAgent class, which serves as a base class for agents.
 """
 
-from lionagi.core.mail.schema import StartMail
-from lionagi.core.schema.base_node import BaseRelatableNode
-from lionagi.core.mail.mail_manager import MailManager
+from pydantic import Field
+from typing import Any, Callable
 
 from lionagi.libs import func_call, AsyncUtil
 
 
-class BaseAgent(BaseRelatableNode):
-    """
-    A base class for agents.
-
-    Attributes:
-        structure: The structure of the agent.
-        executable: The executable object of the agent.
-        start: The StartMail object for triggering the agent.
-        mailManager: The MailManager object for managing agent communication.
-        output_parser: A function for parsing the agent's output (optional).
-        start_context: The initial context for the agent (optional).
-
-    Methods:
-        __init__(self, structure, executable_obj, output_parser=None) -> None:
-            Initializes the BaseAgent instance.
+from lionagi.core.mail.schema import StartMail
+from lionagi.core.generic import Node
+from lionagi.core.mail.mail_manager import MailManager
+from lionagi.core.execute.base_executor import BaseExecutor
+from lionagi.core.execute.structure_executor import StructureExecutor
 
-        async mail_manager_control(self, refresh_time=1) -> None:
-            Controls the mail manager execution based on the structure and executable states.
 
-        async execute(self, context=None) -> Any:
-            Executes the agent with the given context and returns the parsed output (if available).
-    """
+class BaseAgent(Node):
 
-    def __init__(self, structure, executable_obj, output_parser=None) -> None:
+    def __init__(
+        self,
+        structure: StructureExecutor,
+        executable: BaseExecutor,
+        output_parser=None,
+        **kwargs,
+    ) -> None:
         """
         Initializes the BaseAgent instance.
 
@@ -42,12 +33,16 @@ class BaseAgent(BaseRelatableNode):
             output_parser: A function for parsing the agent's output (optional).
         """
         super().__init__()
-        self.structure = structure
-        self.executable = executable_obj
-        self.start = StartMail()
-        self.mailManager = MailManager([self.structure, self.executable, self.start])
-        self.output_parser = output_parser
-        self.start_context = None
+        self.structure: StructureExecutor = structure
+        self.executable: BaseExecutor = executable
+        for v, k in kwargs.items():
+            executable.__setattr__(v, k)
+        self.start: StartMail = StartMail()
+        self.mailManager: MailManager = MailManager(
+            [self.structure, self.executable, self.start]
+        )
+        self.output_parser: Callable | None = output_parser
+        self.start_context: Any | None = None
 
     async def mail_manager_control(self, refresh_time=1):
         """
@@ -92,3 +87,4 @@ class BaseAgent(BaseRelatableNode):
 
         if self.output_parser:
             return self.output_parser(self)
+        

lionagi-0.0.315/lionagi/core/branch/base_branch.py → lionagi-0.1.0/lionagi/core/branch/base.py

@@ -1,22 +1,21 @@
 from abc import ABC
 from typing import Any
 
-from lionagi.libs.sys_util import PATH_TYPE
+from pathlib import Path
 from lionagi.libs import convert, dataframe, SysUtil
 
-from ..schema.base_node import BaseRelatableNode
-from ..schema.data_logger import DataLogger, DLog
-from ..messages.schema import (
+from lionagi.core.generic import BaseNode, DataLogger, DLog
+from lionagi.core.messages.schema import (
     BranchColumns,
     System,
     Response,
     Instruction,
     BaseMessage,
 )
-from .util import MessageUtil
+from lionagi.core.branch.util import MessageUtil
 
 
-class BaseBranch(BaseRelatableNode, ABC):
+class BaseBranch(BaseNode, ABC):
     """
     Base class for managing branches of conversation, incorporating messages
     and logging functionality.
@@ -24,7 +23,7 @@ class BaseBranch(BaseRelatableNode, ABC):
     Attributes:
             messages (dataframe.ln_DataFrame): Holds the messages in the branch.
             datalogger (DataLogger): Logs data related to the branch's operation.
-            persist_path (PATH_TYPE): Filesystem path for data persistence.
+            persist_path (str | Path): Filesystem path for data persistence.
     """
 
     _columns: list[str] = BranchColumns.COLUMNS.value
@@ -33,7 +32,7 @@ class BaseBranch(BaseRelatableNode, ABC):
         self,
         messages: dataframe.ln_DataFrame | None = None,
         datalogger: DataLogger | None = None,
-        persist_path: PATH_TYPE | None = None,
+        persist_path: str | Path | None = None,
         name=None,
         **kwargs,
     ) -> None:
@@ -97,6 +96,7 @@ class BaseBranch(BaseRelatableNode, ABC):
                 if self.name is not None:
                     _msg.sender = self.name
 
+        setattr(_msg, "node_id", _msg.id_)
         _msg.content = _msg.msg_content
         self.messages.loc[len(self.messages)] = _msg.to_pd_series()
 
@@ -332,7 +332,7 @@ class BaseBranch(BaseRelatableNode, ABC):
 
     def to_csv_file(
         self,
-        filename: PATH_TYPE = "messages.csv",
+        filename: str | Path = "messages.csv",
         dir_exist_ok: bool = True,
         timestamp: bool = True,
         time_prefix: bool = False,
@@ -375,7 +375,7 @@ class BaseBranch(BaseRelatableNode, ABC):
 
     def to_json_file(
         self,
-        filename: PATH_TYPE = "messages.json",
+        filename: str | Path = "messages.json",
         dir_exist_ok: bool = True,
         timestamp: bool = True,
         time_prefix: bool = False,
@@ -420,7 +420,7 @@ class BaseBranch(BaseRelatableNode, ABC):
 
     def log_to_csv(
         self,
-        filename: PATH_TYPE = "log.csv",
+        filename: str | Path = "log.csv",
         dir_exist_ok: bool = True,
         timestamp: bool = True,
         time_prefix: bool = False,
@@ -456,7 +456,7 @@ class BaseBranch(BaseRelatableNode, ABC):
 
     def log_to_json(
         self,
-        filename: PATH_TYPE = "log.json",
+        filename: str | Path = "log.json",
         dir_exist_ok: bool = True,
         timestamp: bool = True,
         time_prefix: bool = False,
@@ -636,7 +636,6 @@ class BaseBranch(BaseRelatableNode, ABC):
             case_sensitive=case_sensitive,
         )
 
-    # noinspection PyTestUnpassedFixture
     def _info(self, use_sender: bool = False) -> dict[str, int]:
         """
         Helper method to generate summaries of messages either by role or sender.
@@ -651,4 +650,4 @@ class BaseBranch(BaseRelatableNode, ABC):
         messages = self.messages["sender"] if use_sender else self.messages["role"]
         result = messages.value_counts().to_dict()
         result["total"] = len(self.messages)
-        return result
+        return result

{lionagi-0.0.315 → lionagi-0.1.0}/lionagi/core/branch/branch.py

@@ -4,19 +4,18 @@ This module contains the Branch class, which represents a branch in a conversati
 
 from collections import deque
 from typing import Any, Union, TypeVar, Callable
+from pathlib import Path
 
-from lionagi.libs.sys_util import PATH_TYPE
 from lionagi.libs import StatusTracker, BaseService, convert, dataframe
 
-from ..schema import TOOL_TYPE, Tool, DataLogger
-from ..tool import ToolManager, func_to_tool
+from lionagi.core.generic import DataLogger
+from lionagi.core.tool import ToolManager, func_to_tool, Tool, TOOL_TYPE
+from lionagi.core.messages.schema import System
+from lionagi.core.mail.schema import BaseMail
 
-from ..messages import System
-from ..mail import BaseMail
-
-from .util import MessageUtil
-from .base_branch import BaseBranch
-from .branch_flow_mixin import BranchFlowMixin
+from lionagi.core.branch.util import MessageUtil
+from lionagi.core.branch.base import BaseBranch
+from lionagi.core.branch.flow_mixin import BranchFlowMixin
 
 from dotenv import load_dotenv
 
@@ -95,7 +94,7 @@ class Branch(BaseBranch, BranchFlowMixin):
         llmconfig: dict[str, str | int | dict] | None = None,
         tools: list[Callable | Tool] | None = None,
         datalogger: None | DataLogger = None,
-        persist_path: PATH_TYPE | None = None,  # instruction_sets=None,
+        persist_path: str | Path | None = None,  # instruction_sets=None,
         tool_manager: ToolManager | None = None,
         **kwargs,
     ):
@@ -111,7 +110,7 @@ class Branch(BaseBranch, BranchFlowMixin):
             llmconfig (dict[str, str | int | dict]): The configuration for the language model (optional).
             tools (list[Callable | Tool]): The tools to register in the branch (optional).
             datalogger (DataLogger): The data logger for the branch (optional).
-            persist_path (PATH_TYPE): The path to persist the branch data (optional).
+            persist_path (str | Path): The path to persist the branch data (optional).
             tool_manager (ToolManager): The tool manager for the branch (optional).
             **kwargs: Additional keyword arguments.
 
@@ -165,7 +164,7 @@ class Branch(BaseBranch, BranchFlowMixin):
         llmconfig: dict[str, str | int | dict] | None = None,
         tools: TOOL_TYPE | None = None,
         datalogger: None | DataLogger = None,
-        persist_path: PATH_TYPE | None = None,  # instruction_sets=None,
+        persist_path: str | Path | None = None,  # instruction_sets=None,
         tool_manager: ToolManager | None = None,
         read_kwargs=None,
         **kwargs,
@@ -180,7 +179,7 @@ class Branch(BaseBranch, BranchFlowMixin):
             llmconfig (dict[str, str | int | dict]): The configuration for the language model (optional).
             tools (TOOL_TYPE): The tools to register in the branch (optional).
             datalogger (DataLogger): The data logger for the branch (optional).
-            persist_path (PATH_TYPE): The path to persist the branch data (optional).
+            persist_path (str | Path): The path to persist the branch data (optional).
             tool_manager (ToolManager): The tool manager for the branch (optional).
             read_kwargs: Additional keyword arguments for reading the CSV file (optional).
             **kwargs: Additional keyword arguments.
@@ -211,7 +210,7 @@ class Branch(BaseBranch, BranchFlowMixin):
         llmconfig: dict[str, str | int | dict] | None = None,
         tools: TOOL_TYPE | None = None,
         datalogger: None | DataLogger = None,
-        persist_path: PATH_TYPE | None = None,  # instruction_sets=None,
+        persist_path: str | Path | None = None,  # instruction_sets=None,
         tool_manager: ToolManager | None = None,
         read_kwargs=None,
         **kwargs,
@@ -226,7 +225,7 @@ class Branch(BaseBranch, BranchFlowMixin):
             llmconfig (dict[str, str | int | dict]): The configuration for the language model (optional).
             tools (TOOL_TYPE): The tools to register in the branch (optional).
             datalogger (DataLogger): The data logger for the branch (optional).
-            persist_path (PATH_TYPE): The path to persist the branch data (optional).
+            persist_path (str | Path): The path to persist the branch data (optional).
             tool_manager (ToolManager): The tool manager for the branch (optional).
             read_kwargs: Additional keyword arguments for reading the JSON string file (optional).
             **kwargs: Additional keyword arguments.
@@ -348,7 +347,7 @@ class Branch(BaseBranch, BranchFlowMixin):
             print("tools deletion failed")
         return False
 
-    def send(self, recipient: str, category: str, package: Any) -> None:
+    def send(self, recipient_id: str, category: str, package: Any) -> None:
         """
         Sends a mail to a recipient.
 
@@ -357,10 +356,13 @@ class Branch(BaseBranch, BranchFlowMixin):
             category (str): The category of the mail.
             package (Any): The package to send in the mail.
         """
-        mail_ = BaseMail(
-            sender=self.sender, recipient=recipient, category=category, package=package
+        mail = BaseMail(
+            sender_id=self.id_,
+            recipient_id=recipient_id,
+            category=category,
+            package=package,
         )
-        self.pending_outs.append(mail_)
+        self.pending_outs.append(mail)
 
     def receive(
         self,
@@ -468,4 +470,4 @@ class Branch(BaseBranch, BranchFlowMixin):
             }:
                 return True
         except Exception:
-            return False
+            return False

lionagi-0.0.315/lionagi/core/branch/branch_flow_mixin.py → lionagi-0.1.0/lionagi/core/branch/flow_mixin.py

@@ -1,9 +1,9 @@
 from abc import ABC
 from typing import Any, Optional, Union, TypeVar
 
-from ..schema import TOOL_TYPE, Tool
-from ..messages import Instruction, System
-from ..flow.monoflow import MonoChat, MonoFollowup, MonoReAct
+from lionagi.core.tool import Tool, TOOL_TYPE
+from lionagi.core.messages.schema import Instruction, System
+from lionagi.core.flow.monoflow import MonoChat, MonoFollowup, MonoReAct
 
 T = TypeVar("T", bound=Tool)
 
@@ -20,7 +20,7 @@ class BranchFlowMixin(ABC):
         out: bool = True,
         invoke: bool = True,
         output_fields=None,
-        prompt_template=None,
+        form=None,
         **kwargs,
     ) -> Any:
         flow = MonoChat(self)
@@ -33,7 +33,7 @@ class BranchFlowMixin(ABC):
             out=out,
             invoke=invoke,
             output_fields=output_fields,
-            prompt_template=prompt_template,
+            form=form,
             **kwargs,
         )
 
@@ -93,4 +93,4 @@ class BranchFlowMixin(ABC):
             output_prompt=output_prompt,
             out=out,
             **kwargs,
-        )
+        )

{lionagi-0.0.315 → lionagi-0.1.0}/lionagi/core/branch/util.py

@@ -320,4 +320,4 @@ class MessageUtil:
             else:
                 with contextlib.suppress(Exception):
                     answers.append(nested.nget(content, ["system_info"]))
-        return "\n".join(answers)
+        return "\n".join(answers)

lionagi-0.1.0/lionagi/core/direct/__init__.py

@@ -0,0 +1,19 @@
+from .predict import predict
+from .select import select
+from .score import score
+from .react import react
+from .vote import vote
+from .plan import plan
+from .cot import chain_of_thoughts, chain_of_react
+
+
+__all__ = [
+    "predict",
+    "select",
+    "score",
+    "vote",
+    "react",
+    "plan",
+    "chain_of_thoughts",
+    "chain_of_react",
+]

lionagi-0.1.0/lionagi/core/direct/cot.py

@@ -0,0 +1,123 @@
+from lionagi.libs import convert
+
+from lionagi.core.direct.predict import predict
+from lionagi.core.direct.plan import plan
+from lionagi.core.direct.react import react
+
+from .utils import _process_tools
+
+
+async def chain_of_thoughts(
+    sentence=None,
+    branch=None,
+    instruction=None,
+    reason=False,
+    confidence_score=False,
+    num_steps=3,
+    directive_kwargs={},
+    return_branch=False,
+    **kwargs,
+):
+
+    out_, outs, answer, reasons, confidence_score = "", [], "", [], 0
+    if branch is not None:
+        out_ = await plan(
+            sentence,
+            branch=branch,
+            instruction=instruction,
+            num_steps=num_steps,
+            **kwargs,
+        )
+    else:
+        out_, branch = await plan(
+            sentence,
+            instruction=instruction,
+            branch=branch,
+            num_steps=num_steps,
+            return_branch=True,
+            **kwargs,
+        )
+
+    for i in range(len(out_.plan)):
+        _out = await predict(
+            branch=branch,
+            instruction=out_.plan[f"step_{i+1}"],
+            reason=reason,
+            confidence_score=confidence_score,
+            **directive_kwargs,
+        )
+        answer += _out.answer
+        if reason:
+            reasons.append(_out.reason)
+        if confidence_score:
+            confidence_score += _out.confidence_score
+        outs.append(_out)
+
+    setattr(out_, "chain_output", outs)
+    setattr(out_, "chain_answer", answer)
+
+    if reason:
+        setattr(out_, "chain_reasons", reasons)
+    if confidence_score:
+        setattr(out_, "chain_confidence_score", confidence_score / len(outs))
+
+    if return_branch:
+        return out_, branch
+
+    return out_
+
+
+async def chain_of_react(
+    sentence=None,
+    branch=None,
+    instruction=None,
+    num_steps=3,
+    tools=None,
+    directive_system=None,
+    directive_kwargs={},
+    return_branch=False,
+    **kwargs,
+):
+    out_, outs, reasons, actions, action_responses = "", [], [], [], []
+    if branch is not None:
+        out_ = await plan(
+            sentence,
+            branch=branch,
+            instruction=instruction,
+            num_steps=num_steps,
+            **kwargs,
+        )
+    else:
+        out_, branch = await plan(
+            sentence,
+            instruction=instruction,
+            branch=branch,
+            num_steps=num_steps,
+            return_branch=True,
+            **kwargs,
+        )
+
+    _process_tools(tools, branch)
+
+    for i in range(len(out_.plan)):
+        _out = await react(
+            branch=branch,
+            system=directive_system,
+            instruction=out_.plan[f"step_{i+1}"],
+            **directive_kwargs,
+        )
+        outs.append(_out)
+        reasons.append(_out.reason)
+        actions.append(_out.actions)
+        if _out.action_needed:
+            action_responses.append(_out.action_response)
+
+    setattr(out_, "chain_output", convert.to_list(outs))
+    setattr(out_, "chain_reason", convert.to_list(reasons))
+    setattr(out_, "chain_actions", convert.to_list(actions))
+    setattr(out_, "chain_action_response", convert.to_list(action_responses))
+
+    if return_branch:
+        return out_, branch
+
+    return out_

lionagi-0.1.0/lionagi/core/direct/plan.py

@@ -0,0 +1,164 @@
+# plan.py
+
+from lionagi.libs import func_call, ParseUtil
+from lionagi.integrations.bridge.pydantic_.pydantic_bridge import Field
+from lionagi.core.form.scored_form import ScoredForm
+from lionagi.core.branch.branch import Branch
+
+
+class PlanTemplate(ScoredForm):
+    template_name: str = "default_plan"
+    sentence: str | list | dict = Field(
+        default_factory=str,
+        description="the given sentence(s) or context to generate a plan for",
+    )
+    plan: dict | str = Field(
+        default_factory=dict,
+        description="the generated step by step plan, return as a dictionary following {step_n: {plan: ..., reason: ...}} format",
+    )
+    signature: str = "sentence -> plan"
+
+    def __init__(
+        self,
+        sentence=None,
+        instruction=None,
+        confidence_score=False,
+        reason=False,
+        num_step=3,
+        **kwargs,
+    ):
+        super().__init__(**kwargs)
+
+        self.sentence = sentence
+        self.task = f"Generate a {num_step}_step plan based on the given context. Instruction: {instruction}."
+
+        if reason:
+            self.output_fields.append("reason")
+
+        if confidence_score:
+            self.output_fields.append("confidence_score")
+
+
+async def _plan(
+    sentence,
+    *,
+    instruction=None,
+    branch=None,
+    confidence_score=False,
+    reason=False,
+    retries=2,
+    delay=0.5,
+    backoff_factor=2,
+    default_value=None,
+    timeout=None,
+    branch_name=None,
+    system=None,
+    messages=None,
+    service=None,
+    sender=None,
+    llmconfig=None,
+    tools=None,
+    datalogger=None,
+    persist_path=None,
+    tool_manager=None,
+    return_branch=False,
+    **kwargs,
+):
+    if "temperature" not in kwargs:
+        kwargs["temperature"] = 0.1
+
+    instruction = instruction or ""
+
+    branch = branch or Branch(
+        name=branch_name,
+        system=system,
+        messages=messages,
+        service=service,
+        sender=sender,
+        llmconfig=llmconfig,
+        tools=tools,
+        datalogger=datalogger,
+        persist_path=persist_path,
+        tool_manager=tool_manager,
+    )
+
+    _template = PlanTemplate(
+        sentence=sentence,
+        instruction=instruction,
+        confidence_score=confidence_score,
+        reason=reason,
+    )
+
+    await func_call.rcall(
+        branch.chat,
+        form=_template,
+        retries=retries,
+        delay=delay,
+        backoff_factor=backoff_factor,
+        default=default_value,
+        timeout=timeout,
+        **kwargs,
+    )
+
+    _template.plan = ParseUtil.fuzzy_parse_json(_template.plan)
+
+    return (_template, branch) if return_branch else _template
+
+
+async def plan(
+    sentence,
+    *,
+    instruction=None,
+    num_instances=1,
+    branch=None,
+    confidence_score=False,
+    reason=False,
+    retries=2,
+    delay=0.5,
+    backoff_factor=2,
+    default_value=None,
+    timeout=None,
+    branch_name=None,
+    system=None,
+    messages=None,
+    service=None,
+    sender=None,
+    llmconfig=None,
+    tools=None,
+    datalogger=None,
+    persist_path=None,
+    tool_manager=None,
+    return_branch=False,
+    **kwargs,
+):
+    async def _inner(i=0):
+        return await _plan(
+            sentence=sentence,
+            instruction=instruction,
+            branch=branch,
+            confidence_score=confidence_score,
+            reason=reason,
+            retries=retries,
+            delay=delay,
+            backoff_factor=backoff_factor,
+            default_value=default_value,
+            timeout=timeout,
+            branch_name=branch_name,
+            system=system,
+            messages=messages,
+            service=service,
+            sender=sender,
+            llmconfig=llmconfig,
+            tools=tools,
+            datalogger=datalogger,
+            persist_path=persist_path,
+            tool_manager=tool_manager,
+            return_branch=return_branch,
+            **kwargs,
+        )
+
+    if num_instances == 1:
+        return await _inner()
+
+    elif num_instances > 1:
+        return await func_call.alcall(range(num_instances), _inner)