lionagi 0.12.2__py3-none-any.whl → 0.12.4__py3-none-any.whl

lionagi/service/endpoints/chat_completion.py

@@ -1,116 +0,0 @@
-# Copyright (c) 2023 - 2025, HaiyangLi <quantocean.li at gmail dot com>
-#
-# SPDX-License-Identifier: Apache-2.0
-import warnings
-from collections.abc import AsyncGenerator
-
-from .base import EndPoint
-
-warnings.filterwarnings(
-    "ignore",
-    message=".*Valid config keys have changed in V2.*",
-    category=UserWarning,
-    module="pydantic._internal._config",
-)
-
-
-CHAT_COMPLETION_CONFIG = {
-    "endpoint": "chat/completions",
-    "method": "post",
-    "requires_tokens": True,
-    "openai_compatible": True,
-    "is_invokeable": True,
-    "is_streamable": True,
-}
-
-
-class ChatCompletionEndPoint(EndPoint):
-
-    def __init__(self, config: dict = CHAT_COMPLETION_CONFIG):
-        super().__init__(config)
-
-    async def _invoke(
-        self,
-        payload: dict,
-        headers: dict,
-        **kwargs,
-    ):
-        from lionagi.libs.package.imports import check_import
-
-        check_import("litellm")
-        import litellm  # type: ignore
-
-        litellm.drop_params = True
-        from litellm import acompletion  # type: ignore
-
-        provider = self.config.provider
-
-        if not provider in payload["model"]:
-            payload["model"] = f"{provider}/{payload['model']}"
-
-        api_key = None
-
-        if "Authorization" in headers:
-            api_key = headers.pop("Authorization").replace("Bearer ", "")
-
-        if "x-api-key" in headers:
-            api_key = headers.pop("x-api-key")
-
-        params = {
-            "api_key": api_key,
-            "base_url": self.config.base_url,
-            **payload,
-            **kwargs,
-        }
-        if headers:
-            params["extra_headers"] = headers
-        if not self.openai_compatible:
-            params.pop("base_url")
-
-        return await acompletion(**params)
-
-    async def _stream(
-        self,
-        payload: dict,
-        headers: dict,
-        **kwargs,
-    ) -> AsyncGenerator:
-        from lionagi.libs.package.imports import check_import
-
-        check_import("litellm")
-        import litellm  # type: ignore
-
-        litellm.drop_params = True
-        from litellm import acompletion  # type: ignore
-
-        provider = self.config.provider
-
-        if not provider in payload["model"]:
-            payload["model"] = f"{provider}/{payload['model']}"
-
-        api_key = None
-
-        if "Authorization" in headers:
-            api_key = headers.pop("Authorization").replace("Bearer ", "")
-
-        if "x-api-key" in headers:
-            api_key = headers.pop("x-api-key")
-
-        params = {
-            "api_key": api_key,
-            "base_url": self.config.base_url,
-            **payload,
-            **kwargs,
-        }
-        if headers:
-            params["extra_headers"] = headers
-        if not self.openai_compatible:
-            params.pop("base_url")
-
-        params["stream"] = True
-        async for i in await acompletion(**params):
-            yield i
-
-    @property
-    def allowed_roles(self):
-        return ["system", "user", "assistant"]

lionagi/service/endpoints/match_endpoint.py

@@ -1,72 +0,0 @@
-# Copyright (c) 2023 - 2025, HaiyangLi <quantocean.li at gmail dot com>
-#
-# SPDX-License-Identifier: Apache-2.0
-
-from .chat_completion import EndPoint
-
-
-def match_endpoint(
-    provider: str,
-    base_url: str,
-    endpoint: str,
-    endpoint_params: list[str] | None = None,
-) -> EndPoint:
-
-    if endpoint in ["chat/completions", "chat", "messages"]:
-        from ..providers.openai_.chat_completions import (
-            OpenAIChatCompletionEndPoint,
-        )
-
-        if provider == "openai":
-            return OpenAIChatCompletionEndPoint()
-
-        if provider == "anthropic":
-            from ..providers.anthropic_.messages import (
-                AnthropicChatCompletionEndPoint,
-            )
-
-            return AnthropicChatCompletionEndPoint()
-
-        if provider == "groq":
-            from ..providers.groq_.chat_completions import (
-                GroqChatCompletionEndPoint,
-            )
-
-            return GroqChatCompletionEndPoint()
-
-        if provider == "perplexity":
-            from ..providers.perplexity_.chat_completions import (
-                PerplexityChatCompletionEndPoint,
-            )
-
-            return PerplexityChatCompletionEndPoint()
-
-        if provider == "openrouter":
-            from ..providers.openrouter_.chat_completions import (
-                OpenRouterChatCompletionEndPoint,
-            )
-
-            return OpenRouterChatCompletionEndPoint()
-
-        if provider == "ollama":
-            from ..providers.ollama_.chat_completions import (
-                OllamaChatCompletionEndPoint,
-            )
-
-            return OllamaChatCompletionEndPoint()
-
-        return OpenAIChatCompletionEndPoint(
-            config={
-                "provider": provider,
-                "base_url": base_url,
-                "endpoint": endpoint,
-                "endpoint_params": endpoint_params,
-            }
-        )
-
-    if provider == "exa" and endpoint == "search":
-        from ..providers.exa_.search import ExaSearchEndPoint
-
-        return ExaSearchEndPoint()
-
-    raise ValueError(f"Unsupported endpoint: {endpoint}")

lionagi/service/providers/__init__.py

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

lionagi/service/providers/anthropic_/__init__.py

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

lionagi/service/providers/anthropic_/messages.py

@@ -1,99 +0,0 @@
-# Copyright (c) 2023 - 2025, HaiyangLi <quantocean.li at gmail dot com>
-#
-# SPDX-License-Identifier: Apache-2.0
-
-from lionagi.service.endpoints.chat_completion import ChatCompletionEndPoint
-
-CHAT_COMPLETION_CONFIG = {
-    "provider": "anthropic",
-    "endpoint": "messages",
-    "method": "post",
-    "requires_tokens": True,
-    "openai_compatible": False,
-    "is_invokeable": True,
-    "is_streamable": True,
-    "base_url": "https://api.anthropic.com/v1",
-    "api_version": "2023-06-01",
-    "required_kwargs": {
-        "messages",
-        "model",
-        "max_tokens",
-    },
-    "optional_kwargs": {
-        "metadata",
-        "stop_sequences",
-        "stream",
-        "system",
-        "temperature",
-        "tool_choice",
-        "tools",
-        "top_p",
-        "top_k",
-        "cache_control",
-    },
-    "allowed_roles": ["user", "assistant"],
-}
-
-
-class AnthropicChatCompletionEndPoint(ChatCompletionEndPoint):
-    """
-    Documentation: https://docs.anthropic.com/en/api/
-    """
-
-    def __init__(self, config: dict = CHAT_COMPLETION_CONFIG):
-        super().__init__(config)
-
-    def create_payload(self, **kwargs) -> dict:
-        payload = {}
-        cached = kwargs.get("cached", False)
-        headers = kwargs.get("headers", {})
-        for k, v in kwargs.items():
-            if k in self.acceptable_kwargs:
-                payload[k] = v
-
-        for i in self.required_kwargs:
-            if i not in payload:
-                raise ValueError(f"Missing required argument: {i}")
-
-        if "cache_control" in payload:
-            cache_control = payload.pop("cache_control")
-            if cache_control:
-                cache_control = {"type": "ephemeral"}
-                last_message = payload["messages"][-1]["content"]
-                if isinstance(last_message, str):
-                    last_message = {
-                        "type": "text",
-                        "text": last_message,
-                        "cache_control": cache_control,
-                    }
-                elif isinstance(last_message, list) and isinstance(
-                    last_message[-1], dict
-                ):
-                    last_message[-1]["cache_control"] = cache_control
-                payload["messages"][-1]["content"] = (
-                    [last_message]
-                    if not isinstance(last_message, list)
-                    else last_message
-                )
-
-        first_message = payload["messages"][0]
-        system = None
-        if first_message.get("role") == "system":
-            system = first_message["content"]
-            system = [{"type": "text", "text": system}]
-            payload["messages"] = payload["messages"][1:]
-            payload["system"] = system
-
-        if "api_key" in kwargs:
-            headers["x-api-key"] = kwargs["api_key"]
-        headers["anthropic-version"] = kwargs.pop(
-            "api_version", self.config.api_version
-        )
-        if "content-type" not in kwargs:
-            headers["content-type"] = "application/json"
-
-        return {
-            "payload": payload,
-            "headers": headers,
-            "cached": cached,
-        }

lionagi/service/providers/exa_/models.py

@@ -1,3 +0,0 @@
-from khive.providers.exa_ import ExaSearchRequest
-
-__all__ = ("ExaSearchRequest",)

lionagi/service/providers/exa_/search.py

@@ -1,80 +0,0 @@
-from typing import Literal
-
-from lionagi.service.endpoints.base import EndPoint
-
-from .models import ExaSearchRequest
-
-CATEGORY_OPTIONS = Literal[
-    "article",
-    "book",
-    "company",
-    "research paper",
-    "news",
-    "pdf",
-    "github",
-    "tweet",
-    "personal site",
-    "linkedin profile",
-    "financial report",
-]
-
-SEARCH_CONFIG = {
-    "name": "search_exa",
-    "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",
-    },
-    "request_options": ExaSearchRequest,
-}
-
-
-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

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

lionagi/service/providers/groq_/__init__.py

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

lionagi/service/providers/groq_/chat_completions.py

@@ -1,56 +0,0 @@
-# Copyright (c) 2023 - 2025, HaiyangLi <quantocean.li at gmail dot com>
-#
-# SPDX-License-Identifier: Apache-2.0
-
-from lionagi.service.endpoints.chat_completion import ChatCompletionEndPoint
-
-CHAT_COMPLETION_CONFIG = {
-    "provider": "groq",
-    "base_url": "https://api.groq.com/openai/v1",
-    "endpoint": "chat/completions",
-    "method": "post",
-    "openai_compatible": True,
-    "is_invokeable": True,
-    "requires_tokens": True,
-    "is_streamable": True,
-    "required_kwargs": {
-        "messages",
-        "model",
-    },
-    "deprecated_kwargs": {
-        "max_tokens",
-        "function_call",
-        "functions",
-    },
-    "optional_kwargs": {
-        "store",
-        "reasoning_effort",
-        "metadata",
-        "frequency_penalty",
-        "max_completion_tokens",
-        "modalities",
-        "prediction",
-        "audio",
-        "presence_penalty",
-        "seed",
-        "service_tier",
-        "stop",
-        "stream",
-        "stream_options",
-        "temperature",
-        "top_p",
-        "tools",
-        "tool_choice",
-        "parallel_tool_calls",
-        "user",
-    },
-}
-
-
-class GroqChatCompletionEndPoint(ChatCompletionEndPoint):
-    """
-    Documentation: https://console.groq.com/docs/overview
-    """
-
-    def __init__(self, config: dict = CHAT_COMPLETION_CONFIG):
-        super().__init__(config)

lionagi/service/providers/ollama_/__init__.py

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

lionagi/service/providers/ollama_/chat_completions.py

@@ -1,134 +0,0 @@
-# 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  # type: ignore
-        from openai import AsyncOpenAI  # type: ignore
-
-        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_/__init__.py

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