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

lionagi/operations/operate/step.py

@@ -0,0 +1,203 @@
+# Copyright (c) 2023-2025, HaiyangLi <quantocean.li at gmail dot com>
+# SPDX-License-Identifier: Apache-2.0
+
+"""Step factory methods for creating configured Operative instances."""
+
+from typing import TYPE_CHECKING, Literal
+
+from lionagi.ln.types import Operable, Spec
+
+from ..fields import get_default_field
+from .operative import Operative
+
+if TYPE_CHECKING:
+    from pydantic import BaseModel
+
+
+class Step:
+    """Factory methods for common Operative patterns.
+
+    Provides methods to create Operative instances with pre-configured
+    field specifications for common patterns like ReAct, QA, and task execution.
+    """
+
+    @staticmethod
+    def request_operative(
+        *,
+        name: str | None = None,
+        operative_name: str | None = None,  # backward compat
+        adapter: Literal["pydantic"] = "pydantic",
+        reason: bool = False,
+        actions: bool = False,
+        fields: dict[str, Spec] | None = None,
+        field_models: list | None = None,  # backward compat
+        max_retries: int = 3,
+        auto_retry_parse: bool = True,
+        base_type: type["BaseModel"] | None = None,
+        # Deprecated/ignored parameters for backward compatibility
+        parse_kwargs: dict | None = None,
+        exclude_fields: list | None = None,
+        field_descriptions: dict | None = None,
+        inherit_base: bool = True,
+        config_dict: dict | None = None,
+        doc: str | None = None,
+        frozen: bool = False,
+        new_model_name: str | None = None,
+        parameter_fields: dict | None = None,
+        request_params: dict | None = None,
+        **kwargs,
+    ) -> Operative:
+        """Create request-configured Operative with common field patterns.
+
+        Args:
+            name: Operative name
+            operative_name: (Deprecated) Use 'name' instead
+            adapter: Validation framework
+            reason: Add reasoning trace field
+            actions: Add action request/response fields
+            fields: Additional custom field specs (dict[str, Spec])
+            field_models: (Deprecated) Use 'fields' instead - list of FieldModel/Spec
+            max_retries: Max validation retries
+            auto_retry_parse: Auto-retry on parse failure
+            base_type: Base Pydantic model to extend
+            parse_kwargs: (Deprecated) Ignored - parse config handled internally
+            exclude_fields: (Deprecated) Ignored
+            field_descriptions: (Deprecated) Ignored
+            inherit_base: (Deprecated) Ignored
+            config_dict: (Deprecated) Ignored
+            doc: (Deprecated) Ignored
+            frozen: (Deprecated) Ignored
+            new_model_name: (Deprecated) Ignored
+            parameter_fields: (Deprecated) Ignored
+            request_params: (Deprecated) Ignored
+
+        Returns:
+            Configured Operative instance
+        """
+        # Handle backward compatibility
+        name = name or operative_name
+
+        # Convert field_models list to fields dict if provided
+        if field_models and not fields:
+            from lionagi.models import FieldModel
+
+            fields = {}
+            for fm in field_models:
+                # Convert FieldModel to Spec if needed
+                if isinstance(fm, FieldModel):
+                    spec = fm.to_spec()
+                elif isinstance(fm, Spec):
+                    spec = fm
+                else:
+                    continue  # Skip invalid types
+
+                # Use spec name as key
+                if spec.name:
+                    fields[spec.name] = spec
+
+        # Build fields dict to avoid duplicates (dict preserves insertion order in Python 3.7+)
+        fields_dict = {}
+
+        # Add common fields (convert FieldModel to Spec)
+        if reason:
+            reason_spec = get_default_field("reason").to_spec()
+            fields_dict["reason"] = reason_spec
+
+        if actions:
+            fields_dict["action_required"] = get_default_field(
+                "action_required"
+            ).to_spec()
+            fields_dict["action_requests"] = get_default_field(
+                "action_requests"
+            ).to_spec()
+            fields_dict["action_responses"] = get_default_field(
+                "action_responses"
+            ).to_spec()
+
+        # Add custom fields (will override defaults if same name)
+        if fields:
+            for field_name, spec in fields.items():
+                # Ensure spec has name
+                if not spec.name:
+                    # Update spec with name using Spec metadata update
+                    spec = Spec(
+                        spec.base_type,
+                        name=field_name,
+                        metadata=spec.metadata,
+                    )
+                fields_dict[spec.name] = spec
+
+        # Convert to list
+        all_fields = list(fields_dict.values())
+
+        # Create Operable with all fields
+        operable = Operable(
+            tuple(all_fields),
+            name=name or (base_type.__name__ if base_type else "Operative"),
+        )
+
+        # Request excludes action_responses
+        request_exclude = {"action_responses"} if actions else set()
+
+        return Operative(
+            name=name,
+            adapter=adapter,
+            max_retries=max_retries,
+            auto_retry_parse=auto_retry_parse,
+            base_type=base_type,
+            operable=operable,
+            request_exclude=request_exclude,
+        )
+
+    @staticmethod
+    def respond_operative(
+        operative: Operative,
+        additional_fields: dict[str, Spec] | None = None,
+    ) -> Operative:
+        """Create response type from operative.
+
+        Args:
+            operative: Source operative with all fields
+            additional_fields: Extra fields for response
+
+        Returns:
+            Operative with response type configured
+        """
+        # If additional fields provided, create new Operative
+        if additional_fields:
+            # Get existing fields
+            existing_fields = list(operative.operable.__op_fields__)
+
+            # Add new fields
+            for field_name, spec in additional_fields.items():
+                if not spec.name:
+                    spec = Spec(
+                        spec.base_type,
+                        name=field_name,
+                        metadata=spec.metadata,
+                    )
+                existing_fields.append(spec)
+
+            # Create new Operable
+            new_operable = Operable(
+                tuple(existing_fields),
+                name=operative.name,
+            )
+
+            # Create new Operative
+            return Operative(
+                name=operative.name,
+                adapter=operative.adapter,
+                max_retries=operative.max_retries,
+                auto_retry_parse=operative.auto_retry_parse,
+                base_type=operative.base_type,
+                operable=new_operable,
+                request_exclude=operative.request_exclude,
+            )
+
+        # Otherwise just create response model
+        operative.create_response_model()
+        return operative
+
+
+__all__ = ("Step",)

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,9 +7,9 @@ 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.ln.types import ModelConfig, Params
 from lionagi.protocols.action.tool import ToolRef
 from lionagi.protocols.types import ID, SenderRecipient
 from lionagi.service.imodel import iModel
@@ -43,7 +43,7 @@ class MorphParam(Params):
     transformations between message states with well-defined parameters.
     """
 
-    _none_as_sentinel: ClassVar[bool] = True
+    _config: ClassVar[ModelConfig] = ModelConfig(none_as_sentinel=True)
 
 
 @dataclass(slots=True, frozen=True, init=False)
@@ -57,7 +57,7 @@ class ChatParam(MorphParam):
     This gets mapped to InstructionContent.prompt_context during message creation.
     """
 
-    _none_as_sentinel: ClassVar[bool] = True
+    _config: ClassVar[ModelConfig] = ModelConfig(none_as_sentinel=True)
     guidance: JsonValue = None
     context: JsonValue = None
     sender: SenderRecipient = None
@@ -81,7 +81,7 @@ class InterpretParam(MorphParam):
     transforming content according to specified guidelines.
     """
 
-    _none_as_sentinel: ClassVar[bool] = True
+    _config: ClassVar[ModelConfig] = ModelConfig(none_as_sentinel=True)
     domain: str = None
     style: str = None
     sample_writing: str = None
@@ -97,7 +97,7 @@ class ParseParam(MorphParam):
     fuzzy matching, and error handling strategies.
     """
 
-    _none_as_sentinel: ClassVar[bool] = True
+    _config: ClassVar[ModelConfig] = ModelConfig(none_as_sentinel=True)
     response_format: type[BaseModel] | dict = None
     fuzzy_match_params: FuzzyMatchKeysParams | dict = None
     handle_validation: HandleValidation = "raise"
@@ -114,7 +114,7 @@ class ActionParam(MorphParam):
     for action-based operations.
     """
 
-    _none_as_sentinel: ClassVar[bool] = True
+    _config: ClassVar[ModelConfig] = ModelConfig(none_as_sentinel=True)
     action_call_params: AlcallParams = None
     tools: ToolRef = None
     strategy: Literal["concurrent", "sequential"] = "concurrent"

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