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

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

lionagi/protocols/ids.py

@@ -3,7 +3,7 @@
 
 """ID bridge utilities for V0/V1 compatibility.
 
-This module provides utilities to convert between V0's IDType and V1's
+This module provides utilities to convert between V0's UUID and V1's
 canonical UUID representation, enabling seamless interoperability during
 the gradual evolution process.
 """
@@ -13,7 +13,7 @@ from __future__ import annotations
 from typing import Any
 from uuid import UUID
 
-from .generic.element import Element, IDType
+from .generic.element import ID, Element
 
 __all__ = (
     "to_uuid",
@@ -22,60 +22,17 @@ __all__ = (
 
 
 def to_uuid(value: Any) -> UUID:
-    """Convert ID-like values (IDType | UUID | str | Element) to UUID (v4).
-
-    Optimized version that avoids string conversion when possible by directly
-    accessing IDType's internal UUID. Falls back to V0's IDType.validate()
-    for validation semantics only when necessary.
-
-    Args:
-        value: An ID-like value to convert (IDType, UUID, str, or Element)
-
-    Returns:
-        UUID: A validated UUIDv4
-
-    Raises:
-        IDError: If the value cannot be converted to a valid UUIDv4
-
-    Examples:
-        >>> element = Element()
-        >>> uuid_val = to_uuid(element)
-        >>> isinstance(uuid_val, UUID)
-        True
-        >>> to_uuid("550e8400-e29b-41d4-a716-446655440000")
-        UUID('550e8400-e29b-41d4-a716-446655440000')
-    """
+    """Convert ID-like values (UUID | str | Element) to UUID (v4)."""
     if isinstance(value, Element):
-        return value.id._id
+        return value.id
     if isinstance(value, UUID):
         return value
     if hasattr(value, "_id") and isinstance(value._id, UUID):
         return value._id
-    # Fallback: Validate then access ._id directly (no string conversion)
-    validated_id = IDType.validate(value)
-    return validated_id._id
+    return ID.get_id(value)
 
 
 def canonical_id(obj: Any) -> UUID:
-    """Accept an Observable-like object or raw ID and return canonical UUID.
-
-    Safe to use across V0/V1 without changing class definitions. Prefers
-    attribute access (.id) but falls back to treating the object as a raw ID.
-
-    Args:
-        obj: An Observable object with .id attribute, or a raw ID value
-
-    Returns:
-        UUID: The canonical UUID representation
-
-    Examples:
-        >>> element = Element()
-        >>> uuid_val = canonical_id(element)
-        >>> isinstance(uuid_val, UUID)
-        True
-        >>> canonical_id("550e8400-e29b-41d4-a716-446655440000")
-        UUID('550e8400-e29b-41d4-a716-446655440000')
-    """
-    # Prefer attribute access; fall back to treating obj as a raw id
+    """Accept an Observable-like object or raw ID and return canonical UUID."""
     id_like = getattr(obj, "id", obj)
     return to_uuid(id_like)

lionagi/protocols/messages/__init__.py

@@ -4,7 +4,7 @@
 from .action_request import ActionRequest, ActionRequestContent
 from .action_response import ActionResponse, ActionResponseContent
 from .assistant_response import AssistantResponse, AssistantResponseContent
-from .base import MessageRole
+from .base import MESSAGE_FIELDS, MessageRole, SenderRecipient
 from .instruction import Instruction, InstructionContent
 from .manager import MessageManager
 from .message import MessageContent, MessageRole, RoledMessage
@@ -26,4 +26,6 @@ __all__ = (
     "SystemContent",
     "MessageManager",
     "MessageRole",
+    "SenderRecipient",
+    "MESSAGE_FIELDS",
 )

lionagi/protocols/messages/base.py

@@ -3,8 +3,9 @@
 
 from enum import Enum
 from typing import Any, TypeAlias
+from uuid import UUID
 
-from ..generic.element import ID, Element, IDError, IDType, Observable
+from ..generic.element import ID, Element, Observable
 
 __all__ = (
     "MessageRole",
@@ -27,10 +28,10 @@ class MessageRole(str, Enum):
     ACTION = "action"
 
 
-SenderRecipient: TypeAlias = IDType | MessageRole | str
+SenderRecipient: TypeAlias = MessageRole | str | UUID
 """
 A union type indicating that a sender or recipient could be:
-- A lionagi IDType,
+- A UUID,
 - A string-based role or ID,
 - A specific enum role from `MessageRole`.
 """
@@ -69,7 +70,7 @@ def validate_sender_recipient(value: Any, /) -> SenderRecipient:
     if isinstance(value, MessageRole):
         return value
 
-    if isinstance(value, IDType):
+    if isinstance(value, UUID):
         return value
 
     if isinstance(value, Observable):
@@ -86,7 +87,7 @@ def validate_sender_recipient(value: Any, /) -> SenderRecipient:
         # Try to parse as ID first, but allow plain strings as fallback
         try:
             return ID.get_id(value)
-        except IDError:
+        except Exception:
             return value
 
     raise ValueError("Invalid sender or recipient")
@@ -98,7 +99,7 @@ def serialize_sender_recipient(value: Any) -> str | None:
     # Check instance types first before enum membership
     if isinstance(value, Element):
         return str(value.id)
-    if isinstance(value, IDType):
+    if isinstance(value, UUID):
         return str(value)
     if isinstance(value, MessageRole):
         return value.value

lionagi/protocols/messages/instruction.py

@@ -1,4 +1,3 @@
-import inspect
 from dataclasses import dataclass, field
 from typing import Any, Literal
 

lionagi/protocols/types.py

@@ -5,7 +5,7 @@ from ._concepts import Collective, Communicatable, Condition, Manager
 from ._concepts import Observable as LegacyObservable
 from ._concepts import Observer, Ordering, Relational, Sendable
 from .contracts import Observable, ObservableProto
-from .generic.element import ID, Element, IDError, IDType, validate_order
+from .generic.element import ID, Element, validate_order
 from .generic.event import Event, EventStatus, Execution
 from .generic.log import (
     DataLogger,
@@ -20,8 +20,6 @@ from .generic.progression import Progression, prog
 from .graph.edge import EdgeCondition
 from .graph.graph import Edge, Graph, Node
 from .ids import canonical_id, to_uuid
-from .mail.exchange import Exchange, Mail, Mailbox, Package, PackageCategory
-from .mail.manager import MailManager
 from .messages.base import (
     MESSAGE_FIELDS,
     MessageField,
@@ -55,8 +53,6 @@ __all__ = (
     "to_uuid",  # ID conversion utility
     "ID",
     "Element",
-    "IDError",
-    "IDType",
     "validate_order",
     "Event",
     "EventStatus",
@@ -74,11 +70,6 @@ __all__ = (
     "Edge",
     "Graph",
     "Node",
-    "Exchange",
-    "Mail",
-    "Mailbox",
-    "Package",
-    "PackageCategory",
     "MESSAGE_FIELDS",
     "MessageField",
     "MessageRole",
@@ -91,7 +82,6 @@ __all__ = (
     "RoledMessage",
     "SenderRecipient",
     "System",
-    "MailManager",
     "DataLogger",
     "DataLoggerConfig",
 )

lionagi/service/connections/__init__.py

@@ -1,6 +1,7 @@
 # Copyright (c) 2023-2025, HaiyangLi <quantocean.li at gmail dot com>
 # SPDX-License-Identifier: Apache-2.0
 
+from .api_calling import APICalling
 from .endpoint import Endpoint
 from .endpoint_config import EndpointConfig
 from .header_factory import HeaderFactory
@@ -11,4 +12,6 @@ __all__ = (
     "EndpointConfig",
     "HeaderFactory",
     "match_endpoint",
+    "APICalling",
+    "match_endpoint",
 )

lionagi/service/connections/providers/claude_code_cli.py

@@ -84,8 +84,9 @@ class ClaudeCodeCLIEndpoint(Endpoint):
     async def stream(
         self, request: dict | BaseModel, **kwargs
     ) -> AsyncIterator[ClaudeChunk | dict | ClaudeSession]:
-        payload, _ = self.create_payload(request, **kwargs)["request"]
-        async for chunk in stream_claude_code_cli(payload):
+        payload, _ = self.create_payload(request, **kwargs)
+        request_obj = payload["request"]
+        async for chunk in stream_claude_code_cli(request_obj):
             yield chunk
 
     async def _call(

lionagi/service/hooks/_types.py

@@ -8,7 +8,7 @@ from typing import TypeVar
 
 from typing_extensions import TypedDict
 
-from lionagi.utils import Enum
+from lionagi.ln.types import Enum
 
 SC = TypeVar("SC")  # streaming chunk type
 

lionagi/service/hooks/_utils.py

@@ -6,7 +6,7 @@ from __future__ import annotations
 from anyio import sleep
 
 from lionagi._errors import ValidationError
-from lionagi.utils import is_coro_func
+from lionagi.ln import is_coro_func
 
 from ._types import ALLOWED_HOOKS_TYPES, HookEventTypes
 

lionagi/service/hooks/hook_event.py

@@ -3,7 +3,7 @@
 
 from __future__ import annotations
 
-from typing import TYPE_CHECKING, Any
+from typing import Any
 
 import anyio
 from pydantic import Field, PrivateAttr, field_validator
@@ -12,19 +12,14 @@ from lionagi.ln.concurrency import fail_after, get_cancelled_exc_class
 from lionagi.protocols.types import Event, EventStatus
 
 from ._types import AssosiatedEventInfo, HookEventTypes
-
-if TYPE_CHECKING:
-    from .hook_registry import HookRegistry
-else:
-    # Import at runtime for Pydantic
-    from .hook_registry import HookRegistry
+from .hook_registry import HookRegistry
 
 
 class HookEvent(Event):
     registry: HookRegistry = Field(..., exclude=True)
     hook_type: HookEventTypes
     exit: bool = Field(False, exclude=True)
-    timeout: int = Field(30, exclude=True)
+    timeout: int | float = Field(30, exclude=True)
     params: dict[str, Any] = Field(default_factory=dict, exclude=True)
     event_like: Event | type[Event] = Field(..., exclude=True)
     _should_exit: bool = PrivateAttr(False)

lionagi/service/hooks/hook_registry.py

@@ -6,8 +6,8 @@ from __future__ import annotations
 from typing import Any, TypeVar
 
 from lionagi.ln.concurrency import get_cancelled_exc_class
+from lionagi.ln.types import Undefined
 from lionagi.protocols.types import Event, EventStatus
-from lionagi.utils import UNDEFINED
 
 from ._types import HookDict, HookEventTypes, StreamHandlers
 from ._utils import get_handler, validate_hooks, validate_stream_handlers
@@ -99,7 +99,7 @@ class HookRegistry:
             )
             return (res, False, EventStatus.COMPLETED)
         except get_cancelled_exc_class() as e:
-            return ((UNDEFINED, e), True, EventStatus.CANCELLED)
+            return ((Undefined, e), True, EventStatus.CANCELLED)
         except Exception as e:
             return (e, exit, EventStatus.CANCELLED)
 
@@ -125,7 +125,7 @@ class HookRegistry:
             )
             return (res, False, EventStatus.COMPLETED)
         except get_cancelled_exc_class() as e:
-            return ((UNDEFINED, e), True, EventStatus.CANCELLED)
+            return ((Undefined, e), True, EventStatus.CANCELLED)
         except Exception as e:
             return (e, exit, EventStatus.CANCELLED)
 
@@ -147,7 +147,7 @@ class HookRegistry:
             )
             return (res, False, EventStatus.COMPLETED)
         except get_cancelled_exc_class() as e:
-            return ((UNDEFINED, e), True, EventStatus.CANCELLED)
+            return ((Undefined, e), True, EventStatus.CANCELLED)
         except Exception as e:
             return (e, exit, EventStatus.ABORTED)
 
@@ -171,7 +171,7 @@ class HookRegistry:
             )
             return (res, False, None)
         except get_cancelled_exc_class() as e:
-            return ((UNDEFINED, e), True, EventStatus.CANCELLED)
+            return ((Undefined, e), True, EventStatus.CANCELLED)
         except Exception as e:
             return (e, exit, EventStatus.ABORTED)