lionagi 0.5.5__py3-none-any.whl → 0.6.1__py3-none-any.whl

lionagi/{protocols/operatives/action.py → operatives/action/utils.py}

@@ -3,21 +3,49 @@
 # SPDX-License-Identifier: Apache-2.0
 
 import re
+from typing import Any
 
-from lionagi.core.typing import (
-    Any,
-    BaseModel,
-    Field,
-    FieldModel,
-    field_validator,
+from pydantic import BaseModel
+
+from lionagi.libs.validate.common_field_validators import (
+    validate_boolean_field,
+    validate_nullable_string_field,
+)
+from lionagi.utils import to_dict, to_json, to_list
+
+from ..models.field_model import FieldModel
+
+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."
 )
-from lionagi.libs.parse import to_dict, to_json, validate_boolean
 
-from .prompts import (
-    action_requests_field_description,
-    action_required_field_description,
-    arguments_field_description,
-    function_field_description,
+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."
+)
+
+
+__all__ = (
+    "FUNCTION_FIELD",
+    "ARGUMENTS_FIELD",
+    "ACTION_REQUIRED_FIELD",
+    "parse_action_request",
 )
 
 
@@ -30,12 +58,13 @@ def parse_action_request(content: str | dict) -> list[dict]:
 
     elif isinstance(content, str):
         json_blocks = to_json(content, fuzzy_parse=True)
-        print(json_blocks)
         if not json_blocks:
             pattern2 = r"```python\s*(.*?)\s*```"
             _d = re.findall(pattern2, content, re.DOTALL)
-            json_blocks = [to_dict(match, fuzzy_parse=True) for match in _d]
-            json_blocks = [i for i in json_blocks if i]
+            json_blocks = [to_json(match, fuzzy_parse=True) for match in _d]
+            json_blocks = to_list(json_blocks, dropna=True)
+
+        print(json_blocks)
 
     elif content and isinstance(content, dict):
         json_blocks = [content]
@@ -46,12 +75,11 @@ def parse_action_request(content: str | dict) -> list[dict]:
     out = []
 
     for i in json_blocks:
-        print(i)
         j = {}
         if isinstance(i, dict):
             if "function" in i and isinstance(i["function"], dict):
                 if "name" in i["function"]:
-                    i = i["function"]
+                    i["function"] = i["function"]["name"]
             for k, v in i.items():
                 k = (
                     k.replace("action_", "")
@@ -60,7 +88,7 @@ def parse_action_request(content: str | dict) -> list[dict]:
                 )
                 if k in ["name", "function", "recipient"]:
                     j["function"] = v
-                elif k in ["parameter", "argument", "arg"]:
+                elif k in ["parameter", "argument", "arg", "param"]:
                     j["arguments"] = to_dict(
                         v, str_type="json", fuzzy_parse=True, suppress=True
                     )
@@ -74,20 +102,11 @@ def parse_action_request(content: str | dict) -> list[dict]:
     return out
 
 
-def _validate_function_name(cls, value: Any) -> str | None:
-    if not isinstance(value, str):
-        return None
-    return value
-
-
-def _validate_action_required(cls, value) -> bool:
-    try:
-        return validate_boolean(value)
-    except Exception:
-        return False
+def validate_function_name(cls, value: Any) -> str | None:
+    return validate_nullable_string_field(cls, value, strict=False)
 
 
-def _validate_arguments(cls, value: Any) -> dict:
+def validate_arguments(cls, value: Any) -> dict:
     return to_dict(
         value,
         fuzzy_parse=True,
@@ -103,7 +122,7 @@ FUNCTION_FIELD = FieldModel(
     title="Function",
     description=function_field_description,
     examples=["add", "multiply", "divide"],
-    validator=_validate_function_name,
+    validator=validate_function_name,
 )
 
 ARGUMENTS_FIELD = FieldModel(
@@ -113,7 +132,7 @@ ARGUMENTS_FIELD = FieldModel(
     title="Action Arguments",
     description=arguments_field_description,
     examples=[{"num1": 1, "num2": 2}, {"x": "hello", "y": "world"}],
-    validator=_validate_arguments,
+    validator=validate_arguments,
     validator_kwargs={"mode": "before"},
 )
 
@@ -123,63 +142,6 @@ ACTION_REQUIRED_FIELD = FieldModel(
     default=False,
     title="Action Required",
     description=action_required_field_description,
-    validator=_validate_action_required,
+    validator=lambda cls, v: validate_boolean_field(cls, v, False),
     validator_kwargs={"mode": "before"},
 )
-
-
-class ActionRequestModel(BaseModel):
-
-    function: str | None = FUNCTION_FIELD.field_info
-    arguments: dict[str, Any] | None = ARGUMENTS_FIELD.field_info
-
-    @field_validator("arguments", mode="before")
-    def validate_arguments(cls, value: Any) -> dict[str, Any]:
-        return to_dict(
-            value,
-            fuzzy_parse=True,
-            recursive=True,
-            recursive_python_only=False,
-        )
-
-    @classmethod
-    def create(cls, content: str):
-        try:
-            content = parse_action_request(content)
-            if content:
-                return [cls.model_validate(i) for i in content]
-            return []
-        except Exception:
-            return []
-
-
-class ActionResponseModel(BaseModel):
-
-    function: str = Field(default_factory=str)
-    arguments: dict[str, Any] = Field(default_factory=dict)
-    output: Any = None
-
-
-ACTION_REQUESTS_FIELD = FieldModel(
-    name="action_requests",
-    annotation=list[ActionRequestModel],
-    default_factory=list,
-    title="Actions",
-    description=action_requests_field_description,
-)
-
-
-ACTION_RESPONSES_FIELD = FieldModel(
-    name="action_responses",
-    annotation=list[ActionResponseModel],
-    default_factory=list,
-    title="Actions",
-    description="**do not fill**",
-)
-
-__all__ = [
-    "ActionRequestModel",
-    "ActionResponseModel",
-    "ACTION_REQUESTS_FIELD",
-    "ACTION_RESPONSES_FIELD",
-]

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

@@ -2,13 +2,18 @@
 #
 # SPDX-License-Identifier: Apache-2.0
 
-from pydantic import field_validator
+from typing import Any, Literal
 
-from ..generic.types import Component
-from ..typing import UNDEFINED, Any, Field, Literal, PydanticUndefined
+from pydantic import Field, field_validator
+from pydantic_core import PydanticUndefined
 
+from lionagi.protocols.types import Node
+from lionagi.utils import UNDEFINED
 
-class BaseForm(Component):
+from ..models.operable_model import OperableModel
+
+
+class BaseForm(Node, OperableModel):
     """Base form class providing core functionality for form handling.
 
     This class serves as a foundation for creating custom forms within the

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/{core/models/__init__.py → operatives/manager.py}

@@ -2,4 +2,8 @@
 #
 # SPDX-License-Identifier: Apache-2.0
 
-from .types import *
+
+class OperativeManager:
+
+    def __init__(self):
+        self.registry = {}