lionagi 0.1.1__py3-none-any.whl → 0.2.0__py3-none-any.whl

lionagi/core/message/action_response.py

@@ -0,0 +1,135 @@
+"""
+Copyright 2024 HaiyangLi
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+"""
+
+from typing import Any
+from pydantic import Field
+from .message import RoledMessage, MessageRole
+from .action_request import ActionRequest
+
+
+# action response must correlates to a specific action request
+class ActionResponse(RoledMessage):
+    """
+    Represents a response to a specific action request.
+
+    Inherits from `RoledMessage` and provides attributes specific to action responses.
+
+    Attributes:
+        action_request (str): The ID of the action request that this response corresponds to.
+        function (str): The name of the function called.
+        arguments (dict): The keyword arguments provided.
+        func_outputs (Any): The output of the function call.
+    """
+
+    action_request: str | None = Field(
+        None,
+        description="The id of the action request that this response corresponds to",
+    )
+
+    function: str | None = Field(None, description="The name of the function called")
+    arguments: dict | None = Field(None, description="The keyword arguments provided")
+    func_outputs: Any | None = Field(
+        None, description="The output of the function call"
+    )
+
+    def __init__(
+        self,
+        action_request: ActionRequest,
+        sender: str | None = None,  # the sender of action request
+        func_outputs=None,
+        **kwargs,
+    ):
+        """
+        Initializes the ActionResponse.
+
+        Args:
+            action_request (ActionRequest): The action request that this response corresponds to.
+            sender (str, optional): The sender of the action request.
+            func_outputs (Any, optional): The output of the function call.
+
+        Raises:
+            ValueError: If the action request has already been responded to.
+        """
+        if action_request.is_responded():
+            raise ValueError("Action request has already been responded to")
+
+        super().__init__(
+            role=MessageRole.ASSISTANT,
+            sender=sender or "N/A",  # sender is the actionable component
+            recipient=action_request.sender,  # recipient is the assistant who made the request
+            content={
+                "action_response": {
+                    "function": action_request.function,
+                    "arguments": action_request.arguments,
+                    "output": func_outputs,
+                }
+            },
+            **kwargs,
+        )
+        self.update_request(action_request)
+        self.func_outputs = func_outputs
+
+    def update_request(self, action_request: ActionRequest):
+        """
+        Updates the action request details in the action response.
+
+        Args:
+            action_request (ActionRequest): The action request to update from.
+        """
+        self.function = action_request.function
+        self.arguments = action_request.arguments
+        self.action_request = action_request.ln_id
+        action_request.action_response = self.ln_id
+
+    def _to_dict(self):
+        """
+        Converts the action response to a dictionary.
+
+        Returns:
+            dict: A dictionary representation of the action response.
+        """
+        return {
+            "function": self.function,
+            "arguments": self.arguments,
+            "output": self.func_outputs,
+        }
+
+    def clone(self, **kwargs):
+        """
+        Creates a copy of the current object with optional additional arguments.
+
+        This method clones the current object, preserving its function and arguments.
+        It also retains the original `action_request`, `func_outputs`, and metadata,
+        while allowing for the addition of new attributes through keyword arguments.
+
+        Args:
+            **kwargs: Optional keyword arguments to be included in the cloned object.
+
+        Returns:
+            ActionResponse: A new instance of the object with the same function, arguments,
+            and additional keyword arguments.
+        """
+        import json
+
+        arguments = json.dumps(self.arguments)
+        action_request = ActionRequest(
+            function=self.function, arguments=json.loads(arguments)
+        )
+        action_response_copy = ActionResponse(action_request=action_request, **kwargs)
+        action_response_copy.action_request = self.action_request
+        action_response_copy.func_outputs = self.func_outputs
+        action_response_copy.metadata["origin_ln_id"] = self.ln_id
+        return action_response_copy

lionagi/core/message/assistant_response.py

@@ -0,0 +1,95 @@
+"""
+Copyright 2024 HaiyangLi
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+"""
+
+from typing import Any
+from .message import RoledMessage, MessageRole
+
+
+class AssistantResponse(RoledMessage):
+    """
+    Represents a response generated by an assistant.
+
+    Inherits from `RoledMessage` and provides attributes specific to assistant responses.
+
+    Attributes:
+        assistant_response (Any): The content of the assistant's response.
+        sender (str): The sender of the response.
+        recipient (str): The recipient of the response.
+    """
+
+    def __init__(
+        self,
+        assistant_response: Any = None,
+        sender: str | None = None,
+        recipient: str | None = None,
+        **kwargs,
+    ):
+        """
+        Initializes the AssistantResponse.
+
+        Args:
+            assistant_response (Any, optional): The content of the assistant's response.
+            sender (str, optional): The sender of the response.
+            recipient (str, optional): The recipient of the response.
+            **kwargs: Additional keyword arguments to be passed to the parent class.
+        """
+
+        super().__init__(
+            role=MessageRole.ASSISTANT,
+            sender=sender or "N/A",
+            content={"assistant_response": assistant_response["content"]},
+            recipient=recipient,
+            **kwargs,
+        )
+
+    def clone(self, **kwargs):
+        """
+        Creates a copy of the current AssistantResponse object with optional additional arguments.
+
+        This method clones the current object, preserving its content.
+        It also retains the original metadata, while allowing
+        for the addition of new attributes through keyword arguments.
+
+        Args:
+            **kwargs: Optional keyword arguments to be included in the cloned object.
+
+        Returns:
+            AssistantResponse: A new instance of the object with the same content and additional keyword arguments.
+        """
+        import json
+
+        content = json.dumps(self.content["assistant_response"])
+        content = {"content": json.loads(content)}
+        response_copy = AssistantResponse(assistant_response=content, **kwargs)
+        response_copy.metadata["origin_ln_id"] = self.ln_id
+        return response_copy
+
+    @property
+    def chat_msg(self) -> dict | None:
+        """Return message in chat representation."""
+        try:
+            return self._check_chat_msg()
+        except:
+            return None
+
+    def _check_chat_msg(self):
+        text_msg = super()._check_chat_msg()
+        return text_msg
+
+    @property
+    def response(self):
+        """Return the assistant response content."""
+        return self.content["assistant_response"]

lionagi/core/message/instruction.py

@@ -0,0 +1,234 @@
+"""
+Copyright 2024 HaiyangLi
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+"""
+
+from lionagi.core.collections.abc import LionIDable, SYSTEM_FIELDS
+from lionagi.core.report.form import Form
+from lionagi.core.message.message import RoledMessage, MessageRole
+
+
+class Instruction(RoledMessage):
+    """
+    Represents an instruction message with additional context and requested fields.
+
+    Inherits from `RoledMessage` and provides methods to manage context and
+    requested fields specific to instructions.
+
+    Attributes:
+        instruction (str): The instruction content.
+        context (dict or str): Additional context for the instruction.
+        sender (LionIDable): The sender of the instruction.
+        recipient (LionIDable): The recipient of the instruction.
+        requested_fields (dict): Fields requested in the instruction.
+    """
+
+    def __init__(
+        self,
+        instruction: str | None = None,
+        context: dict | str | None = None,
+        images: list | None = None,
+        sender: LionIDable | None = None,
+        recipient: LionIDable | None = None,
+        requested_fields: dict | None = None,  # {"field": "description"}
+        additional_context: dict | None = None,
+        image_detail: str | None = None,
+        **kwargs,
+    ):
+        """
+        Initializes the Instruction message.
+
+        Args:
+            instruction (str, optional): The instruction content.
+            context (dict or str, optional): Additional context for the instruction.
+            image (str, optional): The image content in base64 encoding.
+            sender (LionIDable, optional): The sender of the instruction.
+            recipient (LionIDable, optional): The recipient of the instruction.
+            requested_fields (dict, optional): Fields requested in the instruction.
+            **kwargs: Additional context fields to be added to the message content, must be JSON serializable.
+        """
+        if not instruction:
+            if "metadata" in kwargs and "instruction" in kwargs["metadata"]:
+                instruction = kwargs["metadata"].pop("instruction")
+
+        super().__init__(
+            role=MessageRole.USER,
+            sender=sender or "user",
+            content={"instruction": instruction or "N/A"},
+            recipient=recipient or "N/A",
+            **kwargs,
+        )
+
+        additional_context = additional_context or {}
+        self._initiate_content(
+            context=context,
+            requested_fields=requested_fields,
+            images=images,
+            image_detail=image_detail or "low",
+            **additional_context,
+        )
+
+    @property
+    def instruct(self):
+        """Returns the instruction content."""
+        return self.content["instruction"]
+
+    def _check_chat_msg(self):
+        text_msg = super()._check_chat_msg()
+        if "images" not in self.content:
+            return text_msg
+
+        text_msg["content"].pop("images", None)
+        text_msg["content"].pop("image_detail", None)
+        text_msg["content"] = [
+            {"type": "text", "text": text_msg["content"]},
+        ]
+
+        for i in self.content["images"]:
+            text_msg["content"].append(
+                {
+                    "type": "image_url",
+                    "image_url": {
+                        "url": f"data:image/jpeg;base64,{i}",
+                        "detail": self.content["image_detail"],
+                    },
+                }
+            )
+        return text_msg
+
+    def _add_context(self, context: dict | str | None = None, **kwargs):
+        """
+        Adds context to the instruction message.
+
+        Args:
+            context (dict or str, optional): Additional context to be added.
+            **kwargs: Additional context fields to be added.
+        """
+        if "context" not in self.content:
+            self.content["context"] = {}
+        if isinstance(context, dict):
+            self.content["context"].update({**context, **kwargs})
+        elif isinstance(context, str):
+            self.content["context"]["additional_context"] = context
+
+    def _update_requested_fields(self, requested_fields: dict):
+        """
+        Updates the requested fields in the instruction message.
+
+        Args:
+            requested_fields (dict): The fields requested in the instruction.
+        """
+        if "context" not in self.content:
+            self.content["context"] = {}
+            self.content["context"]["requested_fields"] = {}
+        self.content["context"]["requested_fields"].update(requested_fields)
+
+    def _initiate_content(
+        self, context, requested_fields, images, image_detail, **kwargs
+    ):
+        """
+        Processes context and requested fields to update the message content.
+
+        Args:
+            context (dict or str, optional): Additional context for the instruction.
+            requested_fields (dict, optional): Fields requested in the instruction.
+            **kwargs: Additional context fields to be added.
+        """
+        if context:
+            context = {"context": context} if not isinstance(context, dict) else context
+            if (
+                additional_context := {
+                    k: v for k, v in kwargs.items() if k not in SYSTEM_FIELDS
+                }
+            ) != {}:
+                context["additional_context"] = additional_context
+            self.content.update(context)
+
+        if not requested_fields in [None, {}]:
+            self.content["requested_fields"] = self._format_requested_fields(
+                requested_fields
+            )
+
+        if images:
+            self.content["images"] = images if isinstance(images, list) else [images]
+            self.content["image_detail"] = image_detail
+
+    def clone(self, **kwargs):
+        """
+        Creates a copy of the current Instruction object with optional additional arguments.
+
+        This method clones the current object, preserving its content.
+        It also retains the original metadata, while allowing
+        for the addition of new attributes through keyword arguments.
+
+        Args:
+            **kwargs: Optional keyword arguments to be included in the cloned object.
+
+        Returns:
+            Instruction: A new instance of the object with the same content and additional keyword arguments.
+        """
+        import json
+
+        content = json.dumps(self.content)
+        instruction_copy = Instruction(**kwargs)
+        instruction_copy.content = json.loads(content)
+        instruction_copy.metadata["origin_ln_id"] = self.ln_id
+        return instruction_copy
+
+    @staticmethod
+    def _format_requested_fields(requested_fields):
+        """
+        Formats the requested fields into a JSON-parseable response format.
+
+        Args:
+            requested_fields (dict): The fields requested in the instruction.
+
+        Returns:
+            dict: The formatted requested fields.
+        """
+        format_ = f"""
+        MUST RETURN JSON-PARSEABLE RESPONSE ENCLOSED BY JSON CODE BLOCKS. ----
+        ```json
+        {requested_fields}
+        ```---
+        """
+        return {"response_format": format_.strip()}
+
+    @classmethod
+    def from_form(
+        cls,
+        form: Form,
+        sender: str | None = None,
+        recipient=None,
+        image=None,
+    ):
+        """
+        Creates an Instruction instance from a form.
+
+        Args:
+            form (Form): The form containing instruction details.
+            sender (str, optional): The sender of the instruction.
+            recipient (LionIDable, optional): The recipient of the instruction.
+
+        Returns:
+            Instruction: The created Instruction instance.
+        """
+        return cls(
+            instruction=form._instruction_prompt,
+            context=form._instruction_context,
+            requested_fields=form._instruction_requested_fields,
+            image=image,
+            sender=sender,
+            recipient=recipient,
+        )

lionagi/core/message/message.py

@@ -0,0 +1,101 @@
+"""
+Copyright 2024 HaiyangLi
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+"""
+
+from enum import Enum
+from lionagi.core.collections.abc import Sendable, Field
+from lionagi.core.generic.node import Node
+
+
+# Enums for defining message fields and roles
+class MessageField(str, Enum):
+    """
+    Enum to store message fields for consistent referencing.
+    """
+
+    LION_ID = "lion_id"
+    TIMESTAMP = "timestamp"
+    ROLE = "role"
+    SENDER = "sender"
+    RECIPIENT = "recipient"
+    CONTENT = "content"
+
+
+class MessageRole(str, Enum):
+    """
+    Enum for possible roles a message can assume in a conversation.
+    """
+
+    SYSTEM = "system"
+    USER = "user"
+    ASSISTANT = "assistant"
+
+
+# Base class for messages
+class RoledMessage(Node, Sendable):
+    """
+    A base class representing a message with validators and properties.
+    """
+
+    role: MessageRole | None = Field(
+        default=None,
+        description="The role of the message in the conversation.",
+        examples=["system", "user", "assistant"],
+    )
+
+    @property
+    def image_content(self):
+        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
+
+    @property
+    def chat_msg(self) -> dict | None:
+        """return message in chat representation"""
+        try:
+            return self._check_chat_msg()
+        except:
+            return None
+
+    def _check_chat_msg(self):
+        if self.role is None:
+            raise ValueError("Message role not set")
+
+        role = self.role.value if isinstance(self.role, Enum) else self.role
+        if role not in [i.value for i in MessageRole]:
+            raise ValueError(f"Invalid message role: {role}")
+
+        content_dict = self.content.copy()
+
+        if not content_dict.get("images", None):
+            if len(content_dict) == 1:
+                content_dict = str(list(content_dict.values())[0])
+            else:
+                content_dict = str(content_dict)
+
+        return {"role": role, "content": content_dict}
+
+    def __str__(self):
+        """
+        Provides a string representation of the message with content preview.
+        """
+        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}')"

lionagi/core/message/system.py

@@ -0,0 +1,86 @@
+"""
+Copyright 2024 HaiyangLi
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+"""
+
+from typing import Any
+from ..collections.abc import Field
+from .message import RoledMessage, MessageRole
+
+
+class System(RoledMessage):
+    """
+    Represents a system message with system-related information.
+
+    Inherits from `RoledMessage` and provides methods to manage system-specific content.
+
+    Attributes:
+        system (str | Any | None): The system information.
+    """
+
+    system: str | Any | None = Field(None)
+
+    def __init__(self, system=None, sender=None, recipient=None, **kwargs):
+        """
+        Initializes the System message.
+
+        Args:
+            system (str or Any, optional): The system information.
+            sender (str, optional): The sender of the message.
+            recipient (str, optional): The recipient of the message.
+            **kwargs: Additional fields to be added to the message content, must be JSON serializable.
+        """
+        if not system:
+            if "metadata" in kwargs and "system" in kwargs["metadata"]:
+                system = kwargs["metadata"].pop("system")
+
+        super().__init__(
+            role=MessageRole.SYSTEM,
+            sender=sender or "system",
+            content={"system_info": system},
+            recipient=recipient or "N/A",
+            system=system,
+            **kwargs,
+        )
+
+    @property
+    def system_info(self):
+        """
+        Retrieves the system information stored in the message content.
+
+        Returns:
+            Any: The system information.
+        """
+        return self.content["system_info"]
+
+    def clone(self, **kwargs):
+        """
+        Creates a copy of the current System object with optional additional arguments.
+
+        This method clones the current object, preserving its content.
+        It also retains the original metadata, while allowing
+        for the addition of new attributes through keyword arguments.
+
+        Args:
+            **kwargs: Optional keyword arguments to be included in the cloned object.
+
+        Returns:
+            System: A new instance of the object with the same content and additional keyword arguments.
+        """
+        import json
+
+        system = json.dumps(self.system_info)
+        system_copy = System(system=json.loads(system), **kwargs)
+        system_copy.metadata["origin_ln_id"] = self.ln_id
+        return system_copy