lionagi 0.15.9__py3-none-any.whl → 0.15.13__py3-none-any.whl

lionagi/protocols/graph/node.py

@@ -4,10 +4,10 @@
 
 from __future__ import annotations
 
-import json
 from typing import Any
 
-from pydantic import field_validator
+import orjson
+from pydantic import BaseModel, field_serializer, field_validator
 from pydapter import Adaptable, AsyncAdaptable
 
 from lionagi._class_registry import LION_CLASS_REGISTRY
@@ -44,7 +44,7 @@ class Node(Element, Relational, AsyncAdaptable, Adaptable):
             return None
         if isinstance(value, str):
             try:
-                loaded = json.loads(value)
+                loaded = orjson.loads(value)
                 if not isinstance(loaded, list):
                     raise ValueError
                 return [float(x) for x in loaded]
@@ -63,6 +63,7 @@ class Node(Element, Relational, AsyncAdaptable, Adaptable):
         self, obj_key: str, many=False, **kwargs: Any
     ) -> Any:
         kwargs["adapt_meth"] = "to_dict"
+        kwargs["mode"] = "db"
         return await super().adapt_to_async(
             obj_key=obj_key, many=many, **kwargs
         )
@@ -76,6 +77,7 @@ class Node(Element, Relational, AsyncAdaptable, Adaptable):
         **kwargs: Any,
     ) -> Node:
         kwargs["adapt_meth"] = "from_dict"
+        kwargs["mode"] = "db"
         return await super().adapt_from_async(
             obj, obj_key=obj_key, many=many, **kwargs
         )
@@ -85,6 +87,7 @@ class Node(Element, Relational, AsyncAdaptable, Adaptable):
         Convert this Node to another format using a registered adapter.
         """
         kwargs["adapt_meth"] = "to_dict"
+        kwargs["mode"] = "db"
         return super().adapt_to(obj_key=obj_key, many=many, **kwargs)
 
     @classmethod
@@ -101,8 +104,25 @@ class Node(Element, Relational, AsyncAdaptable, Adaptable):
         auto-delegate to the correct subclass via from_dict.
         """
         kwargs["adapt_meth"] = "from_dict"
+        kwargs["mode"] = "db"
         return super().adapt_from(obj, obj_key=obj_key, many=many, **kwargs)
 
+    @field_serializer("content")
+    def _serialize_content(self, value: Any) -> Any:
+        if isinstance(value, Element):
+            return value.to_dict()
+        if isinstance(value, BaseModel):
+            return value.model_dump()
+        return value
+
+    @field_validator("content", mode="before")
+    def _validate_content(cls, value: Any) -> Any:
+        if isinstance(value, dict) and "lion_class" in value.get(
+            "metadata", {}
+        ):
+            return Element.from_dict(value)
+        return value
+
 
 if not _ADAPATER_REGISTERED:
     from pydapter.adapters import JsonAdapter, TomlAdapter

lionagi/protocols/messages/manager.py

@@ -392,79 +392,75 @@ class MessageManager(Manager):
 
     @property
     def last_response(self) -> AssistantResponse | None:
-        """
-        Retrieve the most recent `AssistantResponse`.
-        """
-        for mid in reversed(self.messages.progression):
-            if isinstance(self.messages[mid], AssistantResponse):
-                return self.messages[mid]
+        """Retrieve the most recent `AssistantResponse`."""
+        res = self.messages.filter_by_type(
+            item_type=AssistantResponse,
+            strict_type=True,
+            as_pile=False,
+            reverse=True,
+            num_items=1,
+        )
+        if len(res) == 1:
+            return res[0]
         return None
 
     @property
     def last_instruction(self) -> Instruction | None:
-        """
-        Retrieve the most recent `Instruction`.
-        """
-        for mid in reversed(self.messages.progression):
-            if isinstance(self.messages[mid], Instruction):
-                return self.messages[mid]
+        """Retrieve the most recent `Instruction`."""
+        res = self.messages.filter_by_type(
+            item_type=Instruction,
+            strict_type=True,
+            as_pile=False,
+            reverse=True,
+            num_items=1,
+        )
+        if len(res) == 1:
+            return res[0]
         return None
 
     @property
     def assistant_responses(self) -> Pile[AssistantResponse]:
         """All `AssistantResponse` messages in the manager."""
-        return Pile(
-            collections=[
-                self.messages[mid]
-                for mid in self.messages.progression
-                if isinstance(self.messages[mid], AssistantResponse)
-            ]
+        return self.messages.filter_by_type(
+            item_type=AssistantResponse,
+            strict_type=True,
+            as_pile=True,
         )
 
     @property
     def actions(self) -> Pile[ActionRequest | ActionResponse]:
         """All action messages in the manager."""
-        return Pile(
-            collections=[
-                self.messages[mid]
-                for mid in self.messages.progression
-                if isinstance(
-                    self.messages[mid], (ActionRequest, ActionResponse)
-                )
-            ]
+        return self.messages.filter_by_type(
+            item_type={ActionRequest, ActionResponse},
+            strict_type=True,
+            as_pile=True,
         )
 
     @property
     def action_requests(self) -> Pile[ActionRequest]:
         """All `ActionRequest` messages in the manager."""
-        return Pile(
-            collections=[
-                self.messages[mid]
-                for mid in self.messages.progression
-                if isinstance(self.messages[mid], ActionRequest)
-            ]
+        return self.messages.filter_by_type(
+            item_type=ActionRequest,
+            strict_type=True,
+            as_pile=True,
         )
 
     @property
     def action_responses(self) -> Pile[ActionResponse]:
         """All `ActionResponse` messages in the manager."""
-        return Pile(
-            collections=[
-                self.messages[mid]
-                for mid in self.messages.progression
-                if isinstance(self.messages[mid], ActionResponse)
-            ]
+        return self.messages.filter_by_type(
+            item_type=ActionResponse,
+            strict_type=True,
+            as_pile=True,
         )
 
     @property
     def instructions(self) -> Pile[Instruction]:
         """All `Instruction` messages in the manager."""
-        return Pile(
-            collections=[
-                self.messages[mid]
-                for mid in self.messages.progression
-                if isinstance(self.messages[mid], Instruction)
-            ]
+        return self.messages.filter_by_type(
+            item_type=Instruction,
+            strict_type=True,
+            as_pile=True,
         )
 
     def remove_last_instruction_tool_schemas(self) -> None:
@@ -481,7 +477,7 @@ class MessageManager(Manager):
         Example method to merge the content of recent ActionResponses
         into an instruction's context.
         """
-        for i in reversed(self.messages.progression):
+        for i in reversed(list(self.messages.progression)):
             if isinstance(self.messages[i], ActionResponse):
                 instruction.context.append(self.messages[i].content)
             else:

lionagi/protocols/operatives/step.py

@@ -2,36 +2,19 @@
 #
 # SPDX-License-Identifier: Apache-2.0
 
-from pydantic import BaseModel, Field
+from pydantic import BaseModel
 from pydantic.fields import FieldInfo
 
 from lionagi.fields.action import (
     ACTION_REQUESTS_FIELD,
     ACTION_REQUIRED_FIELD,
     ACTION_RESPONSES_FIELD,
-    ActionRequestModel,
-    ActionResponseModel,
 )
-from lionagi.fields.reason import REASON_FIELD, Reason
+from lionagi.fields.reason import REASON_FIELD
 from lionagi.models import FieldModel, ModelParams
 from lionagi.protocols.operatives.operative import Operative
 
 
-class StepModel(BaseModel):
-    """Model representing a single operational step with optional reasoning and actions."""
-
-    title: str
-    description: str
-    reason: Reason | None = Field(**REASON_FIELD.to_dict())
-    action_requests: list[ActionRequestModel] = Field(
-        **ACTION_REQUESTS_FIELD.to_dict()
-    )
-    action_required: bool = Field(**ACTION_REQUIRED_FIELD.to_dict())
-    action_responses: list[ActionResponseModel] = Field(
-        **ACTION_RESPONSES_FIELD.to_dict()
-    )
-
-
 class Step:
     """Utility class providing methods to create and manage Operative instances for steps."""
 

lionagi/protocols/types.py

@@ -49,7 +49,7 @@ from .messages.manager import (
     SenderRecipient,
     System,
 )
-from .operatives.step import Operative, Step, StepModel
+from .operatives.step import Operative, Step
 
 __all__ = (
     "Collective",
@@ -107,7 +107,6 @@ __all__ = (
     "Report",
     "Operative",
     "Step",
-    "StepModel",
     "ActionManager",
     "Tool",
     "FunctionCalling",

lionagi/tools/file/reader.py

@@ -173,13 +173,12 @@ class ReaderTool(LionTool):
     system_tool_name = "reader_tool"
 
     def __init__(self):
-        from lionagi.libs.package.imports import check_import
+        from lionagi.libs.file.process import _HAS_DOCLING
 
-        DocumentConverter = check_import(
-            "docling",
-            module_name="document_converter",
-            import_name="DocumentConverter",
-        )
+        if _HAS_DOCLING is not True:
+            raise _HAS_DOCLING
+
+        from docling.document_converter import DocumentConverter
 
         super().__init__()
         self.converter = DocumentConverter()