lionagi 0.8.2__tar.gz → 0.8.3__tar.gz

{lionagi-0.8.2 → lionagi-0.8.3}/PKG-INFO

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

{lionagi-0.8.2 → lionagi-0.8.3}/lionagi/operations/ReAct/ReAct.py

@@ -11,6 +11,8 @@ from lionagi.operatives.types import Instruct
 from lionagi.service.imodel import iModel
 from lionagi.utils import copy
 
+from .utils import ReActAnalysis
+
 if TYPE_CHECKING:
     from lionagi.session.branch import Branch
 
@@ -60,11 +62,9 @@ async def ReAct(
     kwargs_for_operate["actions"] = True
     kwargs_for_operate["reason"] = True
 
-    # We'll pass the refined instruct_dict plus the user's other kwargs
-    from .utils import ReActAnalysis
-
     # Step 1: Generate initial ReAct analysis
     analysis: ReActAnalysis = await branch.operate(
+        instruct=instruct_dict,
         response_format=ReActAnalysis,
         tools=tools,
         tool_schemas=tool_schemas,
@@ -83,7 +83,7 @@ async def ReAct(
     while (
         extension_allowed
         and analysis.extension_needed
-        and (extensions if extensions else 1) > 0
+        and (extensions if max_extensions else 0) > 0
     ):
         new_instruction = None
         if extensions == max_extensions:
@@ -95,17 +95,13 @@ async def ReAct(
                 extensions=extensions
             )
 
-        # Each expansion uses a fresh copy of instruct_dict + forcibly "reason" + "actions"
-        expanded_kwargs = copy(instruct_dict)
-        expanded_kwargs["instruction"] = new_instruction
-        expanded_kwargs["reason"] = True
-        expanded_kwargs["actions"] = True
-
         analysis = await branch.operate(
+            instruction=new_instruction,
             response_format=ReActAnalysis,
             tools=tools,
             tool_schemas=tool_schemas,
-            **expanded_kwargs,
+            reason=True,
+            actions=True,
         )
         analyses.append(analysis)
 

{lionagi-0.8.2 → lionagi-0.8.3}/lionagi/operations/ReAct/utils.py

@@ -10,19 +10,19 @@ from pydantic import BaseModel, Field
 class ReActAnalysis(BaseModel):
 
     FIRST_EXT_PROMPT: ClassVar[str] = (
-        "You are provided with another round to perform reason action to provide an accurate final answer. you have max another {extensions} rounds, set extension_needed to False if you are done and ready to provide final answer."
+        "You are provided with additional rounds to perform reason action to provide an accurate final answer. you have max another {extensions} rounds. Pleasen continue."
     )
 
     CONTINUE_EXT_PROMPT: ClassVar[str] = (
-        "You are provided with another round, you have max another {extensions} rounds"
+        "You are provided with another round, you have max another {extensions} rounds. Please continue."
     )
 
     ANSWER_PROMPT: ClassVar[str] = (
-        "given above reason and actions, please provide final answer to the original user request {instruction}"
+        "given above reason and actions, please provide final answer to the original user request:\n\n {instruction}"
     )
 
     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.",
+        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.",
     )

{lionagi-0.8.2 → lionagi-0.8.3}/lionagi/operatives/action/function_calling.py

@@ -5,7 +5,7 @@
 import asyncio
 from typing import Any
 
-from pydantic import Field, model_validator
+from pydantic import BaseModel, Field, field_validator, model_validator
 from typing_extensions import Self
 
 from lionagi.protocols.generic.event import Event, EventStatus
@@ -27,12 +27,22 @@ class FunctionCalling(Event):
         exclude=True,
     )
 
-    arguments: dict[str, Any] = Field(
+    arguments: dict[str, Any] | BaseModel = Field(
         ..., description="Dictionary of arguments to pass to the function"
     )
 
+    @field_validator("arguments", mode="before")
+    def _validate_argument(cls, value):
+        if isinstance(value, BaseModel):
+            return value.model_dump(exclude_unset=True)
+        return value
+
     @model_validator(mode="after")
     def _validate_strict_tool(self) -> Self:
+        if self.func_tool.request_options:
+            args: BaseModel = self.func_tool.request_options(**self.arguments)
+            self.arguments = args.model_dump(exclude_unset=True)
+
         if self.func_tool.strict_func_call is True:
             if (
                 not set(self.arguments.keys())

{lionagi-0.8.2 → lionagi-0.8.3}/lionagi/operatives/action/tool.py

@@ -12,6 +12,7 @@ import inspect
 from collections.abc import Callable
 from typing import Any, TypeAlias
 
+from openai import BaseModel
 from pydantic import Field, field_validator, model_validator
 from typing_extensions import Self
 
@@ -49,6 +50,11 @@ class Tool(Element):
         description="Schema describing the function's parameters and structure",
     )
 
+    request_options: type | None = Field(
+        default=None,
+        description="Optional Pydantic model for validating the function's input",
+    )
+
     preprocessor: Callable[[Any], Any] | None = Field(
         default=None,
         description="Optional function for preprocessing inputs before execution",
@@ -88,6 +94,11 @@ class Tool(Element):
     def _validate_tool_schema(self) -> Self:
         if self.tool_schema is None:
             self.tool_schema = function_to_schema(self.func_callable)
+        if self.request_options is not None:
+            schema_ = self.request_options.model_json_schema()
+            schema_.pop("title", None)
+            self.tool_schema["function"]["parameters"] = schema_
+
         return self
 
     @property

{lionagi-0.8.2 → lionagi-0.8.3}/lionagi/protocols/messages/instruction.py

@@ -81,68 +81,121 @@ def format_text_item(item: Any) -> str:
 
 def format_text_content(content: dict) -> str:
     """
-    Convert a dictionary with keys like 'guidance', 'instruction', 'context', etc.
-    into a readable text block.
+    Convert a content dictionary into a minimal textual summary for LLM consumption.
 
-    Args:
-        content (dict): The content dictionary.
-
-    Returns:
-        str: A textual summary.
+    Emphasizes brevity and clarity:
+      - Skips empty or None fields.
+      - Bullet-points for lists.
+      - Key-value pairs for dicts.
+      - Minimal headings for known fields (guidance, instruction, etc.).
     """
-    if "plain_content" in content and isinstance(
-        content["plain_content"], str
-    ):
-        return content["plain_content"]
 
-    msg = "\n---\n # Task\n"
+    if isinstance(content.get("plain_content"), str):
+        return content["plain_content"]
 
-    for k in [
+    lines = []
+    # We only want minimal headings for certain known fields:
+    known_field_order = [
         "guidance",
         "instruction",
         "context",
         "tool_schemas",
         "respond_schema_info",
         "request_response_format",
-    ]:
-        if k in content:
-            v = content[k]
-
-            if k == "tool_schemas":
-                if "tools" in v:
-                    v = v["tools"]
-
-                if isinstance(v, list):
-                    z = []
-                    for idx, z_ in enumerate(v):
-                        if isinstance(z_, dict) and "function" in z_:
-                            z.append({f"Tool {idx+1}": z_["function"]})
-                    v = z
-
-            if k == "request_response_format":
-                k = "response format"
-
-            if v not in [None, [], {}, UNDEFINED]:
-                if isinstance(v, list):
-                    msg += f"## - **{k}**\n"
-                    for i in v:
-                        if (
-                            len(format_text_item(v).replace("\n", "").strip())
-                            > 0
-                        ):
-                            msg += format_text_item(i).strip()
-                    msg += "\n"
-                else:
-                    if len(format_text_item(v).replace("\n", "").strip()) > 0:
-                        msg += (
-                            f"## - **{k}**\n{format_text_item(v).strip()}\n\n"
-                        )
-
-    if not msg.endswith("\n\n"):
-        msg += "\n\n---\n"
+    ]
+
+    # Render known fields in that order
+    for field in known_field_order:
+        if field in content:
+            val = content[field]
+            if _is_not_empty(val):
+                if field == "request_response_format":
+                    field = "response format"
+                elif field == "respond_schema_info":
+                    field = "response schema info"
+                lines.append(f"\n## {field.upper()}:\n")
+                rendered = _render_value(val)
+                # Indent or bullet the rendered result if multiline
+                # We'll keep it minimal: each line is prefixed with "  ".
+                lines.extend(
+                    f"  {line}"
+                    for line in rendered.split("\n")
+                    if line.strip()
+                )
+
+    # Join all lines into a single string
+    return "\n".join(lines).strip()
+
+
+def _render_value(val) -> str:
+    """
+    Render an arbitrary value (scalar, list, dict) in minimal form:
+    - Lists become bullet points.
+    - Dicts become key-value lines.
+    - Strings returned directly.
+    """
+    if isinstance(val, dict):
+        return _render_dict(val)
+    elif isinstance(val, list):
+        return _render_list(val)
     else:
-        msg += "---\n"
-    return msg
+        return str(val).strip()
+
+
+def _render_dict(dct: dict) -> str:
+    """
+    Minimal bullet list for dictionary items:
+      key: rendered subvalue
+    """
+    lines = []
+    for k, v in dct.items():
+        if not _is_not_empty(v):
+            continue
+        subrendered = _render_value(v)
+        # Indent subrendered if multiline
+        sublines = subrendered.split("\n")
+        if len(sublines) == 1:
+            if sublines[0].startswith("- "):
+                lines.append(f"- {k}: {sublines[0][2:]}")
+            else:
+                lines.append(f"- {k}: {sublines[0]}")
+        else:
+            lines.append(f"- {k}:")
+            for s in sublines:
+                lines.append(f"  {s}")
+    return "\n".join(lines)
+
+
+def _render_list(lst: list) -> str:
+    """
+    Each item in the list gets a bullet. Nested structures are recursed.
+    """
+    lines = []
+    for idx, item in enumerate(lst, 1):
+        sub = _render_value(item)
+        sublines = sub.split("\n")
+        if len(sublines) == 1:
+            if sublines[0].startswith("- "):
+                lines.append(f"- {sublines[0][2:]}")
+            else:
+                lines.append(f"- {sublines[0]}")
+        else:
+            lines.append("-")
+            lines.extend(f"  {s}" for s in sublines)
+    return "\n".join(lines)
+
+
+def _is_not_empty(x) -> bool:
+    """
+    Returns True if x is neither None, nor empty string/list/dict.
+    """
+    if x is None:
+        return False
+    if isinstance(x, (list, dict)) and not x:
+        return False
+    if isinstance(x, str) and not x.strip():
+        return False
+    return True
 
 
 def format_image_content(

lionagi-0.8.3/lionagi/version.py

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

{lionagi-0.8.2 → lionagi-0.8.3}/pyproject.toml

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

{lionagi-0.8.2 → lionagi-0.8.3}/uv.lock

@@ -895,7 +895,7 @@ wheels = [
 
 [[package]]
 name = "lionagi"
-version = "0.8.2"
+version = "0.8.3"
 source = { editable = "." }
 dependencies = [
     { name = "aiocache" },

lionagi-0.8.2/lionagi/version.py

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