lionagi 0.5.4__py3-none-any.whl → 0.6.0__py3-none-any.whl

lionagi/{core → operatives}/forms/form.py

@@ -3,21 +3,16 @@
 # SPDX-License-Identifier: Apache-2.0
 
 import inspect
+from typing import Any, Literal, TypeVar
 
-from lionagi.core.typing import (
-    UNDEFINED,
-    Any,
-    Field,
-    FieldInfo,
-    Literal,
-    Note,
-    PydanticUndefined,
-    TypeVar,
-    model_validator,
-    override,
-)
-from lionagi.libs.utils import copy
+from pydantic import Field, model_validator
+from pydantic.fields import FieldInfo
+from pydantic_core import PydanticUndefined
+from typing_extensions import override
 
+from lionagi.utils import UNDEFINED, copy
+
+from ..models.note import Note
 from .base import BaseForm
 from .utils import get_input_output_fields
 

lionagi/{core → operatives}/forms/report.py

@@ -2,8 +2,10 @@
 #
 # SPDX-License-Identifier: Apache-2.0
 
-from lionagi.core.generic.types import Pile
-from lionagi.core.typing import UNDEFINED, Field
+from pydantic import Field
+
+from lionagi.protocols.generic.pile import Pile
+from lionagi.utils import UNDEFINED
 
 from .base import BaseForm
 from .form import Form
@@ -221,7 +223,7 @@ class Report(BaseForm):
                 )
 
         self.completed_tasks.include(form)
-        self.completed_task_assignments[form.ln_id] = form.assignment
+        self.completed_task_assignments[form.id] = form.assignment
 
         if update_results:
             for i in form.request_fields:

lionagi/operatives/instruct/base.py

@@ -0,0 +1,79 @@
+# Copyright (c) 2023 - 2024, HaiyangLi <quantocean.li at gmail dot com>
+#
+# SPDX-License-Identifier: Apache-2.0
+
+from pydantic import JsonValue
+
+from lionagi.libs.validate.common_field_validators import (
+    validate_boolean_field,
+    validate_nullable_jsonvalue_field,
+)
+
+from ..models.field_model import FieldModel
+from .prompts import (
+    actions_field_description,
+    context_field_description,
+    guidance_field_description,
+    instruction_field_description,
+    reason_field_description,
+)
+
+__all__ = (
+    "INSTRUCTION_FIELD",
+    "GUIDANCE_FIELD",
+    "CONTEXT_FIELD",
+    "REASON_FIELD",
+    "ACTIONS_FIELD",
+)
+
+
+# Field Models
+INSTRUCTION_FIELD = FieldModel(
+    name="instruction",
+    annotation=JsonValue | None,
+    default=None,
+    title="Primary Instruction",
+    description=instruction_field_description,
+    validator=validate_nullable_jsonvalue_field,
+    validator_kwargs={"mode": "before"},
+)
+
+GUIDANCE_FIELD = FieldModel(
+    name="guidance",
+    annotation=JsonValue | None,
+    default=None,
+    title="Execution Guidance",
+    description=guidance_field_description,
+)
+
+CONTEXT_FIELD = FieldModel(
+    name="context",
+    annotation=JsonValue | None,
+    default=None,
+    title="Task Context",
+    description=context_field_description,
+)
+
+REASON_FIELD = FieldModel(
+    name="reason",
+    annotation=bool,
+    default=False,
+    title="Include Reasoning",
+    description=reason_field_description,
+    validator=lambda cls, value: validate_boolean_field(
+        cls, value, default=False
+    ),
+    validator_kwargs={"mode": "before"},
+)
+
+ACTIONS_FIELD = FieldModel(
+    name="actions",
+    annotation=bool,
+    default=False,
+    title="Require Actions",
+    description=actions_field_description,
+    validator=lambda cls, value: validate_boolean_field(
+        cls, value, default=False
+    ),
+    validator_kwargs={"mode": "before"},
+)

lionagi/operatives/instruct/instruct.py

@@ -0,0 +1,105 @@
+# Copyright (c) 2023 - 2024, HaiyangLi <quantocean.li at gmail dot com>
+#
+# SPDX-License-Identifier: Apache-2.0
+
+from typing import Any, ClassVar
+
+from pydantic import JsonValue, field_validator
+
+from lionagi.utils import HashableModel
+
+from ..models.field_model import FieldModel
+from .base import (
+    ACTIONS_FIELD,
+    CONTEXT_FIELD,
+    GUIDANCE_FIELD,
+    INSTRUCTION_FIELD,
+    REASON_FIELD,
+)
+
+__all__ = (
+    "Instruct",
+    "InstructResponse",
+    "INSTRUCT_FIELD",
+    "LIST_INSTRUCT_FIELD_MODEL",
+)
+
+
+class Instruct(HashableModel):
+    """Model for defining instruction parameters and execution requirements.
+
+    Attributes:
+        instruction (JsonValue | None): The primary instruction.
+        guidance (JsonValue | None): Execution guidance.
+        context (JsonValue | None): Task context.
+    """
+
+    reserved_kwargs: ClassVar[list[str]] = [
+        "operative_model",
+        "field_models",
+        "operative",
+        "reason",
+        "actions",
+        "request_params",
+        "response_params",
+    ]
+    instruction: JsonValue | None = INSTRUCTION_FIELD.field_info
+    guidance: JsonValue | None = GUIDANCE_FIELD.field_info
+    context: JsonValue | None = CONTEXT_FIELD.field_info
+    reason: bool = REASON_FIELD.field_info
+    actions: bool = ACTIONS_FIELD.field_info
+
+    @field_validator("instruction", **INSTRUCTION_FIELD.validator_kwargs)
+    def _validate_instruction(cls, v):
+        """Field validator for the 'instruction' field.
+
+        Args:
+            v: The value to validate.
+
+        Returns:
+            JsonValue | None: The validated instruction value.
+        """
+        return INSTRUCTION_FIELD.validator(cls, v)
+
+    @field_validator("reason", **REASON_FIELD.validator_kwargs)
+    def _validate_reason(cls, v):
+        """Field validator for the 'reason' field.
+
+        Args:
+            v: The value to validate.
+
+        Returns:
+            bool | None: The validated boolean value.
+        """
+        return REASON_FIELD.validator(cls, v)
+
+    @field_validator("actions", **ACTIONS_FIELD.validator_kwargs)
+    def _validate_actions(cls, v):
+        """Field validator for the 'actions' field.
+
+        Args:
+            v: The value to validate.
+
+        Returns:
+            bool | None: The validated boolean value.
+        """
+        return ACTIONS_FIELD.validator(cls, v)
+
+
+INSTRUCT_FIELD = FieldModel(
+    name="instruct_model",
+    annotation=Instruct | None,
+    default=None,
+)
+
+
+class InstructResponse(HashableModel):
+    instruct: Instruct
+    response: Any | None = None
+
+
+LIST_INSTRUCT_FIELD_MODEL = FieldModel(
+    name="instruct_models",
+    annotation=list[Instruct] | None,
+    default=None,
+)

lionagi/operatives/instruct/instruct_collection.py

@@ -0,0 +1,52 @@
+# Copyright (c) 2023 - 2024, HaiyangLi <quantocean.li at gmail dot com>
+#
+# SPDX-License-Identifier: Apache-2.0
+
+from functools import lru_cache
+
+from pydantic import BaseModel
+
+from ..models.model_params import ModelParams
+from .instruct import INSTRUCT_FIELD, Instruct
+from .node import InstructNode
+
+__all__ = ("InstructCollection",)
+
+
+class InstructCollection(BaseModel):
+
+    @property
+    def instruct_models(self) -> list[Instruct]:
+        fields = []
+        for field in self.model_fields:
+            if field.startswith("instruct_"):
+                fields.append(field)
+        return [getattr(self, field) for field in fields]
+
+    @classmethod
+    def create_model_params(
+        cls, num_instructs: int = 3, **kwargs
+    ) -> ModelParams:
+        return create_instruct_collection_model_params(
+            cls, num_instructs, **kwargs
+        )
+
+    def to_instruct_nodes(self) -> list[InstructNode]:
+        return [
+            InstructNode(instruct=instruct)
+            for instruct in self.instruct_models
+        ]
+
+
+@lru_cache
+def create_instruct_collection_model_params(
+    base_type: type[BaseModel], num_instructs: int = 3, **kwargs
+) -> ModelParams:
+    model_params = ModelParams(**kwargs)
+    for i in range(num_instructs):
+        field = INSTRUCT_FIELD.model_copy()
+        field.name = f"instruct_{i}"
+        model_params.field_models.append(field)
+
+    model_params.base_type = base_type
+    return model_params

lionagi/operatives/instruct/node.py

@@ -0,0 +1,13 @@
+# Copyright (c) 2023 - 2024, HaiyangLi <quantocean.li at gmail dot com>
+#
+# SPDX-License-Identifier: Apache-2.0
+
+from lionagi.protocols.types import Node
+
+from .instruct import INSTRUCT_FIELD, Instruct
+
+__all__ = ("InstructNode",)
+
+
+class InstructNode(Node):
+    instruct: Instruct | None = INSTRUCT_FIELD.field_info

lionagi/{protocols/operatives → operatives/instruct}/prompts.py

@@ -2,40 +2,6 @@
 #
 # SPDX-License-Identifier: Apache-2.0
 
-function_field_description = (
-    "Name of the function to call from the provided `tool_schemas`. "
-    "If no `tool_schemas` exist, set to None or leave blank. "
-    "Never invent new function names outside what's given."
-)
-
-arguments_field_description = (
-    "Dictionary of arguments for the chosen function. "
-    "Use only argument names/types defined in `tool_schemas`. "
-    "Never introduce extra argument names."
-)
-
-action_required_field_description = (
-    "Whether this step strictly requires performing actions. "
-    "If true, the requests in `action_requests` must be fulfilled, "
-    "assuming `tool_schemas` are available. "
-    "If false or no `tool_schemas` exist, actions are optional."
-)
-
-action_requests_field_description = (
-    "List of actions to be executed when `action_required` is true. "
-    "Each action must align with the available `tool_schemas`. "
-    "Leave empty if no actions are needed."
-)
-
-confidence_description = (
-    "Numeric confidence score (0.0 to 1.0, up to three decimals) indicating "
-    "how well you've met user expectations. Use this guide:\n"
-    "  • 1.0: Highly confident\n"
-    "  • 0.8-1.0: Reasonably sure\n"
-    "  • 0.5-0.8: Re-check or refine\n"
-    "  • 0.0-0.5: Off track"
-)
-
 instruction_field_description = (
     "A clear, actionable task definition. Specify:\n"
     "1) The primary goal or objective\n"

lionagi/{protocols/operatives → operatives/instruct}/reason.py

@@ -4,10 +4,9 @@
 
 from pydantic import BaseModel, field_validator
 
-from lionagi.core.models import FieldModel
-from lionagi.libs.parse import to_num
+from lionagi.utils import to_num
 
-from .prompts import confidence_description
+from ..models.field_model import FieldModel
 
 
 def validate_confidence_score(cls, value) -> float:
@@ -23,6 +22,15 @@ def validate_confidence_score(cls, value) -> float:
         return -1
 
 
+confidence_description = (
+    "Numeric confidence score (0.0 to 1.0, up to three decimals) indicating "
+    "how well you've met user expectations. Use this guide:\n"
+    "  • 1.0: Highly confident\n"
+    "  • 0.8-1.0: Reasonably sure\n"
+    "  • 0.5-0.8: Re-check or refine\n"
+    "  • 0.0-0.5: Off track"
+)
+
 CONFIDENCE_SCORE_FIELD = FieldModel(
     name="confidence_score",
     annotation=float | None,
@@ -35,7 +43,7 @@ CONFIDENCE_SCORE_FIELD = FieldModel(
 )
 
 
-class ReasonModel(BaseModel):
+class Reason(BaseModel):
 
     title: str | None = None
     content: str | None = None
@@ -50,11 +58,10 @@ class ReasonModel(BaseModel):
 
 REASON_FIELD = FieldModel(
     name="reason",
-    annotation=ReasonModel | None,
-    default=None,
+    annotation=Reason | None,
     title="Reason",
     description="**Provide a concise reason for the decision made.**",
 )
 
 
-__all__ = ["ReasonModel"]
+__all__ = ["Reason"]

lionagi/{integrations/anthropic_/version.py → operatives/manager.py}

@@ -2,4 +2,8 @@
 #
 # SPDX-License-Identifier: Apache-2.0
 
-__version__ = "1.0.0"
+
+class OperativeManager:
+
+    def __init__(self):
+        self.registry = {}

lionagi/operatives/models/field_model.py

@@ -0,0 +1,194 @@
+# Copyright (c) 2023 - 2024, HaiyangLi <quantocean.li at gmail dot com>
+#
+# SPDX-License-Identifier: Apache-2.0
+
+from collections.abc import Callable
+from typing import Any, Self
+
+from pydantic import ConfigDict, Field, field_validator, model_validator
+from pydantic.fields import FieldInfo
+
+from lionagi.libs.validate.common_field_validators import (
+    validate_callable,
+    validate_dict_kwargs_params,
+)
+from lionagi.utils import UNDEFINED, UndefinedType
+
+from .schema_model import SchemaModel
+
+__all__ = ("FieldModel",)
+
+
+class FieldModel(SchemaModel):
+    """Model for defining and configuring Pydantic field attributes.
+
+    This class provides a structured way to define fields with comprehensive
+    configuration options including type validation, default values, documentation,
+    and validation rules.
+
+    Attributes:
+        name (str): Required field identifier.
+        annotation (type | Any): Field type annotation, defaults to Any.
+        default (Any): Default value for the field.
+        default_factory (Callable): Function to generate default values.
+        validator (Callable): Optional validation function.
+        validator_kwargs (dict): Parameters for validator configuration.
+        title (str): Human-readable field title.
+        description (str): Detailed field description.
+        examples (list): Example values for documentation.
+        exclude (bool): Whether to exclude from serialization.
+        deprecated (bool): Whether the field is deprecated.
+        frozen (bool): Whether the field is immutable.
+        alias (str): Alternative field name.
+        alias_priority (int): Priority for alias resolution.
+
+    Example:
+        >>> field = FieldModel(
+        ...     name="age",
+        ...     annotation=int,
+        ...     default=0,
+        ...     description="User age in years",
+        ...     validator=lambda cls, v: v if v >= 0 else 0
+        ... )
+    """
+
+    model_config = ConfigDict(
+        extra="allow",
+        validate_default=False,
+        populate_by_name=True,
+        arbitrary_types_allowed=True,
+        use_enum_values=True,
+    )
+
+    # Required core attributes
+    name: str | UndefinedType = Field(
+        ...,
+        description="Field identifier, used as attribute name",
+        exclude=True,
+    )
+
+    annotation: type | Any = Field(
+        default=UNDEFINED,
+        description="Type annotation for the field",
+        exclude=True,
+    )
+
+    validator: Callable | Any = Field(
+        default=UNDEFINED,
+        description="Optional validation function",
+        exclude=True,
+    )
+
+    validator_kwargs: dict | None = Field(
+        default_factory=dict,
+        description="Configuration for validator decorator",
+        exclude=True,
+    )
+
+    # Field configuration
+    default: Any = Field(
+        default=UNDEFINED, description="Default value for the field"
+    )
+
+    default_factory: Callable | UndefinedType = Field(
+        default=UNDEFINED, description="Function to generate default values"
+    )
+
+    title: str | UndefinedType = Field(
+        default=UNDEFINED, description="Human-readable field title"
+    )
+
+    description: str | UndefinedType = Field(
+        default=UNDEFINED, description="Detailed field description"
+    )
+
+    examples: list | UndefinedType = Field(
+        default=UNDEFINED, description="Example values for documentation"
+    )
+
+    exclude: bool | UndefinedType = Field(
+        default=UNDEFINED, description="Whether to exclude from serialization"
+    )
+
+    deprecated: bool | UndefinedType = Field(
+        default=UNDEFINED, description="Whether the field is deprecated"
+    )
+
+    frozen: bool | UndefinedType = Field(
+        default=UNDEFINED, description="Whether the field is immutable"
+    )
+
+    alias: str | UndefinedType = Field(
+        default=UNDEFINED, description="Alternative field name"
+    )
+
+    alias_priority: int | UndefinedType = Field(
+        default=UNDEFINED, description="Priority for alias resolution"
+    )
+
+    @field_validator("validator_kwargs", mode="before")
+    def _validate_validator_kwargs(cls, value):
+        """Validate validator kwargs."""
+        return validate_dict_kwargs_params(cls, value)
+
+    @field_validator("validator", mode="before")
+    def _validate_field_validator(cls, value) -> Callable | Any:
+        """Validate field validator function.
+
+        Args:
+            value: Validator function to check.
+
+        Returns:
+            Callable | Any: Validated validator function.
+
+        Raises:
+            ValueError: If validator is not callable.
+        """
+        return validate_callable(cls, value)
+
+    @property
+    def field_info(self) -> FieldInfo:
+        """Generate Pydantic FieldInfo from current configuration.
+
+        Returns:
+            FieldInfo: Configured field information object.
+        """
+        annotation = (
+            self.annotation if self.annotation is not UNDEFINED else Any
+        )
+        field_obj = Field(**self.to_dict())  # type: ignore
+        field_obj.annotation = annotation
+        return field_obj
+
+    @property
+    def field_validator(self) -> dict[str, Callable] | None:
+        """Create field validator configuration.
+
+        Returns:
+            dict[str, Callable] | None: Validator configuration if defined.
+        """
+        if self.validator is UNDEFINED:
+            return None
+        kwargs = self.validator_kwargs or {}
+        return {
+            f"{self.name}_validator": field_validator(self.name, **kwargs)(
+                self.validator
+            )
+        }
+
+    @model_validator(mode="after")
+    def _validate_defaults(self) -> Self:
+        """Ensure default value configuration is valid.
+
+        Returns:
+            Self: Validated instance.
+
+        Raises:
+            ValueError: If both default and default_factory are set.
+        """
+        if (
+            self.default is not UNDEFINED
+            and self.default_factory is not UNDEFINED
+        ):
+            raise ValueError("Cannot have both default and default_factory")
+        return self