lionagi 0.8.5__tar.gz → 0.8.6__tar.gz

{lionagi-0.8.5 → lionagi-0.8.6}/PKG-INFO

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

{lionagi-0.8.5 → lionagi-0.8.6}/lionagi/__init__.py

@@ -2,6 +2,8 @@
 #
 # SPDX-License-Identifier: Apache-2.0
 
+import logging
+
 from pydantic import BaseModel, Field
 
 from . import _types as types
@@ -13,6 +15,9 @@ from .version import __version__
 
 LiteiModel = iModel
 
+logger = logging.getLogger(__name__)
+logger.setLevel(logging.INFO)
+
 __all__ = (
     "Session",
     "Branch",
@@ -24,4 +29,5 @@ __all__ = (
     "__version__",
     "BaseModel",
     "Field",
+    "logger",
 )

{lionagi-0.8.5 → lionagi-0.8.6}/lionagi/operations/ReAct/ReAct.py

@@ -33,6 +33,7 @@ async def ReAct(
     response_kwargs: dict | None = None,
     return_analysis: bool = False,
     analysis_model: iModel | None = None,
+    verbose_analysis: bool = False,
     **kwargs,
 ):
     # If no tools or tool schemas are provided, default to "all tools"
@@ -60,10 +61,13 @@ async def ReAct(
         if isinstance(instruct, Instruct)
         else dict(instruct)
     )
-    # Overwrite the "instruction" field with the interpreted string (if any)
-    instruct_dict["instruction"] = instruction_str or instruct_dict.get(
-        "instruction"
-    )
+
+    # 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)
@@ -81,6 +85,12 @@ async def ReAct(
     )
     analyses = [analysis]
 
+    # If verbose, show round #1 analysis
+    if verbose_analysis:
+        print(
+            f"ReAct Round #1 Analysis:\n {analysis.model_dump_json(indent=2)}",
+        )
+
     # Validate and clamp max_extensions if needed
     if max_extensions and max_extensions > 5:
         logging.warning("max_extensions should not exceed 5; defaulting to 5.")
@@ -88,6 +98,8 @@ async def ReAct(
 
     # Step 2: Possibly loop through expansions if extension_needed
     extensions = max_extensions
+    round_count = 1
+
     while (
         extension_allowed
         and analysis.extension_needed
@@ -103,16 +115,28 @@ async def ReAct(
                 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
+
         analysis = await branch.operate(
             instruction=new_instruction,
-            response_format=ReActAnalysis,
             tools=tools,
             tool_schemas=tool_schemas,
-            reason=True,
-            actions=True,
+            **operate_kwargs,
         )
         analyses.append(analysis)
+        round_count += 1
 
+        # If verbose, show round analysis
+        if verbose_analysis:
+            print(
+                f"ReAct Round #{round_count} Analysis:\n {analysis.model_dump_json(indent=2)}",
+            )
         if extensions:
             extensions -= 1
 

lionagi-0.8.6/lionagi/operations/ReAct/utils.py

@@ -0,0 +1,92 @@
+# Copyright (c) 2023 - 2024, HaiyangLi <quantocean.li at gmail dot com>
+#
+# SPDX-License-Identifier: Apache-2.0
+
+from typing import ClassVar, Literal
+
+from pydantic import BaseModel, Field
+
+
+class PlannedAction(BaseModel):
+    """
+    Short descriptor for an upcoming action/tool invocation the LLM wants to perform.
+    The model can hold multiple actions in a single round if needed.
+    """
+
+    action_type: str = Field(
+        ...,
+        description="The name or type of tool/action to invoke (e.g., 'search_exa', 'reader_tool').",
+    )
+    description: str = Field(
+        ...,
+        description="A short explanation of why or what is intended to achieve with this action.",
+    )
+
+
+class ReActAnalysis(BaseModel):
+    """
+    Captures the ReAct chain-of-thought output each round:
+    1) The LLM's 'analysis' (reasoning),
+    2) A list of planned actions to perform before finalizing,
+    3) Indication whether more expansions/rounds are needed,
+    4) Additional tuning knobs: how to handle validation, how to execute actions, etc.
+    """
+
+    # Standard ReAct strings for controlling expansions:
+    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."
+    )
+    CONTINUE_EXT_PROMPT: ClassVar[str] = (
+        "Another round is available. You may do multiple actions if needed. "
+        "You have up to {extensions} expansions. Please continue."
+    )
+    ANSWER_PROMPT: ClassVar[str] = (
+        "Given your reasoning and actions, please now provide the final answer "
+        "to the user's request:\n\n{instruction}"
+    )
+
+    analysis: str = Field(
+        ...,
+        description="Free-form reasoning or chain-of-thought summary. Must be consistent with the plan.",
+    )
+
+    planned_actions: list[PlannedAction] = Field(
+        default_factory=list,
+        description=(
+            "One or more short descriptors of the tool calls or operations "
+            "the LLM wants to perform this round. For example, read the doc, "
+            "then run a search."
+        ),
+    )
+
+    extension_needed: bool = Field(
+        False,
+        description="Set True if more expansions are needed. If False, final answer is next.",
+    )
+
+    milestone: str | None = Field(
+        None,
+        description=(
+            "A sub-goal or mini-checkpoint to reach before finalizing. "
+            "E.g. 'Validate results from search_exa, then summarize outcomes.'"
+        ),
+    )
+
+    action_strategy: Literal["sequential", "concurrent", "batch"] = Field(
+        "concurrent",
+        description=(
+            "Specifies how to invoke the planned actions:\n"
+            "'sequential' => Each action is run in order, \n"
+            "'concurrent' => All actions run in parallel, \n"
+            "'batch' => Divide actions into async batches of N (if reasonable)."
+        ),
+    )
+
+    action_batch_size: int | None = Field(
+        None,
+        description=(
+            "provide if and only if action_strategy is 'batch', this specifies the number of actions to run in parallel per batch."
+        ),
+    )

{lionagi-0.8.5 → lionagi-0.8.6}/lionagi/operations/_act/act.py

@@ -18,6 +18,7 @@ async def _act(
     branch: "Branch",
     action_request: BaseModel | dict,
     suppress_errors: bool = False,
+    verbose_action: bool = False,
 ) -> "ActionResponseModel":
 
     _request = {}
@@ -35,6 +36,11 @@ async def _act(
 
     try:
         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),
@@ -43,6 +49,8 @@ async def _act(
             "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}"

lionagi-0.8.6/lionagi/operations/interpret/interpret.py

@@ -0,0 +1,74 @@
+# Copyright (c) 2023 - 2024, HaiyangLi <quantocean.li at gmail dot com>
+#
+# SPDX-License-Identifier: Apache-2.0
+
+from typing import TYPE_CHECKING
+
+if TYPE_CHECKING:
+    from lionagi.session.branch import Branch
+
+
+async def interpret(
+    branch: "Branch",
+    text: str,
+    domain: str | None = None,
+    style: str | None = None,
+    sample_writing: str | None = None,
+    **kwargs,
+) -> str:
+    instruction = """
+You are given a user's raw instruction or question. Your task is to rewrite it into a clearer, more structured prompt for an LLM or system, making any implicit or missing details explicit. 
+
+Follow these guidelines:
+
+1. **Dissect the user's request**:
+   - If the user references a local file, note it clearly (e.g., "paper_file_path": "…").
+   - If the user might need external references or up-to-date data, mention that possibility.
+   - If the user's question is ambiguous, propose clarifications.
+   
+2. **Be explicit about the user's final objective**:
+   - For example, if the user wants a comparison with other works, add that as a bullet point or sub-question.
+   - If the user wants a summary plus code snippet, highlight that in your structured prompt.
+
+3. **Do NOT produce final system actions**:
+   - You're not calling any tools directly here; only rewriting the user query to reflect potential next steps.
+   - If the user's request might require searching or doc reading, note it as an *option*, e.g. "Potential tool usage: {search, partial doc read}."
+
+4. **Return only the improved user prompt**:
+   - The final output should be a single text block or short JSON specifying the clarified user request.
+   - Keep it concise yet thorough.
+
+For instance, if the user's original text is:
+"Please read my local PDF on RL and compare it to the newest research methods from exa or perplexity."
+
+A re-written version might be:
+"**Task**: 
+- Summarize the local PDF (paper_file_path: 'myRLpaper.pdf'). 
+- Compare its approach with recent reinforcement learning research found via exa/perplexity searches.
+**Potential Tool Usage**: 
+- Doc reading (reader_tool)
+- External search (search_exa, search_perplexity)
+**Output**: 
+- A structured summary + comparative analysis."
+
+Now, apply this rewriting to the input below. Return only the re-written prompt.
+        """
+    guidance = (
+        f"Domain hint: {domain or 'general'}. "
+        f"Desired style: {style or 'concise'}. "
+    )
+    if sample_writing:
+        guidance += f" Sample writing: {sample_writing}"
+
+    context = [f"User input: {text}"]
+
+    # Default temperature if none provided
+    kwargs["guidance"] = guidance + "\n" + kwargs.get("guidance", "")
+    kwargs["instruction"] = instruction + "\n" + kwargs.get("instruction", "")
+    kwargs["temperature"] = kwargs.get("temperature", 0.1)
+
+    refined_prompt = await branch.chat(
+        context=context,
+        **kwargs,
+    )
+    return str(refined_prompt)

{lionagi-0.8.5 → lionagi-0.8.6}/lionagi/operations/operate/operate.py

@@ -50,6 +50,8 @@ async def operate(
     action_strategy: Literal[
         "sequential", "concurrent", "batch"
     ] = "concurrent",
+    action_batch_size: int = None,
+    verbose_action: bool = False,
     field_models: list[FieldModel] = None,
     exclude_fields: list | dict | None = None,
     request_params: ModelParams = None,
@@ -189,9 +191,13 @@ async def operate(
             if instruct.action_strategy
             else action_kwargs.get("strategy", "concurrent")
         )
+        if action_batch_size:
+            action_kwargs["batch_size"] = action_batch_size
 
         action_response_models = await branch.act(
-            response_model.action_requests, **action_kwargs
+            response_model.action_requests,
+            verbose_action=verbose_action,
+            **action_kwargs,
         )
         # Possibly refine the operative with the tool outputs
         operative = Step.respond_operative(

{lionagi-0.8.5 → lionagi-0.8.6}/lionagi/session/branch.py

@@ -48,6 +48,7 @@ from lionagi.protocols.types import (
 from lionagi.service.endpoints.base import EndPoint
 from lionagi.service.types import iModel, iModelManager
 from lionagi.settings import Settings
+from lionagi.tools.base import LionTool
 from lionagi.utils import UNDEFINED, alcall, bcall, copy
 
 if TYPE_CHECKING:
@@ -205,7 +206,9 @@ class Branch(Element, Communicatable, Relational):
         )
 
         # --- ActionManager ---
-        self._action_manager = ActionManager(tools)
+        self._action_manager = ActionManager()
+        if tools:
+            self.register_tools(tools)
 
         # --- LogManager ---
         if log_config:
@@ -346,19 +349,28 @@ class Branch(Element, Communicatable, Relational):
 
         return branch_clone
 
+    def _register_tool(self, tools: FuncTool | LionTool, update: bool = False):
+        if isinstance(tools, type) and issubclass(tools, LionTool):
+            tools = tools()
+        if isinstance(tools, LionTool):
+            tools = tools.to_tool()
+        self._action_manager.register_tool(tools, update=update)
+
     def register_tools(
-        self, tools: FuncTool | list[FuncTool], update: bool = False
+        self, tools: FuncTool | list[FuncTool] | LionTool, update: bool = False
     ):
         """
         Registers one or more tools in the ActionManager.
 
         Args:
-            tools (FuncTool | list[FuncTool]):
+            tools (FuncTool | list[FuncTool] | LionTool):
                 A single tool or a list of tools to register.
             update (bool, optional):
                 If `True`, updates existing tools with the same name.
         """
-        self._action_manager.register_tools(tools, update=update)
+        tools = [tools] if not isinstance(tools, list) else tools
+        for tool in tools:
+            self._register_tool(tool, update=update)
 
     # -------------------------------------------------------------------------
     # Conversion / Serialization
@@ -892,6 +904,11 @@ class Branch(Element, Communicatable, Relational):
         actions: bool = False,
         reason: bool = False,
         action_kwargs: dict = None,
+        action_strategy: Literal[
+            "sequential", "concurrent", "batch"
+        ] = "concurrent",
+        action_batch_size: int = None,
+        verbose_action: bool = False,
         field_models: list[FieldModel] = None,
         exclude_fields: list | dict | None = None,
         request_params: ModelParams = None,
@@ -966,6 +983,12 @@ class Branch(Element, Communicatable, Relational):
                 If `True`, signals that the LLM should provide chain-of-thought or reasoning (where applicable).
             action_kwargs (dict | None, optional):
                 Additional parameters for the `branch.act()` call if tools are invoked.
+            action_strategy (Literal["sequential","concurrent","batch"], optional):
+                The strategy for invoking tools (default: "concurrent").
+            action_batch_size (int, optional):
+                The batch size for concurrent tool invocation if `action_strategy="batch"`.
+            verbose_action (bool, optional):
+                If `True`, logs detailed information about tool invocation.
             field_models (list[FieldModel] | None, optional):
                 Field-level definitions or overrides for the model schema.
             exclude_fields (list|dict|None, optional):
@@ -1023,6 +1046,9 @@ class Branch(Element, Communicatable, Relational):
             actions=actions,
             reason=reason,
             action_kwargs=action_kwargs,
+            action_strategy=action_strategy,
+            action_batch_size=action_batch_size,
+            verbose_action=verbose_action,
             field_models=field_models,
             exclude_fields=exclude_fields,
             request_params=request_params,
@@ -1150,6 +1176,7 @@ class Branch(Element, Communicatable, Relational):
         self,
         action_request: ActionRequest | BaseModel | dict,
         suppress_errors: bool = False,
+        verbose_action: bool = False,
     ) -> ActionResponse:
         """
         Internal method to invoke a tool (action) asynchronously.
@@ -1165,13 +1192,19 @@ class Branch(Element, Communicatable, Relational):
         """
         from lionagi.operations._act.act import _act
 
-        return await _act(self, action_request, suppress_errors)
+        return await _act(
+            branch=self,
+            action_request=action_request,
+            suppress_errors=suppress_errors,
+            verbose_action=verbose_action,
+        )
 
     async def act(
         self,
         action_request: list | ActionRequest | BaseModel | dict,
         *,
         strategy: Literal["concurrent", "sequential", "batch"] = "concurrent",
+        verbose_action: bool = False,
         batch_size: int = None,
         suppress_errors: bool = True,
         sanitize_input: bool = False,
@@ -1197,6 +1230,10 @@ class Branch(Element, Communicatable, Relational):
             action_request (list|ActionRequest|BaseModel|dict):
                 A single or list of action requests, each requiring
                 `function` and `arguments`.
+            strategy (Literal["concurrent","sequential","batch"]):
+                The execution strategy to use.
+            verbose_action (bool):
+                If True, log detailed information about the action.
             suppress_errors (bool):
                 If True, log errors instead of raising exceptions.
             sanitize_input (bool):
@@ -1243,6 +1280,7 @@ class Branch(Element, Communicatable, Relational):
             case "concurrent":
                 return await self._concurrent_act(
                     action_request,
+                    verbose_action=verbose_action,
                     suppress_errors=suppress_errors,
                     sanitize_input=sanitize_input,
                     unique_input=unique_input,
@@ -1263,11 +1301,13 @@ class Branch(Element, Communicatable, Relational):
             case "sequential":
                 return await self._sequential_act(
                     action_request,
+                    verbose_action=verbose_action,
                     suppress_errors=suppress_errors,
                 )
             case "batch":
                 return await self._batch_act(
                     action_request,
+                    verbose_action=verbose_action,
                     batch_size=batch_size or 1,
                     max_concurrent=max_concurrent,
                     suppress_errors=suppress_errors,
@@ -1298,6 +1338,7 @@ class Branch(Element, Communicatable, Relational):
         self,
         action_request: ActionRequest | BaseModel | dict,
         suppress_errors: bool = True,
+        verbose_action: bool = False,
     ) -> list:
         action_request = (
             action_request
@@ -1307,7 +1348,11 @@ class Branch(Element, Communicatable, Relational):
         results = []
         for req in action_request:
             results.append(
-                await self._act(req, suppress_errors=suppress_errors)
+                await self._act(
+                    req,
+                    verbose_action=verbose_action,
+                    suppress_errors=suppress_errors,
+                )
             )
         return results
 
@@ -1560,6 +1605,7 @@ class Branch(Element, Communicatable, Relational):
         response_kwargs: dict | None = None,
         return_analysis: bool = False,
         analysis_model: iModel | None = None,
+        verbose: bool = False,
         **kwargs,
     ):
         """
@@ -1646,6 +1692,8 @@ class Branch(Element, Communicatable, Relational):
             response_kwargs=response_kwargs,
             return_analysis=return_analysis,
             analysis_model=analysis_model,
+            verbose_action=verbose,
+            verbose_analysis=verbose,
             **kwargs,
         )
 

lionagi-0.8.6/lionagi/tools/base.py

@@ -0,0 +1,12 @@
+from abc import ABC, abstractmethod
+
+from lionagi.operatives.action.tool import Tool
+
+
+class LionTool(ABC):
+    is_lion_system_tool: bool = True
+    system_tool_name: str
+
+    @abstractmethod
+    def to_tool(self) -> Tool:
+        pass