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

lionagi/protocols/action/manager.py

@@ -4,7 +4,8 @@
 import logging
 from typing import Any
 
-from lionagi.fields.action import ActionRequestModel
+from pydantic import BaseModel
+
 from lionagi.protocols._concepts import Manager
 from lionagi.protocols.messages.action_request import ActionRequest
 from lionagi.utils import to_list
@@ -121,7 +122,7 @@ class ActionManager(Manager):
             self.register_tool(t, update=update)
 
     def match_tool(
-        self, action_request: ActionRequest | ActionRequestModel | dict
+        self, action_request: ActionRequest | BaseModel | dict
     ) -> FunctionCalling:
         """
         Convert an ActionRequest (or dict with "function"/"arguments")
@@ -134,9 +135,7 @@ class ActionManager(Manager):
         Returns:
             FunctionCalling: The event object that can be invoked.
         """
-        if not isinstance(
-            action_request, ActionRequest | ActionRequestModel | dict
-        ):
+        if not isinstance(action_request, ActionRequest | BaseModel | dict):
             raise TypeError(f"Unsupported type {type(action_request)}")
 
         func, args = None, None
@@ -155,7 +154,7 @@ class ActionManager(Manager):
 
     async def invoke(
         self,
-        func_call: ActionRequestModel | ActionRequest,
+        func_call: BaseModel | ActionRequest,
     ) -> FunctionCalling:
         """
         High-level API to parse and run a function call.

lionagi/protocols/contracts.py

@@ -24,7 +24,7 @@ class ObservableProto(Protocol):
 
     This protocol defines the minimal contract for observable objects:
     they must have an 'id' property. The return type is permissive (Any)
-    to maintain compatibility with V0's IDType wrapper while enabling
+    to maintain compatibility with V0's UUID wrapper while enabling
     V1 evolution.
 
     All V0 Element subclasses automatically satisfy this protocol without
@@ -33,7 +33,7 @@ class ObservableProto(Protocol):
 
     @property
     def id(self) -> object:
-        """Unique identifier. Accepts IDType, UUID, or string."""
+        """Unique identifier. Accepts UUID, UUID, or string."""
         ...
 
 

lionagi/protocols/generic/__init__.py

@@ -1,2 +1,24 @@
 # Copyright (c) 2023-2025, HaiyangLi <quantocean.li at gmail dot com>
 # SPDX-License-Identifier: Apache-2.0
+
+from .element import ID, Element
+from .event import Event, EventStatus, Execution
+from .log import DataLogger, DataLoggerConfig, Log
+from .pile import Pile
+from .processor import Executor, Processor
+from .progression import Progression
+
+__all__ = (
+    "Element",
+    "ID",
+    "Event",
+    "Execution",
+    "Log",
+    "DataLogger",
+    "DataLoggerConfig",
+    "Pile",
+    "Progression",
+    "Processor",
+    "Executor",
+    "EventStatus",
+)

lionagi/protocols/generic/element.py

@@ -19,98 +19,16 @@ from pydantic import (
 
 from lionagi import ln
 from lionagi._class_registry import get_class
-from lionagi._errors import IDError
 from lionagi.utils import import_module, to_dict
 
 from .._concepts import Collective, Observable, Ordering
 
 __all__ = (
-    "IDType",
     "Element",
-    "ID",
     "validate_order",
-    "DEFAULT_ELEMENT_SERIALIZER",
 )
 
 
-class IDType:
-    """Represents a UUIDv4-based identifier.
-
-    This class wraps a UUID object and provides helper methods for
-    validating and creating UUID version 4. It also implements equality
-    and hashing so that it can be used as dictionary keys or in sets.
-
-    Attributes:
-        _id (UUID): The wrapped UUID object.
-    """
-
-    __slots__ = ("_id",)
-
-    def __init__(self, id: UUID) -> None:
-        """Initializes an IDType instance."""
-        self._id = id
-
-    @classmethod
-    def validate(cls, value: str | UUID | IDType) -> IDType:
-        """Validates and converts a value into an IDType.
-
-        Returns:
-            IDType: The validated IDType object.
-
-        Raises:
-            IDError: If the provided value is not a valid UUIDv4.
-        """
-        if isinstance(value, IDType):
-            return value
-        try:
-            return cls(UUID(str(value), version=4))
-        except ValueError:
-            raise IDError(f"Invalid ID: {value}") from None
-
-    @classmethod
-    def create(cls) -> IDType:
-        """Creates a new IDType with a randomly generated UUIDv4.
-
-        Returns:
-            IDType: A new IDType instance with a random UUIDv4.
-        """
-        return cls(uuid4())
-
-    def __str__(self) -> str:
-        """Returns the string representation of the underlying UUID.
-
-        Returns:
-            str: The string form of this IDType's UUID.
-        """
-        return str(self._id)
-
-    def __repr__(self) -> str:
-        """Returns the unambiguous string representation of this IDType.
-
-        Returns:
-            str: A developer-friendly string for debugging.
-        """
-        return f"IDType({self._id})"
-
-    def __eq__(self, other: Any) -> bool:
-        """Checks equality with another IDType based on UUID value.
-
-        Returns:
-            bool: True if both have the same underlying UUID; False otherwise.
-        """
-        if not isinstance(other, IDType):
-            return NotImplemented
-        return self._id == other._id
-
-    def __hash__(self) -> int:
-        """Returns a hash based on the underlying UUID.
-
-        Returns:
-            int: The hash of this object, allowing IDType to be dictionary keys.
-        """
-        return hash(self._id)
-
-
 class Element(BaseModel, Observable):
     """Basic identifiable, timestamped element.
 
@@ -119,7 +37,7 @@ class Element(BaseModel, Observable):
     dictionary.
 
     Attributes:
-        id (IDType):
+        id (UUID):
             A unique ID based on UUIDv4 (defaults to a newly generated one).
         created_at (float):
             The creation timestamp as a float (Unix epoch). Defaults to
@@ -135,8 +53,8 @@ class Element(BaseModel, Observable):
         extra="forbid",
     )
 
-    id: IDType = Field(
-        default_factory=IDType.create,
+    id: UUID = Field(
+        default_factory=uuid4,
         title="ID",
         description="Unique identifier for this element.",
         frozen=True,
@@ -211,12 +129,14 @@ class Element(BaseModel, Observable):
             raise ValueError(f"Invalid created_at: {val}") from None
 
     @field_validator("id", mode="before")
-    def _ensure_idtype(cls, val: IDType | UUID | str) -> IDType:
-        """Ensures `id` is validated as an IDType."""
-        return IDType.validate(val)
+    def _ensure_UUID(cls, val: UUID | str) -> UUID:
+        """Ensures `id` is validated as an UUID."""
+        if isinstance(val, UUID):
+            return val
+        return UUID(str(val))
 
     @field_serializer("id")
-    def _serialize_id_type(self, val: IDType) -> str:
+    def _serialize_id_type(self, val: UUID) -> str:
         """Serializes the `id` field to a string."""
         return str(val)
 
@@ -328,28 +248,27 @@ class Element(BaseModel, Observable):
 
 
 DEFAULT_ELEMENT_SERIALIZER = ln.get_orjson_default(
-    order=[IDType, Element, BaseModel],
+    order=[Element, BaseModel],
     additional={
-        IDType: lambda o: str(o),
         Element: lambda o: o.to_dict(),
         BaseModel: lambda o: o.model_dump(mode="json"),
     },
 )
 
 
-def validate_order(order: Any) -> list[IDType]:
-    """Validates and flattens an ordering into a list of IDType objects.
+def validate_order(order: Any) -> list[UUID]:
+    """Validates and flattens an ordering into a list of UUID objects.
 
     This function accepts a variety of possible representations for ordering
     (e.g., a single Element, a list of Elements, a dictionary with ID keys,
-    or a nested structure) and returns a flat list of IDType objects.
+    or a nested structure) and returns a flat list of UUID objects.
 
     Returns:
-        list[IDType]: A flat list of validated IDType objects.
+        list[UUID]: A flat list of validated UUID objects.
 
     Raises:
         ValueError: If an invalid item is encountered or if there's a mixture
-            of types not all convertible to IDType.
+            of types not all convertible to UUID.
     """
     if isinstance(order, Element):
         return [order.id]
@@ -357,89 +276,79 @@ def validate_order(order: Any) -> list[IDType]:
         order = list(order.keys())
 
     stack = [order]
-    out: list[IDType] = []
+    out: list[UUID] = []
     while stack:
         cur = stack.pop()
         if cur is None:
             continue
         if isinstance(cur, Element):
             out.append(cur.id)
-        elif isinstance(cur, IDType):
-            out.append(cur)
         elif isinstance(cur, UUID):
-            out.append(IDType.validate(cur))
+            out.append(cur)
         elif isinstance(cur, str):
-            out.append(IDType.validate(cur))
+            out.append(UUID(cur))
         elif isinstance(cur, (list, tuple, set)):
             stack.extend(reversed(cur))
         else:
             raise ValueError("Invalid item in order.")
 
-    if not out:
-        return []
-
-    # Check for consistent IDType usage
-    first_type = type(out[0])
-    if first_type is IDType:
-        for item in out:
-            if not isinstance(item, IDType):
-                raise ValueError("Mixed types in order.")
-        return out
-    raise ValueError("Unrecognized type(s) in order.")
+    return [] if not out else out
 
 
 E = TypeVar("E", bound=Element)
 
 
 class ID(Generic[E]):
-    """Utility class for working with IDType objects and Elements.
+    """Utility class for working with UUID objects and Elements.
 
     This class provides helper methods to extract IDs from Elements, strings,
     or UUIDs, and to test whether a given object can be interpreted as
     an ID.
     """
 
-    ID: TypeAlias = IDType
+    ID: TypeAlias = UUID
     Item: TypeAlias = E | Element  # type: ignore
-    Ref: TypeAlias = IDType | E | str  # type: ignore
-    IDSeq: TypeAlias = Sequence[IDType] | Ordering[E]  # type: ignore
+    Ref: TypeAlias = UUID | E | str  # type: ignore
+    IDSeq: TypeAlias = Sequence[UUID] | Ordering[E]  # type: ignore
     ItemSeq: TypeAlias = Sequence[E] | Collective[E]  # type: ignore
     RefSeq: TypeAlias = ItemSeq | Sequence[Ref] | Ordering[E]  # type: ignore
 
     @staticmethod
-    def get_id(item: E) -> IDType:
-        """Retrieves an IDType from multiple possible item forms.
+    def get_id(item: E) -> UUID:
+        """Retrieves an UUID from multiple possible item forms.
 
         Acceptable item types include:
         - Element: Uses its `id` attribute.
-        - IDType: Returns it directly.
+        - UUID: Returns it directly.
         - UUID: Validates and wraps it.
         - str: Interpreted as a UUID if possible.
 
         Returns:
-            IDType: The validated ID.
+            UUID: The validated ID.
 
         Raises:
-            ValueError: If the item cannot be converted to an IDType.
+            ValueError: If the item cannot be converted to an UUID.
         """
+        if isinstance(item, UUID):
+            return item
         if isinstance(item, Element):
             return item.id
-        if isinstance(item, (IDType, UUID, str)):
-            return IDType.validate(item)
+        if isinstance(item, str):
+            return UUID(item)
         raise ValueError("Cannot get ID from item.")
 
     @staticmethod
     def is_id(item: Any) -> bool:
-        """Checks if an item can be validated as an IDType.
+        """Checks if an item can be validated as an UUID.
 
         Returns:
-            bool: True if `item` is or can be validated as an IDType;
+            bool: True if `item` is or can be validated as an UUID;
                 otherwise, False.
         """
         try:
-            IDType.validate(item)
+            ID.get_id(item)  # type: ignore
             return True
-        except IDError:
+        except ValueError:
             return False
 
 

lionagi/protocols/generic/log.py

@@ -143,10 +143,11 @@ class DataLogger:
         if self._config.auto_save_on_exit:
             atexit.register(self.save_at_exit)
 
-    def log(self, log_: Log) -> None:
+    def log(self, log_: Any) -> None:
         """
         Add a log synchronously. If capacity is reached, auto-dump to file.
         """
+        log_ = Log.create(log_) if not isinstance(log_, Log) else log_
         if self._config.capacity and len(self.logs) >= self._config.capacity:
             try:
                 self.dump(clear=self._config.clear_after_dump)
@@ -154,7 +155,7 @@ class DataLogger:
                 logger.error(f"Failed to auto-dump logs: {e}")
         self.logs.include(log_)
 
-    async def alog(self, log_: Log) -> None:
+    async def alog(self, log_: Any) -> None:
         """
         Add a log asynchronously. If capacity is reached, auto-dump to file.
         """

lionagi/protocols/generic/pile.py

@@ -16,6 +16,7 @@ from collections.abc import (
 from functools import wraps
 from pathlib import Path
 from typing import TYPE_CHECKING, Any, ClassVar, Generic, Literal, TypeVar
+from uuid import UUID
 
 from pydantic import Field, field_serializer
 from pydapter import Adaptable, AsyncAdaptable
@@ -32,7 +33,7 @@ from lionagi.utils import (
 )
 
 from .._concepts import Observable
-from .element import ID, Collective, E, Element, IDType, validate_order
+from .element import ID, Collective, E, Element, validate_order
 from .progression import Progression
 
 if TYPE_CHECKING:
@@ -112,7 +113,7 @@ def _validate_item_type(value, /) -> set[type[T]] | None:
 
 
 def _validate_progression(
-    value: Any, collections: dict[IDType, T], /
+    value: Any, collections: dict[UUID, T], /
 ) -> Progression:
     if not value:
         return Progression(order=list(collections.keys()))
@@ -198,7 +199,7 @@ class Pile(Element, Collective[T], Generic[T], Adaptable, AsyncAdaptable):
         strict_type (bool): Whether to enforce strict type checking
     """
 
-    collections: dict[IDType, T] = Field(default_factory=dict)
+    collections: dict[UUID, T] = Field(default_factory=dict)
     item_type: set | None = Field(
         default=None,
         description="Set of allowed types for items in the pile.",
@@ -282,9 +283,7 @@ class Pile(Element, Collective[T], Generic[T], Adaptable, AsyncAdaptable):
         super().__init__(**data)
 
     @field_serializer("collections")
-    def _serialize_collections(
-        self, v: dict[IDType, T]
-    ) -> list[dict[str, Any]]:
+    def _serialize_collections(self, v: dict[UUID, T]) -> list[dict[str, Any]]:
         return [i.to_dict() for i in v.values()]
 
     @field_serializer("progression")
@@ -492,7 +491,7 @@ class Pile(Element, Collective[T], Generic[T], Adaptable, AsyncAdaptable):
         """Get all items in order."""
         return [self.collections[key] for key in self.progression]
 
-    def items(self) -> Sequence[tuple[IDType, T]]:
+    def items(self) -> Sequence[tuple[UUID, T]]:
         """Get all (ID, item) pairs in order."""
         return [(key, self.collections[key]) for key in self.progression]
 
@@ -797,7 +796,7 @@ class Pile(Element, Collective[T], Generic[T], Adaptable, AsyncAdaptable):
             except Exception as e:
                 raise ItemNotFoundError(f"index {key}. Error: {e}")
 
-        elif isinstance(key, IDType):
+        elif isinstance(key, UUID):
             try:
                 return self.collections[key]
             except Exception as e:
@@ -904,7 +903,7 @@ class Pile(Element, Collective[T], Generic[T], Adaptable, AsyncAdaptable):
         if isinstance(key, int | slice):
             try:
                 pops = self.progression[key]
-                pops = [pops] if isinstance(pops, IDType) else pops
+                pops = [pops] if isinstance(pops, UUID) else pops
                 result = []
                 for i in pops:
                     self.progression.remove(i)
@@ -1196,7 +1195,7 @@ def to_list_type(value: Any, /) -> list[Any]:
     """Convert input to a list format"""
     if value is None:
         return []
-    if isinstance(value, IDType):
+    if isinstance(value, UUID):
         return [value]
     if isinstance(value, str):
         return ID.get_id(value) if ID.is_id(value) else []

lionagi/protocols/generic/progression.py

@@ -4,6 +4,7 @@
 from __future__ import annotations
 
 from typing import Any, Generic, TypeVar
+from uuid import UUID
 
 from pydantic import Field, field_serializer, field_validator
 from typing_extensions import Self
@@ -11,7 +12,7 @@ from typing_extensions import Self
 from lionagi._errors import ItemNotFoundError
 
 from .._concepts import Ordering
-from .element import ID, Element, IDError, IDType, validate_order
+from .element import ID, Element, validate_order
 
 T = TypeVar("T", bound=Element)
 
@@ -26,7 +27,7 @@ class Progression(Element, Ordering[T], Generic[T]):
     """Tracks an ordered sequence of item IDs, with optional naming.
 
     This class extends `Element` and implements `Ordering`, providing
-    list-like operations for managing item IDs (based on `IDType`). It
+    list-like operations for managing item IDs (based on `UUID`). It
     supports insertion, removal, slicing, and more. Items are stored in
     `order`, which is a simple list of IDs, and an optional `name`
     attribute can be assigned for identification.
@@ -50,23 +51,23 @@ class Progression(Element, Ordering[T], Generic[T]):
     )
 
     @field_validator("order", mode="before")
-    def _validate_ordering(cls, value: Any) -> list[IDType]:
-        """Ensures `order` is a valid list of IDTypes.
+    def _validate_ordering(cls, value: Any) -> list[UUID]:
+        """Ensures `order` is a valid list of UUIDs.
 
         Args:
             value (Any): Input sequence (could be elements, IDs, etc.).
 
         Returns:
-            list[IDType]: The list of validated IDType objects.
+            list[UUID]: The list of validated UUID objects.
         """
         return validate_order(value)
 
     @field_serializer("order")
-    def _serialize_order(self, value: list[IDType]) -> list[str]:
+    def _serialize_order(self, value: list[UUID]) -> list[str]:
         """Serializes IDs in `order` to string form.
 
         Args:
-            value (list[IDType]): The order list of ID objects.
+            value (list[UUID]): The order list of ID objects.
 
         Returns:
             list[str]: A list of stringified IDs.
@@ -85,7 +86,7 @@ class Progression(Element, Ordering[T], Generic[T]):
         """Checks if one or more IDs exist in the progression.
 
         Args:
-            item (Any): Could be an `Element`, `IDType`, `UUID`, string,
+            item (Any): Could be an `Element`, `UUID`, `UUID`, string,
                 or a sequence of these.
 
         Returns:
@@ -98,14 +99,14 @@ class Progression(Element, Ordering[T], Generic[T]):
         except Exception:
             return False
 
-    def __getitem__(self, key: int | slice) -> IDType | list[IDType]:
+    def __getitem__(self, key: int | slice) -> UUID | list[UUID]:
         """Gets one or more items by index or slice.
 
         Args:
             key (int | slice): The index or slice.
 
         Returns:
-            IDType | list[IDType]:
+            UUID | list[UUID]:
                 A single ID if `key` is an int; a new `Progression`
                 if `key` is a slice.
 
@@ -164,15 +165,15 @@ class Progression(Element, Ordering[T], Generic[T]):
         """Iterates over the IDs in this progression.
 
         Returns:
-            Iterator[IDType]: An iterator over the ID elements.
+            Iterator[UUID]: An iterator over the ID elements.
         """
         return iter(self.order)
 
-    def __next__(self) -> IDType:
+    def __next__(self) -> UUID:
         """Returns the next item if used as an iterator.
 
         Returns:
-            IDType: The next item in the iteration.
+            UUID: The next item in the iteration.
 
         Raises:
             StopIteration: If there are no more items.
@@ -182,11 +183,11 @@ class Progression(Element, Ordering[T], Generic[T]):
         except StopIteration:
             raise StopIteration("No more items in the progression")
 
-    def __list__(self) -> list[IDType]:
+    def __list__(self) -> list[UUID]:
         """Returns a copy of all IDs in the progression.
 
         Returns:
-            list[IDType]: A shallow copy of the ID list.
+            list[UUID]: A shallow copy of the ID list.
         """
         return self.order[:]
 
@@ -256,7 +257,7 @@ class Progression(Element, Ordering[T], Generic[T]):
         refs = validate_order(item)
         self.order.extend(refs)
 
-    def pop(self, index: int = -1) -> IDType:
+    def pop(self, index: int = -1) -> UUID:
         """Removes and returns one ID by index.
 
         Args:
@@ -264,7 +265,7 @@ class Progression(Element, Ordering[T], Generic[T]):
                 Position of the item to pop (default is the last item).
 
         Returns:
-            IDType: The removed ID.
+            UUID: The removed ID.
 
         Raises:
             ItemNotFoundError: If the index is invalid or out of range.
@@ -274,11 +275,11 @@ class Progression(Element, Ordering[T], Generic[T]):
         except Exception as e:
             raise ItemNotFoundError(str(e)) from e
 
-    def popleft(self) -> IDType:
+    def popleft(self) -> UUID:
         """Removes and returns the first ID.
 
         Returns:
-            IDType: The ID at the front of the progression.
+            UUID: The ID at the front of the progression.
 
         Raises:
             ItemNotFoundError: If the progression is empty.
@@ -300,9 +301,9 @@ class Progression(Element, Ordering[T], Generic[T]):
         """
         try:
             refs = validate_order(item)
-        except IDError:
-            raise ItemNotFoundError("Invalid ID(s) provided.")
-
+        except ValueError as e:
+            # Invalid UUID strings are treated as not found
+            raise ItemNotFoundError(str(item)) from e
         if not refs:
             return
         missing = [r for r in refs if r not in self.order]

lionagi/protocols/graph/edge.py

@@ -2,6 +2,7 @@
 # SPDX-License-Identifier: Apache-2.0
 
 from typing import Any
+from uuid import UUID
 
 from pydantic import (
     BaseModel,
@@ -14,7 +15,7 @@ from pydantic import (
 from lionagi.utils import is_same_dtype
 
 from .._concepts import Condition, Relational
-from ..generic.element import ID, Element, IDType
+from ..generic.element import ID, Element
 
 __all__ = (
     "EdgeCondition",
@@ -51,8 +52,8 @@ class Edge(Element):
     metadata, etc., may be stored in `properties`.
     """
 
-    head: IDType
-    tail: IDType
+    head: UUID
+    tail: UUID
     properties: dict[str, Any] = Field(
         default_factory=dict,
         title="Properties",
@@ -106,11 +107,11 @@ class Edge(Element):
         super().__init__(head=head, tail=tail, properties=kwargs)
 
     @field_serializer("head", "tail")
-    def _serialize_id(self, value: IDType) -> str:
+    def _serialize_id(self, value: UUID) -> str:
         return str(value)
 
     @field_validator("head", "tail", mode="before")
-    def _validate_id(cls, value: str) -> IDType:
+    def _validate_id(cls, value: str) -> UUID:
         return ID.get_id(value)
 
     @property