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

lionagi/protocols/messages/manager.py

@@ -3,7 +3,6 @@
 
 from typing import Any, Literal
 
-from jinja2 import Template
 from pydantic import BaseModel, JsonValue
 
 from .._concepts import Manager
@@ -88,6 +87,7 @@ class MessageManager(Manager):
         *,
         instruction: JsonValue = None,
         context: JsonValue = None,
+        handle_context: Literal["extend", "replace"] = "extend",
         guidance: JsonValue = None,
         images: list = None,
         request_fields: JsonValue = None,
@@ -105,17 +105,49 @@ class MessageManager(Manager):
         If `instruction` is an existing Instruction, it is updated in place.
         Otherwise, a new instance is created.
         """
-        params = {
+        raw_params = {
             k: v
             for k, v in locals().items()
             if k != "instruction" and v is not None
         }
 
+        handle_ctx = raw_params.get("handle_context", "extend")
+
         if isinstance(instruction, Instruction):
+            params = {
+                k: v for k, v in raw_params.items() if k != "handle_context"
+            }
+            ctx_value = params.pop("context", None)
+            if ctx_value is not None:
+                if isinstance(ctx_value, list):
+                    ctx_list = list(ctx_value)
+                else:
+                    ctx_list = [ctx_value]
+                if handle_ctx == "extend":
+                    merged = list(instruction.content.prompt_context)
+                    merged.extend(ctx_list)
+                    params["context"] = merged
+                else:
+                    params["context"] = list(ctx_list)
+                # Always replace in from_dict since we've already done the merge logic
+                params["handle_context"] = "replace"
             instruction.update(**params)
             return instruction
         else:
-            return Instruction.create(instruction=instruction, **params)
+            # Build content dict for Instruction
+            content_dict = {
+                k: v
+                for k, v in raw_params.items()
+                if k not in ["sender", "recipient"]
+            }
+            content_dict["handle_context"] = handle_ctx
+            if instruction is not None:
+                content_dict["instruction"] = instruction
+            return Instruction(
+                content=content_dict,
+                sender=raw_params.get("sender"),
+                recipient=raw_params.get("recipient"),
+            )
 
     @staticmethod
     def create_assistant_response(
@@ -123,8 +155,6 @@ class MessageManager(Manager):
         sender: Any = None,
         recipient: Any = None,
         assistant_response: AssistantResponse | Any = None,
-        template: Template | str = None,
-        template_context: dict[str, Any] = None,
     ) -> AssistantResponse:
         """
         Build or update an `AssistantResponse`. If `assistant_response` is an
@@ -133,17 +163,23 @@ class MessageManager(Manager):
         params = {
             k: v
             for k, v in locals().items()
-            if k not in ["assistant_response", "template_context"]
+            if k != "assistant_response" and v is not None
         }
-        t_ctx = template_context or {}
-        params.update(t_ctx)
 
         if isinstance(assistant_response, AssistantResponse):
             assistant_response.update(**params)
             return assistant_response
 
-        return AssistantResponse.create(
-            assistant_response=assistant_response, **params
+        # Create new AssistantResponse
+        content_dict = (
+            {"assistant_response": assistant_response}
+            if assistant_response
+            else {}
+        )
+        return AssistantResponse(
+            content=content_dict,
+            sender=params.get("sender"),
+            recipient=params.get("recipient"),
         )
 
     @staticmethod
@@ -154,8 +190,6 @@ class MessageManager(Manager):
         function: str = None,
         arguments: dict[str, Any] = None,
         action_request: ActionRequest | None = None,
-        template: Template | str = None,
-        template_context: dict[str, Any] = None,
     ) -> ActionRequest:
         """
         Build or update an ActionRequest.
@@ -166,25 +200,31 @@ class MessageManager(Manager):
             function: Function name for the request.
             arguments: Arguments for the function.
             action_request: Possibly existing ActionRequest to update.
-            template: Optional jinja template.
-            template_context: Extra context for the template.
 
         Returns:
             ActionRequest: The new or updated request object.
         """
         params = {
-            "sender": sender,
-            "recipient": recipient,
-            "function": function,
-            "arguments": arguments,
-            "template": template,
+            k: v
+            for k, v in locals().items()
+            if k != "action_request" and v is not None
         }
-        params.update(template_context or {})
 
         if isinstance(action_request, ActionRequest):
             action_request.update(**params)
             return action_request
-        return ActionRequest.create(**params)
+
+        # Create new ActionRequest
+        content_dict = {}
+        if function:
+            content_dict["function"] = function
+        if arguments:
+            content_dict["arguments"] = arguments
+        return ActionRequest(
+            content=content_dict,
+            sender=params.get("sender"),
+            recipient=params.get("recipient"),
+        )
 
     @staticmethod
     def create_action_response(
@@ -217,17 +257,27 @@ class MessageManager(Manager):
             raise ValueError(
                 "Error: please provide a corresponding action request for an action response."
             )
-        params = {
-            "action_request": action_request,
-            "output": action_output,
-            "sender": sender,
-            "recipient": recipient,
-        }
         if isinstance(action_response, ActionResponse):
-            action_response.update(**params)
+            action_response.update(
+                output=action_output, sender=sender, recipient=recipient
+            )
             return action_response
 
-        return ActionResponse.create(**params)
+        # Create new ActionResponse
+        content_dict = {
+            "function": action_request.content.function,
+            "arguments": action_request.content.arguments,
+            "output": action_output,
+            "action_request_id": str(action_request.id),
+        }
+        response = ActionResponse(
+            content=content_dict, sender=sender, recipient=recipient
+        )
+
+        # Update the request to reference this response
+        action_request.content.action_response_id = str(response.id)
+
+        return response
 
     @staticmethod
     def create_system(
@@ -236,28 +286,33 @@ class MessageManager(Manager):
         system_datetime: bool | str = None,
         sender: Any = None,
         recipient: Any = None,
-        template: Template | str = None,
-        template_context: dict[str, Any] = None,
     ) -> System:
         """
         Create or update a `System` message. If `system` is an instance, update.
         Otherwise, create a new System message.
         """
         params = {
-            "system_datetime": system_datetime,
-            "sender": sender,
-            "recipient": recipient,
-            "template": template,
-            **(template_context or {}),
+            k: v
+            for k, v in locals().items()
+            if k != "system" and v is not None
         }
+
         if isinstance(system, System):
             system.update(**params)
             return system
 
+        # Create new System message
+        content_dict = {}
         if system:
-            params["system_message"] = system
-
-        return System.create(**params)
+            content_dict["system_message"] = system
+        if system_datetime is not None:
+            content_dict["system_datetime"] = system_datetime
+
+        return System(
+            content=content_dict if content_dict else None,
+            sender=params.get("sender"),
+            recipient=params.get("recipient"),
+        )
 
     def add_message(
         self,
@@ -265,12 +320,11 @@ class MessageManager(Manager):
         # common
         sender: SenderRecipient = None,
         recipient: SenderRecipient = None,
-        template: Template | str = None,
-        template_context: dict[str, Any] = None,
         metadata: dict[str, Any] = None,
         # instruction
         instruction: JsonValue = None,
         context: JsonValue = None,
+        handle_context: Literal["extend", "replace"] = "extend",
         guidance: JsonValue = None,
         request_fields: JsonValue = None,
         plain_content: JsonValue = None,
@@ -299,18 +353,13 @@ class MessageManager(Manager):
         - ActionRequest / ActionResponse
         """
         _msg = None
-        if (
-            sum(
-                bool(x)
-                for x in (
-                    instruction,
-                    assistant_response,
-                    system,
-                    action_request,
-                )
-            )
-            > 1
-        ):
+        # When creating ActionResponse, both action_request and action_output are needed
+        # So don't count action_request as a message type when action_output is present
+        message_types = [instruction, assistant_response, system]
+        if action_request and not action_output:
+            message_types.append(action_request)
+
+        if sum(bool(x) for x in message_types) > 1:
             raise ValueError("Only one message type can be added at a time.")
 
         if system:
@@ -319,8 +368,6 @@ class MessageManager(Manager):
                 system_datetime=system_datetime,
                 sender=sender,
                 recipient=recipient,
-                template=template,
-                template_context=template_context,
             )
             self.set_system(_msg)
 
@@ -333,15 +380,15 @@ class MessageManager(Manager):
                 recipient=recipient,
             )
 
-        elif action_request or (action_function and action_arguments):
+        elif action_request or (
+            action_function and action_arguments is not None
+        ):
             _msg = self.create_action_request(
                 sender=sender,
                 recipient=recipient,
                 function=action_function,
                 arguments=action_arguments,
                 action_request=action_request,
-                template=template,
-                template_context=template_context,
             )
 
         elif assistant_response:
@@ -349,14 +396,13 @@ class MessageManager(Manager):
                 sender=sender,
                 recipient=recipient,
                 assistant_response=assistant_response,
-                template=template,
-                template_context=template_context,
             )
 
         else:
             _msg = self.create_instruction(
                 instruction=instruction,
                 context=context,
+                handle_context=handle_context,
                 guidance=guidance,
                 images=images,
                 request_fields=request_fields,
@@ -466,7 +512,9 @@ class MessageManager(Manager):
         Convenience method to strip 'tool_schemas' from the most recent Instruction.
         """
         if self.last_instruction:
-            self.messages[self.last_instruction.id].tool_schemas = None
+            self.messages[
+                self.last_instruction.id
+            ].content.tool_schemas.clear()
 
     def concat_recent_action_responses_to_instruction(
         self, instruction: Instruction
@@ -477,7 +525,9 @@ class MessageManager(Manager):
         """
         for i in reversed(list(self.messages.progression)):
             if isinstance(self.messages[i], ActionResponse):
-                instruction.context.append(self.messages[i].content)
+                instruction.content.prompt_context.append(
+                    self.messages[i].content
+                )
             else:
                 break
 

lionagi/protocols/messages/message.py

@@ -1,252 +1,142 @@
 # Copyright (c) 2023-2025, HaiyangLi <quantocean.li at gmail dot com>
 # SPDX-License-Identifier: Apache-2.0
 
-from __future__ import annotations
+from dataclasses import dataclass
+from typing import Any, ClassVar
 
-from pathlib import Path
-from typing import Any
+from pydantic import field_serializer, field_validator
 
-from jinja2 import Environment, FileSystemLoader, Template
-from pydantic import Field, PrivateAttr, field_serializer
-
-from lionagi import ln
+from lionagi.ln.types import DataClass
 
 from .._concepts import Sendable
-from ..generic.element import Element, IDType
-from ..generic.log import Log
 from ..graph.node import Node
 from .base import (
-    MessageFlag,
     MessageRole,
     SenderRecipient,
+    serialize_sender_recipient,
     validate_sender_recipient,
 )
 
-template_path = Path(__file__).parent / "templates"
-jinja_env = Environment(loader=FileSystemLoader(template_path))
-
-__all__ = ("RoledMessage",)
 
+@dataclass(slots=True)
+class MessageContent(DataClass):
+    """A base class for message content structures."""
 
-class RoledMessage(Node, Sendable):
-    """
-    A base class for all messages that have a `role` and carry structured
-    `content`. Subclasses might be `Instruction`, `ActionRequest`, etc.
-    """
+    _none_as_sentinel: ClassVar[bool] = True
 
-    content: dict = Field(
-        default_factory=dict,
-        description="The content of the message.",
-    )
+    @property
+    def rendered(self) -> str:
+        """Render the content as a string."""
+        raise NotImplementedError(
+            "Subclasses must implement rendered property."
+        )
 
-    role: MessageRole | None = Field(
-        None,
-        description="The role of the message in the conversation.",
-    )
+    @classmethod
+    def from_dict(cls, data: dict[str, Any]) -> "MessageContent":
+        """Create an instance from a dictionary."""
+        raise NotImplementedError(
+            "Subclasses must implement from_dict method."
+        )
 
-    _flag: MessageFlag | None = PrivateAttr(None)
 
-    template: str | Template | None = None
+class RoledMessage(Node, Sendable):
+    """Base class for all messages with a role and structured content.
 
-    sender: SenderRecipient | None = Field(
-        default=MessageRole.UNSET,
-        title="Sender",
-        description="The ID of the sender node or a role.",
-    )
+    Subclasses must provide a concrete MessageContent type.
+    """
 
-    recipient: SenderRecipient | None = Field(
-        default=MessageRole.UNSET,
-        title="Recipient",
-        description="The ID of the recipient node or a role.",
-    )
+    role: MessageRole = MessageRole.UNSET
+    content: MessageContent
+    sender: SenderRecipient | None = MessageRole.UNSET
+    recipient: SenderRecipient | None = MessageRole.UNSET
 
     @field_serializer("sender", "recipient")
     def _serialize_sender_recipient(self, value: SenderRecipient) -> str:
-        if isinstance(value, MessageRole | MessageFlag):
-            return value.value
-        if isinstance(value, str):
-            return value
-        if isinstance(value, Element):
-            return str(value.id)
-        if isinstance(value, IDType):
-            return str(value)
-        return str(value)
+        return serialize_sender_recipient(value)
 
-    @property
-    def image_content(self) -> list[dict[str, Any]] | None:
-        """
-        Extract structured image data from the message content if it is
-        represented as a chat message array.
-
-        Returns:
-            list[dict[str,Any]] | None: If no images found, None.
-        """
-        msg_ = self.chat_msg
-        if isinstance(msg_, dict) and isinstance(msg_["content"], list):
-            return [i for i in msg_["content"] if i["type"] == "image_url"]
-        return None
+    @field_validator("sender", "recipient")
+    def _validate_sender_recipient(cls, v):
+        if v is None:
+            return None
+        return validate_sender_recipient(v)
 
     @property
     def chat_msg(self) -> dict[str, Any] | None:
-        """
-        A dictionary representation typically used in chat-based contexts.
-
-        Returns:
-            dict: `{"role": <role>, "content": <rendered content>}`
-        """
+        """A dictionary representation typically used in chat-based contexts."""
         try:
-            return {"role": str(self.role), "content": self.rendered}
+            role_str = (
+                self.role.value
+                if isinstance(self.role, MessageRole)
+                else str(self.role)
+            )
+            return {"role": role_str, "content": self.rendered}
         except Exception:
             return None
 
     @property
     def rendered(self) -> str:
-        """
-        Attempt to format the message with a Jinja template (if provided).
-        If no template, fallback to JSON.
+        """Render the message content as a string.
 
-        Returns:
-            str: The final formatted string.
+        Delegates to the content's rendered property.
         """
-        try:
-            if isinstance(self.template, str):
-                return self.template.format(**self.content)
-            if isinstance(self.template, Template):
-                return self.template.render(**self.content)
-        except Exception:
-            return ln.json_dumps(
-                self.content,
-                pretty=True,
-                sort_keys=True,
-                append_newline=True,
-                deterministic_sets=True,
-                decimal_as_float=True,
-            )
+        return self.content.rendered
 
-    @classmethod
-    def create(cls, **kwargs):
-        raise NotImplementedError("create() must be implemented in subclass.")
+    @field_validator("role", mode="before")
+    def _validate_role(cls, v):
+        if isinstance(v, str):
+            return MessageRole(v)
+        if isinstance(v, MessageRole):
+            return v
+        return MessageRole.UNSET
 
-    @classmethod
-    def from_dict(cls, dict_: dict):
-        """
-        Deserialize a dictionary into a RoledMessage or subclass.
+    def update(self, sender=None, recipient=None, **kw):
+        """Update message fields.
 
         Args:
-            dict_ (dict): The raw data.
-
-        Returns:
-            RoledMessage: A newly constructed instance.
+            sender: New sender role or ID.
+            recipient: New recipient role or ID.
+            **kw: Content updates to apply via from_dict() reconstruction.
         """
-        try:
-            self: RoledMessage = super().from_dict(
-                {k: v for k, v in dict_.items() if v}
-            )
-            self._flag = MessageFlag.MESSAGE_LOAD
-            return self
-        except Exception as e:
-            raise ValueError(f"Invalid RoledMessage data: {e}")
+        if sender:
+            self.sender = validate_sender_recipient(sender)
+        if recipient:
+            self.recipient = validate_sender_recipient(recipient)
+        if kw:
+            _dict = self.content.to_dict()
+            _dict.update(kw)
+            self.content = type(self.content).from_dict(_dict)
 
-    def is_clone(self) -> bool:
-        """
-        Check if this message is flagged as a clone.
+    def clone(self) -> "RoledMessage":
+        """Create a clone with a new ID but reference to original.
 
         Returns:
-            bool: True if flagged `MESSAGE_CLONE`.
+            A new message instance with a new ID and deep-copied content,
+            with a reference to the original message in metadata.
         """
-        return self._flag == MessageFlag.MESSAGE_CLONE
+        # Create a new instance from dict, excluding frozen fields (id, created_at)
+        # This allows new id and created_at to be generated
+        data = self.to_dict()
+        original_id = data.pop("id")
+        data.pop("created_at")  # Let new created_at be generated
 
-    def clone(self, keep_role: bool = True) -> RoledMessage:
-        """
-        Create a shallow copy of this message, possibly resetting the role.
+        # Create new instance
+        cloned = type(self).from_dict(data)
 
-        Args:
-            keep_role (bool): If False, set the new message's role to `UNSET`.
-
-        Returns:
-            RoledMessage: The new cloned message.
-        """
-        instance = self.__class__(
-            content=self.content,
-            role=self.role if keep_role else MessageRole.UNSET,
-            metadata={"clone_from": self},
-        )
-        instance._flag = MessageFlag.MESSAGE_CLONE
-        return instance
-
-    def to_log(self) -> Log:
-        """
-        Convert this message into a `Log`, preserving all current fields.
+        # Store reference to original in metadata
+        cloned.metadata["clone_from"] = str(original_id)
 
-        Returns:
-            Log: An immutable log entry derived from this message.
-        """
-        return Log.create(self)
-
-    @field_serializer("role")
-    def _serialize_role(self, value: MessageRole):
-        if isinstance(value, MessageRole):
-            return value.value
-        return str(value)
-
-    @field_serializer("metadata")
-    def _serialize_metadata(self, value: dict):
-        if "clone_from" in value:
-            origin_obj: RoledMessage = value.pop("clone_from")
-            origin_info = origin_obj.to_dict()
-            value["clone_from_info"] = {
-                "clone_from_info": {
-                    "original_id": origin_info["id"],
-                    "original_created_at": origin_info["created_at"],
-                    "original_sender": origin_info["sender"],
-                    "original_recipient": origin_info["recipient"],
-                    "original_lion_class": origin_info["metadata"][
-                        "lion_class"
-                    ],
-                    "original_role": origin_info["role"],
-                }
-            }
-        return value
-
-    @field_serializer("template")
-    def _serialize_template(self, value: Template | str):
-        # We do not store or transmit the raw Template object.
-        if isinstance(value, Template):
-            return None
-        return value
+        return cloned
 
-    def update(self, sender, recipient, template, **kwargs):
+    @property
+    def image_content(self) -> list[dict[str, Any]] | None:
         """
-        Generic update mechanism for customizing the message in place.
-
-        Args:
-            sender (SenderRecipient):
-                New sender or role.
-            recipient (SenderRecipient):
-                New recipient or role.
-            template (Template | str):
-                New jinja Template or format string.
-            **kwargs:
-                Additional content to merge into self.content.
+        Extract structured image data from the message content if it is
+        represented as a chat message array.
         """
-        if sender:
-            self.sender = validate_sender_recipient(sender)
-        if recipient:
-            self.recipient = validate_sender_recipient(recipient)
-        if kwargs:
-            self.content.update(kwargs)
-        if template:
-            if not isinstance(template, Template | str):
-                raise ValueError("Template must be a Jinja2 Template or str")
-            self.template = template
-
-    def __str__(self) -> str:
-        content_preview = (
-            f"{str(self.content)[:75]}..."
-            if len(str(self.content)) > 75
-            else str(self.content)
-        )
-        return f"Message(role={self.role}, sender={self.sender}, content='{content_preview}')"
+        msg_ = self.chat_msg
+        if isinstance(msg_, dict) and isinstance(msg_["content"], list):
+            return [i for i in msg_["content"] if i["type"] == "image_url"]
+        return None
 
 
 # File: lionagi/protocols/messages/message.py