lionagi 0.18.0__py3-none-any.whl → 0.18.2__py3-none-any.whl

lionagi/session/branch.py

@@ -2,52 +2,48 @@
 # SPDX-License-Identifier: Apache-2.0
 
 from collections.abc import AsyncGenerator, Callable
-from typing import TYPE_CHECKING, Any, Literal, Optional
+from typing import TYPE_CHECKING, Any, Literal
 
 from pydantic import BaseModel, Field, JsonValue, PrivateAttr, field_serializer
 
 from lionagi.config import settings
-from lionagi.fields import Instruct
+from lionagi.ln import AlcallParams
 from lionagi.ln.types import Unset
 from lionagi.models.field_model import FieldModel
-from lionagi.operations.flow import AlcallParams
+from lionagi.operations.fields import Instruct
 from lionagi.operations.manager import OperationManager
+from lionagi.protocols._concepts import Relational
 from lionagi.protocols.action.manager import ActionManager
 from lionagi.protocols.action.tool import FuncTool, Tool, ToolRef
-from lionagi.protocols.types import (
+from lionagi.protocols.generic import (
     ID,
-    MESSAGE_FIELDS,
+    DataLogger,
+    DataLoggerConfig,
+    Element,
+    Log,
+    Pile,
+    Progression,
+)
+from lionagi.protocols.messages import (
     ActionRequest,
     ActionResponse,
     AssistantResponse,
-    Communicatable,
-    Element,
-    IDType,
     Instruction,
-    Log,
-    LogManager,
-    LogManagerConfig,
-    Mail,
-    Mailbox,
     MessageManager,
     MessageRole,
-    PackageCategory,
-    Pile,
-    Progression,
-    Relational,
     RoledMessage,
     SenderRecipient,
     System,
 )
-from lionagi.service import Endpoint, iModel, iModelManager
+from lionagi.service.connections.endpoint import Endpoint
+from lionagi.service.manager import iModel, iModelManager
 from lionagi.tools.base import LionTool
 from lionagi.utils import copy
 
 from .prompts import LION_SYSTEM_MESSAGE
 
 if TYPE_CHECKING:
-    from lionagi.fields import Instruct
-    from lionagi.protocols.operatives.operative import Operative
+    from lionagi.operations.operate.operative import Operative
 
 
 __all__ = ("Branch",)
@@ -56,7 +52,7 @@ __all__ = ("Branch",)
 _DEFAULT_ALCALL_PARAMS = None
 
 
-class Branch(Element, Communicatable, Relational):
+class Branch(Element, Relational):
     """
     Manages a conversation 'branch' with messages, tools, and iModels.
 
@@ -65,20 +61,17 @@ class Branch(Element, Communicatable, Relational):
         - Registers and invokes tools/actions (`ActionManager`).
         - Manages model instances (`iModelManager`).
         - Logs activity (`LogManager`).
-        - Communicates via mailboxes (`Mailbox`).
 
     **Key responsibilities**:
         - Storing and organizing messages, including system instructions, user instructions, and model responses.
         - Handling asynchronous or synchronous execution of LLM calls and tool invocations.
-        - Providing a consistent interface for “operate,” “chat,” “communicate,” “parse,” etc.
+        - Providing a consistent interface for "operate," "chat," "communicate," "parse," etc.
 
     Attributes:
         user (SenderRecipient | None):
             The user or "owner" of this branch (often tied to a session).
         name (str | None):
             A human-readable name for this branch.
-        mailbox (Mailbox):
-            A mailbox for sending and receiving `Package` objects to/from other branches.
 
     Note:
         Actual implementations for chat, parse, operate, etc., are referenced
@@ -101,16 +94,10 @@ class Branch(Element, Communicatable, Relational):
         description="A human-readable name of the branch (optional).",
     )
 
-    mailbox: Mailbox = Field(
-        default_factory=Mailbox,
-        exclude=True,
-        description="Mailbox for cross-branch or external communication.",
-    )
-
     _message_manager: MessageManager | None = PrivateAttr(None)
     _action_manager: ActionManager | None = PrivateAttr(None)
     _imodel_manager: iModelManager | None = PrivateAttr(None)
-    _log_manager: LogManager | None = PrivateAttr(None)
+    _log_manager: DataLogger | None = PrivateAttr(None)
     _operation_manager: OperationManager | None = PrivateAttr(None)
 
     def __init__(
@@ -125,7 +112,7 @@ class Branch(Element, Communicatable, Relational):
         parse_model: iModel | dict = None,
         imodel: iModel = None,  # deprecated, alias of chat_model
         tools: FuncTool | list[FuncTool] = None,  # ActionManager kwargs
-        log_config: LogManagerConfig | dict = None,  # LogManager kwargs
+        log_config: DataLoggerConfig | dict = None,  # LogManager kwargs
         system_datetime: bool | str = None,
         system_template=None,
         system_template_context: dict = None,
@@ -229,10 +216,10 @@ class Branch(Element, Communicatable, Relational):
         # --- LogManager ---
         if log_config:
             if isinstance(log_config, dict):
-                log_config = LogManagerConfig(**log_config)
-            self._log_manager = LogManager.from_config(log_config, logs=logs)
+                log_config = DataLoggerConfig(**log_config)
+            self._log_manager = DataLogger.from_config(log_config, logs=logs)
         else:
-            self._log_manager = LogManager(**settings.LOG_CONFIG, logs=logs)
+            self._log_manager = DataLogger(**settings.LOG_CONFIG, logs=logs)
 
         self._operation_manager = OperationManager()
 
@@ -414,6 +401,7 @@ class Branch(Element, Communicatable, Relational):
             pd.DataFrame: Each row represents a message, with columns defined by MESSAGE_FIELDS.
         """
         from lionagi.protocols.generic.pile import Pile
+        from lionagi.protocols.messages.base import MESSAGE_FIELDS
 
         if progression is None:
             progression = self.msgs.progression
@@ -426,170 +414,6 @@ class Branch(Element, Communicatable, Relational):
         p = Pile(collections=msgs)
         return p.to_df(columns=MESSAGE_FIELDS)
 
-    # -------------------------------------------------------------------------
-    # Mailbox Send / Receive
-    # -------------------------------------------------------------------------
-    def send(
-        self,
-        recipient: IDType,
-        category: Optional["PackageCategory"],
-        item: Any,
-        request_source: IDType | None = None,
-    ) -> None:
-        """
-        Sends a `Package` (wrapped in a `Mail` object) to a specified recipient.
-
-        Args:
-            recipient (IDType):
-                ID of the recipient branch or component.
-            category (PackageCategory | None):
-                The category/type of the package (e.g., 'message', 'tool', 'imodel').
-            item (Any):
-                The payload to send (e.g., a message, tool reference, model, etc.).
-            request_source (IDType | None):
-                The ID that prompted or requested this send operation (optional).
-        """
-        from lionagi.protocols.mail.package import Package
-
-        package = Package(
-            category=category,
-            item=item,
-            request_source=request_source,
-        )
-
-        mail = Mail(
-            sender=self.id,
-            recipient=recipient,
-            package=package,
-        )
-        self.mailbox.append_out(mail)
-
-    def receive(
-        self,
-        sender: IDType,
-        message: bool = False,
-        tool: bool = False,
-        imodel: bool = False,
-    ) -> None:
-        """
-        Retrieves and processes mail from a given sender according to the specified flags.
-
-        Args:
-            sender (IDType):
-                The ID of the mail sender.
-            message (bool):
-                If `True`, process packages categorized as "message".
-            tool (bool):
-                If `True`, process packages categorized as "tool".
-            imodel (bool):
-                If `True`, process packages categorized as "imodel".
-
-        Raises:
-            ValueError: If no mail exists from the specified sender,
-                        or if a package is invalid for the chosen category.
-        """
-        sender = ID.get_id(sender)
-        if sender not in self.mailbox.pending_ins.keys():
-            raise ValueError(f"No mail or package found from sender: {sender}")
-
-        skipped_requests = Progression()
-        while self.mailbox.pending_ins[sender]:
-            mail_id = self.mailbox.pending_ins[sender].popleft()
-            mail: Mail = self.mailbox.pile_[mail_id]
-
-            if mail.category == "message" and message:
-                if not isinstance(mail.package.item, RoledMessage):
-                    raise ValueError(
-                        "Invalid message package: The item must be a `RoledMessage`."
-                    )
-                new_message = mail.package.item.model_copy(deep=True)
-                new_message.sender = mail.sender
-                new_message.recipient = self.id
-                self.msgs.messages.include(new_message)
-                self.mailbox.pile_.pop(mail_id)
-
-            elif mail.category == "tool" and tool:
-                if not isinstance(mail.package.item, Tool):
-                    raise ValueError(
-                        "Invalid tool package: The item must be a `Tool` instance."
-                    )
-                self._action_manager.register_tools(mail.package.item)
-                self.mailbox.pile_.pop(mail_id)
-
-            elif mail.category == "imodel" and imodel:
-                if not isinstance(mail.package.item, iModel):
-                    raise ValueError(
-                        "Invalid iModel package: The item must be an `iModel` instance."
-                    )
-                self._imodel_manager.register_imodel(
-                    mail.package.item.name or "chat", mail.package.item
-                )
-                self.mailbox.pile_.pop(mail_id)
-
-            else:
-                # If the category doesn't match the flags or is unhandled
-                skipped_requests.append(mail)
-
-        # Requeue any skipped mail
-        self.mailbox.pending_ins[sender] = skipped_requests
-        if len(self.mailbox.pending_ins[sender]) == 0:
-            self.mailbox.pending_ins.pop(sender)
-
-    async def asend(
-        self,
-        recipient: IDType,
-        category: PackageCategory | None,
-        package: Any,
-        request_source: IDType | None = None,
-    ):
-        """
-        Async version of `send()`.
-
-        Args:
-            recipient (IDType):
-                ID of the recipient branch or component.
-            category (PackageCategory | None):
-                The category/type of the package.
-            package (Any):
-                The item(s) to send (message/tool/model).
-            request_source (IDType | None):
-                The origin request ID (if any).
-        """
-        async with self.mailbox.pile_:
-            self.send(recipient, category, package, request_source)
-
-    async def areceive(
-        self,
-        sender: IDType,
-        message: bool = False,
-        tool: bool = False,
-        imodel: bool = False,
-    ) -> None:
-        """
-        Async version of `receive()`.
-
-        Args:
-            sender (IDType):
-                The ID of the mail sender.
-            message (bool):
-                If `True`, process packages categorized as "message".
-            tool (bool):
-                If `True`, process packages categorized as "tool".
-            imodel (bool):
-                If `True`, process packages categorized as "imodel".
-        """
-        async with self.mailbox.pile_:
-            self.receive(sender, message, tool, imodel)
-
-    def receive_all(self) -> None:
-        """
-        Receives mail from all known senders without filtering.
-
-        (Duplicate method included in your snippet; you may unify or remove.)
-        """
-        for key in self.mailbox.pending_ins:
-            self.receive(key)
-
     def connect(
         self,
         provider: str = None,
@@ -892,13 +716,14 @@ class Branch(Element, Communicatable, Relational):
             BaseModel | dict | str | None:
                 Parsed model instance, or a fallback based on `handle_validation`.
         """
-        from lionagi.operations.parse.parse import parse, prepare_parse_kws
 
         _pms = {
             k: v
             for k, v in locals().items()
             if k not in ("self", "_pms") and v is not None
         }
+        from lionagi.operations.parse.parse import parse, prepare_parse_kws
+
         return await parse(self, **prepare_parse_kws(self, **_pms))
 
     async def operate(
@@ -1197,33 +1022,6 @@ class Branch(Element, Communicatable, Relational):
 
         return await interpret(self, **prepare_interpret_kw(self, **_pms))
 
-    async def instruct(
-        self,
-        instruct: "Instruct",
-        /,
-        **kwargs,
-    ):
-        """
-        A convenience method that chooses between `operate()` and `communicate()`
-        based on the contents of an `Instruct` object.
-
-        If the `Instruct` indicates tool usage or advanced response format,
-        `operate()` is used. Otherwise, it defaults to `communicate()`.
-
-        Args:
-            instruct (Instruct):
-                An object containing `instruction`, `guidance`, `context`, etc.
-            **kwargs:
-                Additional args forwarded to `operate()` or `communicate()`.
-
-        Returns:
-            Any:
-                The result of the underlying call (structured object, raw text, etc.).
-        """
-        from lionagi.operations.instruct.instruct import instruct as _ins
-
-        return await _ins(self, instruct, **kwargs)
-
     async def ReAct(
         self,
         instruct: "Instruct | dict[str, Any]",

lionagi/session/session.py

@@ -4,6 +4,7 @@
 import contextlib
 from collections.abc import Callable
 from typing import Any
+from uuid import UUID
 
 from pydantic import (
     Field,
@@ -17,11 +18,7 @@ from typing_extensions import Self
 from lionagi.protocols.types import (
     ID,
     MESSAGE_FIELDS,
-    Communicatable,
-    Exchange,
     Graph,
-    IDType,
-    MailManager,
     Node,
     Pile,
     Progression,
@@ -37,25 +34,19 @@ from ..service.imodel import iModel
 from .branch import ActionManager, Branch, OperationManager, Tool
 
 
-class Session(Node, Communicatable, Relational):
+class Session(Node, Relational):
     """
-    Manages multiple conversation branches and mail transfer in a session.
+    Manages multiple conversation branches in a session.
 
     Attributes:
         branches (Pile | None): Collection of conversation branches.
         default_branch (Branch | None): The default conversation branch.
-        mail_transfer (Exchange | None): Mail transfer system.
-        mail_manager (MailManager | None): Manages mail operations.
     """
 
     branches: Pile[Branch] = Field(
         default_factory=lambda: Pile(item_type={Branch}, strict_type=False)
     )
     default_branch: Any = Field(default=None, exclude=True)
-    mail_transfer: Exchange = Field(default_factory=Exchange, exclude=True)
-    mail_manager: MailManager = Field(
-        default_factory=MailManager, exclude=True
-    )
     name: str = Field(default="Session")
     user: SenderRecipient | None = None
     _operation_manager: OperationManager = PrivateAttr(
@@ -76,7 +67,6 @@ class Session(Node, Communicatable, Relational):
         def _take_in_branch(branch: Branch):
             if branch not in self.branches:
                 self.branches.include(branch)
-                self.mail_manager.add_sources(branch)
 
             branch.user = self.id
             branch._operation_manager = self._operation_manager
@@ -119,7 +109,7 @@ class Session(Node, Communicatable, Relational):
         return decorator
 
     @model_validator(mode="after")
-    def _add_mail_sources(self) -> Self:
+    def _initialize_branches(self) -> Self:
         if self.default_branch is None:
             self.default_branch = Branch()
         if self.default_branch not in self.branches:
@@ -196,7 +186,6 @@ class Session(Node, Communicatable, Relational):
         branch: Branch = self.branches[branch]
 
         self.branches.exclude(branch)
-        self.mail_manager.delete_source(branch.id)
 
         if self.default_branch.id == branch.id:
             if not self.branches:
@@ -288,80 +277,6 @@ class Session(Node, Communicatable, Relational):
             collections=messages, item_type={RoledMessage}, strict_type=False
         )
 
-    def send(self, to_: ID.RefSeq = None):
-        """
-        Send mail to specified branches.
-
-        Args:
-            to_: The branches to send mail to. If None, send to all.
-
-        Raises:
-            ValueError: If mail sending fails.
-        """
-        if to_ is None:
-            self.mail_manager.send_all()
-        else:
-            try:
-                lcall(
-                    to_,
-                    lambda x: self.mail_manager.send(ID.get_id(x)),
-                    input_unique=True,
-                    input_flatten=True,
-                    input_dropna=True,
-                    input_use_values=True,
-                )
-            except Exception as e:
-                raise ValueError(f"Failed to send mail. Error: {e}")
-
-    async def acollect_send_all(self, receive_all: bool = True):
-        """
-        Collect and send mail for all branches, optionally receiving all mail.
-
-        Args:
-            receive_all: If True, receive all mail for all branches.
-        """
-        async with self.mail_manager.sources:
-            self.collect_send_all(receive_all)
-
-    def collect_send_all(self, receive_all: bool = True):
-        """
-        Collect and send mail for all branches, optionally receiving all mail.
-
-        Args:
-            receive_all: If True, receive all mail for all branches.
-        """
-        self.collect()
-        self.send()
-        if receive_all:
-            for i in self.branches:
-                i.receive_all()
-
-    def collect(self, from_: ID.RefSeq = None):
-        """
-        Collect mail from specified branches.
-
-        Args:
-            from_: The branches to collect mail from. If None, collect
-                from all.
-
-        Raises:
-            ValueError: If mail collection fails.
-        """
-        if from_ is None:
-            self.mail_manager.collect_all()
-        else:
-            try:
-                lcall(
-                    from_,
-                    lambda x: self.mail_manager.collect(ID.get_id(x)),
-                    input_flatten=True,
-                    input_dropna=True,
-                    input_unique=True,
-                    input_use_values=True,
-                )
-            except Exception as e:
-                raise ValueError(f"Failed to collect mail. Error: {e}")
-
     async def flow(
         self,
         graph: Graph,
@@ -395,7 +310,7 @@ class Session(Node, Communicatable, Relational):
 
         # Use specified branch or session's default
         branch = default_branch or self.default_branch
-        if isinstance(branch, (str, IDType)):
+        if isinstance(branch, (str, UUID)):
             branch = self.branches[branch]
 
         return await flow(

lionagi/version.py

@@ -1 +1 @@
-__version__ = "0.18.0"
+__version__ = "0.18.2"

{lionagi-0.18.0.dist-info → lionagi-0.18.2.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: lionagi
-Version: 0.18.0
+Version: 0.18.2
 Summary: An Intelligence Operating System.
 Author-email: HaiyangLi <quantocean.li@gmail.com>
 License:            Apache License
@@ -227,7 +227,7 @@ Requires-Dist: json-repair>=0.40.0
 Requires-Dist: msgspec>=0.18.0
 Requires-Dist: pydantic-settings>=2.8.0
 Requires-Dist: pydantic>=2.8.0
-Requires-Dist: pydapter[pandas]>=1.1.1
+Requires-Dist: pydapter[pandas]>=1.2.0
 Requires-Dist: python-dotenv>=1.1.0
 Requires-Dist: tiktoken>=0.9.0
 Provides-Extra: all
@@ -240,6 +240,7 @@ Requires-Dist: networkx>=3.0.0; extra == 'all'
 Requires-Dist: ollama>=0.4.0; extra == 'all'
 Requires-Dist: pydapter[postgres]; extra == 'all'
 Requires-Dist: rich>=13.0.0; extra == 'all'
+Requires-Dist: xmltodict>=0.12.0; extra == 'all'
 Provides-Extra: graph
 Requires-Dist: matplotlib>=3.7.0; extra == 'graph'
 Requires-Dist: networkx>=3.0.0; extra == 'graph'
@@ -465,13 +466,13 @@ from lionagi.fields import LIST_INSTRUCT_FIELD_MODEL, Instruct
 response3 = await orchestrator.operate(
   instruct=Instruct(
     instruction="create 4 research questions for parallel discovery",
-    guidance="put into `instruct_models` field as part of your structured result message",
+    guidance="put into `instruct_model` field as part of your structured result message",
     context="I'd like to create an orchestration system for AI agents using lionagi"
   ),
   field_models=[LIST_INSTRUCT_FIELD_MODEL],
 )
 
-len(response3.instruct_models)  # should be 4
+len(response3.instruct_model)  # should be 4
 
 async def handle_instruct(instruct):
   sub_branch = Branch(
@@ -482,7 +483,7 @@ async def handle_instruct(instruct):
 
 # run in parallel across all instruct models
 from lionagi.ln import alcall
-responses = await alcall(response3.instruct_models, handle_instruct)
+responses = await alcall(response3.instruct_model, handle_instruct)
 
 # now hand these reports back to the orchestrator
 final_response = await orchestrator.communicate(