lionagi 0.7.5__py3-none-any.whl → 0.7.7__py3-none-any.whl

lionagi/__init__.py

@@ -2,6 +2,8 @@
 #
 # SPDX-License-Identifier: Apache-2.0
 
+from pydantic import BaseModel, Field
+
 from . import _types as types
 from .operations import types as op
 from .operatives import types as ops_types  # deprecated
@@ -20,4 +22,6 @@ __all__ = (
     "ops_types",
     "op",
     "__version__",
+    "BaseModel",
+    "Field",
 )

lionagi/libs/token_transform/synthlang.py

@@ -387,10 +387,16 @@ async def translate_to_synthlang(
     calculator = TokenCalculator()
 
     len_tokens = calculator.tokenize(text, return_tokens=False)
-    out = await branch.communicate(
+
+    kwargs["guidance"] = (
+        "Following SynthLang, translate the provided text into SynthLang syntax. "
+        "Shrink the token size by 60-85%. Return only the translated text.\n\n"
+        + kwargs.get("guidance", "")
+    )
+
+    out = await branch.chat(
         instruction=f"Converts the given text into SynthLang's hyper-efficient format.",
         context="Text to convert:\n\n" + text,
-        guidance=f"Following SynthLang, translate the provided text into SynthLang syntax. Shrink the token size by 60-85%. Return only the translated text.",
         **kwargs,
     )
     if sys1:

lionagi/operations/interpret/interpret.py

@@ -13,6 +13,7 @@ async def interpret(
     text: str,
     domain: str | None = None,
     style: str | None = None,
+    sample_writing: str | None = None,
     **kwargs,
 ) -> str:
     instruction = (
@@ -25,14 +26,17 @@ async def interpret(
         f"Desired style: {style or 'concise'}. "
         "You can add or clarify context if needed."
     )
+    if sample_writing:
+        guidance += f" Sample writing: {sample_writing}"
+
     context = [f"User input: {text}"]
 
     # Default temperature if none provided
     kwargs["temperature"] = kwargs.get("temperature", 0.1)
+    kwargs["guidance"] = guidance + "\n" + kwargs.get("guidance", "")
 
     refined_prompt = await branch.chat(
         instruction=instruction,
-        guidance=guidance,
         context=context,
         **kwargs,
     )

lionagi/operations/manager.py

@@ -0,0 +1,22 @@
+from typing import Callable
+
+from lionagi.protocols._concepts import Manager
+
+"""
+experimental
+"""
+
+
+class OperationManager(Manager):
+
+    def __init__(self, *args, **kwargs):
+        super().__init__()
+        self.registry: dict[str, Callable] = {}
+        self.register_operations(*args, **kwargs)
+
+    def register_operations(self, *args, **kwargs) -> None:
+        operations = {}
+        if args:
+            operations = {i.__name__ for i in args if hasattr(i, "__name__")}
+        operations.update(kwargs)
+        self.registry.update(operations)

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/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/operatives/instruct/instruct.py

@@ -2,26 +2,23 @@
 #
 # SPDX-License-Identifier: Apache-2.0
 
-from typing import Any, ClassVar
+from typing import Any, ClassVar, Literal
 
-from pydantic import JsonValue, field_validator
+from pydantic import Field, JsonValue, field_validator
 
-from lionagi.utils import HashableModel
+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
-from .base import (
-    ACTIONS_FIELD,
-    CONTEXT_FIELD,
-    GUIDANCE_FIELD,
-    INSTRUCTION_FIELD,
-    REASON_FIELD,
-)
 
 __all__ = (
     "Instruct",
     "InstructResponse",
     "INSTRUCT_FIELD",
-    "LIST_INSTRUCT_FIELD_MODEL",
+    "LIST_INSTRUCT_FIELD",
 )
 
 
@@ -40,50 +37,101 @@ class Instruct(HashableModel):
         "operative",
         "reason",
         "actions",
+        "action_strategy",
+        "batch_size",
         "request_params",
         "response_params",
     ]
-    instruction: JsonValue | None = INSTRUCTION_FIELD.field_info
-    guidance: JsonValue | None = GUIDANCE_FIELD.field_info
-    context: JsonValue | None = CONTEXT_FIELD.field_info
-    reason: bool = REASON_FIELD.field_info
-    actions: bool = ACTIONS_FIELD.field_info
-
-    @field_validator("instruction", **INSTRUCTION_FIELD.validator_kwargs)
+    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):
-        """Field validator for the 'instruction' field.
-
-        Args:
-            v: The value to validate.
-
-        Returns:
-            JsonValue | None: The validated instruction value.
-        """
-        return INSTRUCTION_FIELD.validator(cls, v)
+        return validate_nullable_jsonvalue_field(cls, v)
 
-    @field_validator("reason", **REASON_FIELD.validator_kwargs)
+    @field_validator("reason", "actions", mode="before")
     def _validate_reason(cls, v):
-        """Field validator for the 'reason' field.
-
-        Args:
-            v: The value to validate.
-
-        Returns:
-            bool | None: The validated boolean value.
-        """
-        return REASON_FIELD.validator(cls, v)
-
-    @field_validator("actions", **ACTIONS_FIELD.validator_kwargs)
-    def _validate_actions(cls, v):
-        """Field validator for the 'actions' field.
-
-        Args:
-            v: The value to validate.
-
-        Returns:
-            bool | None: The validated boolean value.
-        """
-        return ACTIONS_FIELD.validator(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(

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/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/service/endpoints/match_endpoint.py

@@ -11,50 +11,55 @@ def match_endpoint(
     endpoint: str,
     endpoint_params: list[str] | None = None,
 ) -> EndPoint:
-    if endpoint not in ["chat/completions", "chat", "messages"]:
-        raise ValueError(
-            "Invalid endpoint, must be one of 'chat/completions' (openai compatible), 'chat' (an alias), 'messages' (anthropic), other endpoints are not supported yet"
+
+    if endpoint in ["chat/completions", "chat", "messages"]:
+        from ..providers.openai_.chat_completions import (
+            OpenAIChatCompletionEndPoint,
         )
-    from ..providers.openai_.chat_completions import (
-        OpenAIChatCompletionEndPoint,
-    )
 
-    if provider == "openai":
-        return OpenAIChatCompletionEndPoint()
+        if provider == "openai":
+            return OpenAIChatCompletionEndPoint()
 
-    if provider == "anthropic":
-        from ..providers.anthropic_.messages import (
-            AnthropicChatCompletionEndPoint,
-        )
+        if provider == "anthropic":
+            from ..providers.anthropic_.messages import (
+                AnthropicChatCompletionEndPoint,
+            )
 
-        return AnthropicChatCompletionEndPoint()
+            return AnthropicChatCompletionEndPoint()
 
-    if provider == "groq":
-        from ..providers.groq_.chat_completions import (
-            GroqChatCompletionEndPoint,
-        )
+        if provider == "groq":
+            from ..providers.groq_.chat_completions import (
+                GroqChatCompletionEndPoint,
+            )
 
-        return GroqChatCompletionEndPoint()
+            return GroqChatCompletionEndPoint()
 
-    if provider == "perplexity":
-        from ..providers.perplexity_.chat_completions import (
-            PerplexityChatCompletionEndPoint,
-        )
+        if provider == "perplexity":
+            from ..providers.perplexity_.chat_completions import (
+                PerplexityChatCompletionEndPoint,
+            )
 
-        return PerplexityChatCompletionEndPoint()
+            return PerplexityChatCompletionEndPoint()
 
-    if provider == "openrouter":
-        from ..providers.openrouter_.chat_completions import (
-            OpenRouterChatCompletionEndPoint,
+        if provider == "openrouter":
+            from ..providers.openrouter_.chat_completions import (
+                OpenRouterChatCompletionEndPoint,
+            )
+
+            return OpenRouterChatCompletionEndPoint()
+
+        return OpenAIChatCompletionEndPoint(
+            config={
+                "provider": provider,
+                "base_url": base_url,
+                "endpoint": endpoint,
+                "endpoint_params": endpoint_params,
+            }
         )
 
-        return OpenRouterChatCompletionEndPoint()
+    if provider == "exa" and endpoint == "search":
+        from ..providers.exa_.search import ExaSearchEndPoint
+
+        return ExaSearchEndPoint()
 
-    return OpenAIChatCompletionEndPoint(
-        config={
-            "provider": provider,
-            "base_url": base_url,
-            "endpoint": endpoint,
-            "endpoint_params": endpoint_params,
-        }
-    )
+    raise ValueError(f"Unsupported endpoint: {endpoint}")

lionagi/service/imodel.py

@@ -102,6 +102,8 @@ class iModel:
                     api_key = "PERPLEXITY_API_KEY"
                 case "groq":
                     api_key = "GROQ_API_KEY"
+                case "exa":
+                    api_key = "EXA_API_KEY"
 
         if os.getenv(api_key, None) is not None:
             self.api_key_scheme = api_key
@@ -198,7 +200,9 @@ class iModel:
         except Exception as e:
             raise ValueError(f"Failed to stream API call: {e}")
 
-    async def invoke(self, **kwargs) -> APICalling | None:
+    async def invoke(
+        self, api_call: APICalling = None, **kwargs
+    ) -> APICalling | None:
         """Invokes a rate-limited API call with the given arguments.
 
         Args:
@@ -215,8 +219,9 @@ class iModel:
                 If the call fails or if an error occurs during invocation.
         """
         try:
-            kwargs.pop("stream", None)
-            api_call = self.create_api_calling(**kwargs)
+            if api_call is None:
+                kwargs.pop("stream", None)
+                api_call = self.create_api_calling(**kwargs)
             if (
                 self.executor.processor is None
                 or self.executor.processor.is_stopped()
@@ -252,6 +257,15 @@ class iModel:
         """
         return self.endpoint.sequential_exchange
 
+    @property
+    def model_name(self) -> str:
+        """str: The name of the model used by the endpoint.
+
+        Returns:
+            The model name if available; otherwise, an empty string.
+        """
+        return self.kwargs.get("model", "")
+
     def to_dict(self):
         kwargs = self.kwargs
         if "kwargs" in self.kwargs:

lionagi/service/providers/exa_/models.py

@@ -0,0 +1,160 @@
+from enum import Enum
+
+from pydantic import BaseModel, Field
+
+
+class CategoryEnum(str, Enum):
+    company = "company"
+    research_paper = "research paper"
+    news = "news"
+    pdf = "pdf"
+    github = "github"
+    tweet = "tweet"
+    personal_site = "personal site"
+    linkedin_profile = "linkedin profile"
+    financial_report = "financial report"
+
+
+class LivecrawlEnum(str, Enum):
+    never = "never"
+    fallback = "fallback"
+    always = "always"
+
+
+class SearchTypeEnum(str, Enum):
+    keyword = "keyword"
+    neural = "neural"
+    auto = "auto"
+
+
+class ContentsText(BaseModel):
+    includeHtmlTags: bool | None = Field(
+        default=False,
+        description="Whether to include HTML tags in the text. Set to True if you want to retain HTML structure for the LLM to interpret.",
+    )
+    maxCharacters: int | None = Field(
+        default=None,
+        description="The maximum number of characters to return from the webpage text.",
+    )
+
+
+class ContentsHighlights(BaseModel):
+    highlightsPerUrl: int | None = Field(
+        default=1,
+        description="The number of highlight snippets you want per page.",
+    )
+    numSentences: int | None = Field(
+        default=5,
+        description="Number of sentences to return in each highlight snippet.",
+    )
+    query: None | str = Field(
+        default=None,
+        description="A specific query used to generate the highlight snippets.",
+    )
+
+
+class ContentsSummary(BaseModel):
+    query: None | str = Field(
+        default=None,
+        description="A specific query used to generate a summary of the webpage.",
+    )
+
+
+class ContentsExtras(BaseModel):
+    links: int | None = Field(
+        default=None, description="Number of links to return from each page."
+    )
+    imageLinks: int | None = Field(
+        default=None, description="Number of images to return for each result."
+    )
+
+
+class Contents(BaseModel):
+    text: None | ContentsText = Field(
+        default=None,
+        description="Return full or partial text for each page, with optional HTML structure or size limit.",
+    )
+    highlights: None | ContentsHighlights = Field(
+        default=None, description="Return snippet highlights for each page."
+    )
+    summary: None | ContentsSummary = Field(
+        default=None, description="Return a short summary of each page."
+    )
+    livecrawl: None | LivecrawlEnum = Field(
+        default=LivecrawlEnum.never,
+        description="Livecrawling setting for each page. Options: never, fallback, always.",
+    )
+    livecrawlTimeout: int | None = Field(
+        default=10000,
+        description="Timeout in milliseconds for livecrawling. Default 10000.",
+    )
+    subpages: int | None = Field(
+        default=None,
+        description="Number of subpages to crawl within each URL.",
+    )
+    subpageTarget: None | str | list[str] = Field(
+        default=None,
+        description="A target subpage or multiple subpages (list) to crawl, e.g. 'cited papers'.",
+    )
+    extras: None | ContentsExtras = Field(
+        default=None,
+        description="Additional extras like links or images to return for each page.",
+    )
+
+
+class ExaSearchRequest(BaseModel):
+    query: str = Field(
+        ...,
+        description="The main query string describing what you're looking for.",
+    )
+    category: None | CategoryEnum = Field(
+        default=None,
+        description="A data category to focus on, such as 'company', 'research paper', 'news', etc.",
+    )
+    type: None | SearchTypeEnum = Field(
+        default=None,
+        description="The type of search to run. Can be 'auto', 'keyword', or 'neural'.",
+    )
+    useAutoprompt: None | bool = Field(
+        default=False,
+        description="If True, Exa auto-optimizes your query for best results (neural or auto search only).",
+    )
+    numResults: int | None = Field(
+        default=10, description="Number of results to return. Default is 10."
+    )
+    includeDomains: None | list[str] = Field(
+        default=None,
+        description="List of domains you want to include exclusively.",
+    )
+    excludeDomains: None | list[str] = Field(
+        default=None,
+        description="List of domains you do NOT want to see in the results.",
+    )
+    startCrawlDate: None | str = Field(
+        default=None,
+        description="Include results crawled after this ISO date (e.g., '2023-01-01T00:00:00.000Z').",
+    )
+    endCrawlDate: None | str = Field(
+        default=None,
+        description="Include results crawled before this ISO date.",
+    )
+    startPublishedDate: None | str = Field(
+        default=None,
+        description="Only return results published after this ISO date.",
+    )
+    endPublishedDate: None | str = Field(
+        default=None,
+        description="Only return results published before this ISO date.",
+    )
+    includeText: None | list[str] = Field(
+        default=None,
+        description="Strings that must appear in the webpage text. Only a single string up to 5 words is currently supported.",
+    )
+    excludeText: None | list[str] = Field(
+        default=None,
+        description="Strings that must NOT appear in the webpage text. Only a single string up to 5 words is currently supported.",
+    )
+    contents: None | Contents = Field(
+        default=None,
+        description="Dict defining the different ways you want to retrieve webpage contents, including text, highlights, or summaries.",
+    )

lionagi/service/providers/exa_/search.py

@@ -0,0 +1,80 @@
+from typing import TYPE_CHECKING, Literal
+
+from lionagi.service.endpoints.base import EndPoint
+
+if TYPE_CHECKING:
+    from .models import ExaSearchRequest
+
+
+CATEGORY_OPTIONS = Literal[
+    "article",
+    "book",
+    "company",
+    "research paper",
+    "news",
+    "pdf",
+    "github",
+    "tweet",
+    "personal site",
+    "linkedin profile",
+    "financial report",
+]
+
+SEARCH_CONFIG = {
+    "provider": "exa",
+    "base_url": "https://api.exa.ai",
+    "endpoint": "search",
+    "method": "post",
+    "openai_compatible": False,
+    "is_invokeable": False,
+    "requires_tokens": False,
+    "is_streamable": False,
+    "required_kwargs": {
+        "query",
+    },
+    "optional_kwargs": {
+        "category",
+        "contents",
+        "endCrawlDate",
+        "endPublishedDate",
+        "excludeDomains",
+        "excludeText",
+        "includeDomains",
+        "includeText",
+        "numResults",
+        "startCrawlDate",
+        "startPublishedDate",
+        "type",  # keyword, neural, auto
+        "useAutoPrompt",
+    },
+}
+
+
+class ExaSearchEndPoint(EndPoint):
+
+    def __init__(self, config: dict = SEARCH_CONFIG):
+        super().__init__(config)
+
+    def create_payload(
+        self, request_obj: "ExaSearchRequest" = None, **kwargs
+    ) -> dict:
+        if request_obj is not None:
+            kwargs.update(request_obj.to_dict(exclude_none=True))
+
+        payload = {}
+        is_cached = kwargs.get("is_cached", False)
+        headers = kwargs.get("headers", {})
+
+        for k, v in kwargs.items():
+            if k in self.acceptable_kwargs:
+                payload[k] = v
+        if "api_key" in kwargs:
+            headers["x-api-key"] = kwargs["api_key"]
+        if "content-type" not in kwargs:
+            headers["content-type"] = "application/json"
+
+        return {
+            "payload": payload,
+            "headers": headers,
+            "is_cached": is_cached,
+        }

lionagi/service/providers/exa_/types.py

@@ -0,0 +1,7 @@
+from .models import ExaSearchRequest
+from .search import ExaSearchEndPoint
+
+__all__ = (
+    "ExaSearchRequest",
+    "ExaSearchEndPoint",
+)

lionagi/service/providers/types.py

@@ -0,0 +1,17 @@
+from .anthropic_.messages import AnthropicChatCompletionEndPoint
+from .exa_.models import ExaSearchRequest
+from .exa_.search import ExaSearchEndPoint
+from .groq_.chat_completions import GroqChatCompletionEndPoint
+from .openai_.chat_completions import OpenAIChatCompletionEndPoint
+from .openrouter_.chat_completions import OpenRouterChatCompletionEndPoint
+from .perplexity_.chat_completions import PerplexityChatCompletionEndPoint
+
+__all__ = (
+    "AnthropicChatCompletionEndPoint",
+    "ExaSearchEndPoint",
+    "ExaSearchRequest",
+    "GroqChatCompletionEndPoint",
+    "OpenAIChatCompletionEndPoint",
+    "OpenRouterChatCompletionEndPoint",
+    "PerplexityChatCompletionEndPoint",
+)

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/version.py

@@ -1 +1 @@
-__version__ = "0.7.5"
+__version__ = "0.7.7"

{lionagi-0.7.5.dist-info → lionagi-0.7.7.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: lionagi
-Version: 0.7.5
+Version: 0.7.7
 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.5.dist-info → lionagi-0.7.7.dist-info}/RECORD

@@ -1,10 +1,10 @@
-lionagi/__init__.py,sha256=Z_cWmXAAYFrUDQsB9xJR8SqCrc7fKShllJFQd1N11BI,505
+lionagi/__init__.py,sha256=-tKLn-wTj_VK4XQr3CV16ioTNnaUYD2fhUAtJOZZ0vU,574
 lionagi/_class_registry.py,sha256=dutMsw-FQNqVV5gGH-NEIv90uBkSr8fERJ_x3swbb-s,3112
 lionagi/_errors.py,sha256=wNKdnVQvE_CHEstK7htrrj334RA_vbGcIds-3pUiRkc,455
 lionagi/_types.py,sha256=9g7iytvSj3UjZxD-jL06_fxuNfgZyWT3Qnp0XYp1wQU,63
 lionagi/settings.py,sha256=k9zRJXv57TveyfHO3Vr9VGiKrSwlRUUVKt5zf6v9RU4,1627
 lionagi/utils.py,sha256=X12H-O8Lx9tUOKGtjpoxHjRsKYHRqty0qD9i2W12kpI,73121
-lionagi/version.py,sha256=6qL_qyowXO9Pc6v11Zx2s-yd28_548ZZC-OsfzO_Pjc,22
+lionagi/version.py,sha256=eOm8myGPtPLNpkuxL0xhVmstPQbwXv3Ok7FbH0re-TA,22
 lionagi/libs/__init__.py,sha256=v8vNyJVIVj8_Oz9RJdVe6ZKUQMYTgDh1VQpnr1KdLaw,112
 lionagi/libs/parse.py,sha256=tpEbmIRGuHhLCJlUlm6fjmqm_Z6XJLAXGNFHNuk422I,1011
 lionagi/libs/file/__init__.py,sha256=v8vNyJVIVj8_Oz9RJdVe6ZKUQMYTgDh1VQpnr1KdLaw,112
@@ -37,7 +37,7 @@ lionagi/libs/schema/json_schema.py,sha256=Z45azAI_7lr5BWj-X6VQwUhuvuqXibciXgla8w
 lionagi/libs/token_transform/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 lionagi/libs/token_transform/llmlingua.py,sha256=DkeLUlrb7rGx3nZ04aADU9HXXu5mZTf_DBwT0xhzIv4,7
 lionagi/libs/token_transform/perplexity.py,sha256=XX-RoqGbeVYSl7fG1T_hF3I2pCAJ0A1LSKkrUpqsbeI,14091
-lionagi/libs/token_transform/synthlang.py,sha256=dD2JD0WCB0xLMF2PG8nJluJXEQ6VSTyqmTnmrFm9IgU,12709
+lionagi/libs/token_transform/synthlang.py,sha256=xQYbpKIX5T7mK9PoBFikJGB8dp18JlLHdwpFhrIRMgQ,12778
 lionagi/libs/validate/__init__.py,sha256=v8vNyJVIVj8_Oz9RJdVe6ZKUQMYTgDh1VQpnr1KdLaw,112
 lionagi/libs/validate/common_field_validators.py,sha256=5pu3kH13dVy1Nq-AQcHx0bIPusOnhvvCwUmaBX5l8bw,4778
 lionagi/libs/validate/fuzzy_match_keys.py,sha256=S7kzJnh-aKDMFbecmtMjFHNk2h-xMJqtQygMnq839lY,6255
@@ -45,6 +45,7 @@ lionagi/libs/validate/fuzzy_validate_mapping.py,sha256=SQqyxgrAgJ5zBKxIAnulWsZXb
 lionagi/libs/validate/string_similarity.py,sha256=7x8D4LZCMNJGz2ZCeKmct7Nc4i8m_ORoHIeGvkeMZOA,8733
 lionagi/libs/validate/validate_boolean.py,sha256=h3d7Dn7asJokBozWaKxaV_3Y6vUWBc0-zfNJjTQ9Bo8,3614
 lionagi/operations/__init__.py,sha256=O7nV0tedpUe7_OlUWmCcduGPFtqtzWZcR_SIOnjLsro,134
+lionagi/operations/manager.py,sha256=qjDMSOJ35XjDXkVq0SlEb4inTS7OXGwxly2doiQCNas,556
 lionagi/operations/types.py,sha256=LIa68xcyKLVafof-DSFwKtSkneuYPFqrtGyClohYI6o,704
 lionagi/operations/utils.py,sha256=Twy6L_UFt9JqJFRYuKKTKVZIXsePidNl5ipcYcCbesI,1220
 lionagi/operations/ReAct/ReAct.py,sha256=tAZ-3Ya68tVUa112wgOMUJpBVw-RWBSYTfgicbInRuQ,3954
@@ -62,9 +63,9 @@ lionagi/operations/communicate/communicate.py,sha256=1PzBpzgATcAdBog0EUxtj5_uJGi
 lionagi/operations/instruct/__init__.py,sha256=v8vNyJVIVj8_Oz9RJdVe6ZKUQMYTgDh1VQpnr1KdLaw,112
 lionagi/operations/instruct/instruct.py,sha256=CYICzWvmgALtSPIetfF3csx6WDsCuiu4NRRPL56UA2g,795
 lionagi/operations/interpret/__init__.py,sha256=v8vNyJVIVj8_Oz9RJdVe6ZKUQMYTgDh1VQpnr1KdLaw,112
-lionagi/operations/interpret/interpret.py,sha256=EtgXTeOezEPR03HSUVz8PGK-xf8p2nXoUMUhFkAntK0,1081
+lionagi/operations/interpret/interpret.py,sha256=mjTcOCOixc34JNnX0WowSVACtZXz9IBuzjp9VyOus5w,1244
 lionagi/operations/operate/__init__.py,sha256=v8vNyJVIVj8_Oz9RJdVe6ZKUQMYTgDh1VQpnr1KdLaw,112
-lionagi/operations/operate/operate.py,sha256=jgVV9CjtnVLmR5ZdDmunicS5Pp9dT3hV5kMEBuk16iI,6614
+lionagi/operations/operate/operate.py,sha256=kzH7R4J3O-1Ue-PYqIoEdrXHrkYYQVfHa6gSC4Km_sc,7003
 lionagi/operations/parse/__init__.py,sha256=v8vNyJVIVj8_Oz9RJdVe6ZKUQMYTgDh1VQpnr1KdLaw,112
 lionagi/operations/parse/parse.py,sha256=LpF6LVAvCVoE8n63BkhSxXSHYgSx7CNkN7yXUwaNpQo,3003
 lionagi/operations/plan/__init__.py,sha256=AFkAmOJBTqPlYuqFRRn7rCvIw3CGh9XXH_22cNWbfig,156
@@ -92,12 +93,12 @@ lionagi/operatives/forms/form.py,sha256=5z5VfDqcKVFYvhDVZZQwMDczSof2lSx_VxQo32jl
 lionagi/operatives/forms/report.py,sha256=KUapeSAB67ElyU1fl4DxtfvobKGnpDPetso6cT6GT4E,11167
 lionagi/operatives/forms/utils.py,sha256=sCjYRy-EJIh1py9qIb04LVgALy2YiPHbhXhNyDNwvoQ,701
 lionagi/operatives/instruct/__init__.py,sha256=v8vNyJVIVj8_Oz9RJdVe6ZKUQMYTgDh1VQpnr1KdLaw,112
-lionagi/operatives/instruct/base.py,sha256=dyw5JZw0o1FCm4KQqeSvYGaO75ReHQQ-xOyPjgOdfJM,1877
-lionagi/operatives/instruct/instruct.py,sha256=kRKc-OGcY4nSMqTTR7uUjMFBJpYcBfKv8iiEmpKAp0s,2674
+lionagi/operatives/instruct/base.py,sha256=Vw9u3BGzjNRGcPfW1ROr2uCZcZsjrm4WU6491P6ecCI,1895
+lionagi/operatives/instruct/instruct.py,sha256=vzIQks5gSXJQzdEE_l4PgJPw2ZUZPbAfZ-cDt6CPmeQ,4794
 lionagi/operatives/instruct/instruct_collection.py,sha256=Fj7R7TR33PdkqzbWhev52jKeIMmEQ1q227Bu4zsrHiA,1449
 lionagi/operatives/instruct/node.py,sha256=0g7g2jsLO8L8VlD-L1mFmjcFTwWy39moWCDtLNmNEFY,317
-lionagi/operatives/instruct/prompts.py,sha256=g16IooxpAJfNvv1jdRe7nLQ28mO9UezRS2SDQE8Lnus,1729
-lionagi/operatives/instruct/reason.py,sha256=1DYviNf5D_3DH0lnguXYGEyFycYzRjoyLob-BnIpmSA,1679
+lionagi/operatives/instruct/prompts.py,sha256=RG8rB7Y0J17aTHTb9kTTHxltVjgRAuC4vjM9B1_hTuQ,1747
+lionagi/operatives/instruct/reason.py,sha256=mdCMBO3YSWYncXU_B1bYuZqpkj4pfUMsxsz9vXXAMw4,2341
 lionagi/operatives/models/__init__.py,sha256=v8vNyJVIVj8_Oz9RJdVe6ZKUQMYTgDh1VQpnr1KdLaw,112
 lionagi/operatives/models/field_model.py,sha256=yfRRBbfQ5llPGIt_QkyLrIrmNwNQ14aUXA-llHeER4M,6083
 lionagi/operatives/models/model_params.py,sha256=UnugiT0GDFzB9igYeCvN6pcq01bqTpZuAHom0yCBSdk,9653
@@ -160,18 +161,23 @@ lionagi/protocols/messages/templates/instruction_message.jinja2,sha256=L-ptw5OHx
 lionagi/protocols/messages/templates/system_message.jinja2,sha256=JRKJ0aFpYfaXSFouKc_N4unZ35C3yZTOWhIrIdCB5qk,215
 lionagi/protocols/messages/templates/tool_schemas.jinja2,sha256=ozIaSDCRjIAhLyA8VM6S-YqS0w2NcctALSwx4LjDwII,126
 lionagi/service/__init__.py,sha256=DMGXIqPsmut9H5GT0ZeSzQIzYzzPwI-2gLXydpbwiV8,21
-lionagi/service/imodel.py,sha256=MaiBcKM00vH0tq0nD_C7jV6S7OyV71a4YwVDrDfPMrA,11539
+lionagi/service/imodel.py,sha256=Mv5wVsmZj4hYmrvXfHVmA-fskfAKrDY0mbdmgOCAGoE,11946
 lionagi/service/manager.py,sha256=MKSYBkg23s7YhZy5GEFdnpspEnhPVfFhpkpoJe20D7k,1435
 lionagi/service/types.py,sha256=v9SAn5-GTmds4Mar13Or_VFrRHCinBK99dmeDUd-QNk,486
 lionagi/service/endpoints/__init__.py,sha256=v8vNyJVIVj8_Oz9RJdVe6ZKUQMYTgDh1VQpnr1KdLaw,112
 lionagi/service/endpoints/base.py,sha256=RbBBQIbtNtkP1LT9U3ZrhL35SfmVIpaq-AGW8d538k4,18275
 lionagi/service/endpoints/chat_completion.py,sha256=9ltSQaKPH43WdEDW32_-f5x07I9hOU8g-T_PAG-nYsQ,2529
-lionagi/service/endpoints/match_endpoint.py,sha256=n7F9NoTXfUBL29HrDcFLF5AXYR8pcx_IumQ7BiJXC-w,1740
+lionagi/service/endpoints/match_endpoint.py,sha256=hIGYyok1y53FfI6av5NfYMygRIpDWYZbdCj0pJJfmPY,1874
 lionagi/service/endpoints/rate_limited_processor.py,sha256=umri0FofbyBSFdAQBEsviDB5K6N12LkRiXQgSOorGKg,4663
 lionagi/service/endpoints/token_calculator.py,sha256=MflqImGUr_1jh465hB7cUAaIPICBkjirvre1fWGXLrA,6161
 lionagi/service/providers/__init__.py,sha256=v8vNyJVIVj8_Oz9RJdVe6ZKUQMYTgDh1VQpnr1KdLaw,112
+lionagi/service/providers/types.py,sha256=NS91ysRFwOs0cpNeQgFhmtl7JrSz2pJm-tt7sZILmQY,683
 lionagi/service/providers/anthropic_/__init__.py,sha256=v8vNyJVIVj8_Oz9RJdVe6ZKUQMYTgDh1VQpnr1KdLaw,112
 lionagi/service/providers/anthropic_/messages.py,sha256=PTZZ2VXVMRHWY84YFIzrft9gVrcH2V-NIq_Phi9_-xI,1760
+lionagi/service/providers/exa_/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+lionagi/service/providers/exa_/models.py,sha256=263KP-JSxbxmomNrFeYjB_cebquoMOsCJeWsiKZ0mL4,5420
+lionagi/service/providers/exa_/search.py,sha256=Z9bOxTjPZbtI_qH4fSePYKSXhkc8N3ZFbCHdsml8YSA,1903
+lionagi/service/providers/exa_/types.py,sha256=8ODjXpFajBE9-DGqBJNS--GObwmLSDi667xS84z_AgA,139
 lionagi/service/providers/groq_/__init__.py,sha256=v8vNyJVIVj8_Oz9RJdVe6ZKUQMYTgDh1VQpnr1KdLaw,112
 lionagi/service/providers/groq_/chat_completions.py,sha256=578NqQYyrIYjIemyL3bagvFGE6ear_w4S1HNlPWA5mg,1343
 lionagi/service/providers/openai_/__init__.py,sha256=v8vNyJVIVj8_Oz9RJdVe6ZKUQMYTgDh1VQpnr1KdLaw,112
@@ -181,9 +187,9 @@ lionagi/service/providers/openrouter_/chat_completions.py,sha256=MRf4ZbMCgzNIL4g
 lionagi/service/providers/perplexity_/__init__.py,sha256=v8vNyJVIVj8_Oz9RJdVe6ZKUQMYTgDh1VQpnr1KdLaw,112
 lionagi/service/providers/perplexity_/chat_completions.py,sha256=SsDbrtXwQsR4Yu2VMU43KfeS86QWI8UTNhDth5lNWNs,1055
 lionagi/session/__init__.py,sha256=v8vNyJVIVj8_Oz9RJdVe6ZKUQMYTgDh1VQpnr1KdLaw,112
-lionagi/session/branch.py,sha256=2KMMl-YVVfbgbz1qtyXpw3SrRZ5yAfoqm44s-gnbjyU,59319
+lionagi/session/branch.py,sha256=JvErd9YUuGdWyLj37rtKOteSqV0ltn9lg0R2G8GO40c,62539
 lionagi/session/session.py,sha256=po6C7PnM0iu_ISHUo4PBzzQ61HFOgcsAUfPoO--eLak,8987
-lionagi-0.7.5.dist-info/METADATA,sha256=BzOxAvQTuo7KixBKczhR3Ne6LPcWNDo1zOV36Y0fZo4,22768
-lionagi-0.7.5.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
-lionagi-0.7.5.dist-info/licenses/LICENSE,sha256=VXFWsdoN5AAknBCgFqQNgPWYx7OPp-PFEP961zGdOjc,11288
-lionagi-0.7.5.dist-info/RECORD,,
+lionagi-0.7.7.dist-info/METADATA,sha256=XzhIG5ZehXeF7UXYkd4dvIuqT1W8E969aAOliftxmJU,22819
+lionagi-0.7.7.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+lionagi-0.7.7.dist-info/licenses/LICENSE,sha256=VXFWsdoN5AAknBCgFqQNgPWYx7OPp-PFEP961zGdOjc,11288
+lionagi-0.7.7.dist-info/RECORD,,