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

lionagi/protocols/operatives/operative.py

@@ -1,25 +1,13 @@
-"""
-Copyright 2024 HaiyangLi
-
-   Licensed under the Apache License, Version 2.0 (the "License");
-   you may not use this file except in compliance with the License.
-   You may obtain a copy of the License at
-
-       http://www.apache.org/licenses/LICENSE-2.0
-
-   Unless required by applicable law or agreed to in writing, software
-   distributed under the License is distributed on an "AS IS" BASIS,
-   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-   See the License for the specific language governing permissions and
-   limitations under the License.
-"""
+# Copyright (c) 2023 - 2024, HaiyangLi <quantocean.li at gmail dot com>
+#
+# SPDX-License-Identifier: Apache-2.0
 
 from typing import Self
 
 from pydantic import BaseModel, Field, PrivateAttr, model_validator
 from pydantic.fields import FieldInfo
 
-from lionagi.core.models import FieldModel, NewModelParams, OperableModel
+from lionagi.core.models import FieldModel, ModelParams, OperableModel
 from lionagi.core.typing import UNDEFINED
 from lionagi.libs.parse import to_json, validate_keys
 
@@ -29,10 +17,10 @@ class Operative(OperableModel):
 
     name: str | None = None
 
-    request_params: NewModelParams | None = Field(default=None)
+    request_params: ModelParams | None = Field(default=None)
     request_type: type[BaseModel] | None = Field(default=None)
 
-    response_params: NewModelParams | None = Field(default=None)
+    response_params: ModelParams | None = Field(default=None)
     response_type: type[BaseModel] | None = Field(default=None)
     response_model: OperableModel | None = Field(default=None)
     response_str_dict: dict | str | None = Field(default=None)
@@ -140,7 +128,7 @@ class Operative(OperableModel):
 
     def create_response_type(
         self,
-        response_params: NewModelParams | None = None,
+        response_params: ModelParams | None = None,
         field_models: list[FieldModel] | None = None,
         parameter_fields: dict[str, FieldInfo] | None = None,
         exclude_fields: list[str] | None = None,
@@ -154,7 +142,7 @@ class Operative(OperableModel):
         """Creates a new response type based on the provided parameters.
 
         Args:
-            response_params (NewModelParams, optional): Parameters for the new response model.
+            response_params (ModelParams, optional): Parameters for the new response model.
             field_models (list[FieldModel], optional): List of field models.
             parameter_fields (dict[str, FieldInfo], optional): Dictionary of parameter fields.
             exclude_fields (list, optional): List of fields to exclude.
@@ -165,7 +153,7 @@ class Operative(OperableModel):
             frozen (bool, optional): Whether the model is frozen.
             validators (dict, optional): Dictionary of validators.
         """
-        self.response_params = response_params or NewModelParams(
+        self.response_params = response_params or ModelParams(
             parameter_fields=parameter_fields,
             field_models=field_models,
             exclude_fields=exclude_fields,

lionagi/protocols/operatives/prompts.py

@@ -1,232 +1,83 @@
-from pydantic import JsonValue
+# Copyright (c) 2023 - 2024, HaiyangLi <quantocean.li at gmail dot com>
+#
+# SPDX-License-Identifier: Apache-2.0
 
 function_field_description = (
-    "Specify the name of the function to execute. **Choose "
-    "from the provided `tool_schemas`; do not invent function names.**"
-    "Only provide function names if tool_schemas are provided. Otherwise, "
-    "must leave blank or set to None."
+    "Name of the function to call from the provided `tool_schemas`. "
+    "If no `tool_schemas` exist, set to None or leave blank. "
+    "Never invent new function names outside what's given."
 )
 
 arguments_field_description = (
-    "Provide the arguments to pass to the function as a "
-    "dictionary. **Use argument names and types as specified in the "
-    "`tool_schemas`; do not invent argument names.**"
+    "Dictionary of arguments for the chosen function. "
+    "Use only argument names/types defined in `tool_schemas`. "
+    "Never introduce extra argument names."
 )
 
 action_required_field_description = (
-    "Specify whether the step requires actions to be "
-    "performed. If **True**, the actions in `action_requests` "
-    "must be performed. If **False**, the actions in "
-    "`action_requests` are optional. If no tool_schemas"
-    " are provided, this field is ignored."
+    "Whether this step strictly requires performing actions. "
+    "If true, the requests in `action_requests` must be fulfilled, "
+    "assuming `tool_schemas` are available. "
+    "If false or no `tool_schemas` exist, actions are optional."
 )
 
 action_requests_field_description = (
-    "List of actions to be performed if `action_required` "
-    "is **True**. Leave empty if no action is required. "
-    "**When providing actions, you must choose from the "
-    "provided `tool_schemas`. Do not invent function or "
-    "argument names.**"
+    "List of actions to be executed when `action_required` is true. "
+    "Each action must align with the available `tool_schemas`. "
+    "Leave empty if no actions are needed."
 )
 
 confidence_description = (
-    "Provide an objective numeric confidence score between 0 and 1 (with 3 "
-    "decimal places) indicating how likely you successfully achieved the task"
-    " according to user expectation. Interpret the score as:\n"
-    "- **1**: Very confident in a good job.\n"
-    "- **0**: Not confident at all.\n"
-    "- **[0.8, 1]**: You can continue the path of reasoning if needed.\n"
-    "- **[0.5, 0.8)**: Recheck your reasoning and consider reverting to a "
-    "previous, more confident reasoning path.\n"
-    "- **[0, 0.5)**: Stop because the reasoning is starting to be off track."
+    "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"
 )
 
 instruction_field_description = (
-    "Define the core task or instruction to be executed. Your instruction should:\n\n"
-    "1. Be specific and actionable\n"
-    "2. Clearly state the expected outcome\n"
-    "3. Include any critical constraints or requirements\n\n"
-    "**Guidelines for writing effective instructions:**\n"
-    "- Start with a clear action verb (e.g., analyze, create, evaluate)\n"
-    "- Specify the scope and boundaries of the task\n"
-    "- Include success criteria when applicable\n"
-    "- Break complex tasks into distinct steps\n\n"
-    "**Examples:**\n"
-    "- 'Analyze the provided sales data and identify top 3 performing products'\n"
-    "- 'Generate a Python function that validates email addresses'\n"
-    "- 'Create a data visualization showing monthly revenue trends'"
+    "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_field_description = (
-    "Provide strategic direction and constraints for task execution.\n\n"
-    "**Key components to include:**\n"
-    "1. Methodological preferences\n"
-    "2. Quality standards and requirements\n"
-    "3. Specific limitations or boundaries\n"
-    "4. Performance expectations\n\n"
-    "**Best practices:**\n"
-    "- Be explicit about any assumptions that should be made\n"
-    "- Specify preferred approaches or techniques\n"
-    "- Detail any constraints on resources or methods\n"
-    "- Include relevant standards or compliance requirements\n\n"
-    "Leave as None if no specific guidance is needed beyond the instruction."
+    "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_field_description = (
-    "Supply essential background information and current state data required for "
-    "task execution.\n\n"
-    "**Include relevant details about:**\n"
-    "1. Environmental conditions\n"
-    "2. Historical context\n"
-    "3. Related systems or processes\n"
-    "4. Previous outcomes or decisions\n\n"
-    "**Context should:**\n"
-    "- Be directly relevant to the task\n"
-    "- Provide necessary background without excess detail\n"
-    "- Include any dependencies or prerequisites\n"
-    "- Specify the current state of the system\n\n"
-    "Set to None if no additional context is required."
+    "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_field_description = (
-    "Control whether detailed reasoning should be included in the response.\n\n"
-    "**When set to True:**\n"
-    "- Must include a ReasonModel explaining decision rationale\n"
-    "- Should detail key decision points\n"
-    "- Must provide confidence scores for decisions\n"
-    "- Should explain trade-offs considered\n\n"
-    "**When set to False:**\n"
-    "- Skip detailed reasoning\n"
-    "- Focus on direct results\n"
-    "- Omit confidence scoring\n\n"
-    "Set to None to make reasoning optional based on context."
+    "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_field_description = (
-    "Specify whether concrete actions should be taken as part of task execution.\n\n"
-    "**When set to True:**\n"
-    "- Must include appropriate ActionRequestModels\n"
-    "- Actions should directly relate to task goals\n"
-    "- Each action must be properly structured and validated\n"
-    "- Actions must use available tool schemas\n\n"
-    "**When set to False:**\n"
-    "- No actions should be included\n"
-    "- Focus on analysis and recommendations\n\n"
-    "Set to None to make actions optional based on requirements."
+    "Controls execution mode. "
+    "True: Execute specified actions. "
+    "False: Analysis/recommendations only. "
+    "None: Contextual execution."
 )
-
-# Example structures for each field to demonstrate proper formatting
-instruction_examples: list[JsonValue] = [
-    "Analyze the dataset 'sales_2023.csv' and identify revenue trends",
-    "Create a Python function to process customer feedback data",
-    {
-        "task": "data_analysis",
-        "target": "sales_performance",
-        "scope": ["revenue", "growth", "seasonality"],
-    },
-]
-
-guidance_examples: list[JsonValue] = [
-    "Use statistical methods for trend analysis",
-    "Optimize for readability and maintainability",
-    {
-        "methods": ["regression", "time_series"],
-        "constraints": {"memory": "2GB", "time": "5min"},
-    },
-]
-
-context_examples: list[JsonValue] = [
-    "Previous analysis showed seasonal patterns",
-    {
-        "prior_results": {"accuracy": 0.95},
-        "system_state": "production",
-        "dependencies": ["numpy", "pandas"],
-    },
-]
-
-"""Field description for InstructModel."""
-
-instruct_model_description = (
-    "Generate structured instructions for task execution.\n\n"
-    "**Key Components:**\n"
-    "1. Task Definition: Clear description of what needs to be accomplished\n"
-    "2. Execution Parameters: How the task should be performed\n"
-    "3. Success Criteria: What constitutes successful completion\n"
-    "4. Scope and Boundaries: Limits and constraints of the task\n\n"
-    "**Structure Guidelines:**\n"
-    "- `instruction`: Core task or objective to accomplish\n"
-    "- `guidance`: Parameters, preferences, and constraints\n"
-    "- `context`: Relevant background and environmental information\n"
-    "- `reason`: Whether to include reasoning in output\n"
-    "- `actions`: Whether specific actions are required\n\n"
-    "**Best Practices:**\n"
-    "- Keep instructions clear and specific\n"
-    "- Provide necessary but not excessive detail\n"
-    "- Define measurable outcomes\n"
-    "- Include relevant dependencies\n"
-    "- Specify critical constraints\n\n"
-    "**Common Issues to Avoid:**\n"
-    "- Vague or ambiguous directives\n"
-    "- Missing essential context\n"
-    "- Undefined success criteria\n"
-    "- Incomplete requirements\n"
-    "- Conflicting parameters\n\n"
-    "Structure instructions to enable successful task execution while maintaining "
-    "appropriate flexibility for implementation details."
-)
-
-instruct_model_examples = [
-    {
-        "instruction": "Process the input data according to specified requirements",
-        "guidance": {
-            "requirements": ["validation", "transformation", "aggregation"],
-            "output_format": "structured_report",
-            "quality_metrics": ["accuracy", "completeness"],
-        },
-        "context": {
-            "input_source": "data_stream",
-            "domain": "general",
-            "priority": "standard",
-        },
-        "reason": True,
-        "actions": True,
-    },
-    {
-        "instruction": "Evaluate system performance against baseline metrics",
-        "guidance": {
-            "evaluation_criteria": [
-                "response_time",
-                "resource_usage",
-                "error_rate",
-            ],
-            "methodology": "standard",
-            "reporting": "detailed",
-        },
-        "context": {
-            "environment": "test",
-            "criticality": "medium",
-            "constraints": {"time": "bounded"},
-        },
-        "reason": True,
-        "actions": False,
-    },
-]
-
-
-__all__ = [
-    "function_field_description",
-    "arguments_field_description",
-    "action_required_field_description",
-    "action_requests_field_description",
-    "confidence_description",
-    "instruction_field_description",
-    "guidance_field_description",
-    "context_field_description",
-    "reason_field_description",
-    "actions_field_description",
-    "instruction_examples",
-    "guidance_examples",
-    "context_examples",
-    "instruct_model_description",
-    "instruct_model_examples",
-]

lionagi/protocols/operatives/reason.py

@@ -1,3 +1,7 @@
+# Copyright (c) 2023 - 2024, HaiyangLi <quantocean.li at gmail dot com>
+#
+# SPDX-License-Identifier: Apache-2.0
+
 from pydantic import BaseModel, field_validator
 
 from lionagi.core.models import FieldModel

lionagi/protocols/operatives/step.py

@@ -1,23 +1,11 @@
-"""
-Copyright 2024 HaiyangLi
-
-   Licensed under the Apache License, Version 2.0 (the "License");
-   you may not use this file except in compliance with the License.
-   You may obtain a copy of the License at
-
-       http://www.apache.org/licenses/LICENSE-2.0
-
-   Unless required by applicable law or agreed to in writing, software
-   distributed under the License is distributed on an "AS IS" BASIS,
-   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-   See the License for the specific language governing permissions and
-   limitations under the License.
-"""
+# Copyright (c) 2023 - 2024, HaiyangLi <quantocean.li at gmail dot com>
+#
+# SPDX-License-Identifier: Apache-2.0
 
 from pydantic import BaseModel
 from pydantic.fields import FieldInfo
 
-from lionagi.core.typing import FieldModel, NewModelParams
+from lionagi.core.typing import FieldModel, ModelParams
 from lionagi.protocols.operatives.operative import Operative
 
 from .action import (
@@ -54,7 +42,7 @@ class Step:
         operative_name: str | None = None,
         reason: bool = False,
         actions: bool = False,
-        request_params: NewModelParams | None = None,
+        request_params: ModelParams | None = None,
         parameter_fields: dict[str, FieldInfo] | None = None,
         base_type: type[BaseModel] | None = None,
         field_models: list[FieldModel] | None = None,
@@ -72,7 +60,7 @@ class Step:
             operative_name (str, optional): Name of the operative.
             reason (bool, optional): Whether to include reason field.
             actions (bool, optional): Whether to include action fields.
-            request_params (NewModelParams, optional): Parameters for the new model.
+            request_params (ModelParams, optional): Parameters for the new model.
             parameter_fields (dict[str, FieldInfo], optional): Parameter fields for the model.
             base_type (type[BaseModel], optional): Base type for the model.
             field_models (list[FieldModel], optional): List of field models.
@@ -100,7 +88,7 @@ class Step:
                     ACTION_REQUIRED_FIELD,
                 ]
             )
-        request_params = request_params or NewModelParams(
+        request_params = request_params or ModelParams(
             parameter_fields=parameter_fields,
             base_type=base_type,
             field_models=field_models,
@@ -119,7 +107,7 @@ class Step:
         *,
         operative: Operative,
         additional_data: dict | None = None,
-        response_params: NewModelParams | None = None,
+        response_params: ModelParams | None = None,
         field_models: list[FieldModel] | None = None,
         frozen_response: bool = False,
         response_config_dict: dict | None = None,
@@ -131,7 +119,7 @@ class Step:
         Args:
             operative (Operative): The operative instance to update.
             additional_data (dict | None, optional): Additional data to include in the response.
-            response_params (NewModelParams | None, optional): Parameters for the response model.
+            response_params (ModelParams | None, optional): Parameters for the response model.
             field_models (list[FieldModel] | None, optional): List of field models.
             frozen_response (bool, optional): Whether the response model is frozen.
             response_config_dict (dict | None, optional): Configuration dictionary for the response.
@@ -162,7 +150,7 @@ class Step:
     @staticmethod
     def _create_response_type(
         operative: Operative,
-        response_params: NewModelParams | None = None,
+        response_params: ModelParams | None = None,
         response_validators: dict | None = None,
         frozen_response: bool = False,
         response_config_dict: dict | None = None,
@@ -174,7 +162,7 @@ class Step:
 
         Args:
             operative (Operative): The operative instance.
-            response_params (NewModelParams | None, optional): Parameters for the response model.
+            response_params (ModelParams | None, optional): Parameters for the response model.
             response_validators (dict | None, optional): Validators for the response model.
             frozen_response (bool, optional): Whether the response model is frozen.
             response_config_dict (dict | None, optional): Configuration dictionary for the response.

lionagi/protocols/operatives/types.py

@@ -0,0 +1,19 @@
+# Copyright (c) 2023 - 2024, HaiyangLi <quantocean.li at gmail dot com>
+#
+# SPDX-License-Identifier: Apache-2.0
+
+from .action import ActionRequestModel, ActionResponseModel
+from .instruct import Instruct
+from .operative import Operative
+from .reason import ReasonModel
+from .step import Step, StepModel
+
+__all__: list[str] = [
+    "Operative",
+    "Step",
+    "ActionRequestModel",
+    "ActionResponseModel",
+    "StepModel",
+    "Instruct",
+    "ReasonModel",
+]

lionagi/protocols/registries/__init__.py

@@ -0,0 +1,3 @@
+# Copyright (c) 2023 - 2024, HaiyangLi <quantocean.li at gmail dot com>
+#
+# SPDX-License-Identifier: Apache-2.0

lionagi/protocols/registries/_component_registry.py

@@ -1,3 +1,7 @@
+# Copyright (c) 2023 - 2024, HaiyangLi <quantocean.li at gmail dot com>
+#
+# SPDX-License-Identifier: Apache-2.0
+
 from lionagi.protocols.adapters.adapter import AdapterRegistry
 from lionagi.protocols.adapters.json_adapter import (
     JsonAdapter,

lionagi/protocols/registries/_pile_registry.py

@@ -1,3 +1,7 @@
+# Copyright (c) 2023 - 2024, HaiyangLi <quantocean.li at gmail dot com>
+#
+# SPDX-License-Identifier: Apache-2.0
+
 from lionagi.protocols.adapters.adapter import AdapterRegistry
 from lionagi.protocols.adapters.json_adapter import (
     JsonAdapter,

lionagi/service/__init__.py

@@ -1,3 +1,5 @@
+from lionagi.integrations.litellm_.imodel import LiteiModel
+
 from .imodel import iModel
 from .rate_limiter import RateLimiter, RateLimitError
 from .service import Service, register_service
@@ -10,4 +12,5 @@ __all__ = [
     "RateLimitError",
     "invoke_retry",
     "iModel",
+    "LiteiModel",
 ]

lionagi/service/service_match_util.py

@@ -19,7 +19,7 @@ def match_service(service_name: str, **kwargs):
         return key1 == key2
 
     if service_name == "openai":
-        from lionagi.integrations.services import OpenAIService
+        from lionagi.integrations._services import OpenAIService
 
         api_key = kwargs.get("api_key")
         openai_organization = kwargs.get("openai_organization")
@@ -44,7 +44,7 @@ def match_service(service_name: str, **kwargs):
         )
 
     elif service_name == "anthropic":
-        from lionagi.integrations.services import AnthropicService
+        from lionagi.integrations._services import AnthropicService
 
         api_key = kwargs.get("api_key")
         api_version = kwargs.get("api_version", "2023-06-01")
@@ -63,7 +63,7 @@ def match_service(service_name: str, **kwargs):
         )
 
     elif service_name == "perplexity":
-        from lionagi.integrations.services import PerplexityService
+        from lionagi.integrations._services import PerplexityService
 
         api_key = kwargs.get("api_key")
         api_version = kwargs.get("api_version", "2023-06-01")
@@ -77,7 +77,7 @@ def match_service(service_name: str, **kwargs):
         return PerplexityService(api_key=api_key)
 
     elif service_name == "groq":
-        from lionagi.integrations.services import GroqService
+        from lionagi.integrations._services import GroqService
 
         api_key = kwargs.get("api_key")
         for service in ServiceSetting.services.values():

lionagi/settings.py

@@ -1,19 +1,18 @@
 from datetime import timezone
 from enum import Enum
 
-from lionagi.protocols.configs import (
+from lionagi.protocols.configs.types import (
     BranchConfig,
-    LionIDConfig,
+    LogConfig,
     MessageConfig,
     RetryConfig,
     TimedFuncCallConfig,
     iModelConfig,
 )
-from lionagi.protocols.configs.log_config import LogConfig
 
 
 class BaseSystemFields(str, Enum):
-    ln_id = "ln_id"
+    LN_ID = "ln_id"
     TIMESTAMP = "timestamp"
     METADATA = "metadata"
     EXTRA_FIELDS = "extra_fields"
@@ -22,15 +21,8 @@ class BaseSystemFields(str, Enum):
     EMBEDDING = "embedding"
 
 
-DEFAULT_ID_CONFIG = LionIDConfig(
-    n=36,
-    random_hyphen=True,
-    num_hyphens=4,
-    hyphen_start_index=6,
-    hyphen_end_index=-6,
-    prefix="ao",
-    postfix="",
-)
+UUID_VERSION = 4
+
 
 DEFAULT_TIMED_FUNC_CALL_CONFIG = TimedFuncCallConfig(
     initial_delay=0,
@@ -61,7 +53,7 @@ DEFAULT_CHAT_CONFIG = iModelConfig(
 )
 
 
-DEFAULT_RETRY_iMODEL_CONFIG = iModelConfig(
+DEFAULT_PARSE_CONFIG = iModelConfig(
     provider="openai",
     task="chat",
     model="gpt-4o-mini",
@@ -109,7 +101,7 @@ DEFAULT_BRANCH_CONFIG = BranchConfig(
     auto_register_tools=True,
     action_call_config=DEFAULT_TIMED_FUNC_CALL_CONFIG,
     imodel_config=DEFAULT_CHAT_CONFIG,
-    retry_imodel_config=DEFAULT_RETRY_iMODEL_CONFIG,
+    retry_imodel_config=DEFAULT_PARSE_CONFIG,
 )
 
 
@@ -120,7 +112,7 @@ BASE_LION_FIELDS = set(BaseSystemFields.__members__.values())
 class Settings:
 
     class Config:
-        ID: LionIDConfig = DEFAULT_ID_CONFIG
+        UUID_VERSION: int = UUID_VERSION
         RETRY: RetryConfig = DEFAULT_RETRY_CONFIG
         TIMED_CALL: TimedFuncCallConfig = DEFAULT_TIMED_FUNC_CALL_CONFIG
         TIMEZONE: timezone = DEFAULT_TIMEZONE
@@ -129,8 +121,8 @@ class Settings:
         BRANCH: BranchConfig = DEFAULT_BRANCH_CONFIG
 
     class iModel:
-        CHAT: dict = {"model": "openai/gpt-4o"}
-        PARSE: iModelConfig = DEFAULT_CHAT_CONFIG
+        CHAT: iModelConfig = DEFAULT_CHAT_CONFIG
+        PARSE: iModelConfig = DEFAULT_PARSE_CONFIG
 
 
 # File: autoos/setting.py

lionagi/strategies/base.py

@@ -1,15 +1,14 @@
 from typing import ClassVar
 
-from pydantic import model_validator
+from pydantic import BaseModel, model_validator
 
-from lionagi.fields.instruct import Instruct, InstructResponse
+from lionagi.core.session.types import Branch, Session
+from lionagi.protocols.operatives.instruct import Instruct, InstructResponse
 
-from ..protocols.types import BaseLionModel
-from ..session.types import Branch, Session
 from .params import StrategyParams
 
 
-class StrategyExecutor(BaseLionModel):
+class StrategyExecutor(BaseModel):
     """Base class for different execution strategies.
 
     Each concrete executor should implement `execute()` to run instructions

lionagi/strategies/concurrent.py

@@ -1,6 +1,7 @@
-from lionagi.fields.instruct import Instruct, InstructResponse
-from lionagi.session.types import Branch
-from lionagi.utils import alcall, to_list
+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
 
 from .base import StrategyExecutor