lionagi 0.9.0__tar.gz → 0.9.2__tar.gz

{lionagi-0.9.0 → lionagi-0.9.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: lionagi
-Version: 0.9.0
+Version: 0.9.2
 Summary: An Intelligence Operating System.
 Author-email: HaiyangLi <quantocean.li@gmail.com>
 License:            Apache License

lionagi-0.9.2/lionagi/operations/ReAct/ReAct.py

@@ -0,0 +1,351 @@
+# Copyright (c) 2023 - 2025, HaiyangLi <quantocean.li at gmail dot com>
+#
+# SPDX-License-Identifier: Apache-2.0
+
+import logging
+from collections.abc import AsyncGenerator
+from typing import TYPE_CHECKING, Any, Literal
+
+from pydantic import BaseModel
+
+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.service.imodel import iModel
+from lionagi.utils import copy
+
+from .utils import Analysis, ReActAnalysis
+
+if TYPE_CHECKING:
+    from lionagi.session.branch import Branch
+
+
+async def ReAct(
+    branch: "Branch",
+    instruct: Instruct | dict[str, Any],
+    interpret: bool = False,
+    interpret_domain: str | None = None,
+    interpret_style: str | None = None,
+    interpret_sample: str | None = None,
+    interpret_model: str | None = None,
+    interpret_kwargs: dict | None = None,
+    tools: Any = None,
+    tool_schemas: Any = None,
+    response_format: type[BaseModel] | BaseModel = None,
+    intermediate_response_options: list[BaseModel] | BaseModel = None,
+    intermediate_listable: bool = False,
+    reasoning_effort: Literal["low", "medium", "high"] = None,
+    extension_allowed: bool = True,
+    max_extensions: int | None = 3,
+    response_kwargs: dict | None = None,
+    display_as: Literal["json", "yaml"] = "yaml",
+    return_analysis: bool = False,
+    analysis_model: iModel | None = None,
+    verbose_analysis: bool = False,
+    verbose_length: int = None,
+    **kwargs,
+):
+    outs = []
+    if verbose_analysis:
+        async for i in ReActStream(
+            branch=branch,
+            instruct=instruct,
+            interpret=interpret,
+            interpret_domain=interpret_domain,
+            interpret_style=interpret_style,
+            interpret_sample=interpret_sample,
+            interpret_model=interpret_model,
+            interpret_kwargs=interpret_kwargs,
+            tools=tools,
+            tool_schemas=tool_schemas,
+            response_format=response_format,
+            intermediate_response_options=intermediate_response_options,
+            intermediate_listable=intermediate_listable,
+            reasoning_effort=reasoning_effort,
+            extension_allowed=extension_allowed,
+            max_extensions=max_extensions,
+            response_kwargs=response_kwargs,
+            analysis_model=analysis_model,
+            verbose_analysis=verbose_analysis,
+            display_as=display_as,
+            verbose_length=verbose_length,
+            **kwargs,
+        ):
+            analysis, str_ = i
+            str_ += "\n---------\n"
+            as_readable(str_, md=True, display_str=True)
+            outs.append(analysis)
+    else:
+        async for i in ReActStream(
+            branch=branch,
+            instruct=instruct,
+            interpret=interpret,
+            interpret_domain=interpret_domain,
+            interpret_style=interpret_style,
+            interpret_sample=interpret_sample,
+            interpret_model=interpret_model,
+            interpret_kwargs=interpret_kwargs,
+            tools=tools,
+            tool_schemas=tool_schemas,
+            response_format=response_format,
+            intermediate_response_options=intermediate_response_options,
+            intermediate_listable=intermediate_listable,
+            reasoning_effort=reasoning_effort,
+            extension_allowed=extension_allowed,
+            max_extensions=max_extensions,
+            response_kwargs=response_kwargs,
+            analysis_model=analysis_model,
+            display_as=display_as,
+            verbose_length=verbose_length,
+            **kwargs,
+        ):
+            outs.append(i)
+    if return_analysis:
+        return outs
+    return outs[-1]
+
+
+async def ReActStream(
+    branch: "Branch",
+    instruct: Instruct | dict[str, Any],
+    interpret: bool = False,
+    interpret_domain: str | None = None,
+    interpret_style: str | None = None,
+    interpret_sample: str | None = None,
+    interpret_model: str | None = None,
+    interpret_kwargs: dict | None = None,
+    tools: Any = None,
+    tool_schemas: Any = None,
+    response_format: type[BaseModel] | BaseModel = None,
+    intermediate_response_options: list[BaseModel] | BaseModel = None,
+    intermediate_listable: bool = False,
+    reasoning_effort: Literal["low", "medium", "high"] = None,
+    extension_allowed: bool = True,
+    max_extensions: int | None = 3,
+    response_kwargs: dict | None = None,
+    analysis_model: iModel | None = None,
+    verbose_analysis: bool = False,
+    display_as: Literal["json", "yaml"] = "yaml",
+    verbose_length: int = None,
+    **kwargs,
+) -> AsyncGenerator:
+    irfm: FieldModel | None = None
+
+    if intermediate_response_options is not None:
+        iro = (
+            [intermediate_response_options]
+            if not isinstance(intermediate_response_options, list)
+            else intermediate_response_options
+        )
+        field_models = []
+        for i in iro:
+            type_ = validate_model_to_type(None, i)
+            fm = FieldModel(
+                name=str(type_.__name__).lower(),
+                annotation=type_ | None,
+                validator=lambda cls, x: None if x == {} else x,
+            )
+            field_models.append(fm)
+
+        m_ = ModelParams(
+            name="IntermediateResponseOptions", field_models=field_models
+        ).create_new_model()
+
+        irfm = FieldModel(
+            name="intermediate_response_options",
+            annotation=(
+                m_ | None if not intermediate_listable else list[m_] | None
+            ),
+            description="Optional intermediate deliverable outputs. fill as needed ",
+            validator=lambda cls, x: None if not x else x,
+        )
+
+    # If no tools or tool schemas are provided, default to "all tools"
+    if not tools and not tool_schemas:
+        tools = True
+
+    # Possibly interpret the instruction to refine it
+    instruction_str = None
+    if interpret:
+        instruction_str = await branch.interpret(
+            str(
+                instruct.to_dict()
+                if isinstance(instruct, Instruct)
+                else instruct
+            ),
+            domain=interpret_domain,
+            style=interpret_style,
+            sample_writing=interpret_sample,
+            interpret_model=interpret_model,
+            **(interpret_kwargs or {}),
+        )
+        if verbose_analysis:
+            str_ = "\n### Interpreted instruction:\n"
+            str_ += as_readable(
+                instruction_str,
+                md=True,
+                format_curly=True if display_as == "yaml" else False,
+                max_chars=verbose_length,
+            )
+            yield instruction_str, str_
+        else:
+            yield instruction_str
+
+    # Convert Instruct to dict if necessary
+    instruct_dict = (
+        instruct.to_dict()
+        if isinstance(instruct, Instruct)
+        else dict(instruct)
+    )
+
+    # Overwrite "instruction" with the interpreted prompt (if any) plus a note about expansions
+    max_ext_info = f"\nIf needed, you can do up to {max_extensions or 0 if extension_allowed else 0} expansions."
+    instruct_dict["instruction"] = (
+        instruction_str
+        or (instruct_dict.get("instruction") or "")  # in case it's missing
+    ) + max_ext_info
+
+    # Prepare a copy of user-provided kwargs for the first operate call
+    kwargs_for_operate = copy(kwargs)
+    kwargs_for_operate["actions"] = True
+    kwargs_for_operate["reason"] = True
+
+    # Step 1: Generate initial ReAct analysis
+    analysis: ReActAnalysis = await branch.operate(
+        instruct=instruct_dict,
+        response_format=ReActAnalysis,
+        tools=tools,
+        tool_schemas=tool_schemas,
+        chat_model=analysis_model or branch.chat_model,
+        **kwargs_for_operate,
+    )
+    # If verbose, show round #1 analysis
+    if verbose_analysis:
+        str_ = "\n### ReAct Round No.1 Analysis:\n"
+        str_ += as_readable(
+            analysis,
+            md=True,
+            format_curly=True if display_as == "yaml" else False,
+            max_chars=verbose_length,
+        )
+        yield analysis, str_
+    else:
+        yield analysis
+
+    # Validate and clamp max_extensions if needed
+    if max_extensions and max_extensions > 100:
+        logging.warning(
+            "max_extensions should not exceed 100; defaulting to 100."
+        )
+        max_extensions = 100
+
+    # Step 2: Possibly loop through expansions if extension_needed
+    extensions = max_extensions
+    round_count = 1
+
+    while (
+        extension_allowed and analysis.extension_needed
+        if hasattr(analysis, "extension_needed")
+        else (
+            analysis.get("extension_needed", None)
+            if isinstance(analysis, dict)
+            else False
+        )
+        and (extensions if max_extensions else 0) > 0
+    ):
+        new_instruction = None
+        if extensions == max_extensions:
+            new_instruction = ReActAnalysis.FIRST_EXT_PROMPT.format(
+                extensions=extensions
+            )
+        else:
+            new_instruction = ReActAnalysis.CONTINUE_EXT_PROMPT.format(
+                extensions=extensions
+            )
+
+        operate_kwargs = copy(kwargs)
+        operate_kwargs["actions"] = True
+        operate_kwargs["reason"] = True
+        operate_kwargs["response_format"] = ReActAnalysis
+        operate_kwargs["action_strategy"] = analysis.action_strategy
+        if analysis.action_batch_size:
+            operate_kwargs["action_batch_size"] = analysis.action_batch_size
+        if irfm:
+            operate_kwargs["field_models"] = operate_kwargs.get(
+                "field_models", []
+            ) + [irfm]
+        if reasoning_effort:
+            guide = None
+            if reasoning_effort == "low":
+                guide = "Quick concise reasoning.\n"
+            if reasoning_effort == "medium":
+                guide = "Reasonably balanced reasoning.\n"
+            if reasoning_effort == "high":
+                guide = "Thorough, try as hard as you can in reasoning.\n"
+            operate_kwargs["guidance"] = guide + operate_kwargs.get(
+                "guidance", ""
+            )
+
+        analysis = await branch.operate(
+            instruction=new_instruction,
+            tools=tools,
+            tool_schemas=tool_schemas,
+            **operate_kwargs,
+        )
+        round_count += 1
+
+        # If verbose, show round analysis
+        if verbose_analysis:
+            str_ = f"\n### ReAct Round No.{round_count} Analysis:\n"
+
+            str_ += as_readable(
+                analysis,
+                md=True,
+                format_curly=True if display_as == "yaml" else False,
+                max_chars=verbose_length,
+            )
+
+            yield analysis, str_
+        else:
+            yield analysis
+
+        if extensions:
+            extensions -= 1
+
+    # Step 3: Produce final answer by calling branch.instruct with an answer prompt
+    answer_prompt = ReActAnalysis.ANSWER_PROMPT.format(
+        instruction=instruct_dict["instruction"]
+    )
+    if not response_format:
+        response_format = Analysis
+
+    try:
+        out = await branch.operate(
+            instruction=answer_prompt,
+            response_format=response_format,
+            **(response_kwargs or {}),
+        )
+    except Exception:
+        out = branch.msgs.last_response.response
+
+    if isinstance(out, Analysis):
+        out = out.answer
+
+    if verbose_analysis:
+        str_ = "\n### ReAct Final Answer:\n"
+        str_ += as_readable(
+            out,
+            md=True,
+            format_curly=True if display_as == "yaml" else False,
+            max_chars=verbose_length,
+        )
+        yield out, str_
+    else:
+        yield out
+
+
+# TODO: Do partial intermeditate output for longer analysis with form and report

{lionagi-0.9.0 → lionagi-0.9.2}/lionagi/operations/ReAct/utils.py

@@ -36,7 +36,9 @@ class ReActAnalysis(BaseModel):
     FIRST_EXT_PROMPT: ClassVar[str] = (
         "You can perform multiple reason-action steps for accuracy. "
         "If you are not ready to finalize, set extension_needed to True. "
-        "You have up to {extensions} expansions. Please continue."
+        "hint: you should set extension_needed to True if the overall goal"
+        "is not yet achieved. Do not set it to False, if you are just providing"
+        "an interim answer. You have up to {extensions} expansions. Please continue."
     )
     CONTINUE_EXT_PROMPT: ClassVar[str] = (
         "Another round is available. You may do multiple actions if needed. "
@@ -49,7 +51,11 @@ class ReActAnalysis(BaseModel):
 
     analysis: str = Field(
         ...,
-        description="Free-form reasoning or chain-of-thought summary. Must be consistent with the plan.",
+        description=(
+            "Free-form reasoning or chain-of-thought summary. Must be consistent with"
+            " the plan. Commonly used for divide_and_conquer, brainstorming, reflections, "
+            "regurgitation, review_checkpoints ...etc."
+        ),
     )
 
     planned_actions: list[PlannedAction] = Field(

{lionagi-0.9.0 → lionagi-0.9.2}/lionagi/service/endpoints/base.py

@@ -79,7 +79,7 @@ class EndpointConfig(BaseModel):
     requires_tokens: bool = False
     api_version: str | None = None
     allowed_roles: list[str] | None = None
-    request_options: type | None = None
+    request_options: type | None = Field(None, exclude=True)
 
 
 class EndPoint(ABC):

{lionagi-0.9.0 → lionagi-0.9.2}/lionagi/service/endpoints/chat_completion.py

@@ -1,11 +1,19 @@
 # Copyright (c) 2023 - 2025, HaiyangLi <quantocean.li at gmail dot com>
 #
 # SPDX-License-Identifier: Apache-2.0
-
+import warnings
 from collections.abc import AsyncGenerator
 
 from .base import EndPoint
 
+warnings.filterwarnings(
+    "ignore",
+    message=".*Valid config keys have changed in V2.*",
+    category=UserWarning,
+    module="pydantic._internal._config",
+)
+
+
 CHAT_COMPLETION_CONFIG = {
     "endpoint": "chat/completions",
     "method": "post",

{lionagi-0.9.0 → lionagi-0.9.2}/lionagi/service/imodel.py

@@ -4,7 +4,6 @@
 
 import asyncio
 import os
-import warnings
 from collections.abc import AsyncGenerator, Callable
 
 from pydantic import BaseModel
@@ -16,13 +15,6 @@ from .endpoints.base import APICalling, EndPoint
 from .endpoints.match_endpoint import match_endpoint
 from .endpoints.rate_limited_processor import RateLimitedAPIExecutor
 
-warnings.filterwarnings(
-    "ignore",
-    message=".*Valid config keys have changed in V2.*",
-    category=UserWarning,
-    module="pydantic._internal._config",
-)
-
 
 class iModel:
     """Manages API calls for a specific provider with optional rate-limiting.

{lionagi-0.9.0 → lionagi-0.9.2}/lionagi/session/branch.py

@@ -2,6 +2,7 @@
 #
 # SPDX-License-Identifier: Apache-2.0
 
+from collections.abc import AsyncGenerator
 from enum import Enum
 from typing import TYPE_CHECKING, Any, Literal
 
@@ -9,6 +10,7 @@ import pandas as pd
 from jinja2 import Template
 from pydantic import BaseModel, Field, JsonValue, PrivateAttr
 
+from lionagi.libs.schema.as_readable import as_readable
 from lionagi.operatives.types import (
     ActionManager,
     FieldModel,
@@ -1621,13 +1623,18 @@ class Branch(Element, Communicatable, Relational):
         interpret_domain: str | None = None,
         interpret_style: str | None = None,
         interpret_sample: str | None = None,
+        interpret_model: str | None = None,
         interpret_kwargs: dict | None = None,
         tools: Any = None,
         tool_schemas: Any = None,
-        response_format: type[BaseModel] = None,
-        extension_allowed: bool = False,
-        max_extensions: int = None,
+        response_format: type[BaseModel] | BaseModel = None,
+        intermediate_response_options: list[BaseModel] | BaseModel = None,
+        intermediate_listable: bool = False,
+        reasoning_effort: Literal["low", "medium", "high"] = None,
+        extension_allowed: bool = True,
+        max_extensions: int | None = 3,
         response_kwargs: dict | None = None,
+        display_as: Literal["json", "yaml"] = "yaml",
         return_analysis: bool = False,
         analysis_model: iModel | None = None,
         verbose: bool = False,
@@ -1721,8 +1728,69 @@ class Branch(Element, Communicatable, Relational):
             verbose_action=verbose,
             verbose_analysis=verbose,
             verbose_length=verbose_length,
+            interpret_model=interpret_model,
+            intermediate_response_options=intermediate_response_options,
+            intermediate_listable=intermediate_listable,
+            reasoning_effort=reasoning_effort,
+            display_as=display_as,
             **kwargs,
         )
 
+    async def ReActStream(
+        self,
+        instruct: Instruct | dict[str, Any],
+        interpret: bool = False,
+        interpret_domain: str | None = None,
+        interpret_style: str | None = None,
+        interpret_sample: str | None = None,
+        interpret_model: str | None = None,
+        interpret_kwargs: dict | None = None,
+        tools: Any = None,
+        tool_schemas: Any = None,
+        response_format: type[BaseModel] | BaseModel = None,
+        intermediate_response_options: list[BaseModel] | BaseModel = None,
+        intermediate_listable: bool = False,
+        reasoning_effort: Literal["low", "medium", "high"] = None,
+        extension_allowed: bool = True,
+        max_extensions: int | None = 3,
+        response_kwargs: dict | None = None,
+        analysis_model: iModel | None = None,
+        verbose: bool = False,
+        display_as: Literal["json", "yaml"] = "yaml",
+        verbose_length: int = None,
+        **kwargs,
+    ) -> AsyncGenerator:
+        from lionagi.operations.ReAct.ReAct import ReActStream
+
+        async for result in ReActStream(
+            self,
+            instruct,
+            interpret=interpret,
+            interpret_domain=interpret_domain,
+            interpret_style=interpret_style,
+            interpret_sample=interpret_sample,
+            interpret_model=interpret_model,
+            interpret_kwargs=interpret_kwargs,
+            tools=tools,
+            tool_schemas=tool_schemas,
+            response_format=response_format,
+            intermediate_response_options=intermediate_response_options,
+            intermediate_listable=intermediate_listable,
+            reasoning_effort=reasoning_effort,
+            extension_allowed=extension_allowed,
+            max_extensions=max_extensions,
+            response_kwargs=response_kwargs,
+            analysis_model=analysis_model,
+            verbose_analysis=True,
+            display_as=display_as,
+            verbose_length=verbose_length,
+            **kwargs,
+        ):
+            analysis, str_ = result
+            if verbose:
+                str_ += "\n---------\n"
+                as_readable(str_, md=True, display_str=True)
+            yield analysis
+
 
 # File: lionagi/session/branch.py

lionagi-0.9.2/lionagi/version.py

@@ -0,0 +1 @@
+__version__ = "0.9.2"

{lionagi-0.9.0 → lionagi-0.9.2}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "lionagi"
-version = "0.9.0"
+version = "0.9.2"
 description = "An Intelligence Operating System."
 authors = [
     { name = "HaiyangLi", email = "quantocean.li@gmail.com" },

{lionagi-0.9.0 → lionagi-0.9.2}/uv.lock

@@ -1208,7 +1208,7 @@ wheels = [
 
 [[package]]
 name = "lionagi"
-version = "0.9.0"
+version = "0.9.2"
 source = { editable = "." }
 dependencies = [
     { name = "aiocache" },