lionagi 0.7.4__tar.gz → 0.7.6__tar.gz

{lionagi-0.7.4 → lionagi-0.7.6}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: lionagi
-Version: 0.7.4
+Version: 0.7.6
 Summary: An Intelligence Operating System.
 Author-email: HaiyangLi <quantocean.li@gmail.com>
 License:            Apache License
@@ -214,6 +214,7 @@ Classifier: License :: OSI Approved :: Apache Software License
 Classifier: Operating System :: OS Independent
 Classifier: Programming Language :: Python :: 3
 Classifier: Programming Language :: Python :: 3 :: Only
+Classifier: Programming Language :: Python :: 3.10
 Classifier: Programming Language :: Python :: 3.11
 Classifier: Programming Language :: Python :: 3.12
 Classifier: Programming Language :: Python :: 3.13

{lionagi-0.7.4 → lionagi-0.7.6}/lionagi/operations/ReAct/ReAct.py

@@ -112,7 +112,7 @@ async def ReAct(
         if extensions:
             extensions -= 1
 
-    # Step 3: Produce final answer by calling branch._instruct with an answer prompt
+    # Step 3: Produce final answer by calling branch.instruct with an answer prompt
     answer_prompt = ReActAnalysis.ANSWER_PROMPT.format(
         instruction=instruct_dict["instruction"]
     )

{lionagi-0.7.4 → lionagi-0.7.6}/lionagi/operations/brainstorm/brainstorm.py

@@ -75,7 +75,7 @@ async def run_instruct(
         if verbose:
             snippet = (
                 child_ins.guidance[:100] + "..."
-                if len(child_ins.guidance) > 100
+                if len(child_ins.guidance or "") > 100
                 else child_ins.guidance
             )
             print(f"\n-----Running instruction-----\n{snippet}")
@@ -181,7 +181,7 @@ async def brainstorm(
         if verbose:
             snippet = (
                 ins_.guidance[:100] + "..."
-                if len(ins_.guidance) > 100
+                if len(ins_.guidance or "") > 100
                 else ins_.guidance
             )
             print(f"\n-----Running instruction-----\n{snippet}")
@@ -255,12 +255,12 @@ async def brainstorm(
                         if verbose:
                             snippet = (
                                 ins_.guidance[:100] + "..."
-                                if len(ins_.guidance) > 100
+                                if len(ins_.guidance or "") > 100
                                 else ins_.guidance
                             )
                             print(f"\n-----Exploring Idea-----\n{snippet}")
                         new_branch = session.split(branch)
-                        resp = await new_branch._instruct(
+                        resp = await new_branch.instruct(
                             ins_, **(explore_kwargs or {})
                         )
                         return InstructResponse(instruct=ins_, response=resp)
@@ -303,11 +303,11 @@ async def brainstorm(
                         if verbose:
                             snippet = (
                                 i.guidance[:100] + "..."
-                                if len(i.guidance) > 100
+                                if len(i.guidance or "") > 100
                                 else i.guidance
                             )
                             print(f"\n-----Exploring Idea-----\n{snippet}")
-                        seq_res = await branch._instruct(
+                        seq_res = await branch.instruct(
                             i, **(explore_kwargs or {})
                         )
                         explore_results.append(
@@ -337,7 +337,7 @@ async def brainstorm(
 
                         async def _explore(ins_: Instruct):
                             child_branch = session.split(base_branch)
-                            child_resp = await child_branch._instruct(
+                            child_resp = await child_branch.instruct(
                                 ins_, **(explore_kwargs or {})
                             )
                             return InstructResponse(
@@ -393,14 +393,14 @@ async def brainstorm(
                             if verbose:
                                 snippet = (
                                     ins_.guidance[:100] + "..."
-                                    if len(ins_.guidance) > 100
+                                    if len(ins_.guidance or "") > 100
                                     else ins_.guidance
                                 )
                                 print(
                                     f"\n-----Exploring Idea (sequential in chunk)-----\n{snippet}"
                                 )
 
-                            seq_resp = await local_branch._instruct(
+                            seq_resp = await local_branch.instruct(
                                 ins_, **(explore_kwargs or {})
                             )
                             chunk_results.append(

{lionagi-0.7.4 → lionagi-0.7.6}/lionagi/operations/operate/operate.py

@@ -47,6 +47,9 @@ async def operate(
     actions: bool = False,
     reason: bool = False,
     action_kwargs: dict = None,
+    action_strategy: Literal[
+        "sequential", "concurrent", "batch"
+    ] = "concurrent",
     field_models: list[FieldModel] = None,
     exclude_fields: list | dict | None = None,
     request_params: ModelParams = None,
@@ -97,6 +100,8 @@ async def operate(
         instruct.reason = True
     if actions:
         instruct.actions = True
+        if action_strategy:
+            instruct.action_strategy = action_strategy
 
     # 1) Create or update the Operative
     operative = Step.request_operative(
@@ -178,9 +183,15 @@ async def operate(
         getattr(response_model, "action_required", None) is True
         and getattr(response_model, "action_requests", None) is not None
     ):
+        action_kwargs = action_kwargs or {}
+        action_kwargs["strategy"] = (
+            instruct.action_strategy
+            if instruct.action_strategy
+            else action_kwargs.get("strategy", "concurrent")
+        )
+
         action_response_models = await branch.act(
-            response_model.action_requests,
-            **(action_kwargs or {}),
+            response_model.action_requests, **action_kwargs
         )
         # Possibly refine the operative with the tool outputs
         operative = Step.respond_operative(

{lionagi-0.7.4 → lionagi-0.7.6}/lionagi/operations/plan/plan.py

@@ -249,7 +249,7 @@ async def plan(
                         )
                         print(f"Instruction: {snippet}")
 
-                    step_response = await execute_branch._instruct(
+                    step_response = await execute_branch.instruct(
                         plan_step, **(execution_kwargs or {})
                     )
                     seq_results.append(
@@ -277,7 +277,7 @@ async def plan(
                         print(f"\n------ Executing step (concurrently) ------")
                         print(f"Instruction: {snippet}")
                     local_branch = session.split(execute_branch)
-                    resp = await local_branch._instruct(
+                    resp = await local_branch.instruct(
                         plan_step, **(execution_kwargs or {})
                     )
                     return InstructResponse(instruct=plan_step, response=resp)
@@ -309,7 +309,7 @@ async def plan(
 
                     async def _execute(plan_step: Instruct):
                         local_branch = session.split(execute_branch)
-                        resp = await local_branch._instruct(
+                        resp = await local_branch.instruct(
                             plan_step, **(execution_kwargs or {})
                         )
                         return InstructResponse(
@@ -355,7 +355,7 @@ async def plan(
                             print(
                                 f"\n--- Executing step (sequential in chunk) ---\nInstruction: {snippet}"
                             )
-                        resp = await local_branch._instruct(
+                        resp = await local_branch.instruct(
                             plan_step, **(execution_kwargs or {})
                         )
                         chunk_result.append(

{lionagi-0.7.4 → lionagi-0.7.6}/lionagi/operatives/instruct/base.py

@@ -2,6 +2,8 @@
 #
 # SPDX-License-Identifier: Apache-2.0
 
+"""deprecated"""
+
 from pydantic import JsonValue
 
 from lionagi.libs.validate.common_field_validators import (

lionagi-0.7.6/lionagi/operatives/instruct/instruct.py

@@ -0,0 +1,153 @@
+# Copyright (c) 2023 - 2024, HaiyangLi <quantocean.li at gmail dot com>
+#
+# SPDX-License-Identifier: Apache-2.0
+
+from typing import Any, ClassVar, Literal
+
+from pydantic import Field, JsonValue, field_validator
+
+from lionagi.libs.validate.common_field_validators import (
+    validate_boolean_field,
+    validate_nullable_jsonvalue_field,
+)
+from lionagi.utils import HashableModel, to_num
+
+from ..models.field_model import FieldModel
+
+__all__ = (
+    "Instruct",
+    "InstructResponse",
+    "INSTRUCT_FIELD",
+    "LIST_INSTRUCT_FIELD",
+)
+
+
+class Instruct(HashableModel):
+    """Model for defining instruction parameters and execution requirements.
+
+    Attributes:
+        instruction (JsonValue | None): The primary instruction.
+        guidance (JsonValue | None): Execution guidance.
+        context (JsonValue | None): Task context.
+    """
+
+    reserved_kwargs: ClassVar[list[str]] = [
+        "operative_model",
+        "field_models",
+        "operative",
+        "reason",
+        "actions",
+        "action_strategy",
+        "batch_size",
+        "request_params",
+        "response_params",
+    ]
+    instruction: JsonValue | None = Field(
+        None,
+        title="Primary Instruction",
+        description=(
+            "A clear, actionable task definition. Specify:\n"
+            "1) The primary goal or objective\n"
+            "2) Key success criteria or constraints\n"
+            "\n"
+            "Guidelines:\n"
+            "- Start with a direct action verb (e.g., 'Analyze', 'Generate', 'Create')\n"
+            "- Include scope, boundaries, or constraints\n"
+            "- Provide success criteria if relevant\n"
+            "- For complex tasks, break them into logical steps"
+        ),
+    )
+    guidance: JsonValue | None = Field(
+        None,
+        title="Guidance",
+        description=(
+            "Strategic direction and constraints for executing the task. "
+            "Include:\n"
+            "1) Preferred methods or frameworks\n"
+            "2) Quality benchmarks (e.g., speed, clarity)\n"
+            "3) Resource or environmental constraints\n"
+            "4) Relevant compliance or standards\n"
+            "Use None if no special guidance."
+        ),
+    )
+    context: JsonValue | None = Field(
+        None,
+        description=(
+            "Background information and current-state data needed for the task. "
+            "Should be:\n"
+            "1) Directly relevant\n"
+            "2) Sufficient to perform the task\n"
+            "3) Free of extraneous detail\n"
+            "Include environment, prior outcomes, system states, or dependencies. "
+            "Use None if no additional context is needed."
+        ),
+    )
+    reason: bool | None = Field(
+        None,
+        description=(
+            "Include a thoughtful explanation of decisions, trade-offs, "
+            "and insights. Encourage deeper introspection on why certain "
+            "choices were made, potential alternatives, and how confidence "
+            "was shaped. If not needed, set to None."
+        ),
+    )
+    actions: bool | None = Field(
+        None,
+        description=(
+            "Controls execution mode. "
+            "True: Execute specified actions. "
+            "False: Analysis/recommendations only. "
+            "None: Contextual execution."
+        ),
+    )
+    action_strategy: Literal["batch", "sequential", "concurrent"] | None = (
+        Field(
+            None,
+            description="Action strategy to use for executing actions. Default "
+            "is 'concurrent'. Only provide for if actions are enabled.",
+        )
+    )
+    batch_size: int | None = Field(
+        None,
+        description="Batch size for executing actions. Only provide for 'batch' strategy.",
+    )
+
+    @field_validator("instruction", "guidance", "context", mode="before")
+    def _validate_instruction(cls, v):
+        return validate_nullable_jsonvalue_field(cls, v)
+
+    @field_validator("reason", "actions", mode="before")
+    def _validate_reason(cls, v):
+        return validate_boolean_field(cls, v)
+
+    @field_validator("action_strategy", mode="before")
+    def _validate_action_strategy(cls, v):
+        if v not in ["batch", "sequential", "concurrent"]:
+            return "concurrent"
+        return v
+
+    @field_validator("batch_size", mode="before")
+    def _validate_batch_size(cls, v):
+        try:
+            return to_num(v, num_type=int)
+        except Exception:
+            return None
+
+
+INSTRUCT_FIELD = FieldModel(
+    name="instruct_model",
+    annotation=Instruct | None,
+    default=None,
+)
+
+
+class InstructResponse(HashableModel):
+    instruct: Instruct
+    response: Any | None = None
+
+
+LIST_INSTRUCT_FIELD_MODEL = FieldModel(
+    name="instruct_models",
+    annotation=list[Instruct] | None,
+    default=None,
+)

{lionagi-0.7.4 → lionagi-0.7.6}/lionagi/operatives/instruct/prompts.py

@@ -2,6 +2,8 @@
 #
 # SPDX-License-Identifier: Apache-2.0
 
+"""deprecated"""
+
 instruction_field_description = (
     "A clear, actionable task definition. Specify:\n"
     "1) The primary goal or objective\n"

{lionagi-0.7.4 → lionagi-0.7.6}/lionagi/operatives/instruct/reason.py

@@ -2,13 +2,19 @@
 #
 # SPDX-License-Identifier: Apache-2.0
 
-from pydantic import BaseModel, field_validator
+from pydantic import BaseModel, Field, field_validator
 
 from lionagi.utils import to_num
 
 from ..models.field_model import FieldModel
 
+__all__ = (
+    "Reason",
+    "REASON_FIELD",
+)
+
 
+# deprecated
 def validate_confidence_score(cls, value) -> float:
     try:
         return to_num(
@@ -22,6 +28,7 @@ def validate_confidence_score(cls, value) -> float:
         return -1
 
 
+# deprecated
 confidence_description = (
     "Numeric confidence score (0.0 to 1.0, up to three decimals) indicating "
     "how well you've met user expectations. Use this guide:\n"
@@ -31,6 +38,7 @@ confidence_description = (
     "  • 0.0-0.5: Off track"
 )
 
+# deprecated
 CONFIDENCE_SCORE_FIELD = FieldModel(
     name="confidence_score",
     annotation=float | None,
@@ -47,13 +55,32 @@ class Reason(BaseModel):
 
     title: str | None = None
     content: str | None = None
-    confidence_score: float | None = CONFIDENCE_SCORE_FIELD.field_info
-
-    @field_validator(
-        "confidence_score", **CONFIDENCE_SCORE_FIELD.validator_kwargs
+    confidence_score: float | None = Field(
+        None,
+        title="Confidence Score",
+        description=(
+            "Numeric confidence score (0.0 to 1.0, up to three decimals) indicating "
+            "how well you've met user expectations. Use this guide:\n"
+            "  • 1.0: Highly confident\n"
+            "  • 0.8-1.0: Reasonably sure\n"
+            "  • 0.5-0.8: Re-check or refine\n"
+            "  • 0.0-0.5: Off track"
+        ),
+        examples=[0.821, 0.257, 0.923, 0.439],
     )
+
+    @field_validator("confidence_score", mode="before")
     def _validate_confidence(cls, v):
-        return CONFIDENCE_SCORE_FIELD.validator(cls, v)
+        try:
+            return to_num(
+                v,
+                upper_bound=1,
+                lower_bound=0,
+                num_type=float,
+                precision=3,
+            )
+        except Exception:
+            return -1
 
 
 REASON_FIELD = FieldModel(
@@ -62,6 +89,3 @@ REASON_FIELD = FieldModel(
     title="Reason",
     description="**Provide a concise reason for the decision made.**",
 )
-
-
-__all__ = ["Reason"]

{lionagi-0.7.4 → lionagi-0.7.6}/lionagi/operatives/strategies/concurrent.py

@@ -25,7 +25,7 @@ class ConcurrentExecutor(StrategyExecutor):
             return await self.execute_instruct(ins_, b_, False, **kwargs)
 
         config = {**ins.model_dump(), **kwargs}
-        res = await branch._instruct(**config)
+        res = await branch.instruct(**config)
         branch.msgs.logger.dump()
         instructs = (
             res.instruct_models if hasattr(res, "instruct_models") else []

{lionagi-0.7.4 → lionagi-0.7.6}/lionagi/operatives/strategies/concurrent_sequential_chunk.py

@@ -68,7 +68,7 @@ class ConcurrentSequentialChunkExecutor(StrategyExecutor):
                 else f"\n-----Executing Instruct {idx}-----\n{msg_}"
             )
 
-        res = await self.branch._instruct(ins_, **self.params.execute_kwargs)
+        res = await self.branch.instruct(ins_, **self.params.execute_kwargs)
         return InstructResponse(instruct=ins_, response=res)
 
     async def _execute_chunk(

{lionagi-0.7.4 → lionagi-0.7.6}/lionagi/operatives/strategies/sequential.py

@@ -20,7 +20,7 @@ class SequentialExecutor(StrategyExecutor):
         for idx, item in enumerate(instructs, start=1):
             if self.params.verbose:
                 print(f"\nExecuting step {idx}/{len(instructs)}")
-            out = await self.execute_branch._instruct(
+            out = await self.execute_branch.instruct(
                 item, **self.params.execute_kwargs
             )
             ress.append(InstructResponse(instruct=item, response=out))

{lionagi-0.7.4 → lionagi-0.7.6}/lionagi/operatives/strategies/sequential_chunk.py

@@ -60,7 +60,7 @@ class SequentialChunkExecutor(StrategyExecutor):
             else:
                 print(f"\n-----Executing Instruct-----\n{msg_}")
 
-        res = await self.branch._instruct(ins_, **self.params.execute_kwargs)
+        res = await self.branch.instruct(ins_, **self.params.execute_kwargs)
         return InstructResponse(instruct=ins_, response=res)
 
     async def _execute_chunk(

{lionagi-0.7.4 → lionagi-0.7.6}/lionagi/operatives/strategies/sequential_concurrent_chunk.py

@@ -71,7 +71,7 @@ class SequentialConcurrentChunkExecutor(StrategyExecutor):
             )
 
         branch = self.session.split(self.branch)
-        res = await branch._instruct(ins_, **self.params.execute_kwargs)
+        res = await branch.instruct(ins_, **self.params.execute_kwargs)
         return InstructResponse(instruct=ins_, response=res)
 
     async def _execute_chunk(

{lionagi-0.7.4 → lionagi-0.7.6}/lionagi/session/branch.py

@@ -47,7 +47,7 @@ from lionagi.protocols.types import (
 )
 from lionagi.service.types import iModel, iModelManager
 from lionagi.settings import Settings
-from lionagi.utils import UNDEFINED, alcall, copy
+from lionagi.utils import UNDEFINED, alcall, bcall, copy
 
 if TYPE_CHECKING:
     # Forward references for type checking (e.g., in operations or extended modules)
@@ -1103,6 +1103,8 @@ class Branch(Element, Communicatable, Relational):
         self,
         action_request: list | ActionRequest | BaseModel | dict,
         *,
+        strategy: Literal["concurrent", "sequential", "batch"] = "concurrent",
+        batch_size: int = None,
         suppress_errors: bool = True,
         sanitize_input: bool = False,
         unique_input: bool = False,
@@ -1119,7 +1121,7 @@ class Branch(Element, Communicatable, Relational):
         dropna: bool = True,
         unique_output: bool = False,
         flatten_tuple_set: bool = False,
-    ) -> list[ActionResponse] | ActionResponse | Any:
+    ) -> list[ActionResponse]:
         """
         Public, potentially batched, asynchronous interface to run one or multiple action requests.
 
@@ -1164,10 +1166,95 @@ class Branch(Element, Communicatable, Relational):
             Any:
                 The result or results from the invoked tool(s).
         """
-        params = locals()
-        params.pop("self")
-        params.pop("action_request")
-        return await alcall(action_request, self._act, **params)
+        if batch_size and not strategy == "batch":
+            raise ValueError(
+                "Batch size is only applicable for 'batch' strategy."
+            )
+
+        match strategy:
+            case "concurrent":
+                return await self._concurrent_act(
+                    action_request,
+                    suppress_errors=suppress_errors,
+                    sanitize_input=sanitize_input,
+                    unique_input=unique_input,
+                    num_retries=num_retries,
+                    initial_delay=initial_delay,
+                    retry_delay=retry_delay,
+                    backoff_factor=backoff_factor,
+                    retry_default=retry_default,
+                    retry_timeout=retry_timeout,
+                    retry_timing=retry_timing,
+                    max_concurrent=max_concurrent,
+                    throttle_period=throttle_period,
+                    flatten=flatten,
+                    dropna=dropna,
+                    unique_output=unique_output,
+                    flatten_tuple_set=flatten_tuple_set,
+                )
+            case "sequential":
+                return await self._sequential_act(
+                    action_request,
+                    suppress_errors=suppress_errors,
+                )
+            case "batch":
+                return await self._batch_act(
+                    action_request,
+                    batch_size=batch_size or 1,
+                    max_concurrent=max_concurrent,
+                    suppress_errors=suppress_errors,
+                    sanitize_input=sanitize_input,
+                    unique_input=unique_input,
+                    num_retries=num_retries,
+                    initial_delay=initial_delay,
+                    retry_delay=retry_delay,
+                    backoff_factor=backoff_factor,
+                    retry_default=retry_default,
+                    retry_timeout=retry_timeout,
+                    retry_timing=retry_timing,
+                    throttle_period=throttle_period,
+                    flatten=flatten,
+                    dropna=dropna,
+                    unique_output=unique_output,
+                    flatten_tuple_set=flatten_tuple_set,
+                )
+
+    async def _concurrent_act(
+        self,
+        action_request: ActionRequest | BaseModel | dict,
+        **kwargs,
+    ) -> list:
+        return await alcall(action_request, self._act, **kwargs)
+
+    async def _sequential_act(
+        self,
+        action_request: ActionRequest | BaseModel | dict,
+        suppress_errors: bool = True,
+    ) -> list:
+        action_request = (
+            action_request
+            if isinstance(action_request, list)
+            else [action_request]
+        )
+        results = []
+        for req in action_request:
+            results.append(
+                await self._act(req, suppress_errors=suppress_errors)
+            )
+        return results
+
+    async def _batch_act(
+        self,
+        action_request: list[ActionRequest | BaseModel | dict],
+        batch_size: int = None,
+        **kwargs,
+    ) -> list:
+        result = []
+        async for i in await bcall(
+            action_request, self._act, batch_size=batch_size, **kwargs
+        ):
+            result.extend(i)
+        return result
 
     async def translate(
         self,

lionagi-0.7.6/lionagi/version.py

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

{lionagi-0.7.4 → lionagi-0.7.6}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "lionagi"
-version = "0.7.4"
+version = "0.7.6"
 description = "An Intelligence Operating System."
 authors = [
     { name = "HaiyangLi", email = "quantocean.li@gmail.com" },
@@ -21,6 +21,7 @@ license = {file = "LICENSE"}
 classifiers=[
     "Programming Language :: Python :: 3",
     "Programming Language :: Python :: 3 :: Only",
+    "Programming Language :: Python :: 3.10",
     "Programming Language :: Python :: 3.11",
     "Programming Language :: Python :: 3.12",
     "Programming Language :: Python :: 3.13",