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

lionagi/fields/instruct.py

@@ -1,135 +0,0 @@
-# Copyright (c) 2023-2025, HaiyangLi <quantocean.li at gmail dot com>
-# SPDX-License-Identifier: Apache-2.0
-
-from typing import Any, ClassVar, Literal
-
-from pydantic import Field, JsonValue, field_validator
-
-from lionagi.libs.validate.common_field_validators import (
-    validate_boolean_field,
-    validate_nullable_jsonvalue_field,
-)
-from lionagi.models import FieldModel, HashableModel
-
-__all__ = (
-    "Instruct",
-    "InstructResponse",
-)
-
-
-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",
-        "action_strategy",
-        "request_params",
-        "response_params",
-    ]
-    instruction: JsonValue | None = Field(
-        None,
-        title="Primary Instruction",
-        description=(
-            "A clear, actionable task definition. Specify:\n"
-            "1) The primary goal or objective\n"
-            "2) Key success criteria or constraints\n"
-            "\n"
-            "Guidelines:\n"
-            "- Start with a direct action verb (e.g., 'Analyze', 'Generate', 'Create')\n"
-            "- Include scope, boundaries, or constraints\n"
-            "- Provide success criteria if relevant\n"
-            "- For complex tasks, break them into logical steps"
-        ),
-    )
-    guidance: JsonValue | None = Field(
-        None,
-        title="Guidance",
-        description=(
-            "Strategic direction and constraints for executing the task. "
-            "Include:\n"
-            "1) Preferred methods or frameworks\n"
-            "2) Quality benchmarks (e.g., speed, clarity)\n"
-            "3) Resource or environmental constraints\n"
-            "4) Relevant compliance or standards\n"
-            "Use None if no special guidance."
-        ),
-    )
-    context: JsonValue | None = Field(
-        None,
-        description=(
-            "Background information and current-state data needed for the task. "
-            "Should be:\n"
-            "1) Directly relevant\n"
-            "2) Sufficient to perform the task\n"
-            "3) Free of extraneous detail\n"
-            "Include environment, prior outcomes, system states, or dependencies. "
-            "Use None if no additional context is needed."
-        ),
-    )
-    reason: bool | None = Field(
-        None,
-        description=(
-            "Include a thoughtful explanation of decisions, trade-offs, "
-            "and insights. Encourage deeper introspection on why certain "
-            "choices were made, potential alternatives, and how confidence "
-            "was shaped. If not needed, set to None."
-        ),
-    )
-    actions: bool | None = Field(
-        None,
-        description=(
-            "Controls execution mode. "
-            "True: Execute specified actions. "
-            "False: Analysis/recommendations only. "
-            "None: Contextual execution."
-        ),
-    )
-    action_strategy: Literal["sequential", "concurrent"] | None = Field(
-        None,
-        description="Action strategy to use for executing actions. Default "
-        "is 'concurrent'. Only provide for if actions are enabled.",
-    )
-
-    @field_validator("instruction", "guidance", "context", mode="before")
-    def _validate_instruction(cls, v):
-        return validate_nullable_jsonvalue_field(cls, v)
-
-    @field_validator("reason", "actions", mode="before")
-    def _validate_reason(cls, v):
-        return validate_boolean_field(cls, v)
-
-    @field_validator("action_strategy", mode="before")
-    def _validate_action_strategy(cls, v):
-        if v not in ["batch", "sequential", "concurrent"]:
-            return "concurrent"
-        return v
-
-
-class InstructResponse(HashableModel):
-    instruct: Instruct
-    response: Any | None = None
-
-
-INSTRUCT_FIELD = FieldModel(
-    name="instruct_model",
-    annotation=Instruct | None,
-    default=None,
-)
-
-LIST_INSTRUCT_FIELD_MODEL = FieldModel(
-    name="instruct_models",
-    annotation=list[Instruct] | None,
-    default=None,
-)
-
-# File: lionagi/fields/instruct.py

lionagi/fields/reason.py

@@ -1,55 +0,0 @@
-# Copyright (c) 2023-2025, HaiyangLi <quantocean.li at gmail dot com>
-# SPDX-License-Identifier: Apache-2.0
-
-from pydantic import Field, field_validator
-
-from lionagi.libs.validate.to_num import to_num
-from lionagi.models import FieldModel, HashableModel
-
-__all__ = ("Reason",)
-
-
-class Reason(HashableModel):
-    title: str | None = None
-    content: str | None = None
-    confidence_score: float | None = Field(
-        None,
-        title="Confidence Score",
-        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, refine or backtrack\n"
-            "  • 0.0-0.5: Off track, stop"
-        ),
-    )
-
-    @field_validator("confidence_score", mode="before")
-    def _validate_confidence(cls, v):
-        return validate_confidence_score(cls, v)
-
-
-def validate_confidence_score(cls, v):
-    if v is None:
-        return None
-    try:
-        return to_num(
-            v,
-            upper_bound=1,
-            lower_bound=0,
-            num_type=float,
-            precision=3,
-        )
-    except Exception:
-        return -1
-
-
-REASON_FIELD = FieldModel(
-    name="reason",
-    annotation=Reason | None,
-    title="Reason",
-    description="**Provide a concise reason for the decision made.**",
-)
-
-# File: lionagi/fields/reason.py

lionagi/fields/research.py

@@ -1,52 +0,0 @@
-# Copyright (c) 2023-2025, HaiyangLi <quantocean.li at gmail dot com>
-# SPDX-License-Identifier: Apache-2.0
-
-from pydantic import Field
-
-from lionagi.models import HashableModel
-
-from .base import CodeSnippet, TextSnippet
-
-__all__ = (
-    "ResearchFinding",
-    "PotentialRisk",
-    "ResearchSummary",
-)
-
-
-class ResearchFinding(HashableModel):
-    """
-    A single piece of information or insight from the research phase.
-    """
-
-    summary: str | None = Field(
-        None,
-        description="Concise text describing the discovered fact, concept, or best practice.",
-    )
-    snippets: list[TextSnippet | CodeSnippet] = Field(
-        default_factory=list,
-        description="Ordered list of content snippets (text or code) that illustrate or support the finding.",
-    )
-    relevance: str | None = Field(
-        default=None,
-        description="Why this finding matters to the project. E.g., 'Helps solve concurrency issue.'",
-    )
-
-
-class PotentialRisk(HashableModel):
-    """
-    Identifies a risk or challenge discovered during research.
-    """
-
-    description: str | None = Field(
-        None,
-        description="Short text describing the risk. E.g., 'Scalability concerns with chosen DB'.",
-    )
-    impact: str | None = Field(
-        default=None,
-        description="Possible consequences if not mitigated. E.g., 'System slowdown, possible downtime.'",
-    )
-    mitigation_ideas: str | None = Field(
-        default=None,
-        description="Preliminary ways to reduce or handle this risk.",
-    )

lionagi/operations/_act/act.py

@@ -1,86 +0,0 @@
-# Copyright (c) 2023-2025, HaiyangLi <quantocean.li at gmail dot com>
-# SPDX-License-Identifier: Apache-2.0
-
-import logging
-from typing import TYPE_CHECKING
-
-from pydantic import BaseModel
-
-from lionagi.fields.action import ActionResponseModel
-from lionagi.protocols.types import ActionRequest, Log
-
-if TYPE_CHECKING:
-    from lionagi.session.branch import Branch
-
-
-async def _act(
-    branch: "Branch",
-    action_request: BaseModel | dict,
-    suppress_errors: bool = False,
-    verbose_action: bool = False,
-) -> "ActionResponseModel":
-    _request = {}
-
-    if isinstance(action_request, BaseModel):
-        if hasattr(action_request, "function") and hasattr(
-            action_request, "arguments"
-        ):
-            _request["function"] = action_request.function
-            _request["arguments"] = action_request.arguments
-    elif isinstance(action_request, dict):
-        if {"function", "arguments"} <= set(action_request.keys()):
-            _request["function"] = action_request["function"]
-            _request["arguments"] = action_request["arguments"]
-
-    try:
-        if verbose_action:
-            args_ = str(_request["arguments"])
-            args_ = args_[:50] + "..." if len(args_) > 50 else args_
-            print(f"Invoking action {_request['function']} with {args_}.")
-
-        func_call = await branch._action_manager.invoke(_request)
-        if verbose_action:
-            print(
-                f"Action {_request['function']} invoked, status: {func_call.status}."
-            )
-
-    except Exception as e:
-        content = {
-            "error": str(e),
-            "function": _request.get("function"),
-            "arguments": _request.get("arguments"),
-            "branch": str(branch.id),
-        }
-        branch._log_manager.log(Log(content=content))
-        if verbose_action:
-            print(f"Action {_request['function']} failed, error: {str(e)}.")
-        if suppress_errors:
-            logging.error(
-                f"Error invoking action '{_request['function']}': {e}"
-            )
-            return None
-        raise e
-
-    branch._log_manager.log(Log.create(func_call))
-
-    if not isinstance(action_request, ActionRequest):
-        action_request = ActionRequest.create(
-            sender=branch.id,
-            recipient=func_call.func_tool.id,
-            **_request,
-        )
-
-    # Add the action request/response to the message manager, if not present
-    if action_request not in branch.messages:
-        branch.msgs.add_message(action_request=action_request)
-
-    branch.msgs.add_message(
-        action_request=action_request,
-        action_output=func_call.response,
-    )
-
-    return ActionResponseModel(
-        function=action_request.function,
-        arguments=action_request.arguments,
-        output=func_call.response,
-    )

lionagi/operations/brainstorm/__init__.py

@@ -1,2 +0,0 @@
-# Copyright (c) 2023-2025, HaiyangLi <quantocean.li at gmail dot com>
-# SPDX-License-Identifier: Apache-2.0