lionagi 0.9.4__py3-none-any.whl → 0.9.6__py3-none-any.whl

lionagi/libs/schema/function_to_schema.py

@@ -5,7 +5,13 @@
 import inspect
 from typing import Any, Literal
 
-from .extract_docstring import extract_docstring
+from pydantic import Field, field_validator
+
+from lionagi.libs.schema.extract_docstring import extract_docstring
+from lionagi.libs.validate.common_field_validators import (
+    validate_model_to_type,
+)
+from lionagi.operatives.models.schema_model import SchemaModel
 
 py_json_msp = {
     "str": "string",
@@ -18,12 +24,60 @@ py_json_msp = {
 }
 
 
+class FunctionSchema(SchemaModel):
+    name: str
+    description: str | None = Field(
+        None,
+        description=(
+            "A description of what the function does, used by the "
+            "model to choose when and how to call the function."
+        ),
+    )
+    parameters: dict[str, Any] | None = Field(
+        None,
+        description=(
+            "The parameters the functions accepts, described as a JSON Schema object. "
+            "See the guide (https://platform.openai.com/docs/guides/function-calling) "
+            "for examples, and the JSON Schema reference for documentation about the "
+            "format. Omitting parameters defines a function with an empty parameter list."
+        ),
+        validation_alias="request_options",
+    )
+    strict: bool | None = Field(
+        None,
+        description=(
+            "Whether to enable strict schema adherence when generating the function call. "
+            "If set to true, the model will follow the exact schema defined in the parameters "
+            "field. Only a subset of JSON Schema is supported when strict is true."
+        ),
+    )
+
+    @field_validator("parameters", mode="before")
+    def _validate_parameters(cls, v):
+        if v is None:
+            return None
+        if isinstance(v, dict):
+            return v
+        try:
+            model_type = validate_model_to_type(cls, v)
+            return model_type.model_json_schema()
+        except Exception:
+            raise ValueError(f"Invalid model type: {v}")
+
+    def to_dict(self):
+        dict_ = super().to_dict()
+        return {"type": "function", "function": dict_}
+
+
 def function_to_schema(
     f_,
     style: Literal["google", "rest"] = "google",
     *,
+    request_options: dict[str, Any] | None = None,
+    strict: bool = None,
     func_description: str = None,
     parametert_description: dict[str, str] = None,
+    return_obj: bool = False,
 ) -> dict:
     """
     Generate a schema description for a given function. in openai format
@@ -78,27 +132,33 @@ def function_to_schema(
         "required": [],
     }
 
-    for name, param in sig.parameters.items():
-        # Default type to string and update if type hint is available
-        param_type = "string"
-        if param.annotation is not inspect.Parameter.empty:
-            param_type = py_json_msp[param.annotation.__name__]
-
-        # Extract parameter description from docstring, if available
-        param_description = parametert_description.get(name)
-
-        # Assuming all parameters are required for simplicity
-        parameters["required"].append(name)
-        parameters["properties"][name] = {
-            "type": param_type,
-            "description": param_description,
-        }
-
-    return {
-        "type": "function",
-        "function": {
-            "name": func_name,
-            "description": func_description,
-            "parameters": parameters,
-        },
+    if not request_options:
+        for name, param in sig.parameters.items():
+            # Default type to string and update if type hint is available
+            param_type = "string"
+            if param.annotation is not inspect.Parameter.empty:
+                param_type = py_json_msp[param.annotation.__name__]
+
+            # Extract parameter description from docstring, if available
+            param_description = parametert_description.get(name)
+
+            # Assuming all parameters are required for simplicity
+            parameters["required"].append(name)
+            parameters["properties"][name] = {
+                "type": param_type,
+                "description": param_description,
+            }
+    else:
+        parameters = request_options
+
+    params = {
+        "name": func_name,
+        "description": func_description,
+        "parameters": parameters,
     }
+    if strict:
+        params["strict"] = strict
+
+    if return_obj:
+        return FunctionSchema(**params)
+    return FunctionSchema(**params).to_dict()

lionagi/operations/ReAct/ReAct.py

@@ -47,6 +47,8 @@ async def ReAct(
     analysis_model: iModel | None = None,
     verbose_analysis: bool = False,
     verbose_length: int = None,
+    include_token_usage_to_model: bool = True,
+    continue_after_failed_response: bool = False,
     **kwargs,
 ):
     outs = []
@@ -73,6 +75,8 @@ async def ReAct(
             verbose_analysis=verbose_analysis,
             display_as=display_as,
             verbose_length=verbose_length,
+            include_token_usage_to_model=include_token_usage_to_model,
+            continue_after_failed_response=continue_after_failed_response,
             **kwargs,
         ):
             analysis, str_ = i
@@ -101,6 +105,8 @@ async def ReAct(
             analysis_model=analysis_model,
             display_as=display_as,
             verbose_length=verbose_length,
+            include_token_usage_to_model=include_token_usage_to_model,
+            continue_after_failed_response=continue_after_failed_response,
             **kwargs,
         ):
             outs.append(i)
@@ -131,6 +137,8 @@ async def ReActStream(
     verbose_analysis: bool = False,
     display_as: Literal["json", "yaml"] = "yaml",
     verbose_length: int = None,
+    include_token_usage_to_model: bool = True,
+    continue_after_failed_response: bool = False,
     **kwargs,
 ) -> AsyncGenerator:
     irfm: FieldModel | None = None
@@ -213,6 +221,9 @@ async def ReActStream(
     kwargs_for_operate = copy(kwargs)
     kwargs_for_operate["actions"] = True
     kwargs_for_operate["reason"] = True
+    kwargs_for_operate["include_token_usage_to_model"] = (
+        include_token_usage_to_model
+    )
 
     # Step 1: Generate initial ReAct analysis
     analysis: ReActAnalysis = await branch.operate(
@@ -255,7 +266,7 @@ async def ReActStream(
             if isinstance(analysis, dict)
             else False
         )
-        and (extensions if max_extensions else 0) > 0
+        and (extensions - 1 if max_extensions else 0) > 0
     ):
         new_instruction = None
         if extensions == max_extensions:
@@ -272,6 +283,9 @@ async def ReActStream(
         operate_kwargs["reason"] = True
         operate_kwargs["response_format"] = ReActAnalysis
         operate_kwargs["action_strategy"] = analysis.action_strategy
+        operate_kwargs["include_token_usage_to_model"] = (
+            include_token_usage_to_model
+        )
         if analysis.action_batch_size:
             operate_kwargs["action_batch_size"] = analysis.action_batch_size
         if irfm:
@@ -289,6 +303,7 @@ async def ReActStream(
             operate_kwargs["guidance"] = guide + operate_kwargs.get(
                 "guidance", ""
             )
+            operate_kwargs["reasoning_effort"] = reasoning_effort
 
         analysis = await branch.operate(
             instruction=new_instruction,
@@ -298,6 +313,16 @@ async def ReActStream(
         )
         round_count += 1
 
+        if isinstance(analysis, dict) and all(
+            i is None for i in analysis.values()
+        ):
+            if not continue_after_failed_response:
+                raise ValueError(
+                    "All values in the response are None. "
+                    "This might be due to a failed response. "
+                    "Set `continue_after_failed_response=True` to ignore this error."
+                )
+
         # If verbose, show round analysis
         if verbose_analysis:
             str_ = f"\n### ReAct Round No.{round_count} Analysis:\n"
@@ -329,6 +354,15 @@ async def ReActStream(
             response_format=response_format,
             **(response_kwargs or {}),
         )
+        if isinstance(analysis, dict) and all(
+            i is None for i in analysis.values()
+        ):
+            if not continue_after_failed_response:
+                raise ValueError(
+                    "All values in the response are None. "
+                    "This might be due to a failed response. "
+                    "Set `continue_after_failed_response=True` to ignore this error."
+                )
     except Exception:
         out = branch.msgs.last_response.response
 

lionagi/operations/ReAct/utils.py

@@ -30,6 +30,8 @@ class ReActAnalysis(BaseModel):
     2) A list of planned actions to perform before finalizing,
     3) Indication whether more expansions/rounds are needed,
     4) Additional tuning knobs: how to handle validation, how to execute actions, etc.
+    Remember do not repeat yourself, and aim to use the most efficient way to achieve
+    the goal to user's satisfaction.
     """
 
     # Standard ReAct strings for controlling expansions:
@@ -38,11 +40,12 @@ class ReActAnalysis(BaseModel):
         "If you are not ready to finalize, set extension_needed to True. "
         "hint: you should set extension_needed to True if the overall goal"
         "is not yet achieved. Do not set it to False, if you are just providing"
-        "an interim answer. You have up to {extensions} expansions. Please continue."
+        "an interim answer. You have up to {extensions} expansions. Please "
+        "strategize accordingly and continue."
     )
     CONTINUE_EXT_PROMPT: ClassVar[str] = (
         "Another round is available. You may do multiple actions if needed. "
-        "You have up to {extensions} expansions. Please continue."
+        "You have up to {extensions} expansions. Please strategize accordingly and continue."
     )
     ANSWER_PROMPT: ClassVar[str] = (
         "Given your reasoning and actions, please now provide the final answer "

lionagi/operations/chat/chat.py

@@ -36,6 +36,7 @@ async def chat(
     image_detail: Literal["low", "high", "auto"] = None,
     plain_content: str = None,
     return_ins_res_message: bool = False,
+    include_token_usage_to_model: bool = False,
     **kwargs,
 ) -> tuple[Instruction, AssistantResponse]:
     ins: Instruction = branch.msgs.create_instruction(
@@ -151,11 +152,12 @@ async def chat(
     kwargs["messages"] = [i.chat_msg for i in messages]
     imodel = imodel or branch.chat_model
 
-    meth = (
-        imodel.invoke
-        if ("stream" not in kwargs or not kwargs["stream"])
-        else imodel.stream
-    )
+    meth = imodel.invoke
+    if "stream" not in kwargs or not kwargs["stream"]:
+        kwargs["include_token_usage_to_model"] = include_token_usage_to_model
+    else:
+        meth = imodel.stream
+
     api_call = await meth(**kwargs)
     branch._log_manager.log(Log.create(api_call))
 

lionagi/operations/communicate/communicate.py

@@ -35,6 +35,7 @@ async def communicate(
     fuzzy_match_kwargs=None,
     clear_messages=False,
     operative_model=None,
+    include_token_usage_to_model: bool = False,
     **kwargs,
 ):
     if operative_model:
@@ -80,6 +81,7 @@ async def communicate(
         image_detail=image_detail,
         plain_content=plain_content,
         return_ins_res_message=True,
+        include_token_usage_to_model=include_token_usage_to_model,
         **kwargs,
     )
     branch.msgs.add_message(instruction=ins)

lionagi/operations/interpret/interpret.py

@@ -20,7 +20,8 @@ async def interpret(
     instruction = (
         "You are given a user's raw instruction or question. Your task is to rewrite it into a clearer,"
         "more structured prompt for an LLM or system, making any implicit or missing details explicit. "
-        "Return only the re-written prompt."
+        "Return only the re-written prompt. Do not assume any details not mentioned in the input, nor "
+        "give additional instruction than what is explicitly stated."
     )
     guidance = (
         f"Domain hint: {domain or 'general'}. "

lionagi/operations/operate/operate.py

@@ -63,6 +63,7 @@ async def operate(
     ] = "return_value",
     operative_model: type[BaseModel] = None,
     request_model: type[BaseModel] = None,
+    include_token_usage_to_model: bool = False,
     **kwargs,
 ) -> list | BaseModel | None | dict | str:
     if operative_model:
@@ -138,6 +139,7 @@ async def operate(
         image_detail=image_detail,
         tool_schemas=tool_schemas,
         return_ins_res_message=True,
+        include_token_usage_to_model=include_token_usage_to_model,
         **kwargs,
     )
     branch.msgs.add_message(instruction=ins)

lionagi/service/endpoints/base.py

@@ -80,6 +80,7 @@ class EndpointConfig(BaseModel):
     api_version: str | None = None
     allowed_roles: list[str] | None = None
     request_options: type | None = Field(None, exclude=True)
+    invoke_with_endpoint: bool | None = None
 
 
 class EndPoint(ABC):
@@ -91,19 +92,28 @@ class EndPoint(ABC):
     HTTP requests.
     """
 
-    def __init__(self, config: dict) -> None:
+    def __init__(
+        self, config: dict | EndpointConfig | type[EndpointConfig], **kwargs
+    ) -> None:
         """Initializes the EndPoint with a given configuration.
 
         Args:
-            config (dict): Configuration data that matches the EndpointConfig
+            config (dict | EndpointConfig): Configuration data that matches the EndpointConfig
                 schema.
         """
-        self.config = EndpointConfig(**config)
+        if isinstance(config, dict):
+            self.config = EndpointConfig(**config)
+        if isinstance(config, EndpointConfig):
+            self.config = config
+        if isinstance(config, type) and issubclass(config, EndpointConfig):
+            self.config = config()
+        if kwargs:
+            self.update_config(**kwargs)
 
     def update_config(self, **kwargs):
         config = self.config.model_dump()
         config.update(kwargs)
-        self.config = EndpointConfig(**config)
+        self.config = self.config.model_validate(config)
 
     @property
     def name(self) -> str | None:
@@ -349,11 +359,38 @@ class APICalling(Event):
     endpoint: EndPoint = Field(exclude=True)
     is_cached: bool = Field(default=False, exclude=True)
     should_invoke_endpoint: bool = Field(default=True, exclude=True)
+    include_token_usage_to_model: bool = Field(
+        default=False,
+        exclude=True,
+        description="Whether to include token usage information into instruction messages",
+    )
+    response_obj: BaseModel | None = Field(None, exclude=True)
 
     @model_validator(mode="after")
     def _validate_streaming(self) -> Self:
         if self.payload.get("stream") is True:
             self.streaming = True
+
+        if self.include_token_usage_to_model:
+            if isinstance(self.payload["messages"][-1], dict):
+                required_tokens = self.required_tokens
+                self.payload["messages"][-1][
+                    "content"
+                ] += f"\n\nEstimated Current Token Usage: {required_tokens}"
+                if "model" in self.payload:
+                    if (
+                        self.payload["model"].startswith("gpt-4")
+                        or "o1mini" in self.payload["model"]
+                        or "o1-preview" in self.payload["model"]
+                    ):
+                        self.payload["messages"][-1]["content"] += "/128_000"
+                    elif "o1" in self.payload["model"]:
+                        self.payload["messages"][-1]["content"] += "/200_000"
+                    elif "sonnet" in self.payload["model"]:
+                        self.payload["messages"][-1]["content"] += "/200_000"
+                    elif "haiku" in self.payload["model"]:
+                        self.payload["messages"][-1]["content"] += "/200_000"
+
         return self
 
     @property
@@ -622,7 +659,12 @@ class APICalling(Event):
                     f"API call to {self.endpoint.full_url} failed: {e1}"
                 )
             else:
-                self.execution.response = response
+                self.response_obj = response
+                self.execution.response = (
+                    response.model_dump()
+                    if isinstance(response, BaseModel)
+                    else response
+                )
                 self.execution.status = EventStatus.COMPLETED
 
     def __str__(self) -> str:

lionagi/service/endpoints/match_endpoint.py

@@ -48,6 +48,13 @@ def match_endpoint(
 
             return OpenRouterChatCompletionEndPoint()
 
+        if provider == "ollama":
+            from ..providers.ollama_.chat_completions import (
+                OllamaChatCompletionEndPoint,
+            )
+
+            return OllamaChatCompletionEndPoint()
+
         return OpenAIChatCompletionEndPoint(
             config={
                 "provider": provider,

lionagi/service/imodel.py

@@ -51,7 +51,7 @@ class iModel:
         interval: float | None = None,
         limit_requests: int = None,
         limit_tokens: int = None,
-        invoke_with_endpoint: bool = False,
+        invoke_with_endpoint: bool = None,
         concurrency_limit: int | None = None,
         streaming_process_func: Callable = None,
         requires_api_key: bool = True,
@@ -95,6 +95,16 @@ class iModel:
                 Additional keyword arguments, such as `model`, or any other
                 provider-specific fields.
         """
+        model = kwargs.get("model", None)
+        if model:
+            if not provider:
+                if "/" in model:
+                    provider = model.split("/")[0]
+                    model = model.replace(provider + "/", "")
+                    kwargs["model"] = model
+                else:
+                    raise ValueError("Provider must be provided")
+
         if api_key is None:
             provider = str(provider or "").strip().lower()
             match provider:
@@ -110,6 +120,8 @@ class iModel:
                     api_key = "GROQ_API_KEY"
                 case "exa":
                     api_key = "EXA_API_KEY"
+                case "ollama":
+                    api_key = "ollama"
                 case "":
                     if requires_api_key:
                         raise ValueError("API key must be provided")
@@ -121,16 +133,6 @@ class iModel:
             api_key = os.getenv(api_key)
 
         kwargs["api_key"] = api_key
-        model = kwargs.get("model", None)
-        if model:
-            if not provider:
-                if "/" in model:
-                    provider = model.split("/")[0]
-                    model = model.replace(provider + "/", "")
-                    kwargs["model"] = model
-                else:
-                    raise ValueError("Provider must be provided")
-
         if isinstance(endpoint, EndPoint):
             self.endpoint = endpoint
         else:
@@ -145,7 +147,13 @@ class iModel:
         if base_url:
             self.endpoint.config.base_url = base_url
 
-        self.should_invoke_endpoint = invoke_with_endpoint
+        if (
+            invoke_with_endpoint is None
+            and self.endpoint.config.invoke_with_endpoint is True
+        ):
+            invoke_with_endpoint = True
+
+        self.should_invoke_endpoint = invoke_with_endpoint or False
         self.kwargs = kwargs
         self.executor = RateLimitedAPIExecutor(
             queue_capacity=queue_capacity,
@@ -162,7 +170,9 @@ class iModel:
         else:
             self.streaming_process_func = streaming_process_func
 
-    def create_api_calling(self, **kwargs) -> APICalling:
+    def create_api_calling(
+        self, include_token_usage_to_model: bool = False, **kwargs
+    ) -> APICalling:
         """Constructs an `APICalling` object from endpoint-specific payload.
 
         Args:
@@ -183,6 +193,7 @@ class iModel:
             endpoint=self.endpoint,
             is_cached=payload.get("is_cached", False),
             should_invoke_endpoint=self.should_invoke_endpoint,
+            include_token_usage_to_model=include_token_usage_to_model,
         )
 
     async def process_chunk(self, chunk) -> None:
@@ -200,7 +211,12 @@ class iModel:
                 return await self.streaming_process_func(chunk)
             return self.streaming_process_func(chunk)
 
-    async def stream(self, api_call=None, **kwargs) -> AsyncGenerator:
+    async def stream(
+        self,
+        api_call=None,
+        include_token_usage_to_model: bool = False,
+        **kwargs,
+    ) -> AsyncGenerator:
         """Performs a streaming API call with the given arguments.
 
         Args:
@@ -214,7 +230,10 @@ class iModel:
         """
         if api_call is None:
             kwargs["stream"] = True
-            api_call = self.create_api_calling(**kwargs)
+            api_call = self.create_api_calling(
+                include_token_usage_to_model=include_token_usage_to_model,
+                **kwargs,
+            )
             await self.executor.append(api_call)
 
         if (

lionagi/service/providers/ollama_/__init__.py

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

lionagi/service/providers/ollama_/chat_completions.py

@@ -0,0 +1,134 @@
+# Copyright (c) 2023 - 2025, HaiyangLi <quantocean.li at gmail dot com>
+#
+# SPDX-License-Identifier: Apache-2.0
+
+from collections.abc import AsyncGenerator
+
+from lionagi.service.endpoints.chat_completion import ChatCompletionEndPoint
+
+CHAT_COMPLETION_CONFIG = {
+    "provider": "ollama",
+    "base_url": "http://localhost:11434/v1",
+    "endpoint": "chat",
+    "method": "post",
+    "openai_compatible": True,
+    "is_invokeable": True,
+    "requires_tokens": True,
+    "is_streamable": True,
+    "required_kwargs": {
+        "messages",
+        "model",
+    },
+    "optional_kwargs": {
+        "frequency_penalty",
+        "presence_penalty",
+        "response_format",
+        "seed",
+        "stop",
+        "stream",
+        "stream_options",
+        "temperature",
+        "top_p",
+        "max_tokens",
+        "tools",
+        # "tool_choice",
+        # "logit_bias",
+        # "user",
+        # "n",
+        # "logprobs",
+    },
+    "allowed_roles": ["user", "assistant", "system"],
+    "invoke_with_endpoint": True,
+}
+
+
+class OllamaChatCompletionEndPoint(ChatCompletionEndPoint):
+    """
+    Documentation: https://platform.openai.com/docs/api-reference/chat/create
+    """
+
+    def __init__(self, config: dict = CHAT_COMPLETION_CONFIG):
+        from lionagi.libs.package.imports import check_import
+
+        check_import("openai")
+        check_import("ollama")
+
+        from ollama import list, pull
+        from openai import AsyncOpenAI
+
+        super().__init__(config)
+        self.client = AsyncOpenAI(
+            base_url=self.config.base_url,
+            api_key="ollama",
+        )
+        self._pull = pull
+        self._list = list
+
+    async def _invoke(
+        self,
+        payload: dict,
+        headers: dict,
+        **kwargs,
+    ):
+        self._check_model(payload["model"])
+        params = {**payload, **kwargs}
+        headers.pop("Authorization", None)
+        params["extra_headers"] = headers
+
+        if "response_format" in payload:
+            return await self.client.beta.chat.completions.parse(**params)
+        params.pop("response_format", None)
+        return await self.client.chat.completions.create(**params)
+
+    async def _stream(
+        self,
+        payload: dict,
+        headers: dict,
+        **kwargs,
+    ) -> AsyncGenerator:
+
+        self._check_model(payload["model"])
+        params = {**payload, **kwargs}
+        headers.pop("Authorization", None)
+        params["extra_headers"] = headers
+
+        async for chunk in self.client.beta.chat.completions.stream(**params):
+            yield chunk
+
+    @property
+    def allowed_roles(self):
+        return ["system", "user", "assistant"]
+
+    def _pull_model(self, model: str):
+        from tqdm import tqdm
+
+        current_digest, bars = "", {}
+        for progress in self._pull(model, stream=True):
+            digest = progress.get("digest", "")
+            if digest != current_digest and current_digest in bars:
+                bars[current_digest].close()
+
+            if not digest:
+                print(progress.get("status"))
+                continue
+
+            if digest not in bars and (total := progress.get("total")):
+                bars[digest] = tqdm(
+                    total=total,
+                    desc=f"pulling {digest[7:19]}",
+                    unit="B",
+                    unit_scale=True,
+                )
+
+            if completed := progress.get("completed"):
+                bars[digest].update(completed - bars[digest].n)
+
+            current_digest = digest
+
+    def _list_local_models(self) -> set:
+        response = self._list()
+        return {i.model for i in response.models}
+
+    def _check_model(self, model: str):
+        if model not in self._list_local_models():
+            self._pull_model(model)

lionagi/service/providers/openai_/chat_completions.py

@@ -89,6 +89,8 @@ class OpenAIChatCompletionEndPoint(ChatCompletionEndPoint):
             payload.pop("top_p", None)
             if payload["messages"][0].get("role") == "system":
                 payload["messages"][0]["role"] = "developer"
+        else:
+            payload.pop("reasoning_effort", None)
 
         return {
             "payload": payload,

lionagi/session/branch.py

@@ -941,6 +941,7 @@ class Branch(Element, Communicatable, Relational):
         ] = "return_value",
         operative_model: type[BaseModel] = None,
         request_model: type[BaseModel] = None,
+        include_token_usage_to_model: bool = False,
         **kwargs,
     ) -> list | BaseModel | None | dict | str:
         """
@@ -1028,6 +1029,8 @@ class Branch(Element, Communicatable, Relational):
                 Alias for `response_format`.
             request_model (type[BaseModel], optional):
                 Another alias for `response_format`.
+            include_token_usage_to_model:
+                If `True`, includes token usage in the model messages.
             **kwargs:
                 Additional keyword arguments passed to the LLM via `branch.chat()`.
 
@@ -1080,6 +1083,7 @@ class Branch(Element, Communicatable, Relational):
             operative_model=operative_model,
             request_model=request_model,
             imodel=imodel,
+            include_token_usage_to_model=include_token_usage_to_model,
             **kwargs,
         )
 
@@ -1106,6 +1110,7 @@ class Branch(Element, Communicatable, Relational):
         fuzzy_match_kwargs: dict = None,
         clear_messages: bool = False,
         operative_model: type[BaseModel] = None,
+        include_token_usage_to_model: bool = False,
         **kwargs,
     ):
         """
@@ -1190,6 +1195,7 @@ class Branch(Element, Communicatable, Relational):
             fuzzy_match_kwargs=fuzzy_match_kwargs,
             clear_messages=clear_messages,
             operative_model=operative_model,
+            include_token_usage_to_model=include_token_usage_to_model,
             **kwargs,
         )
 
@@ -1639,6 +1645,7 @@ class Branch(Element, Communicatable, Relational):
         analysis_model: iModel | None = None,
         verbose: bool = False,
         verbose_length: int = None,
+        include_token_usage_to_model: bool = True,
         **kwargs,
     ):
         """
@@ -1688,6 +1695,12 @@ class Branch(Element, Communicatable, Relational):
             analysis_model (iModel | None, optional):
                 A custom LLM model for generating the ReAct analysis steps. If `None`,
                 uses the branch's default `chat_model`.
+            include_token_usage_to_model:
+                If `True`, includes token usage in the model messages.
+            verbose (bool):
+                If `True`, logs detailed information about the process.
+            verbose_length (int):
+                If `verbose=True`, limits the length of logged strings to this value.
             **kwargs:
                 Additional keyword arguments passed into the initial `branch.operate()` call.
 
@@ -1733,6 +1746,7 @@ class Branch(Element, Communicatable, Relational):
             intermediate_listable=intermediate_listable,
             reasoning_effort=reasoning_effort,
             display_as=display_as,
+            include_token_usage_to_model=include_token_usage_to_model,
             **kwargs,
         )
 
@@ -1758,6 +1772,7 @@ class Branch(Element, Communicatable, Relational):
         verbose: bool = False,
         display_as: Literal["json", "yaml"] = "yaml",
         verbose_length: int = None,
+        include_token_usage_to_model: bool = True,
         **kwargs,
     ) -> AsyncGenerator:
         from lionagi.operations.ReAct.ReAct import ReActStream
@@ -1784,6 +1799,7 @@ class Branch(Element, Communicatable, Relational):
             verbose_analysis=True,
             display_as=display_as,
             verbose_length=verbose_length,
+            include_token_usage_to_model=include_token_usage_to_model,
             **kwargs,
         ):
             analysis, str_ = result

lionagi/version.py

@@ -1 +1 @@
-__version__ = "0.9.4"
+__version__ = "0.9.6"

{lionagi-0.9.4.dist-info → lionagi-0.9.6.dist-info}/METADATA

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

{lionagi-0.9.4.dist-info → lionagi-0.9.6.dist-info}/RECORD

@@ -4,7 +4,7 @@ lionagi/_errors.py,sha256=JlBTFJnRWtVYcRxKb7fWFiJHLbykl1E19mSJ8sXYVxg,455
 lionagi/_types.py,sha256=9g7iytvSj3UjZxD-jL06_fxuNfgZyWT3Qnp0XYp1wQU,63
 lionagi/settings.py,sha256=W52mM34E6jXF3GyqCFzVREKZrmnUqtZm_BVDsUiDI_s,1627
 lionagi/utils.py,sha256=K36D9AAGiMPR4eM9tYoiVgvH-NdPPSeMQPls09s7keQ,73223
-lionagi/version.py,sha256=e56AvHfJCtG2ZwwINqsxINVbehWdKxMYgIDbjd7P-II,22
+lionagi/version.py,sha256=IgVHjr-TeioZYLJSkvpT80LLGi6U3ONzR1cfYfd5XNQ,22
 lionagi/libs/__init__.py,sha256=5y5joOZzfFWERl75auAcNcKC3lImVJ5ZZGvvHZUFCJM,112
 lionagi/libs/parse.py,sha256=JRS3bql0InHJqATnAatl-hQv4N--XXw4P77JHhTFnrc,1011
 lionagi/libs/file/__init__.py,sha256=5y5joOZzfFWERl75auAcNcKC3lImVJ5ZZGvvHZUFCJM,112
@@ -32,7 +32,7 @@ lionagi/libs/schema/__init__.py,sha256=5y5joOZzfFWERl75auAcNcKC3lImVJ5ZZGvvHZUFC
 lionagi/libs/schema/as_readable.py,sha256=W4fi98WVkP5rfZ6A-iWqP5YFJexYCjt9Hf-l0iNs-2Q,5916
 lionagi/libs/schema/extract_code_block.py,sha256=PuJbJj1JnqR5fSZudowPcVPpEoKISLr0MjTOOVXSzwY,2394
 lionagi/libs/schema/extract_docstring.py,sha256=aYyLSRlB8lTH9QF9-6a56uph3AAkNuTyZ0S_duf5-fw,5729
-lionagi/libs/schema/function_to_schema.py,sha256=xAHFYPcrny1HDK9gfd42nmg0h2MftWUYPrIPeN1seJM,3393
+lionagi/libs/schema/function_to_schema.py,sha256=qLsM-_1ERlLdP_zBwz7ttxMZQ8jr5eTJN8IX1QSkSig,5560
 lionagi/libs/schema/json_schema.py,sha256=cuHcaMr748O9g6suNGmRx4tRXcidd5-c7AMGjTIZyHM,7670
 lionagi/libs/token_transform/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 lionagi/libs/token_transform/llmlingua.py,sha256=DkeLUlrb7rGx3nZ04aADU9HXXu5mZTf_DBwT0xhzIv4,7
@@ -48,24 +48,24 @@ lionagi/operations/__init__.py,sha256=2HExKTx2J3iKWsvS9YaF6i5SZgqcpAJkVmWbi2H5A5
 lionagi/operations/manager.py,sha256=H7UY86PIxvxKdzJY9YVsWyJcqlwLWhVyvm4sYePH_uY,565
 lionagi/operations/types.py,sha256=fM8HphnbBifMzhoKKvdl3JxGCBHlEGPJEYkLWj9b7vE,704
 lionagi/operations/utils.py,sha256=LrWr_JEyJmSw5RL03KZhWgDKYsjFk0-OS8SoaGU7Jhs,1220
-lionagi/operations/ReAct/ReAct.py,sha256=eBCQOzVHv85uEL4YH1qv8NhbzM0t-qyKZ4JI7tQRXQ8,11971
+lionagi/operations/ReAct/ReAct.py,sha256=f3_Q3Sc9U7i_4IBzFN3KxohUnMTMa_yFJ2I9rSlERvE,13578
 lionagi/operations/ReAct/__init__.py,sha256=5y5joOZzfFWERl75auAcNcKC3lImVJ5ZZGvvHZUFCJM,112
-lionagi/operations/ReAct/utils.py,sha256=jXf9LafAg0GtZajXqT4jOLJHW_Y4eL-hbz5_OlFCBh8,3612
+lionagi/operations/ReAct/utils.py,sha256=84Giel5ToqfbN5F6Tm0uw8yZTTnxiM_jWuFEhnKOxM8,3800
 lionagi/operations/_act/__init__.py,sha256=5y5joOZzfFWERl75auAcNcKC3lImVJ5ZZGvvHZUFCJM,112
 lionagi/operations/_act/act.py,sha256=CunHTTZcS6xNUe0xKSDgtMJ7-ucSvHeW4BtmVjXnaxk,2958
 lionagi/operations/brainstorm/__init__.py,sha256=5y5joOZzfFWERl75auAcNcKC3lImVJ5ZZGvvHZUFCJM,112
 lionagi/operations/brainstorm/brainstorm.py,sha256=iRZUW_V-0Ncw7Av0_WBk3oNRWb4LqQU5i2gQDxulYWY,17222
 lionagi/operations/brainstorm/prompt.py,sha256=Dqi4NNeztdI4iutggRqjnOrG4a4E2JtwIAtRnjZ_ghQ,610
 lionagi/operations/chat/__init__.py,sha256=5y5joOZzfFWERl75auAcNcKC3lImVJ5ZZGvvHZUFCJM,112
-lionagi/operations/chat/chat.py,sha256=GHhudJlQk-okoP-S8ceUnoWF-ccxbdQW_p8gqsE7t6w,5348
+lionagi/operations/chat/chat.py,sha256=xJAH2H0zyVvxiL3XtW3MC6YrwCCB1uCkwcQIJ1YsIOk,5466
 lionagi/operations/communicate/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-lionagi/operations/communicate/communicate.py,sha256=f8dQGzFSCrBHcoe_z75GcD8zxgcWQ5umK_Y8BUVaQ3c,2962
+lionagi/operations/communicate/communicate.py,sha256=dPaPqg898biY6j_FlgH4HEJxTK6T_87ixXWhD6kbk40,3077
 lionagi/operations/instruct/__init__.py,sha256=5y5joOZzfFWERl75auAcNcKC3lImVJ5ZZGvvHZUFCJM,112
 lionagi/operations/instruct/instruct.py,sha256=-HDdCgvRGCNB5vMCV0xM2KEa9VrjosApXSKtQQ9d0xQ,795
 lionagi/operations/interpret/__init__.py,sha256=5y5joOZzfFWERl75auAcNcKC3lImVJ5ZZGvvHZUFCJM,112
-lionagi/operations/interpret/interpret.py,sha256=zdsPx8qylFOTH3QYfpQeqNj3wddaqJORKy0_1flDWnk,1399
+lionagi/operations/interpret/interpret.py,sha256=8_F3oYaoYK8MDcK4iCwksBP7sI0UlgBiZSrUusdlKNo,1528
 lionagi/operations/operate/__init__.py,sha256=5y5joOZzfFWERl75auAcNcKC3lImVJ5ZZGvvHZUFCJM,112
-lionagi/operations/operate/operate.py,sha256=NFC1EqykJkz__4oFpzzR8wGmH3_nOBRW4vdVnG2C1tI,7218
+lionagi/operations/operate/operate.py,sha256=j5dGWhHlcWnO-aaLZ4Xe0Hb1M7FGp9BGm356-LOH6rA,7333
 lionagi/operations/parse/__init__.py,sha256=5y5joOZzfFWERl75auAcNcKC3lImVJ5ZZGvvHZUFCJM,112
 lionagi/operations/parse/parse.py,sha256=i2q6YGRwsp2WEu0aySfZ6io7iLNAqPAx1wWd2hUjpgM,3296
 lionagi/operations/plan/__init__.py,sha256=yGBPll6lOqVjadbTvDLGrTlMx3FfBW-e00z7AMvg7Uo,156
@@ -161,13 +161,13 @@ 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=w3cqrJSz2q7k_Y3BXsuS85ZTpBOfa0bNM7Gr58IdTaA,14589
+lionagi/service/imodel.py,sha256=GIb0v0gSa9WJA5fmif8nAe-y-j8qHlZNb8FEIuzgE9s,15157
 lionagi/service/manager.py,sha256=FkuqAtLErqLmXNnDtuAdTUFo4uuE_VL660BBGBhzInU,1435
 lionagi/service/types.py,sha256=CHPi8Bxl_yJ1pl2jYZBOrTHbT8_oO9sK75d4LMB651g,486
 lionagi/service/endpoints/__init__.py,sha256=5y5joOZzfFWERl75auAcNcKC3lImVJ5ZZGvvHZUFCJM,112
-lionagi/service/endpoints/base.py,sha256=WuXs2tDrOxbbv9-UkiAgpVcM_6nuCNmvvry7eN1GuoI,23482
+lionagi/service/endpoints/base.py,sha256=sArF7dpSfer3OsBLMFqHGslAd4dgJUkCLtYkBWRmxOM,25441
 lionagi/service/endpoints/chat_completion.py,sha256=nihV7kCYm7ixdm8dH0JW7vKjqH9yIom4QDXGeDwuO6E,2964
-lionagi/service/endpoints/match_endpoint.py,sha256=hPCqFwVirj5g9Husec980OCUynjRmr0zQzrs7O4yP74,1874
+lionagi/service/endpoints/match_endpoint.py,sha256=x2T-ftzdqCrdITRLkH8UNRDY2Pm359DnX2RDXTBnbpc,2082
 lionagi/service/endpoints/rate_limited_processor.py,sha256=P0CsMyhuG8OHCPYe2qez92Bm7v2ZRq4L5I6LOiAoGYs,5199
 lionagi/service/endpoints/token_calculator.py,sha256=-AKwDvV7C8k8MTmd62ymT0ETSUPWBJ_DQKLZUutlyfg,6161
 lionagi/service/providers/__init__.py,sha256=5y5joOZzfFWERl75auAcNcKC3lImVJ5ZZGvvHZUFCJM,112
@@ -180,15 +180,17 @@ lionagi/service/providers/exa_/search.py,sha256=Z3pyJH8KiWiquJSJw8Rd6D7x43BwTFHb
 lionagi/service/providers/exa_/types.py,sha256=8ODjXpFajBE9-DGqBJNS--GObwmLSDi667xS84z_AgA,139
 lionagi/service/providers/groq_/__init__.py,sha256=5y5joOZzfFWERl75auAcNcKC3lImVJ5ZZGvvHZUFCJM,112
 lionagi/service/providers/groq_/chat_completions.py,sha256=q1p_1qus4vduWWBzs9V_KbNrqU2Tu2o8TZm6Fh09fw4,1343
+lionagi/service/providers/ollama_/__init__.py,sha256=5y5joOZzfFWERl75auAcNcKC3lImVJ5ZZGvvHZUFCJM,112
+lionagi/service/providers/ollama_/chat_completions.py,sha256=gPemTJO9dPd68l60kDYppO29uYqmLole4JGkv9Fz1Us,3764
 lionagi/service/providers/openai_/__init__.py,sha256=5y5joOZzfFWERl75auAcNcKC3lImVJ5ZZGvvHZUFCJM,112
-lionagi/service/providers/openai_/chat_completions.py,sha256=d-tRlGBmNCcKS_06Ps6dZ6zUa18l0rHHXKo3xPKYKj8,2803
+lionagi/service/providers/openai_/chat_completions.py,sha256=y3RAgI5WQH5EwT1wZxp5ttnkCxUJEcOM3Cta6u9cpQo,2867
 lionagi/service/providers/openrouter_/__init__.py,sha256=5y5joOZzfFWERl75auAcNcKC3lImVJ5ZZGvvHZUFCJM,112
 lionagi/service/providers/openrouter_/chat_completions.py,sha256=0pdXjJCXmCPPbKKVubrnqofaodTOxWTJam8fd3NgrNk,1525
 lionagi/service/providers/perplexity_/__init__.py,sha256=5y5joOZzfFWERl75auAcNcKC3lImVJ5ZZGvvHZUFCJM,112
 lionagi/service/providers/perplexity_/chat_completions.py,sha256=O4MIS_3xIINGjkAZdlw0Bu_jAfBDR4VZA1F8JW2EU1M,1197
 lionagi/service/providers/perplexity_/models.py,sha256=gXH4XGkhZ4aFxvMSDTlHq9Rz1mhu3aTENXAtE-BIr6U,4866
 lionagi/session/__init__.py,sha256=5y5joOZzfFWERl75auAcNcKC3lImVJ5ZZGvvHZUFCJM,112
-lionagi/session/branch.py,sha256=XL0P507Jfqk9LhC8rDvajkjVE8FkPx7hnLltb-LdqHw,71503
+lionagi/session/branch.py,sha256=dKlaM6hh_q7OoXkz4E5S3aS4ksqC2yzdhjzI7xe6pzU,72439
 lionagi/session/prompts.py,sha256=AhuHL19s0TijVZX3tMKUKMi6l88xeVdpkuEn2vJSRyU,3236
 lionagi/session/session.py,sha256=8SuNMiJX6IAW6Ou8aDK0LsVG7zcD5yd22sakMyrd3pw,8987
 lionagi/tools/__init__.py,sha256=5y5joOZzfFWERl75auAcNcKC3lImVJ5ZZGvvHZUFCJM,112
@@ -211,7 +213,7 @@ lionagi/tools/file/writer.py,sha256=5y5joOZzfFWERl75auAcNcKC3lImVJ5ZZGvvHZUFCJM,
 lionagi/tools/file/providers/__init__.py,sha256=5y5joOZzfFWERl75auAcNcKC3lImVJ5ZZGvvHZUFCJM,112
 lionagi/tools/file/providers/docling_.py,sha256=5y5joOZzfFWERl75auAcNcKC3lImVJ5ZZGvvHZUFCJM,112
 lionagi/tools/query/__init__.py,sha256=5y5joOZzfFWERl75auAcNcKC3lImVJ5ZZGvvHZUFCJM,112
-lionagi-0.9.4.dist-info/METADATA,sha256=46U0oyzqf8A6wuF-KlmsEZWVDiRQCFyZrYfPeG5ZgOQ,18053
-lionagi-0.9.4.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
-lionagi-0.9.4.dist-info/licenses/LICENSE,sha256=VXFWsdoN5AAknBCgFqQNgPWYx7OPp-PFEP961zGdOjc,11288
-lionagi-0.9.4.dist-info/RECORD,,
+lionagi-0.9.6.dist-info/METADATA,sha256=WGUAokWhfSlKKpws48WJRgBmwQJ1MTBAQd3o_EVdPdg,18053
+lionagi-0.9.6.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+lionagi-0.9.6.dist-info/licenses/LICENSE,sha256=VXFWsdoN5AAknBCgFqQNgPWYx7OPp-PFEP961zGdOjc,11288
+lionagi-0.9.6.dist-info/RECORD,,