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

lionagi/operations/plan/plan.py

@@ -2,10 +2,11 @@
 #
 # 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,
     Instruct,
@@ -15,13 +16,45 @@ from lionagi.protocols.operatives.instruct import (
 from ..utils import prepare_instruct, prepare_session
 from .prompt import EXPANSION_PROMPT, PLAN_PROMPT
 
+# ---------------------------------------------------------------------
+# Data Model
+# ---------------------------------------------------------------------
+
 
 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: Any
     plan: list[Instruct] | None = None
     execute: list[InstructResponse] | None = None
 
 
+# ---------------------------------------------------------------------
+# Utilities
+# ---------------------------------------------------------------------
+
+
+def chunked(iterable, n):
+    """
+    Yield successive n-sized chunks from an iterable.
+    Example:
+        >>> list(chunked([1,2,3,4,5], 2))
+        [[1,2],[3,4],[5]]
+    """
+    for i in range(0, len(iterable), n):
+        yield iterable[i : i + n]
+
+
+# ---------------------------------------------------------------------
+# Single-Step Runner
+# ---------------------------------------------------------------------
+
+
 async def run_step(
     ins: Instruct,
     session: Session,
@@ -29,33 +62,41 @@ async def run_step(
     verbose: bool = True,
     **kwargs: Any,
 ) -> Any:
-    """Execute a single step of the plan.
+    """
+    Execute a single step of the plan with an 'expansion' or guidance prompt.
 
     Args:
         ins: The instruction model for the step.
-        session: The current session.
-        branch: The branch to operate on.
+        session: The current session context.
+        branch: The branch to operate on for this step.
         verbose: Whether to enable verbose output.
-        **kwargs: Additional keyword arguments.
+        **kwargs: Additional keyword arguments passed to the branch operation.
 
     Returns:
-        The result of the branch operation.
+        The result of the branch operation (which may contain more instructions).
     """
     if verbose:
-        instruction = (
+        snippet = (
             ins.instruction[:100] + "..."
             if len(ins.instruction) > 100
             else ins.instruction
         )
-        print(f"Further planning: {instruction}")
+        print(f"Further planning: {snippet}")
 
+    # Incorporate the EXPANSION_PROMPT into guidance
     config = {**ins.model_dump(), **kwargs}
-    guide = config.pop("guidance", "")
-    config["guidance"] = EXPANSION_PROMPT + "\n" + str(guide)
+    guidance_text = config.pop("guidance", "")
+    config["guidance"] = f"{EXPANSION_PROMPT}\n{guidance_text}"
+
+    # Run the step
+    result = await branch.operate(**config)
+    branch.msgs.logger.dump()  # Dump logs if needed
+    return result
 
-    res = await branch.operate(**config)
-    branch.msgs.logger.dump()
-    return res
+
+# ---------------------------------------------------------------------
+# Main Plan Function (with Multiple Execution Strategies)
+# ---------------------------------------------------------------------
 
 
 async def plan(
@@ -65,108 +106,280 @@ async def plan(
     branch: Branch | ID.Ref | None = None,
     auto_run: bool = True,
     auto_execute: bool = False,
-    execution_strategy: Literal["sequential"] = "sequential",
+    execution_strategy: Literal[
+        "sequential",
+        "concurrent",
+        "sequential_concurrent_chunk",
+        "concurrent_sequential_chunk",
+    ] = "sequential",
     execution_kwargs: dict[str, Any] | None = None,
     branch_kwargs: dict[str, Any] | None = None,
     return_session: bool = False,
     verbose: bool = True,
     **kwargs: Any,
-) -> PlanOperation | tuple[list[InstructResponse], Session]:
-    """Create and execute a multi-step plan.
+) -> PlanOperation | tuple[PlanOperation, Session]:
+    """
+    Create and optionally execute a multi-step plan with up to `num_steps`.
+
+    Steps:
+      1. Generate an initial plan with up to `num_steps`.
+      2. Optionally (auto_run=True) expand on each planned step
+         to refine or further clarify them.
+      3. Optionally (auto_execute=True) execute those refined steps
+         according to `execution_strategy`.
 
     Args:
-        instruct: Instruction model or dictionary.
-        num_steps: Number of steps in the plan.
-        session: Existing session or None to create a new one.
-        branch: Existing branch or reference.
-        auto_run: If True, automatically run the steps.
-        branch_kwargs: Additional keyword arguments for branch creation.
-        return_session: If True, return the session along with results.
-        verbose: Whether to enable verbose output.
-        **kwargs: Additional keyword arguments.
+        instruct: Initial instruction or a dict describing it.
+        num_steps: Maximum number of plan steps (must be <= 5).
+        session: An existing Session, or None to create a new one.
+        branch: An existing Branch, or None to create a new one.
+        auto_run: If True, automatically run the intermediate plan steps.
+        auto_execute: If True, automatically execute the fully refined steps.
+        execution_strategy:
+            - "sequential" (default) runs steps one by one
+            - "concurrent" runs all steps in parallel
+            - "sequential_concurrent_chunk" processes chunks sequentially, each chunk in parallel
+            - "concurrent_sequential_chunk" processes all chunks in parallel, each chunk sequentially
+        execution_kwargs: Extra kwargs used during execution calls.
+        branch_kwargs: Extra kwargs for branch/session creation.
+        return_session: Whether to return (PlanOperation, Session) instead of just PlanOperation.
+        verbose: If True, prints verbose logs.
+        **kwargs: Additional arguments for the initial plan operation.
 
     Returns:
-        Results of the plan execution, optionally with the session.
+        A PlanOperation object containing:
+            - initial plan
+            - (optional) plan expansions
+            - (optional) execution responses
+        Optionally returns the session as well, if `return_session=True`.
     """
+
+    # -----------------------------------------------------------------
+    # 0. Basic Validation & Setup
+    # -----------------------------------------------------------------
     if num_steps > 5:
         raise ValueError("Number of steps must be 5 or less")
 
     if verbose:
         print(f"Planning execution with {num_steps} steps...")
 
+    # 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)
     kwargs["field_models"] = field_models
+
+    # Prepare session/branch
     session, branch = prepare_session(session, branch, branch_kwargs)
-    execute_branch: Branch = session.split(branch)
-    instruct = prepare_instruct(
-        instruct, PLAN_PROMPT.format(num_steps=num_steps)
-    )
+    execute_branch: Branch = session.split(
+        branch
+    )  # a separate branch for execution
 
-    res1 = await branch.operate(**instruct, **kwargs)
-    out = PlanOperation(initial=res1)
+    # -----------------------------------------------------------------
+    # 1. Run the Initial Plan Prompt
+    # -----------------------------------------------------------------
+    plan_prompt = PLAN_PROMPT.format(num_steps=num_steps)
+    instruct = prepare_instruct(instruct, plan_prompt)
+    initial_res = await branch.operate(**instruct, **kwargs)
+
+    # Wrap initial result in the PlanOperation
+    out = PlanOperation(initial=initial_res)
 
     if verbose:
         print("Initial planning complete. Starting step planning...")
 
+    # If we aren't auto-running the steps, just return the initial plan
     if not auto_run:
-        if return_session:
-            return res1, session
-        return res1
+        return (out, session) if return_session else out
 
+    # -----------------------------------------------------------------
+    # 2. Expand Each Step (auto_run=True)
+    # -----------------------------------------------------------------
     results = []
-    if hasattr(res1, "instruct_models"):
-        instructs: list[Instruct] = res1.instruct_models
-        for i, ins in enumerate(instructs, 1):
+    if hasattr(initial_res, "instruct_models"):
+        instructs: list[Instruct] = initial_res.instruct_models
+        for i, step_ins in enumerate(instructs, start=1):
             if verbose:
                 print(f"\n----- Planning step {i}/{len(instructs)} -----")
-            res = await run_step(
-                ins, session, branch, verbose=verbose, **kwargs
+            expanded_res = await run_step(
+                step_ins, session, branch, verbose=verbose, **kwargs
             )
-            results.append(res)
+            results.append(expanded_res)
 
         if verbose:
-            print("\nAll planning completed successfully!")
+            print("\nAll planning steps expanded/refined successfully!")
+
+    # Gather all newly created plan instructions
+    refined_plans = []
+    for step_result in results:
+        if hasattr(step_result, "instruct_models"):
+            for model in step_result.instruct_models:
+                if model and model not in refined_plans:
+                    refined_plans.append(model)
 
-    all_plans = []
-    for res in results:
-        if hasattr(res, "instruct_models"):
-            for i in res.instruct_models:
-                if i and i not in all_plans:
-                    all_plans.append(i)
-    out.plan = all_plans
+    out.plan = refined_plans
 
+    # -----------------------------------------------------------------
+    # 3. Execute the Plan Steps (auto_execute=True)
+    # -----------------------------------------------------------------
     if auto_execute:
         if verbose:
-            print("\nStarting execution of all steps...")
-        results = []
+            print("\nStarting execution of all plan steps...")
+
+        # We now handle multiple strategies:
         match execution_strategy:
+
+            # ---------------------------------------------------------
+            # Strategy A: SEQUENTIAL
+            # ---------------------------------------------------------
             case "sequential":
-                for i, ins in enumerate(all_plans, 1):
+                seq_results = []
+                for i, plan_step in enumerate(refined_plans, start=1):
+                    if verbose:
+                        snippet = (
+                            plan_step.instruction[:100] + "..."
+                            if len(plan_step.instruction) > 100
+                            else plan_step.instruction
+                        )
+                        print(
+                            f"\n------ Executing step {i}/{len(refined_plans)} ------"
+                        )
+                        print(f"Instruction: {snippet}")
+
+                    step_response = await execute_branch.instruct(
+                        plan_step, **(execution_kwargs or {})
+                    )
+                    seq_results.append(
+                        InstructResponse(
+                            instruct=plan_step, response=step_response
+                        )
+                    )
+
+                out.execute = seq_results
+                if verbose:
+                    print("\nAll steps executed successfully (sequential)!")
+
+            # ---------------------------------------------------------
+            # Strategy B: CONCURRENT
+            # ---------------------------------------------------------
+            case "concurrent":
+
+                async def execute_step_concurrently(plan_step: Instruct):
+                    if verbose:
+                        snippet = (
+                            plan_step.instruction[:100] + "..."
+                            if len(plan_step.instruction) > 100
+                            else plan_step.instruction
+                        )
+                        print(f"\n------ Executing step (concurrently) ------")
+                        print(f"Instruction: {snippet}")
+                    local_branch = session.split(execute_branch)
+                    resp = await local_branch.instruct(
+                        plan_step, **(execution_kwargs or {})
+                    )
+                    return InstructResponse(instruct=plan_step, response=resp)
+
+                # Launch all steps in parallel
+                concurrent_res = await alcall(
+                    refined_plans, execute_step_concurrently
+                )
+                out.execute = concurrent_res
+                if verbose:
+                    print("\nAll steps executed successfully (concurrent)!")
+
+            # ---------------------------------------------------------
+            # Strategy C: SEQUENTIAL_CONCURRENT_CHUNK
+            #   - process plan steps in chunks (one chunk after another),
+            #   - each chunk’s steps run in parallel.
+            # ---------------------------------------------------------
+            case "sequential_concurrent_chunk":
+                chunk_size = (execution_kwargs or {}).get("chunk_size", 5)
+                all_exec_responses = []
+
+                async def execute_chunk_concurrently(
+                    sub_steps: list[Instruct],
+                ):
                     if verbose:
                         print(
-                            f"\n------ Executing step {i}/{len(all_plans)} ------"
+                            f"\n--- Executing a chunk of size {len(sub_steps)} concurrently ---"
                         )
-                        msg = (
-                            ins.instruction[:100] + "..."
-                            if len(ins.instruction) > 100
-                            else ins.instruction
+
+                    async def _execute(plan_step: Instruct):
+                        local_branch = session.split(execute_branch)
+                        resp = await local_branch.instruct(
+                            plan_step, **(execution_kwargs or {})
+                        )
+                        return InstructResponse(
+                            instruct=plan_step, response=resp
                         )
-                        print(f"Instruction: {msg}")
-                    res = await execute_branch.instruct(
-                        ins, **(execution_kwargs or {})
+
+                    # run each chunk in parallel
+                    return await alcall(sub_steps, _execute)
+
+                # process each chunk sequentially
+                for chunk in chunked(refined_plans, chunk_size):
+                    chunk_responses = await execute_chunk_concurrently(chunk)
+                    all_exec_responses.extend(chunk_responses)
+
+                out.execute = all_exec_responses
+                if verbose:
+                    print(
+                        "\nAll steps executed successfully (sequential concurrent chunk)!"
                     )
-                    res_ = InstructResponse(instruct=ins, response=res)
-                    results.append(res_)
-                out.execute = results
+
+            # ---------------------------------------------------------
+            # Strategy D: CONCURRENT_SEQUENTIAL_CHUNK
+            #   - split plan steps into chunks,
+            #   - run all chunks in parallel,
+            #   - but each chunk’s steps run sequentially.
+            # ---------------------------------------------------------
+            case "concurrent_sequential_chunk":
+                chunk_size = (execution_kwargs or {}).get("chunk_size", 5)
+                all_chunks = list(chunked(refined_plans, chunk_size))
+
+                async def execute_chunk_sequentially(
+                    sub_steps: list[Instruct],
+                ):
+                    chunk_result = []
+                    local_branch = session.split(execute_branch)
+                    for plan_step in sub_steps:
+                        if verbose:
+                            snippet = (
+                                plan_step.instruction[:100] + "..."
+                                if len(plan_step.instruction) > 100
+                                else plan_step.instruction
+                            )
+                            print(
+                                f"\n--- Executing step (sequential in chunk) ---\nInstruction: {snippet}"
+                            )
+                        resp = await local_branch.instruct(
+                            plan_step, **(execution_kwargs or {})
+                        )
+                        chunk_result.append(
+                            InstructResponse(instruct=plan_step, response=resp)
+                        )
+                    return chunk_result
+
+                # run all chunks in parallel, each chunk sequentially
+                parallel_chunk_results = await alcall(
+                    all_chunks,
+                    execute_chunk_sequentially,
+                    flatten=True,
+                    dropna=True,
+                )
+
+                out.execute = parallel_chunk_results
                 if verbose:
-                    print("\nAll steps executed successfully!")
+                    print(
+                        "\nAll steps executed successfully (concurrent sequential chunk)!"
+                    )
+
             case _:
                 raise ValueError(
                     f"Invalid execution strategy: {execution_strategy}"
                 )
 
-    if return_session:
-        return out, session
-    return out
+    # -----------------------------------------------------------------
+    # 4. Final Return
+    # -----------------------------------------------------------------
+    return (out, session) if return_session else out

lionagi/service/imodel.py

@@ -121,5 +121,10 @@ class iModel:
     def allowed_roles(self):
         return self.service.allowed_roles
 
+    @property
+    def sequential_exchange(self):
+        """whether the service requires user/assistant exchange"""
+        return self.service.sequential_exchange
+
 
 __all__ = ["iModel"]

lionagi/version.py

@@ -1 +1 @@
-__version__ = "0.5.3"
+__version__ = "0.5.5"

{lionagi-0.5.3.dist-info → lionagi-0.5.5.dist-info}/METADATA

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

{lionagi-0.5.3.dist-info → lionagi-0.5.5.dist-info}/RECORD

@@ -1,10 +1,10 @@
 lionagi/__init__.py,sha256=oybfu2VsZc4ElN7ZeaW3KQrz8T8EcSDHPA8lUE-8G2I,537
 lionagi/settings.py,sha256=BOjxRV4N9zQJervvajPhbaHmgZ-nhbCy7AaQJi3Avug,2726
-lionagi/version.py,sha256=tgzuqHKcEdKBaP57F5oXxq4XlW2n9J4Fj8ZGu7nGOZg,22
+lionagi/version.py,sha256=78mfpLewKVki6c9UONSUdlVme_JsN9ZwIfp4Hf4jmG0,22
 lionagi/core/__init__.py,sha256=v8vNyJVIVj8_Oz9RJdVe6ZKUQMYTgDh1VQpnr1KdLaw,112
 lionagi/core/_class_registry.py,sha256=srSWefqCS9EZrMvyA8zCrZ9KFvzAhTIj8g6mJG5KlIc,1982
 lionagi/core/action/__init__.py,sha256=v8vNyJVIVj8_Oz9RJdVe6ZKUQMYTgDh1VQpnr1KdLaw,112
-lionagi/core/action/action_manager.py,sha256=8yNWV5x8YtaoL2A_U_5xjJdruqwWw8TLPAtq3f3DC7M,10143
+lionagi/core/action/action_manager.py,sha256=R7gXNu--lM8DSFNMP1fUOcNzWPsAE49qizpw8pP11fo,10236
 lionagi/core/action/base.py,sha256=M2K3irxpp7fDwczefzZdUsHhGd_21l1xhFT9iNSbiK0,4110
 lionagi/core/action/function_calling.py,sha256=7N5UFLbHPy6yvPrR6RH9SNSwt73s0X_3iAnOV8YMy0Q,6001
 lionagi/core/action/tool.py,sha256=pDiyttx0obu0qDskz7POHxbyqTwHuD7HCeE31LkzRMg,6884
@@ -12,14 +12,14 @@ lionagi/core/action/types.py,sha256=KqW5ZHXssfxuf1kIiIUoj-r3KIZEoQ_GkZ04tL6fUPQ,
 lionagi/core/communication/__init__.py,sha256=v8vNyJVIVj8_Oz9RJdVe6ZKUQMYTgDh1VQpnr1KdLaw,112
 lionagi/core/communication/action_request.py,sha256=gicqQIs7VLOhnkQYsUuRmSLGittODiG3Pk74FayPSeM,5006
 lionagi/core/communication/action_response.py,sha256=QONcRtvV7Ympbzkdg5gnV0DqCC97Y-gvaA0D7EkjswM,4505
-lionagi/core/communication/assistant_response.py,sha256=WTQjBxAckMILocaZEsOP6u1mfKr3DhYVt4K8TyAh7Ek,5760
+lionagi/core/communication/assistant_response.py,sha256=IidDoxC54lxnDT194w5exWC9hDb0TxTY2mmwzbQwbOg,6004
 lionagi/core/communication/base_mail.py,sha256=Et-WrHlw2x75mLIKy-wMUj3YlGGL_2BF9r1REuiZtM8,1704
 lionagi/core/communication/instruction.py,sha256=Iy3G1sp0lPuA4Ak9pLobIipou4ePLsMdGGvRq6L58UU,12454
-lionagi/core/communication/message.py,sha256=60yaub4C_JFnMR76D_DeYfQ_mQYoZ0eBF9Vqk2UadUw,8550
-lionagi/core/communication/message_manager.py,sha256=RnSYJUnKOKBS8dfY2804Zq2sD-C5qDvBXNxXRsMfRe0,16987
+lionagi/core/communication/message.py,sha256=ZE4hJfDN1LLOGYM-nxFZDIP6v8b3fMNcziS7Pj1gYNA,8556
+lionagi/core/communication/message_manager.py,sha256=MRl7_RdgOOHedUOVZ7FT9DtsWK4C4nj5NzTXgJV71aw,17478
 lionagi/core/communication/system.py,sha256=5DoDODZePy4EDpE3oI5RpkzBXVp9WC2Mf4B3fPImItI,3824
 lionagi/core/communication/types.py,sha256=rBGMpE3NW0SGKc-wJdJvT-VrO3wpjwjQhoWzSC2Dqh0,745
-lionagi/core/communication/utils.py,sha256=9kaBLH2eA2XqhW_aQvqziwm__z-WlBKSM0pwWX4BFjk,6959
+lionagi/core/communication/utils.py,sha256=5W0xW6Tx-DF4Vzpjpk01g1960mNjvBUWrDLGU-thBaQ,7031
 lionagi/core/communication/templates/README.md,sha256=Ch4JrKSjd85fLitAYO1OhZjNOGKHoEwaKQlcV16jiUI,1286
 lionagi/core/communication/templates/action_request.jinja2,sha256=d6OmxHKyvvNDSK4bnBM3TGSUk_HeE_Q2EtLAQ0ZBEJg,120
 lionagi/core/communication/templates/action_response.jinja2,sha256=Mg0UxmXlIvtP_KPB0GcJxE1TP6lml9BwdPkW1PZxkg8,142
@@ -55,8 +55,8 @@ lionagi/core/models/schema_model.py,sha256=H2tSX3r0U6MDNi929rWmAZy3nUKMP47RG-Ma0
 lionagi/core/models/types.py,sha256=elcUuz_9dx4AhZddnICF-Cs62VJWIBqMET7MiRe4c1I,447
 lionagi/core/session/__init__.py,sha256=v8vNyJVIVj8_Oz9RJdVe6ZKUQMYTgDh1VQpnr1KdLaw,112
 lionagi/core/session/branch.py,sha256=r6yNXwTm0oYA-9YOereuvLJtDnhj9IJWJ5fjTyKN88U,4406
-lionagi/core/session/branch_mixins.py,sha256=C9lGHmD1AmXAePw0kGIeuZjZ7SzOrFcIwV6rVaGhoGg,19623
-lionagi/core/session/session.py,sha256=Uup50oMqs00ZH6zgEiqtk0pG_ANByHW_Ael07dfbT1M,5122
+lionagi/core/session/branch_mixins.py,sha256=7uVqxkgvbj53JlDk9roL032c2YeNl_bq5UQSxw24raQ,21240
+lionagi/core/session/session.py,sha256=cutece_iTs5K_m5soRfU9oTfHmw1icDEvx77E1RelIM,5129
 lionagi/core/session/types.py,sha256=MUGTSa2HWK79p7z-CG22RFP07N5AKnPVNXZwZt_wIvU,202
 lionagi/core/typing/__init__.py,sha256=Y9BK1OUXzjQgIo3epCVwWqUYhFwQQ_ayhRwI1UOmINg,228
 lionagi/core/typing/_concepts.py,sha256=uIzqfwtPBsIREhvT7NDAowc4i-u-69n_DRzLHzvHZO4,3730
@@ -65,12 +65,12 @@ lionagi/core/typing/_pydantic.py,sha256=xMNyT0rDhSpKkEDfzj6GHobqlTtRn48svhmA75LP
 lionagi/core/typing/_typing.py,sha256=VJj5W6y-JGK1ZzSbyDs4qAuq0cA5wp5HtRgZUsZ50E0,869
 lionagi/integrations/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 lionagi/integrations/_services.py,sha256=qxffUaPKvp2Bb_LI3Uiyokm7l6ZAbRi0xKxZXCYs67c,498
-lionagi/integrations/anthropic_/AnthropicModel.py,sha256=3Mzw7g6KjCZMzRgURH1AgqUJvmS3AqZaF5k_q4f77j8,9228
-lionagi/integrations/anthropic_/AnthropicService.py,sha256=Z6fGD2nLEKOm3cDK4Gy0_Vl289KAxX1wswCWsEDpp4E,3656
+lionagi/integrations/anthropic_/AnthropicModel.py,sha256=6O9-GAQnq-Erhx62pxQDRuVL-vpCFUWMEe3V6HmR1MA,9076
+lionagi/integrations/anthropic_/AnthropicService.py,sha256=t1LL_64xmz4vFDGVGm8M7Stion8LwfJVVEPvdtYwDtg,4074
 lionagi/integrations/anthropic_/__init__.py,sha256=v8vNyJVIVj8_Oz9RJdVe6ZKUQMYTgDh1VQpnr1KdLaw,112
-lionagi/integrations/anthropic_/anthropic_max_output_token_data.yaml,sha256=u_CT9UAXoNpbAWuPHMxH9g4erZW7XUwY4vdSXyE86t4,203
-lionagi/integrations/anthropic_/anthropic_price_data.yaml,sha256=NCoBo5QFiBvrtztZf2FEyYvtKjIOYDuVMAVUINtp3OY,368
-lionagi/integrations/anthropic_/version.py,sha256=g_pWEWcI5s734NFznrQH3zktRFXpvlB2P-8lty7inwI,135
+lionagi/integrations/anthropic_/anthropic_max_output_token_data.yaml,sha256=MCgwrtCwaVE9SJar3NNKI51uuwQ2Nzko979lTd5mEeU,360
+lionagi/integrations/anthropic_/anthropic_price_data.yaml,sha256=tviu4PY-xjo-9vhx--Vsp0ZNYVhgcaQAAfZvD7GxErc,756
+lionagi/integrations/anthropic_/version.py,sha256=25-aR3n_vIk4o62w93ToEUcEYbH9ZPmmJjwkf4fvZls,135
 lionagi/integrations/anthropic_/api_endpoints/__init__.py,sha256=v8vNyJVIVj8_Oz9RJdVe6ZKUQMYTgDh1VQpnr1KdLaw,112
 lionagi/integrations/anthropic_/api_endpoints/api_request.py,sha256=JWp-m4DFFwrR13ckTMnfg2ULOJAmHDheuXDNR24vk4s,10368
 lionagi/integrations/anthropic_/api_endpoints/data_models.py,sha256=qX6U9G_ZNlASyvhQ3WzgdR0kMvSWbO-kbQyo6R7pIAc,978
@@ -84,19 +84,19 @@ lionagi/integrations/anthropic_/api_endpoints/messages/response/content_models.p
 lionagi/integrations/anthropic_/api_endpoints/messages/response/response_body.py,sha256=96e2GAAiTGkExRullvAsAOGhPPHNByhnv6DK_wz1j40,3213
 lionagi/integrations/anthropic_/api_endpoints/messages/response/usage_models.py,sha256=s6oe5iOU027M7YPS10upnvcPsuFbTV1ZM00lInHPKvA,695
 lionagi/integrations/groq_/GroqModel.py,sha256=y2KaFe8GmlTBnBRvB09dNjYYhNEjq2wujYfB8YzGNHI,11950
-lionagi/integrations/groq_/GroqService.py,sha256=v3bn04njIwV7ysOlfLCmapOhHZJy3bNUTr0i12tFqME,4644
+lionagi/integrations/groq_/GroqService.py,sha256=GKYDONxZpzcH7XgVlLg0Tw2wWBAAcOywsBcahbOQPCU,4781
 lionagi/integrations/groq_/__init__.py,sha256=v8vNyJVIVj8_Oz9RJdVe6ZKUQMYTgDh1VQpnr1KdLaw,112
 lionagi/integrations/groq_/groq_max_output_token_data.yaml,sha256=Y0PbyZ7pyyV1zi7ZJSJGVPsZDhSeN2JMOyghzkqqoKc,559
 lionagi/integrations/groq_/groq_price_data.yaml,sha256=HmN_2-QliKvaC8Ghq7QJAD97ubMYzPSy7EGgqzgCz48,1234
 lionagi/integrations/groq_/groq_rate_limits.yaml,sha256=x8hiZx_-H3ZyMznnxgFCQidWMEK5jIzBvrYpxb8gFYI,2863
-lionagi/integrations/groq_/version.py,sha256=g_pWEWcI5s734NFznrQH3zktRFXpvlB2P-8lty7inwI,135
+lionagi/integrations/groq_/version.py,sha256=25-aR3n_vIk4o62w93ToEUcEYbH9ZPmmJjwkf4fvZls,135
 lionagi/integrations/groq_/api_endpoints/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 lionagi/integrations/groq_/api_endpoints/data_models.py,sha256=bwqAbERAT1xAzLkMKkBrHOLr-hLDcblW4pcQ5Oqmyq8,5424
 lionagi/integrations/groq_/api_endpoints/groq_request.py,sha256=u-GJuu0ZsY7jMWaXtNXnud7Pw3Pxs6Cc280UnTHk3YE,10383
 lionagi/integrations/groq_/api_endpoints/match_response.py,sha256=95vRKsR1QYPPmBY36dC5azdKn5UlXNRrTQqTUZro_YM,3756
 lionagi/integrations/groq_/api_endpoints/response_utils.py,sha256=P5kRsGHe-Rx9xejfRcU8q680yotcWLTSaSUuqXATcho,3710
 lionagi/integrations/litellm_/__init__.py,sha256=v8vNyJVIVj8_Oz9RJdVe6ZKUQMYTgDh1VQpnr1KdLaw,112
-lionagi/integrations/litellm_/imodel.py,sha256=YBaG5f8BavbhooVv7xQXC68K6N7AxPMcUAhgJ1TlYNw,2227
+lionagi/integrations/litellm_/imodel.py,sha256=M52linffjZuytzHzhJStPLcMa90oCs-pfVljzdK-0Es,2365
 lionagi/integrations/ollama_/OllamaModel.py,sha256=5kBYIWShsSpQpSgOxdbRk2_4jmss6Y8iISjUcS3KoWw,8341
 lionagi/integrations/ollama_/OllamaService.py,sha256=bJ4kk1FPjn_kecLzxTJgVj05KZPzF5FclHoDA3jdAlg,4080
 lionagi/integrations/ollama_/__init__.py,sha256=v8vNyJVIVj8_Oz9RJdVe6ZKUQMYTgDh1VQpnr1KdLaw,112
@@ -125,12 +125,12 @@ lionagi/integrations/ollama_/api_endpoints/model/list_model.py,sha256=OrGdJa0evj
 lionagi/integrations/ollama_/api_endpoints/model/pull_model.py,sha256=fiZJcQSRn73SJA9GdlfPBG5RiMISQwBc0y7S_zAlOGA,923
 lionagi/integrations/ollama_/api_endpoints/model/push_model.py,sha256=yDOMVu3ajdNFT1cuzb4R_3qDxlk0qT4aM2oget3aHZ4,961
 lionagi/integrations/ollama_/api_endpoints/model/show_model.py,sha256=CclV6pEmm5iYM25ePnMAiicVJmZzolDim7BsQoEJAw0,864
-lionagi/integrations/openai_/OpenAIModel.py,sha256=4SYgSlz5ZMcpEGf_epF8n4emd7ze1UutTjKDJvZDYcQ,15980
-lionagi/integrations/openai_/OpenAIService.py,sha256=P0sGnxeWPKe15_KndqCgEdM74AKVJ6NJsgFGORqqlrk,13507
+lionagi/integrations/openai_/OpenAIModel.py,sha256=6cv6NIkCMjZ7k2v-kvtCVXjIOHgwwPfGuJV7ttL7Q4M,15889
+lionagi/integrations/openai_/OpenAIService.py,sha256=H48XqIv1IBzraPUGqryQzy83dMxBq4_qmTAo65MCBQE,13736
 lionagi/integrations/openai_/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 lionagi/integrations/openai_/openai_max_output_token_data.yaml,sha256=3gd8TGnFjy4AdHzvsV9wZjK_r_o26pe3Th75n5eN2zs,263
 lionagi/integrations/openai_/openai_price_data.yaml,sha256=O8mRk8_-MVVLMMlRRIggVirq-d91U6aNhpl9F3L7EL4,780
-lionagi/integrations/openai_/version.py,sha256=Y3LSfRioSl2xch70pq_ULlvyECXyEtN3krVaWeGyaxk,22
+lionagi/integrations/openai_/version.py,sha256=2plzdEEb24FLjE2I2XyBBcJEPYWHccNL4SgtLC_6erg,22
 lionagi/integrations/openai_/api_endpoints/__init__.py,sha256=Ave6AXUYRyaRqCwSS3usjr8Jvog26Rjc5HdsCPRAGLk,68
 lionagi/integrations/openai_/api_endpoints/api_request.py,sha256=2hS3tEQlglgvw5Jw6c0JL5GXfQDv0gRo5TWcyTsCUJA,10567
 lionagi/integrations/openai_/api_endpoints/data_models.py,sha256=Jiob2b_2W8idS-mNOjnK8cP_vbphArqoOAC6e5DXmc8,627
@@ -218,11 +218,11 @@ lionagi/integrations/pandas_/search_keywords.py,sha256=AJfN8QVu6rUni6As8AOTnzne_
 lionagi/integrations/pandas_/to_df.py,sha256=3vAOCj0Ib2PZNCblg1oA20PjRIrUXR86FHICQLNhLu0,5757
 lionagi/integrations/pandas_/update_cells.py,sha256=7X1bGcPvnEINrLM_zFCWUXIkrFdMGV3TjoEYBq_SThs,1658
 lionagi/integrations/perplexity_/PerplexityModel.py,sha256=06kURklzmc3f-TPwdB3a2zbYttfBTSlBrgZG_Tkw680,9335
-lionagi/integrations/perplexity_/PerplexityService.py,sha256=q5Ruy60H3cL2a4LOUjB2JI6bkMwKiWVSlrjpATREwqM,3641
+lionagi/integrations/perplexity_/PerplexityService.py,sha256=fyI7S1I9Pxdr1DHxFTkUmTP6djIQLPLlkKyEKGz5QLg,3778
 lionagi/integrations/perplexity_/__init__.py,sha256=v8vNyJVIVj8_Oz9RJdVe6ZKUQMYTgDh1VQpnr1KdLaw,112
 lionagi/integrations/perplexity_/perplexity_max_output_token_data.yaml,sha256=SY6nDrDRhI_HzEBYHaANR_Mc5GRa0SY9Pw_wRuVBlV4,121
 lionagi/integrations/perplexity_/perplexity_price_data.yaml,sha256=eyp_jZktnEbsEv9VJ0TLNzjp99VdOEA0E-el_dAzCTc,284
-lionagi/integrations/perplexity_/version.py,sha256=J-j-u0itpEFT6irdmWmixQqYMadNl1X91TxUmoiLHMI,22
+lionagi/integrations/perplexity_/version.py,sha256=d4QHYmS_30j0hPN8NmNPnQ_Z0TphDRbu4MtQj9cT9e8,22
 lionagi/integrations/perplexity_/api_endpoints/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 lionagi/integrations/perplexity_/api_endpoints/api_request.py,sha256=jcBlSkTta0HIyg-mbY_iNpSoQwuDuQKryFTb0p5JjCM,6657
 lionagi/integrations/perplexity_/api_endpoints/data_models.py,sha256=kQQorMksoibGopJm5oXpoR5pH_ZyLdnpmA5xd855P2c,1689
@@ -257,7 +257,7 @@ lionagi/libs/func/throttle.py,sha256=iOOmS6i81NGRCClf4WaIhMMXwPt_rZ6WXYBqMJ_weEE
 lionagi/libs/func/types.py,sha256=wdjGNmY82pVACQBuDMUt3XJO0G9_wKHR7VesOeMxo_A,831
 lionagi/libs/func/utils.py,sha256=-LMdUEjksXP6JjjcUBh0XEQiXF30Zmv3xpKbmXjfya8,2674
 lionagi/libs/func/async_calls/__init__.py,sha256=qDHIkH7B-Ka5NJqeeyu_YL3TY36xL8kBwTjtCR4H8AU,495
-lionagi/libs/func/async_calls/alcall.py,sha256=U8-lWwqNwhe50Q07kzyW4YVcbx_LkUN5X1K1zvFg7i0,7283
+lionagi/libs/func/async_calls/alcall.py,sha256=GhPXId0YLvfxpDSYOABwr_3D-nRu8aLWshaYboJQzmQ,7436
 lionagi/libs/func/async_calls/bcall.py,sha256=gwfKpRZkExjVn-1YGZfaboFES8RqUgyaBrdpNtz1IdY,4436
 lionagi/libs/func/async_calls/mcall.py,sha256=9O5gWbBT4iIqXfcdZjgAdqsOSLWrNS4_tt6ou231ozA,4607
 lionagi/libs/func/async_calls/pcall.py,sha256=6u3RJPV-3yOkWxC9iSoVFl1veFfZFJpR0QRyGtfBODI,5831
@@ -317,10 +317,10 @@ lionagi/libs/string_similarity/utils.py,sha256=NdD0qF5tuytWBsm0WMrH0gRBBSxw2p4-m
 lionagi/operations/__init__.py,sha256=Dt7o6DFP7zVR-uxZ4xsGHQcse3XVlF6S8Y9NhaUTn_4,68
 lionagi/operations/utils.py,sha256=kn5SkZRczl1aQ-vJBeVPlMdeyUUD0s5iyuAW4P6KOvQ,1164
 lionagi/operations/brainstorm/__init__.py,sha256=amsoH65wepsx58DfgH-TRTN1wDH5TC24qYI_f02zkVg,61
-lionagi/operations/brainstorm/brainstorm.py,sha256=H2D0ZBCbRA2Ig60IHuXhyH6Hu02jxKhbj028UtS4eik,6279
+lionagi/operations/brainstorm/brainstorm.py,sha256=1Uuc11OH34jEYfDdombX5ui9b-bJTn4bVSLt0jjQUIc,16747
 lionagi/operations/brainstorm/prompt.py,sha256=3a7LsmtiqGAK5mtWoX-2qhsjETBzBx8FxM3cFCBEoOo,497
 lionagi/operations/plan/__init__.py,sha256=SVqoVmlSGz9lsLztm487H2qOLwgyFxSi2yZ8ubn-bgE,43
-lionagi/operations/plan/plan.py,sha256=Ui8fFdRNLiD3RJmnKCwfY48yj0Fxxw2LBye0egYttWE,5611
+lionagi/operations/plan/plan.py,sha256=AX4h_TeyhcXag572ywN9rmvo3fEiuGER7skAKf25_LY,15329
 lionagi/operations/plan/prompt.py,sha256=sKHa_jDahzCJ60oILj1XNYCIlbS-H8ybKRXpf9zd5x0,880
 lionagi/operations/select/__init__.py,sha256=dUd-KS1l404_ueYlIQsVNhS9jAqjn5pJbtUEbbh6KlI,49
 lionagi/operations/select/prompt.py,sha256=wbmuDC96fcQ4LFKjqmeErOQwVRpGWRqcwUeLTWnbeNs,186
@@ -351,7 +351,7 @@ lionagi/protocols/registries/_component_registry.py,sha256=C04oie1-CQJCoXsjZ6hYA
 lionagi/protocols/registries/_pile_registry.py,sha256=l2RbkjW6OGOHsgPIq9OitIi27r8Fk0vziMI8N_tP3nQ,656
 lionagi/service/__init__.py,sha256=AQS0ezBCtjZOUbT_QEH-Ev5l41-Pk0_KgmKHUgf_Y_A,375
 lionagi/service/complete_request_info.py,sha256=V9cWqmQ-fo952EWCooAvezaM_xuxYU4Xy0Jo_0XJnug,301
-lionagi/service/imodel.py,sha256=laiwc4FvO0jHpf7Q9GrL0VIABCIInkn0ld8XUcbabKo,4191
+lionagi/service/imodel.py,sha256=OK71j_hCJb9LATocPJfaDRpXfVpq_Z9r3F6OeOgrgyg,4356
 lionagi/service/rate_limiter.py,sha256=1cCtKfpOo_8h4ZN-oX5HXtnq0iGjF1rxi8htyu65kMU,3746
 lionagi/service/service.py,sha256=58FPZzLM85fNm4WgSzmZRwbHHuLUW1K0VagKZ7A2ZAs,1077
 lionagi/service/service_match_util.py,sha256=gjGzfQeQqkyxMrKx8aINS47r3Pmugbcx8JjmvbEBg7Y,4305
@@ -368,7 +368,7 @@ lionagi/strategies/sequential_chunk.py,sha256=jG_WZXG-Ra3yd30CmX4b3XeCNAUrZGA2-i
 lionagi/strategies/sequential_concurrent_chunk.py,sha256=H7GShaqYlD5XxNJMG2GdOR4Vl8JHDhZb5jxNq8zY0hI,3365
 lionagi/strategies/types.py,sha256=fEvE4d1H4SeCcXcd2dz3q4k8jFIBtxYzjxDN7eJRLtI,769
 lionagi/strategies/utils.py,sha256=DX1dvxia8cNRqEJJbssJ3mgRzo7kgWCTA4y5DYLCCZE,1281
-lionagi-0.5.3.dist-info/METADATA,sha256=EDYWV82gJQWvmwXKbRLUaJjEGQ20B2DL-3emvuhdchg,22736
-lionagi-0.5.3.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
-lionagi-0.5.3.dist-info/licenses/LICENSE,sha256=VXFWsdoN5AAknBCgFqQNgPWYx7OPp-PFEP961zGdOjc,11288
-lionagi-0.5.3.dist-info/RECORD,,
+lionagi-0.5.5.dist-info/METADATA,sha256=tVI6_Y0Ykz5C8X0ptfBdfK9vke6V3m4ZyIkBrFpTIoE,22736
+lionagi-0.5.5.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+lionagi-0.5.5.dist-info/licenses/LICENSE,sha256=VXFWsdoN5AAknBCgFqQNgPWYx7OPp-PFEP961zGdOjc,11288
+lionagi-0.5.5.dist-info/RECORD,,