lionagi 0.8.4__py3-none-any.whl → 0.8.6__py3-none-any.whl

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/operations/ReAct/ReAct.py

@@ -21,6 +21,10 @@ 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_kwargs: dict | None = None,
     tools: Any = None,
     tool_schemas: Any = None,
     response_format: type[BaseModel] | BaseModel = None,
@@ -29,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"
@@ -43,7 +48,11 @@ async def ReAct(
                 instruct.to_dict()
                 if isinstance(instruct, Instruct)
                 else instruct
-            )
+            ),
+            domain=interpret_domain,
+            style=interpret_style,
+            sample_writing=interpret_sample,
+            **(interpret_kwargs or {}),
         )
 
     # Convert Instruct to dict if necessary
@@ -52,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)
@@ -73,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.")
@@ -80,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
@@ -95,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/operations/ReAct/utils.py

@@ -2,27 +2,91 @@
 #
 # SPDX-License-Identifier: Apache-2.0
 
-from typing import ClassVar
+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 are provided with additional rounds to perform reason action to provide an accurate final answer. you have max another {extensions} rounds. Pleasen continue."
+        "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] = (
-        "You are provided with another round, you have max another {extensions} rounds. Please continue."
+        "Another round is available. You may do multiple actions if needed. "
+        "You have up to {extensions} expansions. Please continue."
     )
-
     ANSWER_PROMPT: ClassVar[str] = (
-        "given above reason and actions, please provide final answer to the original user request:\n\n {instruction}"
+        "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."
+        ),
     )
 
-    analysis: str
     extension_needed: bool = Field(
         False,
-        description="Set to True if more steps are needed to provide an accurate answer. If True, additional rounds are allowed. Typically should be set to true if more actions should be taken or planned to be taken. If false, will proceed to provide final answer next.",
+        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/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/operations/interpret/interpret.py

@@ -16,15 +16,46 @@ async def interpret(
     sample_writing: str | None = None,
     **kwargs,
 ) -> str:
-    instruction = (
-        "Rewrite the following user input into a clear, structured prompt or "
-        "query for an LLM, ensuring any implicit details are made explicit. "
-        "Return only the improved user prompt."
-    )
+    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'}. "
-        "You can add or clarify context if needed."
     )
     if sample_writing:
         guidance += f" Sample writing: {sample_writing}"
@@ -32,11 +63,11 @@ async def interpret(
     context = [f"User input: {text}"]
 
     # Default temperature if none provided
-    kwargs["temperature"] = kwargs.get("temperature", 0.1)
     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(
-        instruction=instruction,
         context=context,
         **kwargs,
     )

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/service/endpoints/base.py

@@ -61,6 +61,7 @@ class EndpointConfig(BaseModel):
         use_enum_values=True,
     )
 
+    name: str | None = None
     provider: str | None = None
     base_url: str | None = None
     endpoint: str
@@ -75,6 +76,7 @@ class EndpointConfig(BaseModel):
     requires_tokens: bool = False
     api_version: str | None = None
     allowed_roles: list[str] | None = None
+    request_options: type | None = None
 
 
 class EndPoint(ABC):
@@ -100,6 +102,11 @@ class EndPoint(ABC):
         config.update(kwargs)
         self.config = EndpointConfig(**config)
 
+    @property
+    def name(self) -> str | None:
+        """str | None: The name of the endpoint, if any."""
+        return self.config.name or self.endpoint
+
     @property
     def is_streamable(self) -> bool:
         """bool: Whether this endpoint supports streaming responses."""
@@ -185,6 +192,10 @@ class EndPoint(ABC):
         """bool: Indicates if this endpoint uses role-based messages."""
         return self.allowed_roles is not None
 
+    @property
+    def request_options(self) -> type | None:
+        return self.config.request_options
+
     def create_payload(self, **kwargs) -> dict:
         """Generates a request payload (and headers) for this endpoint.
 

lionagi/service/imodel.py

@@ -5,6 +5,8 @@
 import os
 import warnings
 
+from pydantic import BaseModel
+
 from .endpoints.base import APICalling, EndPoint
 from .endpoints.match_endpoint import match_endpoint
 from .endpoints.rate_limited_processor import RateLimitedAPIExecutor
@@ -266,6 +268,15 @@ class iModel:
         """
         return self.kwargs.get("model", "")
 
+    @property
+    def request_options(self) -> type[BaseModel] | None:
+        """type[BaseModel] | None: The request options model for the endpoint.
+
+        Returns:
+            The request options model if available; otherwise, None.
+        """
+        return self.endpoint.request_options
+
     def to_dict(self):
         kwargs = self.kwargs
         if "kwargs" in self.kwargs:

lionagi/service/providers/exa_/search.py

@@ -1,10 +1,8 @@
-from typing import TYPE_CHECKING, Literal
+from typing import Literal
 
 from lionagi.service.endpoints.base import EndPoint
 
-if TYPE_CHECKING:
-    from .models import ExaSearchRequest
-
+from .models import ExaSearchRequest
 
 CATEGORY_OPTIONS = Literal[
     "article",
@@ -21,6 +19,7 @@ CATEGORY_OPTIONS = Literal[
 ]
 
 SEARCH_CONFIG = {
+    "name": "search_exa",
     "provider": "exa",
     "base_url": "https://api.exa.ai",
     "endpoint": "search",
@@ -47,6 +46,7 @@ SEARCH_CONFIG = {
         "type",  # keyword, neural, auto
         "useAutoPrompt",
     },
+    "request_options": ExaSearchRequest,
 }
 
 

lionagi/service/providers/perplexity_/chat_completions.py

@@ -4,7 +4,10 @@
 
 from lionagi.service.endpoints.chat_completion import ChatCompletionEndPoint
 
+from .models import PerplexityChatCompletionRequest
+
 CHAT_COMPLETION_CONFIG = {
+    "name": "search_perplexity",
     "provider": "perplexity",
     "base_url": "https://api.perplexity.ai",
     "endpoint": "chat/completions",
@@ -31,6 +34,7 @@ CHAT_COMPLETION_CONFIG = {
         "frequency_penalty",
     },
     "allowed_roles": ["user", "assistant"],
+    "request_options": PerplexityChatCompletionRequest,
 }
 
 

lionagi/service/providers/perplexity_/models.py

@@ -0,0 +1,144 @@
+from enum import Enum
+from typing import Any
+
+from pydantic import BaseModel, Field, model_validator
+
+
+class PerplexityRole(str, Enum):
+    """Roles allowed in Perplexity's messages."""
+
+    system = "system"
+    user = "user"
+    assistant = "assistant"
+
+
+class PerplexityMessage(BaseModel):
+    """
+    A single message in the conversation.
+    `role` can be 'system', 'user', or 'assistant'.
+    `content` is the text for that conversation turn.
+    """
+
+    role: PerplexityRole = Field(
+        ...,
+        description="The role of the speaker. Must be system, user, or assistant.",
+    )
+    content: str = Field(..., description="The text content of this message.")
+
+
+class PerplexityChatCompletionRequest(BaseModel):
+    """
+    Represents the request body for Perplexity's Chat Completions endpoint.
+    Endpoint: POST https://api.perplexity.ai/chat/completions
+    """
+
+    model: str = Field(
+        ...,
+        description="The model name, e.g. 'llama-3.1-sonar-small-128k-online'.",
+    )
+    messages: list[PerplexityMessage] = Field(
+        ..., description="A list of messages forming the conversation so far."
+    )
+
+    # Optional parameters
+    frequency_penalty: float | None = Field(
+        default=None,
+        gt=0,
+        description=(
+            "Multiplicative penalty > 0. Values > 1.0 penalize repeated tokens more strongly. "
+            "Value=1.0 means no penalty. Incompatible with presence_penalty."
+        ),
+    )
+    presence_penalty: float | None = Field(
+        default=None,
+        ge=-2.0,
+        le=2.0,
+        description=(
+            "Penalizes tokens that have appeared so far (range -2 to 2). "
+            "Positive values encourage talking about new topics. Incompatible with frequency_penalty."
+        ),
+    )
+    max_tokens: int | None = Field(
+        default=None,
+        description=(
+            "Maximum number of completion tokens. If omitted, model generates tokens until it "
+            "hits stop or context limit."
+        ),
+    )
+    return_images: bool | None = Field(
+        default=None,
+        description="If True, attempt to return images (closed beta feature).",
+    )
+    return_related_questions: bool | None = Field(
+        default=None,
+        description="If True, attempt to return related questions (closed beta feature).",
+    )
+    search_domain_filter: list[Any] | None = Field(
+        default=None,
+        description=(
+            "List of domains to limit or exclude in the online search. Example: ['example.com', '-twitter.com']. "
+            "Supports up to 3 entries. (Closed beta feature.)"
+        ),
+    )
+    search_recency_filter: str | None = Field(
+        default=None,
+        description=(
+            "Returns search results within a specified time interval: 'month', 'week', 'day', or 'hour'."
+        ),
+    )
+    stream: bool | None = Field(
+        default=None,
+        description=(
+            "If True, response is returned incrementally via Server-Sent Events (SSE)."
+        ),
+    )
+    temperature: float | None = Field(
+        default=None,
+        ge=0.0,
+        lt=2.0,
+        description=(
+            "Controls randomness of sampling, range [0, 2). Higher => more random. "
+            "Defaults to 0.2."
+        ),
+    )
+    top_k: int | None = Field(
+        default=None,
+        ge=0,
+        le=2048,
+        description=(
+            "Top-K filtering. 0 disables top-k filtering. If set, only the top K tokens are considered. "
+            "We recommend altering either top_k or top_p, but not both."
+        ),
+    )
+    top_p: float | None = Field(
+        default=None,
+        ge=0.0,
+        le=1.0,
+        description=(
+            "Nucleus sampling threshold. We recommend altering either top_k or top_p, but not both."
+        ),
+    )
+
+    @model_validator(mode="before")
+    def validate_penalties(cls, values):
+        """
+        Disallow using both frequency_penalty != 1.0 and presence_penalty != 0.0 at once,
+        since the docs say they're incompatible.
+        """
+        freq_pen = values.get("frequency_penalty", 1.0)
+        pres_pen = values.get("presence_penalty", 0.0)
+
+        # The doc states frequency_penalty is incompatible with presence_penalty.
+        # We'll enforce that if presence_penalty != 0, frequency_penalty must be 1.0
+        # or vice versa. Adjust logic as needed.
+        if pres_pen != 0.0 and freq_pen != 1.0:
+            raise ValueError(
+                "presence_penalty is incompatible with frequency_penalty. "
+                "Please use only one: either presence_penalty=0 with freq_pen !=1, "
+                "or presence_penalty!=0 with freq_pen=1."
+            )
+        return values
+
+    def to_dict(self) -> dict:
+        """Return a dict suitable for JSON serialization and sending to Perplexity API."""
+        return self.model_dump(exclude_none=True)

lionagi/session/branch.py

@@ -45,8 +45,10 @@ from lionagi.protocols.types import (
     SenderRecipient,
     System,
 )
+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:
@@ -204,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:
@@ -345,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
@@ -548,12 +561,38 @@ class Branch(Element, Communicatable, Relational):
 
     def connect(
         self,
-        name: str,
-        imodel: iModel,
-        request_options: type[BaseModel],
+        provider: str = None,
+        base_url: str = None,
+        endpoint: str | EndPoint = "chat",
+        endpoint_params: list[str] | None = None,
+        api_key: str = None,
+        queue_capacity: int = 100,
+        capacity_refresh_time: float = 60,
+        interval: float | None = None,
+        limit_requests: int = None,
+        limit_tokens: int = None,
+        invoke_with_endpoint: bool = False,
+        imodel: iModel = None,
+        name: str = None,
+        request_options: type[BaseModel] = None,
         description: str = None,
         update: bool = False,
     ):
+        if not imodel:
+            imodel = iModel(
+                provider=provider,
+                base_url=base_url,
+                endpoint=endpoint,
+                endpoint_params=endpoint_params,
+                api_key=api_key,
+                queue_capacity=queue_capacity,
+                capacity_refresh_time=capacity_refresh_time,
+                interval=interval,
+                limit_requests=limit_requests,
+                limit_tokens=limit_tokens,
+                invoke_with_endpoint=invoke_with_endpoint,
+            )
+
         if not update and name in self.tools:
             raise ValueError(f"Tool with name '{name}' already exists.")
 
@@ -563,13 +602,13 @@ class Branch(Element, Communicatable, Relational):
             self._log_manager.log(Log.create(api_call))
             return api_call.response
 
-        _connect.__name__ = name
+        _connect.__name__ = name or imodel.endpoint.name
         if description:
             _connect.__doc__ = description
 
         tool = Tool(
             func_callable=_connect,
-            request_options=request_options,
+            request_options=request_options or imodel.request_options,
         )
         self._action_manager.register_tools(tool, update=update)
 
@@ -865,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,
@@ -939,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):
@@ -996,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,
@@ -1123,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.
@@ -1138,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,
@@ -1170,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):
@@ -1216,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,
@@ -1236,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,
@@ -1271,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
@@ -1280,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
 
@@ -1521,6 +1593,10 @@ class Branch(Element, Communicatable, Relational):
         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_kwargs: dict | None = None,
         tools: Any = None,
         tool_schemas: Any = None,
         response_format: type[BaseModel] = None,
@@ -1529,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,
     ):
         """
@@ -1547,6 +1624,14 @@ class Branch(Element, Communicatable, Relational):
             interpret (bool, optional):
                 If `True`, first interprets (`branch.interpret`) the instructions to refine them
                 before proceeding. Defaults to `False`.
+            interpret_domain (str | None, optional):
+                Optional domain hint for the interpretation step.
+            interpret_style (str | None, optional):
+                Optional style hint for the interpretation step.
+            interpret_sample (str | None, optional):
+                Optional sample hint for the interpretation step.
+            interpret_kwargs (dict | None, optional):
+                Additional arguments for the interpretation step.
             tools (Any, optional):
                 Tools to be made available for the ReAct process. If omitted or `None`,
                 and if no `tool_schemas` are provided, it defaults to `True` (all tools).
@@ -1595,6 +1680,10 @@ class Branch(Element, Communicatable, Relational):
             self,
             instruct,
             interpret=interpret,
+            interpret_domain=interpret_domain,
+            interpret_style=interpret_style,
+            interpret_sample=interpret_sample,
+            interpret_kwargs=interpret_kwargs,
             tools=tools,
             tool_schemas=tool_schemas,
             response_format=response_format,
@@ -1603,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/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

lionagi/tools/reader.py

@@ -0,0 +1,244 @@
+import tempfile
+from enum import Enum
+
+from pydantic import BaseModel, Field, field_validator
+
+from lionagi.operatives.action.tool import Tool
+from lionagi.utils import to_num
+
+from .base import LionTool
+
+
+class ReaderAction(str, Enum):
+    """
+    This enumeration indicates the *type* of action the LLM wants to perform.
+    - 'open': Convert a file/URL to text and store it internally for partial reads
+    - 'read': Return a partial slice of the already-opened doc
+    """
+
+    open = "open"
+    read = "read"
+
+
+class ReaderRequest(BaseModel):
+    """
+    The request model for the 'ReaderTool'.
+    It indicates:
+      - whether we are 'open'-ing a doc or 'read'-ing from a doc
+      - which file/URL we want to open (if action='open')
+      - which doc_id and offsets we want to read (if action='read')
+    """
+
+    action: ReaderAction = Field(
+        ...,
+        description=(
+            "Action to perform. Must be one of: "
+            "- 'open': Convert a file/URL to text and store it internally for partial reads. "
+            "- 'read': Return a partial slice of the already-opened doc."
+        ),
+    )
+
+    path_or_url: str | None = Field(
+        None,
+        description=(
+            "Local file path or remote URL to open. This field is REQUIRED if action='open'. "
+            "If action='read', leave it None."
+        ),
+    )
+
+    doc_id: str | None = Field(
+        None,
+        description=(
+            "Unique ID referencing a previously opened document. "
+            "This field is REQUIRED if action='read'. If action='open', leave it None."
+        ),
+    )
+
+    start_offset: int | None = Field(
+        None,
+        description=(
+            "Character start offset in the doc for partial reading. "
+            "If omitted or None, defaults to 0. Only used if action='read'."
+        ),
+    )
+
+    end_offset: int | None = Field(
+        None,
+        description=(
+            "Character end offset in the doc for partial reading. "
+            "If omitted or None, we read until the document's end. Only used if action='read'."
+        ),
+    )
+
+    @field_validator("start_offset", "end_offset", mode="before")
+    def _validate_offsets(cls, v):
+        try:
+            return to_num(v, num_type=int)
+        except ValueError:
+            return None
+
+
+class DocumentInfo(BaseModel):
+    """
+    Returned info when we 'open' a doc.
+    doc_id: The unique string to reference this doc in subsequent 'read' calls
+    length: The total character length of the converted text
+    """
+
+    doc_id: str
+    length: int | None = None
+
+
+class PartialChunk(BaseModel):
+    """
+    Represents a partial slice of text from [start_offset..end_offset).
+    """
+
+    start_offset: int | None = None
+    end_offset: int | None = None
+    content: str | None = None
+
+
+class ReaderResponse(BaseModel):
+    """
+    The response from the 'ReaderTool'.
+    - If action='open' succeeded, doc_info is filled (doc_id & length).
+    - If action='read' succeeded, chunk is filled (the partial text).
+    - If failure occurs, success=False & error hold details.
+    """
+
+    success: bool = Field(
+        ...,
+        description=(
+            "Indicates if the requested action was performed successfully."
+        ),
+    )
+    error: str | None = Field(
+        None,
+        description=("Describes any error that occurred, if success=False."),
+    )
+    doc_info: DocumentInfo | None = Field(
+        None,
+        description=(
+            "Populated only if action='open' succeeded, letting the LLM know doc_id & total length."
+        ),
+    )
+    chunk: PartialChunk | None = Field(
+        None,
+        description=(
+            "Populated only if action='read' succeeded, providing the partial slice of text."
+        ),
+    )
+
+
+class ReaderTool(LionTool):
+    """
+    A single tool that the LLM can call with ReaderRequest to either:
+      - open a doc (File/URL) -> returns doc_id, doc length
+      - read partial text from doc -> returns chunk
+    """
+
+    is_lion_system_tool = True
+    system_tool_name = "reader_tool"
+
+    from lionagi.libs.package.imports import check_import
+
+    DocumentConverter = check_import(
+        "docling",
+        module_name="document_converter",
+        import_name="DocumentConverter",
+    )
+
+    def __init__(self):
+        super().__init__()
+        self.converter = ReaderTool.DocumentConverter()
+        self.documents = {}  # doc_id -> (temp_file_path, doc_length)
+        self._tool = None
+
+    def handle_request(self, request: ReaderRequest) -> ReaderResponse:
+        """
+        A function that takes ReaderRequest to either:
+        - open a doc (File/URL) -> returns doc_id, doc length
+        - read partial text from doc -> returns chunk
+        """
+        if isinstance(request, dict):
+            request = ReaderRequest(**request)
+        if request.action == "open":
+            return self._open_doc(request.path_or_url)
+        elif request.action == "read":
+            return self._read_doc(
+                request.doc_id, request.start_offset, request.end_offset
+            )
+        else:
+            return ReaderResponse(success=False, error="Unknown action type")
+
+    def _open_doc(self, source: str) -> ReaderResponse:
+        try:
+            result = self.converter.convert(source)
+            text = result.document.export_to_markdown()
+        except Exception as e:
+            return ReaderResponse(
+                success=False, error=f"Conversion error: {str(e)}"
+            )
+
+        doc_id = f"DOC_{abs(hash(source))}"
+        temp_file = tempfile.NamedTemporaryFile(
+            delete=False, mode="w", encoding="utf-8"
+        )
+        temp_file.write(text)
+        doc_len = len(text)
+        temp_file.close()
+
+        # store info
+        self.documents[doc_id] = (temp_file.name, doc_len)
+
+        return ReaderResponse(
+            success=True, doc_info=DocumentInfo(doc_id=doc_id, length=doc_len)
+        )
+
+    def _read_doc(self, doc_id: str, start: int, end: int) -> ReaderResponse:
+        if doc_id not in self.documents:
+            return ReaderResponse(
+                success=False, error="doc_id not found in memory"
+            )
+
+        path, length = self.documents[doc_id]
+        # clamp offsets
+        s = max(0, start if start is not None else 0)
+        e = min(length, end if end is not None else length)
+
+        try:
+            with open(path, "r", encoding="utf-8") as f:
+                f.seek(s)
+                content = f.read(e - s)
+        except Exception as ex:
+            return ReaderResponse(
+                success=False, error=f"Read error: {str(ex)}"
+            )
+
+        return ReaderResponse(
+            success=True,
+            chunk=PartialChunk(start_offset=s, end_offset=e, content=content),
+        )
+
+    def to_tool(self):
+        if self._tool is None:
+
+            def reader_tool(**kwargs):
+                """
+                A function that takes ReaderRequest to either:
+                - open a doc (File/URL) -> returns doc_id, doc length
+                - read partial text from doc -> returns chunk
+                """
+                return self.handle_request(
+                    ReaderRequest(**kwargs)
+                ).model_dump()
+
+            if self.system_tool_name != "reader_tool":
+                reader_tool.__name__ = self.system_tool_name
+
+            self._tool = Tool(
+                func_callable=reader_tool,
+                request_options=ReaderRequest,
+            )
+        return self._tool

lionagi/tools/types.py

@@ -0,0 +1,3 @@
+from .reader import ReaderTool
+
+__all__ = ("ReaderTool",)

lionagi/version.py

@@ -1 +1 @@
-__version__ = "0.8.4"
+__version__ = "0.8.6"

{lionagi-0.8.4.dist-info → lionagi-0.8.6.dist-info}/METADATA

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

{lionagi-0.8.4.dist-info → lionagi-0.8.6.dist-info}/RECORD

@@ -1,10 +1,10 @@
-lionagi/__init__.py,sha256=-tKLn-wTj_VK4XQr3CV16ioTNnaUYD2fhUAtJOZZ0vU,574
+lionagi/__init__.py,sha256=TWvUzgX_HgXO6xoShWT3kY8BNaZDOc8JIOu59PFqN2M,672
 lionagi/_class_registry.py,sha256=dutMsw-FQNqVV5gGH-NEIv90uBkSr8fERJ_x3swbb-s,3112
 lionagi/_errors.py,sha256=wNKdnVQvE_CHEstK7htrrj334RA_vbGcIds-3pUiRkc,455
 lionagi/_types.py,sha256=9g7iytvSj3UjZxD-jL06_fxuNfgZyWT3Qnp0XYp1wQU,63
 lionagi/settings.py,sha256=k9zRJXv57TveyfHO3Vr9VGiKrSwlRUUVKt5zf6v9RU4,1627
 lionagi/utils.py,sha256=QbF4E1PG-BaRcEVH3kJIYCJVNq-oRNoTxjda5k8NYW4,73177
-lionagi/version.py,sha256=jhHEJFZWhkQDemoZMomBYq-RNrKXknYzUaeIU9A6XsI,22
+lionagi/version.py,sha256=VpASnrti7EGWxUfSWGgERUfe7NLJltfVXYosOzHbpPg,22
 lionagi/libs/__init__.py,sha256=v8vNyJVIVj8_Oz9RJdVe6ZKUQMYTgDh1VQpnr1KdLaw,112
 lionagi/libs/parse.py,sha256=tpEbmIRGuHhLCJlUlm6fjmqm_Z6XJLAXGNFHNuk422I,1011
 lionagi/libs/file/__init__.py,sha256=v8vNyJVIVj8_Oz9RJdVe6ZKUQMYTgDh1VQpnr1KdLaw,112
@@ -48,11 +48,11 @@ lionagi/operations/__init__.py,sha256=O7nV0tedpUe7_OlUWmCcduGPFtqtzWZcR_SIOnjLsr
 lionagi/operations/manager.py,sha256=H7UY86PIxvxKdzJY9YVsWyJcqlwLWhVyvm4sYePH_uY,565
 lionagi/operations/types.py,sha256=LIa68xcyKLVafof-DSFwKtSkneuYPFqrtGyClohYI6o,704
 lionagi/operations/utils.py,sha256=Twy6L_UFt9JqJFRYuKKTKVZIXsePidNl5ipcYcCbesI,1220
-lionagi/operations/ReAct/ReAct.py,sha256=07F_VhxNnOhOInEZkbY9nT2YiCcnApSibxjz2yAa7Wk,3696
+lionagi/operations/ReAct/ReAct.py,sha256=odFcuNMuwJ2NjUGGdTekFJzD43WFvNFNHCjzS1X6HT8,4962
 lionagi/operations/ReAct/__init__.py,sha256=v8vNyJVIVj8_Oz9RJdVe6ZKUQMYTgDh1VQpnr1KdLaw,112
-lionagi/operations/ReAct/utils.py,sha256=yBsbaZm3NNb-LhdjdK3jVmxSYbp0enWzl8d09iv8oSo,1099
+lionagi/operations/ReAct/utils.py,sha256=uWPZC1aJVAPvJweAgr3NdXpYszeagN5OnJIkUdrSvlw,3228
 lionagi/operations/_act/__init__.py,sha256=v8vNyJVIVj8_Oz9RJdVe6ZKUQMYTgDh1VQpnr1KdLaw,112
-lionagi/operations/_act/act.py,sha256=HBp-sNwNigLDNkuEZqGU_98UCaJXPZsaokkFAXwOMn0,2454
+lionagi/operations/_act/act.py,sha256=FWK8vXiccBZI_sIQcEBw8Cn6slMooZkfmkmxBaYA4kw,2739
 lionagi/operations/brainstorm/__init__.py,sha256=v8vNyJVIVj8_Oz9RJdVe6ZKUQMYTgDh1VQpnr1KdLaw,112
 lionagi/operations/brainstorm/brainstorm.py,sha256=OwByrh6E-rTU_u6fDNTwWOlkJ4ycYJB9ZF-x-HYOs8I,17222
 lionagi/operations/brainstorm/prompt.py,sha256=f-Eh6pO606dT2TrX9BFv_einRDpYwFi6Gep9Strd1cM,610
@@ -63,9 +63,9 @@ lionagi/operations/communicate/communicate.py,sha256=1PzBpzgATcAdBog0EUxtj5_uJGi
 lionagi/operations/instruct/__init__.py,sha256=v8vNyJVIVj8_Oz9RJdVe6ZKUQMYTgDh1VQpnr1KdLaw,112
 lionagi/operations/instruct/instruct.py,sha256=CYICzWvmgALtSPIetfF3csx6WDsCuiu4NRRPL56UA2g,795
 lionagi/operations/interpret/__init__.py,sha256=v8vNyJVIVj8_Oz9RJdVe6ZKUQMYTgDh1VQpnr1KdLaw,112
-lionagi/operations/interpret/interpret.py,sha256=mjTcOCOixc34JNnX0WowSVACtZXz9IBuzjp9VyOus5w,1244
+lionagi/operations/interpret/interpret.py,sha256=Mtg65jletgMZAZ08kNLgjbC_y9C3l2xw67fHpHmBesg,2905
 lionagi/operations/operate/__init__.py,sha256=v8vNyJVIVj8_Oz9RJdVe6ZKUQMYTgDh1VQpnr1KdLaw,112
-lionagi/operations/operate/operate.py,sha256=kzH7R4J3O-1Ue-PYqIoEdrXHrkYYQVfHa6gSC4Km_sc,7003
+lionagi/operations/operate/operate.py,sha256=eHf1wopNm04hOAg1NMcrn6nz4acofUENi0R4r8FQMMs,7218
 lionagi/operations/parse/__init__.py,sha256=v8vNyJVIVj8_Oz9RJdVe6ZKUQMYTgDh1VQpnr1KdLaw,112
 lionagi/operations/parse/parse.py,sha256=LpF6LVAvCVoE8n63BkhSxXSHYgSx7CNkN7yXUwaNpQo,3003
 lionagi/operations/plan/__init__.py,sha256=AFkAmOJBTqPlYuqFRRn7rCvIw3CGh9XXH_22cNWbfig,156
@@ -161,11 +161,11 @@ lionagi/protocols/messages/templates/instruction_message.jinja2,sha256=L-ptw5OHx
 lionagi/protocols/messages/templates/system_message.jinja2,sha256=JRKJ0aFpYfaXSFouKc_N4unZ35C3yZTOWhIrIdCB5qk,215
 lionagi/protocols/messages/templates/tool_schemas.jinja2,sha256=ozIaSDCRjIAhLyA8VM6S-YqS0w2NcctALSwx4LjDwII,126
 lionagi/service/__init__.py,sha256=DMGXIqPsmut9H5GT0ZeSzQIzYzzPwI-2gLXydpbwiV8,21
-lionagi/service/imodel.py,sha256=Mv5wVsmZj4hYmrvXfHVmA-fskfAKrDY0mbdmgOCAGoE,11946
+lionagi/service/imodel.py,sha256=zQq9cdVPpEAPB7IscntExvtHOYA5ToiWonmD2n93pEw,12273
 lionagi/service/manager.py,sha256=MKSYBkg23s7YhZy5GEFdnpspEnhPVfFhpkpoJe20D7k,1435
 lionagi/service/types.py,sha256=v9SAn5-GTmds4Mar13Or_VFrRHCinBK99dmeDUd-QNk,486
 lionagi/service/endpoints/__init__.py,sha256=v8vNyJVIVj8_Oz9RJdVe6ZKUQMYTgDh1VQpnr1KdLaw,112
-lionagi/service/endpoints/base.py,sha256=RbBBQIbtNtkP1LT9U3ZrhL35SfmVIpaq-AGW8d538k4,18275
+lionagi/service/endpoints/base.py,sha256=SaYobDBCdKd4398TyFPp5u3PKyMnzEbm6PsoUxVkZDA,18605
 lionagi/service/endpoints/chat_completion.py,sha256=9ltSQaKPH43WdEDW32_-f5x07I9hOU8g-T_PAG-nYsQ,2529
 lionagi/service/endpoints/match_endpoint.py,sha256=hIGYyok1y53FfI6av5NfYMygRIpDWYZbdCj0pJJfmPY,1874
 lionagi/service/endpoints/rate_limited_processor.py,sha256=umri0FofbyBSFdAQBEsviDB5K6N12LkRiXQgSOorGKg,4663
@@ -176,7 +176,7 @@ lionagi/service/providers/anthropic_/__init__.py,sha256=v8vNyJVIVj8_Oz9RJdVe6ZKU
 lionagi/service/providers/anthropic_/messages.py,sha256=PTZZ2VXVMRHWY84YFIzrft9gVrcH2V-NIq_Phi9_-xI,1760
 lionagi/service/providers/exa_/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 lionagi/service/providers/exa_/models.py,sha256=263KP-JSxbxmomNrFeYjB_cebquoMOsCJeWsiKZ0mL4,5420
-lionagi/service/providers/exa_/search.py,sha256=Z9bOxTjPZbtI_qH4fSePYKSXhkc8N3ZFbCHdsml8YSA,1903
+lionagi/service/providers/exa_/search.py,sha256=Z3pyJH8KiWiquJSJw8Rd6D7x43BwTFHb2ESsgSicCk0,1932
 lionagi/service/providers/exa_/types.py,sha256=8ODjXpFajBE9-DGqBJNS--GObwmLSDi667xS84z_AgA,139
 lionagi/service/providers/groq_/__init__.py,sha256=v8vNyJVIVj8_Oz9RJdVe6ZKUQMYTgDh1VQpnr1KdLaw,112
 lionagi/service/providers/groq_/chat_completions.py,sha256=578NqQYyrIYjIemyL3bagvFGE6ear_w4S1HNlPWA5mg,1343
@@ -185,11 +185,16 @@ lionagi/service/providers/openai_/chat_completions.py,sha256=SfRcEnMTn3MD59YuZCl
 lionagi/service/providers/openrouter_/__init__.py,sha256=v8vNyJVIVj8_Oz9RJdVe6ZKUQMYTgDh1VQpnr1KdLaw,112
 lionagi/service/providers/openrouter_/chat_completions.py,sha256=MRf4ZbMCgzNIL4gxUZTD-KeFe8JYDn1Fu40Jph3bCH8,1525
 lionagi/service/providers/perplexity_/__init__.py,sha256=v8vNyJVIVj8_Oz9RJdVe6ZKUQMYTgDh1VQpnr1KdLaw,112
-lionagi/service/providers/perplexity_/chat_completions.py,sha256=SsDbrtXwQsR4Yu2VMU43KfeS86QWI8UTNhDth5lNWNs,1055
+lionagi/service/providers/perplexity_/chat_completions.py,sha256=jhE-KHWRX6yYEeKWLMCKLgK3bQzieSv2viqQWDP8q0Q,1197
+lionagi/service/providers/perplexity_/models.py,sha256=gXH4XGkhZ4aFxvMSDTlHq9Rz1mhu3aTENXAtE-BIr6U,4866
 lionagi/session/__init__.py,sha256=v8vNyJVIVj8_Oz9RJdVe6ZKUQMYTgDh1VQpnr1KdLaw,112
-lionagi/session/branch.py,sha256=ZLItnjW66__85s0brxhq1LZisjDoVS4HBJSHUpFaxsg,63834
+lionagi/session/branch.py,sha256=EH1JhOe1ZGlCVXpf0znz_xAA3GibNIGFATwLAyxiCK0,67835
 lionagi/session/session.py,sha256=po6C7PnM0iu_ISHUo4PBzzQ61HFOgcsAUfPoO--eLak,8987
-lionagi-0.8.4.dist-info/METADATA,sha256=MHgfVuup5176MSrXlfX2B_tQUaiKNdGAjtITrJVLCWY,22819
-lionagi-0.8.4.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
-lionagi-0.8.4.dist-info/licenses/LICENSE,sha256=VXFWsdoN5AAknBCgFqQNgPWYx7OPp-PFEP961zGdOjc,11288
-lionagi-0.8.4.dist-info/RECORD,,
+lionagi/tools/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+lionagi/tools/base.py,sha256=ffaIcLF_uwEphCkP_wsa3UfkqVenML3HpsnR5kRCTtA,236
+lionagi/tools/reader.py,sha256=TyjSqhSIQwxdkwgYSz760YKBbqJ5OfwZegRwQz47R24,7509
+lionagi/tools/types.py,sha256=_OWzoTHTcqNwPs3OGrPkpO9m_vHDCxVDL-FN-t6ZD60,58
+lionagi-0.8.6.dist-info/METADATA,sha256=SmTcVVpZcb_nfuNo5WrDS6ilr16Tj0qL_yX-AAP1ri0,22819
+lionagi-0.8.6.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+lionagi-0.8.6.dist-info/licenses/LICENSE,sha256=VXFWsdoN5AAknBCgFqQNgPWYx7OPp-PFEP961zGdOjc,11288
+lionagi-0.8.6.dist-info/RECORD,,