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

lionagi/operations/flow.py

@@ -10,8 +10,9 @@ using Events for synchronization and CapacityLimiter for concurrency control.
 
 import os
 from typing import TYPE_CHECKING, Any
+from uuid import UUID
 
-from lionagi.ln._async_call import AlcallParams
+from lionagi.ln import AlcallParams
 from lionagi.ln.concurrency import CapacityLimiter, ConcurrencyEvent
 from lionagi.operations.node import Operation
 from lionagi.protocols.types import EventStatus
@@ -164,13 +165,11 @@ class DependencyAwareExecutor:
                 # Add to session branches collection directly
                 # Check if this is a real branch (not a mock)
                 try:
-                    from lionagi.protocols.types import IDType
-
                     # Try to validate the ID
                     if hasattr(branch_clone, "id"):
                         branch_id = branch_clone.id
                         # Only add to collections if it's a valid ID
-                        if isinstance(branch_id, (str, IDType)) or (
+                        if isinstance(branch_id, (str, UUID)) or (
                             hasattr(branch_id, "__str__")
                             and not hasattr(branch_id, "_mock_name")
                         ):
@@ -334,7 +333,7 @@ class DependencyAwareExecutor:
 
             # Wait for ALL sources (sources are now strings from builder.py)
             for source_id_str in sources:
-                # Convert string back to IDType for lookup
+                # Convert string back to UUID for lookup
                 # Check all operations to find matching ID
                 for op_id in self.completion_events.keys():
                     if str(op_id) == source_id_str:
@@ -367,7 +366,6 @@ class DependencyAwareExecutor:
                         result, (str, int, float, bool)
                     ):
                         result = to_dict(result, recursive=True)
-                    # Use string representation of IDType for JSON serialization
                     pred_context[f"{str(pred.id)}_result"] = result
 
             if "context" not in operation.parameters:

lionagi/operations/node.py

@@ -6,7 +6,7 @@ from uuid import UUID
 from anyio import get_cancelled_exc_class
 from pydantic import BaseModel, Field
 
-from lionagi.protocols.types import ID, Event, EventStatus, IDType, Node
+from lionagi.protocols.types import ID, Event, EventStatus, Node
 
 if TYPE_CHECKING:
     from lionagi.session.branch import Branch
@@ -37,12 +37,12 @@ class Operation(Node, Event):
     )
 
     @property
-    def branch_id(self) -> IDType | None:
+    def branch_id(self) -> UUID | None:
         if a := self.metadata.get("branch_id"):
             return ID.get_id(a)
 
     @branch_id.setter
-    def branch_id(self, value: str | UUID | IDType | None):
+    def branch_id(self, value: str | UUID | None):
         if value is None:
             self.metadata.pop("branch_id", None)
         else:
@@ -54,7 +54,7 @@ class Operation(Node, Event):
             return ID.get_id(a)
 
     @graph_id.setter
-    def graph_id(self, value: str | UUID | IDType | None):
+    def graph_id(self, value: str | UUID | None):
         if value is None:
             self.metadata.pop("graph_id", None)
         else:

lionagi/operations/operate/operate.py

@@ -6,19 +6,21 @@ from typing import TYPE_CHECKING, Literal
 
 from pydantic import BaseModel, JsonValue
 
-from lionagi.fields.instruct import Instruct
+from lionagi.ln import AlcallParams
 from lionagi.ln.fuzzy import FuzzyMatchKeysParams
 from lionagi.models import FieldModel, ModelParams
-from lionagi.protocols.types import Instruction, Progression, SenderRecipient
-from lionagi.session.branch import AlcallParams
+from lionagi.protocols.generic import Progression
+from lionagi.protocols.messages import Instruction, SenderRecipient
 
+from ..fields import Instruct
 from ..types import ActionParam, ChatParam, HandleValidation, ParseParam
 
 if TYPE_CHECKING:
-    from lionagi.protocols.operatives.step import Operative
     from lionagi.service.imodel import iModel
     from lionagi.session.branch import Branch, ToolRef
 
+    from .operative import Operative
+
 
 def prepare_operate_kw(
     branch: "Branch",
@@ -105,7 +107,7 @@ def prepare_operate_kw(
             instruct.action_strategy = action_strategy
 
     # Build the Operative - always create it for backwards compatibility
-    from lionagi.protocols.operatives.step import Step
+    from .step import Step
 
     operative = Step.request_operative(
         request_params=request_params,
@@ -229,7 +231,7 @@ async def operate(
     operative = None
 
     if model_class:
-        from lionagi.protocols.operatives.step import Step
+        from .step import Step
 
         operative = Step.request_operative(
             reason=reason,
@@ -306,7 +308,7 @@ async def operate(
         result.update({"action_responses": action_response_models})
         return result
 
-    from lionagi.protocols.operatives.step import Step
+    from .step import Step
 
     operative.response_model = result
     operative = Step.respond_operative(

lionagi/{protocols/operatives → operations/operate}/operative.py

@@ -6,10 +6,9 @@ from typing import Any
 from pydantic import BaseModel
 from pydantic.fields import FieldInfo
 
-from lionagi.ln import extract_json
-from lionagi.ln.fuzzy._fuzzy_match import fuzzy_match_keys
+from lionagi.ln import extract_json, fuzzy_match_keys
+from lionagi.ln.types import Undefined
 from lionagi.models import FieldModel, ModelParams, OperableModel
-from lionagi.utils import UNDEFINED
 
 
 class Operative:
@@ -169,7 +168,7 @@ class Operative:
             d_ = fuzzy_match_keys(
                 d_, self.request_type.model_fields, handle_unmatched="raise"
             )
-            d_ = {k: v for k, v in d_.items() if v != UNDEFINED}
+            d_ = {k: v for k, v in d_.items() if v != Undefined}
             self.response_model = self.request_type.model_validate(d_)
             self._should_retry = False
         except Exception:
@@ -190,7 +189,7 @@ class Operative:
             d_ = fuzzy_match_keys(
                 d_, self.request_type.model_fields, handle_unmatched="force"
             )
-            d_ = {k: v for k, v in d_.items() if v != UNDEFINED}
+            d_ = {k: v for k, v in d_.items() if v != Undefined}
             self.response_model = self.request_type.model_validate(d_)
             self._should_retry = False
         except Exception:

lionagi/{protocols/operatives → operations/operate}/step.py

@@ -4,14 +4,10 @@
 from pydantic import BaseModel
 from pydantic.fields import FieldInfo
 
-from lionagi.fields.action import (
-    ACTION_REQUESTS_FIELD,
-    ACTION_REQUIRED_FIELD,
-    ACTION_RESPONSES_FIELD,
-)
-from lionagi.fields.reason import REASON_FIELD
 from lionagi.models import FieldModel, ModelParams
-from lionagi.protocols.operatives.operative import Operative
+
+from ..fields import get_default_field
+from .operative import Operative
 
 
 class Step:
@@ -71,18 +67,17 @@ class Step:
         field_models = field_models or []
         exclude_fields = exclude_fields or []
         field_descriptions = field_descriptions or {}
-        if reason and REASON_FIELD not in field_models:
-            field_models.append(REASON_FIELD)
-        if actions and ACTION_REQUESTS_FIELD not in field_models:
-            field_models.extend(
-                [
-                    ACTION_REQUESTS_FIELD,
-                    ACTION_REQUIRED_FIELD,
-                ]
-            )
-
+        if reason and (fm := get_default_field("reason")) not in field_models:
+            field_models.append(fm)
+        if (
+            actions
+            and (fm := get_default_field("action_requests"))
+            not in field_models
+        ):
+            fm2 = get_default_field("action_required")
+            field_models.extend([fm, fm2])
         if isinstance(request_params, ModelParams):
-            request_params = request_params.model_dump()
+            request_params = request_params.to_dict()
 
         request_params = request_params or {}
         request_params_fields = {
@@ -143,15 +138,17 @@ class Step:
         additional_data = additional_data or {}
         field_models = field_models or []
         if hasattr(operative.response_model, "action_required"):
-            field_models.extend(
-                [
-                    ACTION_RESPONSES_FIELD,
-                    ACTION_REQUIRED_FIELD,
-                    ACTION_REQUESTS_FIELD,
-                ]
-            )
+            for i in {
+                "action_requests",
+                "action_required",
+                "action_responses",
+            }:
+                fm = get_default_field(i)
+                if fm not in field_models:
+                    field_models.append(fm)
+
         if "reason" in type(operative.response_model).model_fields:
-            field_models.extend([REASON_FIELD])
+            field_models.append(get_default_field("reason"))
 
         operative = Step._create_response_type(
             operative=operative,
@@ -201,24 +198,22 @@ class Step:
             hasattr(operative.request_type, "action_required")
             and operative.response_model.action_required
         ):
-            field_models.extend(
-                [
-                    ACTION_RESPONSES_FIELD,
-                    ACTION_REQUIRED_FIELD,
-                    ACTION_REQUESTS_FIELD,
-                ]
-            )
-        if hasattr(operative.request_type, "reason"):
-            field_models.extend([REASON_FIELD])
+            for i in {
+                "action_requests",
+                "action_required",
+                "action_responses",
+            }:
+                fm = get_default_field(i)
+                if fm not in field_models:
+                    field_models.append(fm)
 
-        exclude_fields = exclude_fields or []
-        # Note: We no longer have access to request_params.exclude_fields
-        # since Operative doesn't store ModelParams anymore
+        if hasattr(operative.request_type, "reason"):
+            field_models.append(get_default_field("reason"))
 
         operative.create_response_type(
             response_params=response_params,
             field_models=field_models,
-            exclude_fields=exclude_fields,
+            exclude_fields=exclude_fields or [],
             doc=response_doc,
             config_dict=response_config_dict,
             frozen=frozen_response,

lionagi/operations/select/select.py

@@ -6,7 +6,7 @@ from typing import TYPE_CHECKING, Any
 
 from pydantic import BaseModel
 
-from lionagi.fields.instruct import Instruct
+from lionagi.fields import Instruct
 
 from .utils import SelectionModel, parse_selection, parse_to_representation
 

lionagi/operations/select/utils.py

@@ -68,11 +68,17 @@ def get_choice_representation(choice: Any) -> str:
         return choice
 
     if isinstance(choice, BaseModel):
-        return f"{choice.__class__.__name__}:\n{choice.model_json_schema(indent=2)}"
+        import json
+
+        schema = choice.model_json_schema()
+        return f"{choice.__class__.__name__}:\n{json.dumps(schema, indent=2)}"
 
     if isinstance(choice, Enum):
         return get_choice_representation(choice.value)
 
+    # Handle other types (int, dict, etc.) by converting to string
+    return str(choice)
+
 
 def parse_selection(selection_str: str, choices: Any):
     select_from = []

lionagi/operations/types.py

@@ -7,7 +7,7 @@ from typing import ClassVar, Literal
 
 from pydantic import BaseModel, JsonValue
 
-from lionagi.ln._async_call import AlcallParams
+from lionagi.ln import AlcallParams
 from lionagi.ln.fuzzy import FuzzyMatchKeysParams
 from lionagi.ln.types import Params
 from lionagi.protocols.action.tool import ToolRef

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