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

lionagi/protocols/messages/__init__.py

@@ -1,2 +1,29 @@
 # Copyright (c) 2023-2025, HaiyangLi <quantocean.li at gmail dot com>
 # SPDX-License-Identifier: Apache-2.0
+
+from .action_request import ActionRequest, ActionRequestContent
+from .action_response import ActionResponse, ActionResponseContent
+from .assistant_response import AssistantResponse, AssistantResponseContent
+from .base import MessageRole
+from .instruction import Instruction, InstructionContent
+from .manager import MessageManager
+from .message import MessageContent, MessageRole, RoledMessage
+from .system import System, SystemContent
+
+__all__ = (
+    "ActionRequest",
+    "ActionRequestContent",
+    "ActionResponse",
+    "ActionResponseContent",
+    "AssistantResponse",
+    "AssistantResponseContent",
+    "Instruction",
+    "InstructionContent",
+    "MessageContent",
+    "MessageRole",
+    "RoledMessage",
+    "System",
+    "SystemContent",
+    "MessageManager",
+    "MessageRole",
+)

lionagi/protocols/messages/action_request.py

@@ -2,208 +2,110 @@
 # SPDX-License-Identifier: Apache-2.0
 
 from collections.abc import Callable
+from dataclasses import dataclass, field
 from typing import Any
 
-from lionagi.utils import copy, to_dict
-
-from ..generic.element import IDType
-from .base import SenderRecipient
-from .message import MessageRole, RoledMessage, Template, jinja_env
+from pydantic import field_validator
 
+from lionagi.utils import copy, to_dict
 
-def prepare_action_request(
-    function: str | Callable,
-    arguments: dict,
-) -> dict[str, Any]:
-    """
-    Build a structured dict describing the request details.
-
-    Args:
-        function (str | Callable):
-            The name (or callable) representing the function to invoke.
-        arguments (dict):
-            The arguments necessary for the function call.
-
-    Returns:
-        dict[str, Any]: A standardized dictionary containing
-        'action_request' -> {'function':..., 'arguments':...}
+from .message import MessageContent, MessageRole, RoledMessage
 
-    Raises:
-        ValueError: If `function` is neither a string nor callable, or
-            if `arguments` cannot be turned into a dictionary.
-    """
-    if isinstance(function, Callable):
-        function = function.__name__
-    if hasattr(function, "function"):
-        function = function.function
-    if not isinstance(function, str):
-        raise ValueError("Function must be a string or callable.")
-
-    arguments = copy(arguments)
-    if not isinstance(arguments, dict):
-        try:
-            arguments = to_dict(arguments, fuzzy_parse=True)
-            if isinstance(arguments, list | tuple) and len(arguments) > 0:
-                arguments = arguments[0]
-        except Exception:
-            raise ValueError("Arguments must be a dictionary.")
-    return {"action_request": {"function": function, "arguments": arguments}}
 
+@dataclass(slots=True)
+class ActionRequestContent(MessageContent):
+    """Content for action/function call requests.
 
-class ActionRequest(RoledMessage):
-    """
-    A message that requests an action or function to be executed.
-    It inherits from `RoledMessage` and includes function name,
-    arguments, and optional linking to a subsequent `ActionResponse`.
+    Fields:
+        function: Function name to invoke
+        arguments: Arguments for the function call
+        action_response_id: Link to corresponding response (if any)
     """
 
-    template: Template | str | None = jinja_env.get_template(
-        "action_request.jinja2"
-    )
+    function: str = ""
+    arguments: dict[str, Any] = field(default_factory=dict)
+    action_response_id: str | None = None
 
     @property
-    def action_response_id(self) -> IDType | None:
-        """
-        Get or set the ID of the corresponding action response.
-
-        Returns:
-            IDType | None: The ID of the action response, or None if none assigned.
-        """
-        return self.content.get("action_response_id", None)
-
-    @action_response_id.setter
-    def action_response_id(self, action_response_id: IDType) -> None:
-        self.content["action_response_id"] = str(action_response_id)
+    def rendered(self) -> str:
+        """Render action request as YAML."""
+        from lionagi.libs.schema.minimal_yaml import minimal_yaml
 
-    @property
-    def request(self) -> dict[str, Any]:
-        """
-        Get the entire 'action_request' dictionary if present.
+        doc = {
+            "Function": self.function,
+            "Arguments": self.arguments,
+        }
+        return minimal_yaml(doc).strip()
 
-        Returns:
-            dict[str, Any]: The request content or empty dict if missing.
-        """
-        return copy(self.content.get("action_request", {}))
+    @classmethod
+    def from_dict(cls, data: dict[str, Any]) -> "ActionRequestContent":
+        """Construct ActionRequestContent from dictionary."""
+        # Handle nested structure from old format
+        if "action_request" in data:
+            req = data["action_request"]
+            function = req.get("function", "")
+            arguments = req.get("arguments", {})
+        else:
+            function = data.get("function", "")
+            arguments = data.get("arguments", {})
+
+        # Handle callable
+        if isinstance(function, Callable):
+            function = function.__name__
+        if hasattr(function, "function"):
+            function = function.function
+        if not isinstance(function, str):
+            raise ValueError("Function must be a string or callable")
+
+        # Normalize arguments
+        arguments = copy(arguments)
+        if not isinstance(arguments, dict):
+            try:
+                arguments = to_dict(arguments, fuzzy_parse=True)
+                if isinstance(arguments, list | tuple) and len(arguments) > 0:
+                    arguments = arguments[0]
+            except Exception:
+                raise ValueError("Arguments must be a dictionary")
+
+        action_response_id = data.get("action_response_id")
+        if action_response_id:
+            action_response_id = str(action_response_id)
+
+        return cls(
+            function=function,
+            arguments=arguments,
+            action_response_id=action_response_id,
+        )
 
-    @property
-    def arguments(self) -> dict[str, Any]:
-        """
-        Access just the 'arguments' from the action request.
 
-        Returns:
-            dict[str, Any]: The arguments to be used by the function call.
-        """
-        return self.request.get("arguments", {})
+class ActionRequest(RoledMessage):
+    """Message requesting an action or function execution."""
+
+    role: MessageRole = MessageRole.ACTION
+    content: ActionRequestContent
+
+    @field_validator("content", mode="before")
+    def _validate_content(cls, v):
+        if v is None:
+            return ActionRequestContent()
+        if isinstance(v, dict):
+            return ActionRequestContent.from_dict(v)
+        if isinstance(v, ActionRequestContent):
+            return v
+        raise TypeError(
+            "content must be dict or ActionRequestContent instance"
+        )
 
     @property
     def function(self) -> str:
-        """
-        Name of the function to be invoked.
-
-        Returns:
-            str: The function name or empty string if none provided.
-        """
-        return self.request.get("function", "")
+        """Access the function name."""
+        return self.content.function
 
-    @classmethod
-    def create(
-        cls,
-        function=None,
-        arguments: dict | None = None,
-        sender: SenderRecipient | None = None,
-        recipient: SenderRecipient | None = None,
-        template: Template | str | None = None,
-        **kwargs,
-    ) -> "ActionRequest":
-        """
-        Build a new ActionRequest.
-
-        Args:
-            function (str | Callable | None):
-                The function or callable name.
-            arguments (dict | None):
-                Arguments for that function call.
-            sender (SenderRecipient | None):
-                The sender identifier or role.
-            recipient (SenderRecipient | None):
-                The recipient identifier or role.
-            template (Template | str | None):
-                Optional custom template.
-            **kwargs:
-                Extra key-value pairs to merge into the content.
-
-        Returns:
-            ActionRequest: A newly constructed instance.
-        """
-        content = prepare_action_request(function, arguments)
-        content.update(kwargs)
-        params = {
-            "content": content,
-            "sender": sender,
-            "recipient": recipient,
-            "role": MessageRole.ACTION,
-        }
-        if template:
-            params["template"] = template
-        return cls(**{k: v for k, v in params.items() if v is not None})
-
-    def update(
-        self,
-        function: str = None,
-        arguments: dict | None = None,
-        sender: SenderRecipient = None,
-        recipient: SenderRecipient = None,
-        action_response: "ActionResponse" = None,  # type: ignore
-        template: Template | str | None = None,
-        **kwargs,
-    ):
-        """
-        Update this request with new function, arguments, or link to an
-        action response.
-
-        Args:
-            function (str): New function name, if changing.
-            arguments (dict): New arguments dictionary, if changing.
-            sender (SenderRecipient): New sender.
-            recipient (SenderRecipient): New recipient.
-            action_response (ActionResponse):
-                If provided, this request is flagged as responded.
-            template (Template | str | None):
-                Optional new template.
-            **kwargs:
-                Additional fields to store in content.
-
-        Raises:
-            ValueError: If the request is already responded to.
-        """
-        if self.is_responded():
-            raise ValueError("Cannot update a responded action request.")
-
-        # Link action response if given
-        if (
-            isinstance(action_response, RoledMessage)
-            and action_response.class_name() == "ActionResponse"
-        ):
-            self.action_response_id = action_response.id
-
-        # If new function or arguments, create new 'action_request' content
-        if any([function, arguments]):
-            action_request = prepare_action_request(
-                function or self.function, arguments or self.arguments
-            )
-            self.content.update(action_request)
-        super().update(
-            sender=sender, recipient=recipient, template=template, **kwargs
-        )
+    @property
+    def arguments(self) -> dict[str, Any]:
+        """Access the function arguments."""
+        return self.content.arguments
 
     def is_responded(self) -> bool:
-        """
-        Check if there's a linked action response.
-
-        Returns:
-            bool: True if an action response ID is present.
-        """
-        return self.action_response_id is not None
-
-
-# File: lionagi/protocols/messages/action_request.py
+        """Check if this request has been responded to."""
+        return self.content.action_response_id is not None

lionagi/protocols/messages/action_response.py

@@ -1,155 +1,97 @@
 # Copyright (c) 2023-2025, HaiyangLi <quantocean.li at gmail dot com>
 # SPDX-License-Identifier: Apache-2.0
 
+from dataclasses import dataclass, field
 from typing import Any
 
-from typing_extensions import override
+from pydantic import field_validator
 
-from lionagi.protocols.generic.element import IDType
-from lionagi.utils import copy
+from .message import MessageContent, MessageRole, RoledMessage
 
-from .action_request import ActionRequest
-from .base import MessageRole, SenderRecipient
-from .message import RoledMessage, Template, jinja_env
 
+@dataclass(slots=True)
+class ActionResponseContent(MessageContent):
+    """Content for action/function call responses.
 
-def prepare_action_response_content(
-    action_request: ActionRequest,
-    output: Any,
-) -> dict:
+    Fields:
+        function: Function name that was invoked
+        arguments: Arguments used in the function call
+        output: Result returned from the function
+        action_request_id: Link to the original request
     """
-    Convert an ActionRequest + function output into response-friendly dictionary.
 
-    Args:
-        action_request (ActionRequest): The original action request.
-        output (Any): The result of the function call.
+    function: str = ""
+    arguments: dict[str, Any] = field(default_factory=dict)
+    output: Any = None
+    action_request_id: str | None = None
 
-    Returns:
-        dict: A dictionary containing `action_request_id` and `action_response`.
-    """
-    return {
-        "action_request_id": str(action_request.id),
-        "action_response": {
-            "function": action_request.function,
-            "arguments": action_request.arguments,
-            "output": output,
-        },
-    }
+    @property
+    def rendered(self) -> str:
+        """Render action response as YAML."""
+        from lionagi.libs.schema.minimal_yaml import minimal_yaml
 
+        doc = {
+            "Function": self.function,
+            "Arguments": self.arguments,
+            "Output": self.output,
+        }
+        return minimal_yaml(doc).strip()
 
-class ActionResponse(RoledMessage):
-    """
-    A message fulfilling an `ActionRequest`. It stores the function name,
-    the arguments used, and the output produced by the function.
-    """
+    @classmethod
+    def from_dict(cls, data: dict[str, Any]) -> "ActionResponseContent":
+        """Construct ActionResponseContent from dictionary."""
+        # Handle nested structure from old format
+        if "action_response" in data:
+            resp = data["action_response"]
+            function = resp.get("function", "")
+            arguments = resp.get("arguments", {})
+            output = resp.get("output")
+        else:
+            function = data.get("function", "")
+            arguments = data.get("arguments", {})
+            output = data.get("output")
+
+        action_request_id = data.get("action_request_id")
+        if action_request_id:
+            action_request_id = str(action_request_id)
+
+        return cls(
+            function=function,
+            arguments=arguments,
+            output=output,
+            action_request_id=action_request_id,
+        )
 
-    template: Template | str | None = jinja_env.get_template(
-        "action_response.jinja2"
-    )
+
+class ActionResponse(RoledMessage):
+    """Message containing the result of an action/function execution."""
+
+    role: MessageRole = MessageRole.ACTION
+    content: ActionResponseContent
+
+    @field_validator("content", mode="before")
+    def _validate_content(cls, v):
+        if v is None:
+            return ActionResponseContent()
+        if isinstance(v, dict):
+            return ActionResponseContent.from_dict(v)
+        if isinstance(v, ActionResponseContent):
+            return v
+        raise TypeError(
+            "content must be dict or ActionResponseContent instance"
+        )
 
     @property
     def function(self) -> str:
-        """Name of the function that was executed."""
-        return self.content.get("action_response", {}).get("function", None)
+        """Access the function name."""
+        return self.content.function
 
     @property
     def arguments(self) -> dict[str, Any]:
-        """Arguments used for the executed function."""
-        return self.content.get("action_response", {}).get("arguments", {})
+        """Access the function arguments."""
+        return self.content.arguments
 
     @property
     def output(self) -> Any:
-        """The result or returned data from the function call."""
-        return self.content.get("action_response", {}).get("output", None)
-
-    @property
-    def response(self) -> dict[str, Any]:
-        """
-        A helper to get the entire 'action_response' dictionary.
-
-        Returns:
-            dict[str, Any]: The entire response, including function, arguments, and output.
-        """
-        return copy(self.content.get("action_response", {}))
-
-    @property
-    def action_request_id(self) -> IDType:
-        """The ID of the original action request."""
-        return IDType.validate(self.content.get("action_request_id"))
-
-    @override
-    @classmethod
-    def create(
-        cls,
-        action_request: ActionRequest,
-        output: Any | None = None,
-        response_model=None,
-        sender: SenderRecipient | None = None,
-        recipient: SenderRecipient | None = None,
-    ) -> "ActionResponse":
-        """
-        Build an ActionResponse from a matching `ActionRequest` and output.
-
-        Args:
-            action_request (ActionRequest): The original request being fulfilled.
-            output (Any, optional): The function output or result.
-            response_model (Any, optional):
-                If present and has `.output`, this is used instead of `output`.
-            sender (SenderRecipient, optional):
-                The role or ID of the sender (defaults to the request's recipient).
-            recipient (SenderRecipient, optional):
-                The role or ID of the recipient (defaults to the request's sender).
-
-        Returns:
-            ActionResponse: A new instance referencing the `ActionRequest`.
-        """
-        if response_model:
-            output = response_model.output
-
-        instance = ActionResponse(
-            content=prepare_action_response_content(
-                action_request=response_model or action_request, output=output
-            ),
-            role=MessageRole.ACTION,
-            sender=sender or action_request.recipient,
-            recipient=recipient or action_request.sender,
-        )
-        action_request.action_response_id = instance.id
-        return instance
-
-    def update(
-        self,
-        action_request: ActionRequest = None,
-        output: Any = None,
-        response_model=None,
-        sender: SenderRecipient = None,
-        recipient: SenderRecipient = None,
-        template: Template | str | None = None,
-        **kwargs,
-    ):
-        """
-        Update this response with a new request reference or new output.
-
-        Args:
-            action_request (ActionRequest): The updated request.
-            output (Any): The new function output data.
-            response_model: If present, uses response_model.output.
-            sender (SenderRecipient): New sender ID or role.
-            recipient (SenderRecipient): New recipient ID or role.
-            template (Template | str | None): Optional new template.
-            **kwargs: Additional fields to store in content.
-        """
-        if response_model:
-            output = response_model.output
-
-        if action_request:
-            self.content = prepare_action_response_content(
-                action_request=action_request, output=output or self.output
-            )
-            action_request.action_response_id = self.id
-        super().update(
-            sender=sender, recipient=recipient, template=template, **kwargs
-        )
-
-
-# File: lionagi/protocols/messages/action_response.py
+        """Access the function output."""
+        return self.content.output