lionagi 0.9.19__py3-none-any.whl → 0.10.0__py3-none-any.whl

lionagi/__init__.py

@@ -7,14 +7,10 @@ import logging
 from pydantic import BaseModel, Field
 
 from . import _types as types
-from .operations import types as op
-from .operatives import types as ops_types  # deprecated
 from .service.imodel import iModel
 from .session.session import Branch, Session
 from .version import __version__
 
-LiteiModel = iModel
-
 logger = logging.getLogger(__name__)
 logger.setLevel(logging.INFO)
 
@@ -22,10 +18,7 @@ __all__ = (
     "Session",
     "Branch",
     "iModel",
-    "LiteiModel",
     "types",
-    "ops_types",
-    "op",
     "__version__",
     "BaseModel",
     "Field",

lionagi/_types.py

@@ -1,2 +1 @@
-from .operatives.types import *
 from .protocols.types import *

lionagi/libs/fields/__init__.py

@@ -0,0 +1,36 @@
+from .action import (
+    ACTION_REQUESTS_FIELD,
+    ACTION_REQUIRED_FIELD,
+    ACTION_RESPONSES_FIELD,
+    ActionRequestModel,
+    ActionResponseModel,
+)
+from .file import (
+    CODE_FILE_FIELD,
+    DOCUMENTATION_FIELD,
+    FILE_FIELD,
+    CodeFile,
+    Documentation,
+    File,
+)
+from .instruct import INSTRUCT_FIELD, Instruct, InstructResponse
+from .reason import REASON_FIELD, Reason
+
+__all__ = (
+    "ActionRequestModel",
+    "ActionResponseModel",
+    "ACTION_REQUESTS_FIELD",
+    "ACTION_REQUIRED_FIELD",
+    "ACTION_RESPONSES_FIELD",
+    "File",
+    "Documentation",
+    "CodeFile",
+    "CODE_FILE_FIELD",
+    "DOCUMENTATION_FIELD",
+    "FILE_FIELD",
+    "Instruct",
+    "InstructResponse",
+    "INSTRUCT_FIELD",
+    "Reason",
+    "REASON_FIELD",
+)

lionagi/libs/fields/action.py

@@ -0,0 +1,190 @@
+# Copyright (c) 2023 - 2025, HaiyangLi <quantocean.li at gmail dot com>
+#
+# SPDX-License-Identifier: Apache-2.0
+
+import re
+from typing import Any
+
+from pydantic import BaseModel, Field, field_validator
+
+from lionagi.libs.validate.common_field_validators import (
+    validate_boolean_field,
+    validate_nullable_string_field,
+)
+from lionagi.models import FieldModel, HashableModel
+from lionagi.utils import to_dict, to_json, to_list
+
+__all__ = (
+    "ActionRequestModel",
+    "ACTION_REQUESTS_FIELD",
+    "ActionResponseModel",
+    "ACTION_RESPONSES_FIELD",
+)
+
+
+def parse_action_request(content: str | dict) -> list[dict]:
+
+    json_blocks = []
+
+    if isinstance(content, BaseModel):
+        json_blocks = [content.model_dump()]
+
+    elif isinstance(content, str):
+        json_blocks = to_json(content, fuzzy_parse=True)
+        if not json_blocks:
+            pattern2 = r"```python\s*(.*?)\s*```"
+            _d = re.findall(pattern2, content, re.DOTALL)
+            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]
+
+    if json_blocks and not isinstance(json_blocks, list):
+        json_blocks = [json_blocks]
+
+    out = []
+
+    for i in json_blocks:
+        j = {}
+        if isinstance(i, dict):
+            if "function" in i and isinstance(i["function"], dict):
+                if "name" in i["function"]:
+                    i["function"] = i["function"]["name"]
+            for k, v in i.items():
+                k = (
+                    k.replace("action_", "")
+                    .replace("recipient_", "")
+                    .replace("s", "")
+                )
+                if k in ["name", "function", "recipient"]:
+                    j["function"] = v
+                elif k in ["parameter", "argument", "arg", "param"]:
+                    j["arguments"] = to_dict(
+                        v, str_type="json", fuzzy_parse=True, suppress=True
+                    )
+            if (
+                j
+                and all(key in j for key in ["function", "arguments"])
+                and j["arguments"]
+            ):
+                out.append(j)
+
+    return out
+
+
+class ActionRequestModel(HashableModel):
+    """
+    Captures a single action request, typically from a user or system message.
+    Includes the name of the function and the arguments to be passed.
+    """
+
+    function: str | None = Field(
+        None,
+        title="Function",
+        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."
+        ),
+        examples=["multiply", "create_user"],
+    )
+    arguments: dict[str, Any] | None = Field(
+        None,
+        title="Arguments",
+        description=(
+            "Dictionary of arguments for the chosen function. "
+            "Use only argument names/types defined in `tool_schemas`. "
+            "Never introduce extra argument names."
+        ),
+    )
+
+    @field_validator("arguments", mode="before")
+    def validate_arguments(cls, value: Any) -> dict[str, Any]:
+        """
+        Coerce arguments into a dictionary if possible, recursively.
+
+        Raises:
+            ValueError if the data can't be coerced.
+        """
+        return to_dict(
+            value,
+            fuzzy_parse=True,
+            recursive=True,
+            recursive_python_only=False,
+        )
+
+    @field_validator("function", mode="before")
+    def validate_function(cls, value: str) -> str:
+        """
+        Ensure the function name is a valid non-empty string (if provided).
+        """
+        return validate_nullable_string_field(cls, value, "function", False)
+
+    @classmethod
+    def create(cls, content: str):
+        """
+        Attempt to parse a string (usually from a conversation or JSON) into
+        one or more ActionRequestModel instances.
+
+        If no valid structure is found, returns an empty list.
+        """
+        try:
+            content = parse_action_request(content)
+            if content:
+                return [cls.model_validate(i) for i in content]
+            return []
+        except Exception:
+            return []
+
+
+ACTION_REQUESTS_FIELD = FieldModel(
+    name="action_requests",
+    annotation=list[ActionRequestModel],
+    default_factory=list,
+    title="Actions",
+    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."
+    ),
+)
+
+
+class ActionResponseModel(HashableModel):
+    """
+    Encapsulates a function's output after being called. Typically
+    references the original function name, arguments, and the result.
+    """
+
+    function: str = Field(default_factory=str, title="Function")
+    arguments: dict[str, Any] = Field(default_factory=dict)
+    output: Any = None
+
+
+ACTION_RESPONSES_FIELD = FieldModel(
+    name="action_responses",
+    annotation=list[ActionResponseModel],
+    default_factory=list,
+    title="Actions",
+    description="**do not fill**",
+)
+
+
+ACTION_REQUIRED_FIELD = FieldModel(
+    name="action_required",
+    annotation=bool,
+    default=False,
+    title="Action Required",
+    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."
+    ),
+    validator=lambda cls, v: validate_boolean_field(cls, v, False),
+    validator_kwargs={"mode": "before"},
+)
+# File: lionagi/libs/fields/action.py

lionagi/libs/fields/file.py

@@ -0,0 +1,135 @@
+from pathlib import Path
+
+from pydantic import BaseModel, Field, field_validator
+
+from lionagi.models import FieldModel
+
+
+class File(BaseModel):
+    """
+    Represents a generic file with an optional name, content, and brief description.
+    Useful for capturing and validating metadata about any kind of file within a project.
+    """
+
+    file_name: str | None = Field(
+        default=None,
+        description=(
+            "Provide the name of the file or its relative path in the project. "
+            "If an absolute path is given, it will be converted to a string. "
+        ),
+        examples=[
+            "session.py",
+            "src/components/UserCard.tsx",
+            "/absolute/path/to/my_file.txt",
+        ],
+    )
+    content: str | None = Field(
+        default=None,
+        description=(
+            "Paste or generate the full textual content of the file here. "
+            "For example, this might include plain text, Markdown, or any other text format.\n"
+            "Examples:\n"
+            "  - '# My Title\\nSome description...'\n"
+            "  - 'function greet() { return \"Hello\"; }'"
+        ),
+    )
+    description: str | None = Field(
+        default=None,
+        description=(
+            "Briefly explain the file's purpose or function within the project. "
+            "This can be a short summary describing why this file exists or what it does.\n"
+        ),
+        examples=[
+            "Manages user session logic for the LionAGI framework.",
+            "Contains CSS styles for the navbar component.",
+        ],
+    )
+
+    @field_validator("file_name", mode="before")
+    def validate_file_name(cls, value):
+        if isinstance(value, Path):
+            return str(value)
+        return value
+
+
+class CodeFile(File):
+    """
+    Represents a code file with an identifiable programming language. Inherits
+    from the generic File model but specializes for code-related content.
+    """
+
+    language: str | None = Field(
+        default=None,
+        description=(
+            "Indicate the programming language of this code file. "
+            "LLMs or humans can use this info to apply specific formatting or syntax analysis."
+        ),
+        examples=[
+            "python",
+            "json",
+            "typescript",
+            "html",
+            "css",
+            "java",
+            "cpp",
+        ],
+    )
+    content: str | None = Field(
+        default=None,
+        description=(
+            "Provide or generate the **full source code**. This should be the primary text content "
+            "of the code file, including all function/class definitions.\n"
+        ),
+        examples=[
+            'def my_function():\\n    print("Hello, world!")',
+            'export function greet(): string { return "Hello"; }',
+        ],
+    )
+
+
+class Documentation(File):
+    """
+    Represents a documentation file, typically Markdown-based, that includes
+    a title and main content explaining or describing some aspect of the project.
+    """
+
+    title: str = Field(
+        default_factory=str,
+        description=(
+            "Specify the title of this documentation entry or page. "
+            "For instance, this might be the top-level heading in a Markdown file.\n"
+        ),
+        examples=["Getting Started", "API Reference: LionAGI Session Module"],
+    )
+    content: str = Field(
+        default_factory=str,
+        description=(
+            "Provide the primary Markdown (or similar) content for the documentation. "
+            "This can include headings, bullet points, tables, code snippets, etc.\n"
+        ),
+        examples=[
+            "# Getting Started\\nThis guide walks you through ...",
+            "# API Reference\\n## Session Class\\n...",
+        ],
+    )
+
+
+FILE_FIELD = FieldModel(
+    name="file",
+    annotation=File | None,
+    default=None,
+)
+
+CODE_FILE_FIELD = FieldModel(
+    name="code_file",
+    annotation=CodeFile | None,
+    default=None,
+)
+
+DOCUMENTATION_FIELD = FieldModel(
+    name="documentation",
+    annotation=Documentation | None,
+    default=None,
+)
+
+# File: lionagi/libs/fields/file.py

lionagi/{operatives/instruct → libs/fields}/instruct.py

@@ -10,9 +10,8 @@ from lionagi.libs.validate.common_field_validators import (
     validate_boolean_field,
     validate_nullable_jsonvalue_field,
 )
-from lionagi.utils import HashableModel, to_num
-
-from ..models.field_model import FieldModel
+from lionagi.models import FieldModel, HashableModel
+from lionagi.utils import to_num
 
 __all__ = (
     "Instruct",
@@ -134,20 +133,21 @@ class Instruct(HashableModel):
             return None
 
 
+class InstructResponse(HashableModel):
+    instruct: Instruct
+    response: Any | None = None
+
+
 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,
 )
+
+# File: lionagi/libs/fields/instruct.py

lionagi/{operatives/instruct → libs/fields}/reason.py

@@ -4,50 +4,14 @@
 
 from pydantic import BaseModel, Field, field_validator
 
+from lionagi.models import FieldModel
 from lionagi.utils import to_num
 
-from ..models.field_model import FieldModel
-
 __all__ = (
     "Reason",
     "REASON_FIELD",
-)
-
-
-# deprecated
-def validate_confidence_score(cls, value) -> float:
-    try:
-        return to_num(
-            value,
-            upper_bound=1,
-            lower_bound=0,
-            num_type=float,
-            precision=3,
-        )
-    except Exception:
-        return -1
-
-
-# deprecated
-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"
-)
-
-# deprecated
-CONFIDENCE_SCORE_FIELD = FieldModel(
-    name="confidence_score",
-    annotation=float | None,
-    default=None,
-    title="Confidence Score",
-    description=confidence_description,
-    examples=[0.821, 0.257, 0.923, 0.439],
-    validator=validate_confidence_score,
-    validator_kwargs={"mode": "before"},
+    "CONFIDENCE_SCORE_FIELD",
+    "validate_confidence_score",
 )
 
 
@@ -71,16 +35,29 @@ class Reason(BaseModel):
 
     @field_validator("confidence_score", mode="before")
     def _validate_confidence(cls, v):
-        try:
-            return to_num(
-                v,
-                upper_bound=1,
-                lower_bound=0,
-                num_type=float,
-                precision=3,
-            )
-        except Exception:
-            return -1
+        return validate_confidence_score(cls, v)
+
+
+def validate_confidence_score(cls, v):
+    try:
+        return to_num(
+            v,
+            upper_bound=1,
+            lower_bound=0,
+            num_type=float,
+            precision=3,
+        )
+    except Exception:
+        return -1
+
+
+CONFIDENCE_SCORE_FIELD = FieldModel(
+    name="confidence_score",
+    annotation=float | None,
+    default=None,
+    validator=validate_confidence_score,
+    validator_kwargs={"mode": "before"},
+)
 
 
 REASON_FIELD = FieldModel(
@@ -89,3 +66,5 @@ REASON_FIELD = FieldModel(
     title="Reason",
     description="**Provide a concise reason for the decision made.**",
 )
+
+# File: lionagi/libs/fields/reason.py

lionagi/libs/schema/function_to_schema.py

@@ -11,7 +11,7 @@ from lionagi.libs.schema.extract_docstring import extract_docstring
 from lionagi.libs.validate.common_field_validators import (
     validate_model_to_type,
 )
-from lionagi.operatives.models.schema_model import SchemaModel
+from lionagi.models import SchemaModel
 
 py_json_msp = {
     "str": "string",

lionagi/models/__init__.py

@@ -0,0 +1,19 @@
+# Copyright (c) 2023 - 2025, HaiyangLi <quantocean.li at gmail dot com>
+#
+# SPDX-License-Identifier: Apache-2.0
+
+from .field_model import FieldModel
+from .hashable_model import HashableModel
+from .model_params import ModelParams
+from .note import Note
+from .operable_model import OperableModel
+from .schema_model import SchemaModel
+
+__all__ = (
+    "FieldModel",
+    "ModelParams",
+    "OperableModel",
+    "Note",
+    "SchemaModel",
+    "HashableModel",
+)

lionagi/models/hashable_model.py

@@ -0,0 +1,24 @@
+from pydantic import BaseModel
+from typing_extensions import Self
+
+from lionagi.utils import UNDEFINED, hash_dict
+
+
+class HashableModel(BaseModel):
+
+    def to_dict(self, **kwargs) -> dict:
+        """provides interface, specific methods need to be implemented in subclass kwargs for pydantic model_dump"""
+        return {
+            k: v
+            for k, v in self.model_dump(**kwargs).items()
+            if v is not UNDEFINED
+        }
+
+    @classmethod
+    def from_dict(cls, data: dict, **kwargs) -> Self:
+        """provides interface, specific methods need to be implemented in subclass kwargs for pydantic model_validate"""
+        return cls.model_validate(data, **kwargs)
+
+    def __hash__(self):
+        # Convert kwargs to a hashable format by serializing unhashable types
+        return hash_dict(self.to_dict())

lionagi/{operatives/models → models}/operable_model.py

@@ -15,9 +15,10 @@ from pydantic.fields import FieldInfo
 from pydantic_core import PydanticUndefined
 from typing_extensions import Self, override
 
-from lionagi.utils import UNDEFINED, HashableModel, is_same_dtype
+from lionagi.utils import UNDEFINED, is_same_dtype
 
 from .field_model import FieldModel
+from .hashable_model import HashableModel
 from .model_params import ModelParams
 
 FieldName = TypeVar("FieldName", bound=str)

lionagi/{operatives/models → models}/schema_model.py

@@ -4,7 +4,7 @@
 
 from pydantic import ConfigDict
 
-from lionagi.utils import HashableModel
+from .hashable_model import HashableModel
 
 __all__ = ("SchemaModel",)
 

lionagi/operations/ReAct/ReAct.py

@@ -8,13 +8,12 @@ from typing import TYPE_CHECKING, Any, Literal
 
 from pydantic import BaseModel
 
+from lionagi.libs.fields.instruct import Instruct
 from lionagi.libs.schema.as_readable import as_readable
 from lionagi.libs.validate.common_field_validators import (
     validate_model_to_type,
 )
-from lionagi.operatives.models.field_model import FieldModel
-from lionagi.operatives.models.model_params import ModelParams
-from lionagi.operatives.types import Instruct
+from lionagi.models import FieldModel, ModelParams
 from lionagi.service.imodel import iModel
 from lionagi.utils import copy
 

lionagi/operations/_act/act.py

@@ -7,10 +7,10 @@ from typing import TYPE_CHECKING
 
 from pydantic import BaseModel
 
-from lionagi.protocols.types import Log
+from lionagi.libs.fields.action import ActionResponseModel
+from lionagi.protocols.types import ActionRequest, Log
 
 if TYPE_CHECKING:
-    from lionagi.operatives.types import ActionResponseModel
     from lionagi.session.branch import Branch
 
 
@@ -65,8 +65,6 @@ async def _act(
 
     branch._log_manager.log(Log.create(func_call))
 
-    from lionagi.protocols.types import ActionRequest
-
     if not isinstance(action_request, ActionRequest):
         action_request = ActionRequest.create(
             sender=branch.id,
@@ -83,9 +81,6 @@ async def _act(
         action_output=func_call.response,
     )
 
-    # Return an ActionResponse object
-    from lionagi.operatives.types import ActionResponseModel
-
     return ActionResponseModel(
         function=action_request.function,
         arguments=action_request.arguments,

lionagi/operations/brainstorm/brainstorm.py

@@ -7,7 +7,7 @@ from typing import Any, Literal
 
 from pydantic import BaseModel
 
-from lionagi.operatives.instruct.instruct import (
+from lionagi.libs.fields.instruct import (
     LIST_INSTRUCT_FIELD_MODEL,
     Instruct,
     InstructResponse,

lionagi/operations/instruct/instruct.py

@@ -4,7 +4,7 @@
 
 from typing import TYPE_CHECKING, Any
 
-from lionagi.operatives.types import Instruct
+from lionagi.libs.fields.instruct import Instruct
 
 if TYPE_CHECKING:
     from lionagi.session.branch import Branch