lionagi 0.5.5__py3-none-any.whl → 0.6.1__py3-none-any.whl

lionagi/operations/brainstorm/brainstorm.py

@@ -3,18 +3,19 @@
 # SPDX-License-Identifier: Apache-2.0
 
 import logging
-from typing import Literal
-
-from lionagi.core.session.branch import Branch
-from lionagi.core.session.session import Session
-from lionagi.core.typing import ID, Any, BaseModel
-from lionagi.libs.func.types import alcall
-from lionagi.libs.parse import to_flat_list
-from lionagi.protocols.operatives.instruct import (
-    INSTRUCT_FIELD_MODEL,
+from typing import Any, Literal
+
+from pydantic import BaseModel
+
+from lionagi.operatives.instruct.instruct import (
+    LIST_INSTRUCT_FIELD_MODEL,
     Instruct,
     InstructResponse,
 )
+from lionagi.protocols.generic.element import ID
+from lionagi.session.branch import Branch
+from lionagi.session.session import Session
+from lionagi.utils import alcall, to_list
 
 from ..utils import prepare_instruct, prepare_session
 from .prompt import PROMPT
@@ -86,7 +87,7 @@ async def run_instruct(
     # Prepare config for the branch operation
     config = {**ins.model_dump(), **kwargs}
     result = await branch.operate(**config)
-    branch.msgs.logger.dump()
+    branch._log_manager.dump()
 
     # Extract any newly generated instructions
     instructs = []
@@ -126,6 +127,7 @@ async def brainstorm(
     return_session: bool = False,
     verbose: bool = False,
     branch_as_default: bool = True,
+    operative_model: type[BaseModel] | None = None,
     **kwargs: Any,
 ) -> Any:
     """
@@ -137,6 +139,13 @@ async def brainstorm(
       3. Optionally explore the resulting instructions (auto_explore=True)
          using the chosen strategy (concurrent, sequential, etc.).
     """
+    if operative_model:
+        logging.warning(
+            "The 'operative_model' parameter is deprecated and will be removed in a future version.use 'response_format' instead."
+        )
+        kwargs["response_format"] = kwargs.get(
+            "response_format", operative_model
+        )
 
     # -----------------------------------------------------------------
     # Basic Validations and Setup
@@ -149,8 +158,8 @@ async def brainstorm(
 
     # Make sure the correct field model is present
     field_models: list = kwargs.get("field_models", [])
-    if INSTRUCT_FIELD_MODEL not in field_models:
-        field_models.append(INSTRUCT_FIELD_MODEL)
+    if LIST_INSTRUCT_FIELD_MODEL not in field_models:
+        field_models.append(LIST_INSTRUCT_FIELD_MODEL)
     kwargs["field_models"] = field_models
 
     # Prepare session, branch, and the instruction
@@ -199,14 +208,18 @@ async def brainstorm(
             brainstorm_results = await alcall(
                 instructs, run_brainstorm_instruction
             )
-            brainstorm_results = to_flat_list(brainstorm_results, dropna=True)
+            brainstorm_results = to_list(
+                brainstorm_results, dropna=True, flatten=True
+            )
 
             # Filter out plain str/dict responses, keep model-based
             filtered = [
                 r if not isinstance(r, (str, dict)) else None
                 for r in brainstorm_results
             ]
-            filtered = to_flat_list(filtered, unique=True, dropna=True)
+            filtered = to_list(
+                filtered, unique=True, dropna=True, flatten=True
+            )
 
             out.brainstorm = (
                 filtered if isinstance(filtered, list) else [filtered]
@@ -220,7 +233,7 @@ async def brainstorm(
         # -----------------------------------------------------------------
         if response_ and auto_explore:
             # Gather all newly generated instructions
-            all_explore_instructs = to_flat_list(
+            all_explore_instructs = to_list(
                 [
                     r.instruct_models
                     for r in response_
@@ -228,6 +241,7 @@ async def brainstorm(
                 ],
                 dropna=True,
                 unique=True,
+                flatten=True,
             )
 
             # Decide how to explore based on the strategy
@@ -246,7 +260,7 @@ async def brainstorm(
                             )
                             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)
@@ -293,7 +307,7 @@ async def brainstorm(
                                 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(
@@ -323,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(
@@ -386,7 +400,7 @@ async def brainstorm(
                                     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/operations/brainstorm/prompt.py

@@ -1,3 +1,7 @@
+# Copyright (c) 2023 - 2024, HaiyangLi <quantocean.li at gmail dot com>
+#
+# SPDX-License-Identifier: Apache-2.0
+
 PROMPT = """Perform a brainstorm session. Generate {num_instruct} concise and distinct instructions (Instruct), each representing a potential next step. We will run them in parallel under the same context. Ensure each idea:
 
 1. Adheres to project guidelines and standards.

lionagi/operations/plan/__init__.py

@@ -1,3 +1,7 @@
+# Copyright (c) 2023 - 2024, HaiyangLi <quantocean.li at gmail dot com>
+#
+# SPDX-License-Identifier: Apache-2.0
+
 from .plan import plan
 
 __all__ = ["plan"]

lionagi/operations/plan/plan.py

@@ -2,16 +2,19 @@
 #
 # SPDX-License-Identifier: Apache-2.0
 
-from lionagi.core.session.branch import Branch
-from lionagi.core.session.session import Session
-from lionagi.core.typing import ID, Any, BaseModel, Literal
-from lionagi.libs.func.types import alcall
-from lionagi.libs.parse import to_flat_list
-from lionagi.protocols.operatives.instruct import (
-    INSTRUCT_FIELD_MODEL,
+from typing import Any, Literal
+
+from pydantic import BaseModel
+
+from lionagi.operatives.instruct.instruct import (
+    LIST_INSTRUCT_FIELD_MODEL,
     Instruct,
     InstructResponse,
 )
+from lionagi.protocols.types import ID
+from lionagi.session.branch import Branch
+from lionagi.session.session import Session
+from lionagi.utils import alcall
 
 from ..utils import prepare_instruct, prepare_session
 from .prompt import EXPANSION_PROMPT, PLAN_PROMPT
@@ -24,9 +27,9 @@ from .prompt import EXPANSION_PROMPT, PLAN_PROMPT
 class PlanOperation(BaseModel):
     """
     Stores all relevant outcomes for a multi-step Plan:
-      * initial: The result of the initial plan prompt
-      * plan: A list of plan steps (Instruct objects) generated from the initial planning
-      * execute: Any responses from executing those plan steps
+        * initial: The result of the initial plan prompt
+        * plan: A list of plan steps (Instruct objects) generated from the initial planning
+        * execute: Any responses from executing those plan steps
     """
 
     initial: Any
@@ -165,8 +168,8 @@ async def plan(
 
     # Ensure the correct field model
     field_models: list = kwargs.get("field_models", [])
-    if INSTRUCT_FIELD_MODEL not in field_models:
-        field_models.append(INSTRUCT_FIELD_MODEL)
+    if LIST_INSTRUCT_FIELD_MODEL not in field_models:
+        field_models.append(LIST_INSTRUCT_FIELD_MODEL)
     kwargs["field_models"] = field_models
 
     # Prepare session/branch
@@ -246,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(
@@ -274,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)
@@ -306,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(
@@ -352,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/operations/plan/prompt.py

@@ -1,3 +1,7 @@
+# Copyright (c) 2023 - 2024, HaiyangLi <quantocean.li at gmail dot com>
+#
+# SPDX-License-Identifier: Apache-2.0
+
 PLAN_PROMPT = """
 Develop a high-level plan containing {num_steps} distinct steps. Each step must:
 1. Represent a clear milestone or phase.

lionagi/operations/select/__init__.py

@@ -1,3 +1,7 @@
+# Copyright (c) 2023 - 2024, HaiyangLi <quantocean.li at gmail dot com>
+#
+# SPDX-License-Identifier: Apache-2.0
+
 from .select import select
 
 __all__ = ["select"]

lionagi/operations/select/prompt.py

@@ -1 +1,5 @@
+# Copyright (c) 2023 - 2024, HaiyangLi <quantocean.li at gmail dot com>
+#
+# SPDX-License-Identifier: Apache-2.0
+
 PROMPT = "Please select up to {max_num_selections} items from the following list {choices}. Provide the selection(s) into appropriate field in format required, and no comments from you"

lionagi/operations/select/select.py

@@ -8,8 +8,8 @@ from typing import Any
 
 from pydantic import BaseModel, Field
 
-from lionagi import Branch
-from lionagi.protocols.operatives.instruct import Instruct
+from lionagi.operatives.types import Instruct
+from lionagi.session.branch import Branch
 
 from .prompt import PROMPT
 from .utils import parse_selection, parse_to_representation

lionagi/operations/select/utils.py

@@ -2,14 +2,14 @@
 #
 # SPDX-License-Identifier: Apache-2.0
 
-
 import inspect
 from enum import Enum
 from typing import Any
 
-from lionagi.core.typing import BaseModel, JsonValue
-from lionagi.libs.parse import is_same_dtype
-from lionagi.libs.string_similarity import string_similarity
+from pydantic import BaseModel, JsonValue
+
+from lionagi.libs.validate.string_similarity import string_similarity
+from lionagi.utils import is_same_dtype
 
 
 def parse_to_representation(

lionagi/{strategies → operations/strategies}/base.py

@@ -1,9 +1,13 @@
+# Copyright (c) 2023 - 2024, HaiyangLi <quantocean.li at gmail dot com>
+#
+# SPDX-License-Identifier: Apache-2.0
+
 from typing import ClassVar
 
 from pydantic import BaseModel, model_validator
 
-from lionagi.core.session.types import Branch, Session
-from lionagi.protocols.operatives.instruct import Instruct, InstructResponse
+from lionagi.operatives.instruct.instruct import Instruct, InstructResponse
+from lionagi.session.session import Branch, Session
 
 from .params import StrategyParams
 

lionagi/{strategies → operations/strategies}/concurrent.py

@@ -1,7 +1,10 @@
-from lionagi.core.session.types import Branch
-from lionagi.libs.func.types import alcall
-from lionagi.libs.parse.types import to_list
-from lionagi.protocols.operatives.instruct import Instruct, InstructResponse
+# Copyright (c) 2023 - 2024, HaiyangLi <quantocean.li at gmail dot com>
+#
+# SPDX-License-Identifier: Apache-2.0
+
+from lionagi.operatives.instruct.instruct import Instruct, InstructResponse
+from lionagi.session.session import Branch
+from lionagi.utils import alcall, to_list
 
 from .base import StrategyExecutor
 
@@ -22,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/{strategies → operations/strategies}/concurrent_chunk.py

@@ -1,8 +1,11 @@
+# Copyright (c) 2023 - 2024, HaiyangLi <quantocean.li at gmail dot com>
+#
+# SPDX-License-Identifier: Apache-2.0
+
 from typing import ClassVar
 
-from lionagi.libs.func.types import bcall
-from lionagi.libs.parse.types import to_list
-from lionagi.protocols.operatives.instruct import Instruct, InstructResponse
+from lionagi.operatives.instruct.instruct import Instruct, InstructResponse
+from lionagi.utils import bcall, to_list
 
 from .concurrent import ConcurrentExecutor
 from .params import ChunkStrategyParams

lionagi/{strategies → operations/strategies}/concurrent_sequential_chunk.py

@@ -1,8 +1,12 @@
+# Copyright (c) 2023 - 2024, HaiyangLi <quantocean.li at gmail dot com>
+#
+# SPDX-License-Identifier: Apache-2.0
+
 from pydantic import model_validator
 
-from lionagi.core.session.types import Branch, Session
-from lionagi.libs.func.types import alcall
-from lionagi.protocols.operatives.instruct import Instruct, InstructResponse
+from lionagi.operatives.instruct.instruct import Instruct, InstructResponse
+from lionagi.session.session import Branch, Session
+from lionagi.utils import alcall
 
 from .base import StrategyExecutor
 from .params import HybridStrategyParams
@@ -64,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/{strategies → operations/strategies}/params.py

@@ -1,14 +1,34 @@
+# Copyright (c) 2023 - 2024, HaiyangLi <quantocean.li at gmail dot com>
+#
+# SPDX-License-Identifier: Apache-2.0
+
 from typing import Any, Literal
 
 from pydantic import Field, field_validator, model_validator
 
-from lionagi.core.models.types import FieldModel, SchemaModel
-from lionagi.core.session.types import Branch, Session
-from lionagi.libs.func.types import RCallParams
-from lionagi.protocols.operatives.instruct import (
-    INSTRUCT_FIELD_MODEL,
+from lionagi.operatives.instruct.instruct import (
+    LIST_INSTRUCT_FIELD_MODEL,
     Instruct,
 )
+from lionagi.operatives.types import FieldModel, SchemaModel
+from lionagi.session.session import Branch, Session
+
+
+class RCallParams(SchemaModel):
+    """Parameters for remote function calls."""
+
+    timeout: float = Field(
+        default=60, description="Timeout for remote function call"
+    )
+    max_retries: int = Field(
+        default=3, description="Maximum number of retries"
+    )
+    retry_delay: float = Field(
+        default=0.5, description="Delay between retries"
+    )
+    retry_backoff: float = Field(
+        default=2, description="Backoff factor for retry delay"
+    )
 
 
 class StrategyParams(SchemaModel):
@@ -36,7 +56,7 @@ class StrategyParams(SchemaModel):
     )
     auto_run: bool = False
     auto_execute: bool = False
-    instruct_model_field: type[FieldModel] = INSTRUCT_FIELD_MODEL
+    instruct_model_field: type[FieldModel] = LIST_INSTRUCT_FIELD_MODEL
 
     @field_validator("branch_kwargs", mode="before")
     def _validate_branch_kwargs(cls, v: Any) -> dict:

lionagi/{strategies → operations/strategies}/sequential.py

@@ -1,4 +1,8 @@
-from lionagi.fields.instruct import Instruct, InstructResponse
+# Copyright (c) 2023 - 2024, HaiyangLi <quantocean.li at gmail dot com>
+#
+# SPDX-License-Identifier: Apache-2.0
+
+from lionagi.operatives.instruct.instruct import Instruct, InstructResponse
 
 from .base import StrategyExecutor
 
@@ -16,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/{strategies → operations/strategies}/sequential_chunk.py

@@ -1,7 +1,11 @@
+# Copyright (c) 2023 - 2024, HaiyangLi <quantocean.li at gmail dot com>
+#
+# SPDX-License-Identifier: Apache-2.0
+
 from pydantic import model_validator
 
-from lionagi.fields.instruct import Instruct, InstructResponse
-from lionagi.session.types import Branch, Session
+from lionagi.operatives.instruct.instruct import Instruct, InstructResponse
+from lionagi.session.session import Branch, Session
 
 from .base import StrategyExecutor
 from .params import ChunkStrategyParams
@@ -56,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/{strategies → operations/strategies}/sequential_concurrent_chunk.py

@@ -1,9 +1,14 @@
+# Copyright (c) 2023 - 2024, HaiyangLi <quantocean.li at gmail dot com>
+#
+# SPDX-License-Identifier: Apache-2.0
+
 from pydantic import model_validator
 
-from lionagi.fields.instruct import Instruct, InstructResponse
-from lionagi.session.types import Branch, Session
+from lionagi.operations.strategies.params import HybridStrategyParams
+from lionagi.operatives.instruct.instruct import Instruct, InstructResponse
+from lionagi.session.session import Branch, Session
+from lionagi.utils import alcall
 
-from ..libs.async_utils import alcall
 from .base import StrategyExecutor
 from .params import HybridStrategyParams
 
@@ -66,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/{strategies → operations/strategies}/utils.py

@@ -1,10 +1,13 @@
+# Copyright (c) 2023 - 2024, HaiyangLi <quantocean.li at gmail dot com>
+#
+# SPDX-License-Identifier: Apache-2.0
+
 from typing import Any
 
-from lionagi.fields.instruct import Instruct
+from lionagi.operatives.instruct.instruct import Instruct
+from lionagi.session.session import Branch, Session
 from lionagi.utils import alcall
 
-from ..session.types import Branch, Session
-
 
 async def run_instruct(
     ins: Instruct,

lionagi/operations/types.py

@@ -0,0 +1,13 @@
+# Copyright (c) 2023 - 2024, HaiyangLi <quantocean.li at gmail dot com>
+#
+# SPDX-License-Identifier: Apache-2.0
+
+from .brainstorm.brainstorm import brainstorm
+from .plan.plan import plan
+from .select.select import select
+
+__all__ = (
+    "brainstorm",
+    "plan",
+    "select",
+)

lionagi/operations/utils.py

@@ -1,6 +1,9 @@
-from lionagi.core.session.branch import Branch
-from lionagi.core.session.session import Session
-from lionagi.protocols.operatives.instruct import Instruct
+# Copyright (c) 2023 - 2024, HaiyangLi <quantocean.li at gmail dot com>
+#
+# SPDX-License-Identifier: Apache-2.0
+
+from lionagi.operatives.types import Instruct
+from lionagi.session.session import Branch, Session
 
 
 def prepare_session(