lionagi 0.9.5__tar.gz → 0.9.6__tar.gz

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: lionagi
-Version: 0.9.5
+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.5 → 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:
@@ -354,6 +364,7 @@ class APICalling(Event):
         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:
@@ -648,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.5 → 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.5 → 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,

lionagi-0.9.6/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-0.9.6/lionagi/tools/query/__init__.py

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

lionagi-0.9.6/lionagi/version.py

@@ -0,0 +1 @@
+__version__ = "0.9.6"

{lionagi-0.9.5 → lionagi-0.9.6}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "lionagi"
-version = "0.9.5"
+version = "0.9.6"
 description = "An Intelligence Operating System."
 authors = [
     { name = "HaiyangLi", email = "quantocean.li@gmail.com" },
@@ -49,7 +49,13 @@ dev = [
 ]
 tools = [
     "docling>=2.15.1",
+]
+llms = [
     "litellm>=1.59.5",
+    "openai>=1.60.0",
+]
+ollama = [
+    "ollama>=0.4.7",
 ]
 
 [tool.black]

{lionagi-0.9.5 → lionagi-0.9.6}/uv.lock

@@ -1208,7 +1208,7 @@ wheels = [
 
 [[package]]
 name = "lionagi"
-version = "0.9.5"
+version = "0.9.6"
 source = { editable = "." }
 dependencies = [
     { name = "aiocache" },
@@ -1235,9 +1235,15 @@ dev = [
     { name = "sphinx" },
     { name = "sphinx-autobuild" },
 ]
+llms = [
+    { name = "litellm" },
+    { name = "openai" },
+]
+ollama = [
+    { name = "ollama" },
+]
 tools = [
     { name = "docling" },
-    { name = "litellm" },
 ]
 
 [package.metadata]
@@ -1266,10 +1272,12 @@ dev = [
     { name = "sphinx", specifier = ">=8.1.3" },
     { name = "sphinx-autobuild", specifier = ">=2024.10.3" },
 ]
-tools = [
-    { name = "docling", specifier = ">=2.15.1" },
+llms = [
     { name = "litellm", specifier = ">=1.59.5" },
+    { name = "openai", specifier = ">=1.60.0" },
 ]
+ollama = [{ name = "ollama", specifier = ">=0.4.7" }]
+tools = [{ name = "docling", specifier = ">=2.15.1" }]
 
 [[package]]
 name = "litellm"
@@ -1837,6 +1845,19 @@ wheels = [
     { url = "https://files.pythonhosted.org/packages/87/20/199b8713428322a2f22b722c62b8cc278cc53dffa9705d744484b5035ee9/nvidia_nvtx_cu12-12.4.127-py3-none-manylinux2014_x86_64.whl", hash = "sha256:781e950d9b9f60d8241ccea575b32f5105a5baf4c2351cab5256a24869f12a1a", size = 99144 },
 ]
 
+[[package]]
+name = "ollama"
+version = "0.4.7"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "httpx" },
+    { name = "pydantic" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/b0/6d/dc77539c735bbed5d0c873fb029fb86aa9f0163df169b34152914331c369/ollama-0.4.7.tar.gz", hash = "sha256:891dcbe54f55397d82d289c459de0ea897e103b86a3f1fad0fdb1895922a75ff", size = 12843 }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/31/83/c3ffac86906c10184c88c2e916460806b072a2cfe34cdcaf3a0c0e836d39/ollama-0.4.7-py3-none-any.whl", hash = "sha256:85505663cca67a83707be5fb3aeff0ea72e67846cea5985529d8eca4366564a1", size = 13210 },
+]
+
 [[package]]
 name = "openai"
 version = "1.60.0"

lionagi-0.9.5/lionagi/libs/schema/function_to_schema.py

@@ -1,104 +0,0 @@
-# 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 .extract_docstring import extract_docstring
-
-py_json_msp = {
-    "str": "string",
-    "int": "number",
-    "float": "number",
-    "list": "array",
-    "tuple": "array",
-    "bool": "boolean",
-    "dict": "object",
-}
-
-
-def function_to_schema(
-    f_,
-    style: Literal["google", "rest"] = "google",
-    *,
-    func_description: str = None,
-    parametert_description: dict[str, str] = None,
-) -> 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": [],
-    }
-
-    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,
-        },
-    }

lionagi-0.9.5/lionagi/version.py

@@ -1 +0,0 @@
-__version__ = "0.9.5"