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

lionagi/protocols/messages/assistant_response.py

@@ -1,208 +1,178 @@
-# Copyright (c) 2023 - 2025, HaiyangLi <quantocean.li at gmail dot com>
-#
+# Copyright (c) 2023-2025, HaiyangLi <quantocean.li at gmail dot com>
 # SPDX-License-Identifier: Apache-2.0
 
+from dataclasses import dataclass
 from typing import Any
 
-from pydantic import BaseModel
+from pydantic import BaseModel, field_validator
 
-from lionagi.utils import copy
+from .base import SenderRecipient
+from .message import MessageContent, MessageRole, RoledMessage
 
-from .base import MessageRole, SenderRecipient
-from .message import MessageRole, RoledMessage, Template, jinja_env
 
+def parse_assistant_response(
+    response: BaseModel | list[BaseModel] | dict | str | Any,
+) -> tuple[str, dict | list[dict]]:
+    """Parse various AI model response formats into text and raw data.
 
-def prepare_assistant_response(
-    assistant_response: BaseModel | list[BaseModel] | dict | str | Any, /
-) -> dict:
-    assistant_response = (
-        [assistant_response]
-        if not isinstance(assistant_response, list)
-        else assistant_response
-    )
+    Supports:
+    - Anthropic format (content field)
+    - OpenAI chat completions (choices field)
+    - OpenAI responses API (output field)
+    - Claude Code (result field)
+    - Raw strings
+
+    Returns:
+        tuple: (extracted_text, raw_model_response)
+    """
+    responses = [response] if not isinstance(response, list) else response
 
     text_contents = []
     model_responses = []
 
-    for i in assistant_response:
-        if isinstance(i, BaseModel):
-            i = i.model_dump(exclude_none=True, exclude_unset=True)
+    for item in responses:
+        if isinstance(item, BaseModel):
+            item = item.model_dump(exclude_none=True, exclude_unset=True)
 
-        model_responses.append(i)
+        model_responses.append(item)
 
-        if isinstance(i, dict):
-            # anthropic standard
-            if "content" in i:
-                content = i["content"]
+        if isinstance(item, dict):
+            # Anthropic standard
+            if "content" in item:
+                content = item["content"]
                 content = (
                     [content] if not isinstance(content, list) else content
                 )
-                for j in content:
-                    if isinstance(j, dict):
-                        if j.get("type") == "text":
-                            text_contents.append(j["text"])
-                    elif isinstance(j, str):
-                        text_contents.append(j)
-
-            # openai chat completions standard
-            elif "choices" in i:
-                choices = i["choices"]
+                for c in content:
+                    if isinstance(c, dict) and c.get("type") == "text":
+                        text_contents.append(c["text"])
+                    elif isinstance(c, str):
+                        text_contents.append(c)
+
+            # OpenAI chat completions standard
+            elif "choices" in item:
+                choices = item["choices"]
                 choices = (
                     [choices] if not isinstance(choices, list) else choices
                 )
-                for j in choices:
-                    if "message" in j:
-                        text_contents.append(j["message"]["content"] or "")
-                    elif "delta" in j:
-                        text_contents.append(j["delta"]["content"] or "")
-
-            # openai responses API standard
-            elif "output" in i:
-                output = i["output"]
+                for choice in choices:
+                    if "message" in choice:
+                        text_contents.append(
+                            choice["message"].get("content") or ""
+                        )
+                    elif "delta" in choice:
+                        text_contents.append(
+                            choice["delta"].get("content") or ""
+                        )
+
+            # OpenAI responses API standard
+            elif "output" in item:
+                output = item["output"]
                 output = [output] if not isinstance(output, list) else output
-                for item in output:
-                    if isinstance(item, dict):
-                        if item.get("type") == "message":
-                            # Extract content from message
-                            content = item.get("content", [])
-                            if isinstance(content, list):
-                                for c in content:
-                                    if (
-                                        isinstance(c, dict)
-                                        and c.get("type") == "output_text"
-                                    ):
-                                        text_contents.append(c.get("text", ""))
-                                    elif isinstance(c, str):
-                                        text_contents.append(c)
-
-            # claude code standard
-            elif "result" in i:
-                text_contents.append(i["result"])
-
-        elif isinstance(i, str):
-            text_contents.append(i)
-
-    text_contents = "".join(text_contents)
-    model_responses = (
+                for out in output:
+                    if isinstance(out, dict) and out.get("type") == "message":
+                        content = out.get("content", [])
+                        if isinstance(content, list):
+                            for c in content:
+                                if (
+                                    isinstance(c, dict)
+                                    and c.get("type") == "output_text"
+                                ):
+                                    text_contents.append(c.get("text", ""))
+                                elif isinstance(c, str):
+                                    text_contents.append(c)
+
+            # Claude Code standard
+            elif "result" in item:
+                text_contents.append(item["result"])
+
+        elif isinstance(item, str):
+            text_contents.append(item)
+
+    text = "".join(text_contents)
+    model_response = (
         model_responses[0] if len(model_responses) == 1 else model_responses
     )
-    return {
-        "assistant_response": text_contents,
-        "model_response": model_responses,
-    }
 
+    return text, model_response
 
-class AssistantResponse(RoledMessage):
+
+@dataclass(slots=True)
+class AssistantResponseContent(MessageContent):
+    """Content for assistant responses.
+
+    Fields:
+        assistant_response: Extracted text from the model
     """
-    A message representing the AI assistant's reply, typically
-    from a model or LLM call. If the raw model output is available,
-    it's placed in `metadata["model_response"]`.
+
+    assistant_response: str = ""
+
+    @property
+    def rendered(self) -> str:
+        """Render assistant response as plain text."""
+        return self.assistant_response
+
+    @classmethod
+    def from_dict(cls, data: dict[str, Any]) -> "AssistantResponseContent":
+        """Construct AssistantResponseContent from dictionary."""
+        assistant_response = data.get("assistant_response", "")
+        return cls(assistant_response=assistant_response)
+
+
+class AssistantResponse(RoledMessage):
+    """Message representing an AI assistant's reply.
+
+    The raw model output is stored in metadata["model_response"].
     """
 
-    template: Template | str | None = jinja_env.get_template(
-        "assistant_response.jinja2"
-    )
+    role: MessageRole = MessageRole.ASSISTANT
+    content: AssistantResponseContent
+    recipient: SenderRecipient | None = MessageRole.USER
+
+    @field_validator("content", mode="before")
+    def _validate_content(cls, v):
+        if v is None:
+            return AssistantResponseContent()
+        if isinstance(v, dict):
+            return AssistantResponseContent.from_dict(v)
+        if isinstance(v, AssistantResponseContent):
+            return v
+        raise TypeError(
+            "content must be dict or AssistantResponseContent instance"
+        )
 
     @property
     def response(self) -> str:
-        """Get or set the text portion of the assistant's response."""
-        return copy(self.content["assistant_response"])
-
-    @response.setter
-    def response(self, value: str) -> None:
-        self.content["assistant_response"] = value
+        """Access the text response from the assistant."""
+        return self.content.assistant_response
 
     @property
     def model_response(self) -> dict | list[dict]:
-        """
-        Access the underlying model's raw data, if available.
-
-        Returns:
-            dict or list[dict]: The stored model output data.
-        """
-        return copy(self.metadata.get("model_response", {}))
+        """Access the underlying model's raw data from metadata."""
+        return self.metadata.get("model_response", {})
 
     @classmethod
-    def create(
+    def from_response(
         cls,
-        assistant_response: BaseModel | list[BaseModel] | dict | str | Any,
+        response: BaseModel | list[BaseModel] | dict | str | Any,
         sender: SenderRecipient | None = None,
         recipient: SenderRecipient | None = None,
-        template: Template | str | None = None,
-        **kwargs,
     ) -> "AssistantResponse":
-        """
-        Build an AssistantResponse from arbitrary assistant data.
+        """Create AssistantResponse from raw model output.
 
         Args:
-            assistant_response:
-                A pydantic model, list, dict, or string representing
-                an LLM or system response.
-            sender (SenderRecipient | None):
-                The ID or role denoting who sends this response.
-            recipient (SenderRecipient | None):
-                The ID or role to receive it.
-            template (Template | str | None):
-                Optional custom template.
-            **kwargs:
-                Additional content key-value pairs.
+            response: Raw model output in any supported format
+            sender: Message sender
+            recipient: Message recipient
 
         Returns:
-            AssistantResponse: The constructed instance.
+            AssistantResponse with parsed content and metadata
         """
-        content = prepare_assistant_response(assistant_response)
-        model_response = content.pop("model_response", {})
-        content.update(kwargs)
-        params = {
-            "content": content,
-            "role": MessageRole.ASSISTANT,
-            "recipient": recipient or MessageRole.USER,
-        }
-        if sender:
-            params["sender"] = sender
-        if template:
-            params["template"] = template
-        if model_response:
-            params["metadata"] = {"model_response": model_response}
-        return cls(**params)
-
-    def update(
-        self,
-        assistant_response: (
-            BaseModel | list[BaseModel] | dict | str | Any
-        ) = None,
-        sender: SenderRecipient | None = None,
-        recipient: SenderRecipient | None = None,
-        template: Template | str | None = None,
-        **kwargs,
-    ):
-        """
-        Update this AssistantResponse with new data or fields.
+        text, model_response = parse_assistant_response(response)
 
-        Args:
-            assistant_response:
-                Additional or replaced assistant model output.
-            sender (SenderRecipient | None):
-                Updated sender.
-            recipient (SenderRecipient | None):
-                Updated recipient.
-            template (Template | str | None):
-                Optional new template.
-            **kwargs:
-                Additional content updates for `self.content`.
-        """
-        if assistant_response:
-            content = prepare_assistant_response(assistant_response)
-            self.content.update(content)
-        super().update(
-            sender=sender, recipient=recipient, template=template, **kwargs
+        return cls(
+            content=AssistantResponseContent(assistant_response=text),
+            sender=sender,
+            recipient=recipient or MessageRole.USER,
+            metadata={"model_response": model_response},
         )
-
-    def as_context(self) -> dict:
-        return f"""
-            Response: {self.response or "Not available"}
-            Summary: {self.model_response.get("summary") or "Not available"}
-        """.strip()
-
-
-# File: lionagi/protocols/messages/assistant_response.py

lionagi/protocols/messages/base.py

@@ -1,18 +1,17 @@
-# Copyright (c) 2023 - 2025, HaiyangLi <quantocean.li at gmail dot com>
-#
+# Copyright (c) 2023-2025, HaiyangLi <quantocean.li at gmail dot com>
 # SPDX-License-Identifier: Apache-2.0
 
 from enum import Enum
 from typing import Any, TypeAlias
 
-from ..generic.element import ID, IDError, IDType, Observable
+from ..generic.element import ID, Element, IDError, IDType, Observable
 
 __all__ = (
     "MessageRole",
-    "MessageFlag",
     "MessageField",
     "MESSAGE_FIELDS",
     "validate_sender_recipient",
+    "serialize_sender_recipient",
 )
 
 
@@ -28,15 +27,6 @@ class MessageRole(str, Enum):
     ACTION = "action"
 
 
-class MessageFlag(str, Enum):
-    """
-    Internal flags for certain message states, e.g., clones or loads.
-    """
-
-    MESSAGE_CLONE = "MESSAGE_CLONE"
-    MESSAGE_LOAD = "MESSAGE_LOAD"
-
-
 SenderRecipient: TypeAlias = IDType | MessageRole | str
 """
 A union type indicating that a sender or recipient could be:
@@ -76,7 +66,7 @@ def validate_sender_recipient(value: Any, /) -> SenderRecipient:
     Raises:
         ValueError: If the input cannot be recognized as a role or ID.
     """
-    if isinstance(value, MessageRole | MessageFlag):
+    if isinstance(value, MessageRole):
         return value
 
     if isinstance(value, IDType):
@@ -91,13 +81,30 @@ def validate_sender_recipient(value: Any, /) -> SenderRecipient:
     if value in ["system", "user", "unset", "assistant", "action"]:
         return MessageRole(value)
 
-    if value in ["MESSAGE_CLONE", "MESSAGE_LOAD"]:
-        return MessageFlag(value)
+    # Accept plain strings (user names, identifiers, etc)
+    if isinstance(value, str):
+        # Try to parse as ID first, but allow plain strings as fallback
+        try:
+            return ID.get_id(value)
+        except IDError:
+            return value
 
-    try:
-        return ID.get_id(value)
-    except IDError as e:
-        raise ValueError("Invalid sender or recipient") from e
+    raise ValueError("Invalid sender or recipient")
+
+
+def serialize_sender_recipient(value: Any) -> str | None:
+    if not value:
+        return None
+    # Check instance types first before enum membership
+    if isinstance(value, Element):
+        return str(value.id)
+    if isinstance(value, IDType):
+        return str(value)
+    if isinstance(value, MessageRole):
+        return value.value
+    if isinstance(value, str):
+        return value
+    return str(value)
 
 
 # File: lionagi/protocols/messages/base.py