lionagi 0.8.4__tar.gz → 0.8.6__tar.gz

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

@@ -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 → 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.4 → lionagi-0.8.6}/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-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.4 → 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.4 → 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.4 → lionagi-0.8.6}/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-0.8.4 → lionagi-0.8.6}/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-0.8.4 → lionagi-0.8.6}/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-0.8.4 → lionagi-0.8.6}/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-0.8.6/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)