lionagi 0.9.4__tar.gz → 0.9.6__tar.gz

{lionagi-0.9.4 → lionagi-0.9.6}/PKG-INFO

@@ -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.6/lionagi/libs/schema/function_to_schema.py

@@ -0,0 +1,164 @@
+# Copyright (c) 2023 - 2025, HaiyangLi <quantocean.li at gmail dot com>
+#
+# SPDX-License-Identifier: Apache-2.0
+
+import inspect
+from typing import Any, Literal
+
+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",
+    "int": "number",
+    "float": "number",
+    "list": "array",
+    "tuple": "array",
+    "bool": "boolean",
+    "dict": "object",
+}
+
+
+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
+
+    This function generates a schema description for the given function
+    using typing hints and docstrings. The schema includes the function's
+    name, description, and parameter details.
+
+    Args:
+        func (Callable): The function to generate a schema for.
+        style (str): The docstring format. Can be 'google' (default) or
+            'reST'.
+        func_description (str, optional): A custom description for the
+            function. If not provided, the description will be extracted
+            from the function's docstring.
+        params_description (dict, optional): A dictionary mapping
+            parameter names to their descriptions. If not provided, the
+            parameter descriptions will be extracted from the function's
+            docstring.
+
+    Returns:
+        dict: A schema describing the function, including its name,
+        description, and parameter details.
+
+    Example:
+        >>> def example_func(param1: int, param2: str) -> bool:
+        ...     '''Example function.
+        ...
+        ...     Args:
+        ...         param1 (int): The first parameter.
+        ...         param2 (str): The second parameter.
+        ...     '''
+        ...     return True
+        >>> schema = function_to_schema(example_func)
+        >>> schema['function']['name']
+        'example_func'
+    """
+    # Extract function name
+    func_name = f_.__name__
+
+    # Extract function description and parameter descriptions
+    if not func_description or not parametert_description:
+        func_desc, params_desc = extract_docstring(f_, style)
+        func_description = func_description or func_desc
+        parametert_description = parametert_description or params_desc
+
+    # Extract parameter details using typing hints
+    sig = inspect.signature(f_)
+    parameters: dict[str, Any] = {
+        "type": "object",
+        "properties": {},
+        "required": [],
+    }
+
+    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-0.9.4 → lionagi-0.9.6}/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-0.9.4 → lionagi-0.9.6}/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-0.9.4 → lionagi-0.9.6}/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-0.9.4 → lionagi-0.9.6}/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-0.9.4 → lionagi-0.9.6}/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-0.9.4 → lionagi-0.9.6}/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-0.9.4 → lionagi-0.9.6}/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-0.9.4 → lionagi-0.9.6}/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-0.9.4 → lionagi-0.9.6}/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 (