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

lionagi/service/connections/endpoint_config.py

@@ -0,0 +1,137 @@
+# Copyright (c) 2025, HaiyangLi <quantocean.li at gmail dot com>
+#
+# SPDX-License-Identifier: Apache-2.0
+
+import os
+from typing import Any, TypeVar
+
+from pydantic import (
+    BaseModel,
+    Field,
+    PrivateAttr,
+    SecretStr,
+    field_serializer,
+    field_validator,
+    model_validator,
+)
+
+from .header_factory import AUTH_TYPES
+
+B = TypeVar("B", bound=type[BaseModel])
+
+
+class EndpointConfig(BaseModel):
+    name: str
+    provider: str
+    base_url: str | None = None
+    endpoint: str
+    endpoint_params: list[str] | None = None
+    method: str = "POST"
+    params: dict[str, str] = Field(default_factory=dict)
+    content_type: str = "application/json"
+    auth_type: AUTH_TYPES = "bearer"
+    default_headers: dict = {}
+    request_options: B | None = None
+    api_key: str | SecretStr | None = None
+    timeout: int = 300
+    max_retries: int = 3
+    openai_compatible: bool = False
+    requires_tokens: bool = False
+    kwargs: dict = Field(default_factory=dict)
+    client_kwargs: dict = Field(default_factory=dict)
+    _api_key: str | None = PrivateAttr(None)
+
+    @model_validator(mode="before")
+    def _validate_kwargs(cls, data: dict):
+        kwargs = data.pop("kwargs", {})
+        field_keys = list(cls.model_json_schema().get("properties", {}).keys())
+        for k in list(data.keys()):
+            if k not in field_keys:
+                kwargs[k] = data.pop(k)
+        data["kwargs"] = kwargs
+        return data
+
+    @model_validator(mode="after")
+    def _validate_api_key(self):
+
+        if self.api_key is not None:
+            if isinstance(self.api_key, SecretStr):
+                self._api_key = self.api_key.get_secret_value()
+            elif isinstance(self.api_key, str):
+                # Skip settings lookup for ollama special case
+                if self.provider == "ollama" and self.api_key == "ollama_key":
+                    self._api_key = "ollama_key"
+                else:
+                    from lionagi.config import settings
+
+                    try:
+                        self._api_key = settings.get_secret(self.api_key)
+                    except (AttributeError, ValueError):
+                        self._api_key = os.getenv(self.api_key, self.api_key)
+
+        return self
+
+    @property
+    def full_url(self):
+        if not self.endpoint_params:
+            return f"{self.base_url}/{self.endpoint}"
+        return f"{self.base_url}/{self.endpoint.format(**self.params)}"
+
+    @field_validator("request_options", mode="before")
+    def _validate_request_options(cls, v):
+        # Create a simple empty model if None is provided
+        if v is None:
+            return None
+
+        try:
+            if isinstance(v, type) and issubclass(v, BaseModel):
+                return v
+            if isinstance(v, BaseModel):
+                return v.__class__
+            if isinstance(v, dict | str):
+                from lionagi.libs.schema import SchemaUtil
+
+                return SchemaUtil.load_pydantic_model_from_schema(v)
+        except Exception as e:
+            raise ValueError("Invalid request options") from e
+        raise ValueError(
+            "Invalid request options: must be a Pydantic model or a schema dict"
+        )
+
+    @field_serializer("request_options")
+    def _serialize_request_options(self, v: B | None):
+        if v is None:
+            return None
+        return v.model_json_schema()
+
+    def update(self, **kwargs):
+        """Update the config with new values."""
+        # Handle the special case of kwargs dict
+        if "kwargs" in kwargs:
+            # Merge the kwargs dicts
+            self.kwargs.update(kwargs.pop("kwargs"))
+
+        for key, value in kwargs.items():
+            if hasattr(self, key):
+                setattr(self, key, value)
+            else:
+                # Add to kwargs dict if not a direct attribute
+                self.kwargs[key] = value
+
+    def validate_payload(self, data: dict[str, Any]) -> dict[str, Any]:
+        """Validate payload data against the request_options model.
+
+        Args:
+            data: The payload data to validate
+
+        Returns:
+            The validated data
+        """
+        if not self.request_options:
+            return data
+
+        try:
+            self.request_options.model_validate(data)
+            return data
+        except Exception as e:
+            raise ValueError("Invalid payload") from e

lionagi/service/connections/header_factory.py

@@ -0,0 +1,56 @@
+# Copyright (c) 2025, HaiyangLi <quantocean.li at gmail dot com>
+#
+# SPDX-License-Identifier: Apache-2.0
+
+from typing import Literal
+
+from pydantic import SecretStr
+
+AUTH_TYPES = Literal["bearer", "x-api-key", "none"]
+
+
+class HeaderFactory:
+    @staticmethod
+    def get_content_type_header(
+        content_type: str = "application/json",
+    ) -> dict[str, str]:
+        return {"Content-Type": content_type}
+
+    @staticmethod
+    def get_bearer_auth_header(api_key: str) -> dict[str, str]:
+        return {"Authorization": f"Bearer {api_key}"}
+
+    @staticmethod
+    def get_x_api_key_header(api_key: str) -> dict[str, str]:
+        return {"x-api-key": api_key}
+
+    @staticmethod
+    def get_header(
+        auth_type: AUTH_TYPES,
+        content_type: str = "application/json",
+        api_key: str | SecretStr | None = None,
+        default_headers: dict[str, str] | None = None,
+    ) -> dict[str, str]:
+        dict_ = HeaderFactory.get_content_type_header(content_type)
+
+        if auth_type == "none":
+            # No authentication needed
+            pass
+        elif not api_key:
+            raise ValueError("API key is required for authentication")
+        else:
+            api_key = (
+                api_key.get_secret_value()
+                if isinstance(api_key, SecretStr)
+                else api_key
+            )
+            if auth_type == "bearer":
+                dict_.update(HeaderFactory.get_bearer_auth_header(api_key))
+            elif auth_type == "x-api-key":
+                dict_.update(HeaderFactory.get_x_api_key_header(api_key))
+            else:
+                raise ValueError(f"Unsupported auth type: {auth_type}")
+
+        if default_headers:
+            dict_.update(default_headers)
+        return dict_

lionagi/service/connections/match_endpoint.py

@@ -0,0 +1,49 @@
+# Copyright (c) 2023 - 2025, HaiyangLi <quantocean.li at gmail dot com>
+#
+# SPDX-License-Identifier: Apache-2.0
+
+from .endpoint import Endpoint
+
+
+def match_endpoint(
+    provider: str,
+    endpoint: str,
+    **kwargs,
+) -> Endpoint:
+    if provider == "openai":
+        if "chat" in endpoint:
+            from .providers.oai_ import OpenaiChatEndpoint
+
+            return OpenaiChatEndpoint(**kwargs)
+        if "response" in endpoint:
+            from .providers.oai_ import OpenaiResponseEndpoint
+
+            return OpenaiResponseEndpoint(**kwargs)
+    if provider == "openrouter" and "chat" in endpoint:
+        from .providers.oai_ import OpenrouterChatEndpoint
+
+        return OpenrouterChatEndpoint(**kwargs)
+    if provider == "ollama" and "chat" in endpoint:
+        from .providers.ollama_ import OllamaChatEndpoint
+
+        return OllamaChatEndpoint(**kwargs)
+    if provider == "exa" and "search" in endpoint:
+        from .providers.exa_ import ExaSearchEndpoint
+
+        return ExaSearchEndpoint(**kwargs)
+    if provider == "anthropic" and (
+        "messages" in endpoint or "chat" in endpoint
+    ):
+        from .providers.anthropic_ import AnthropicMessagesEndpoint
+
+        return AnthropicMessagesEndpoint(**kwargs)
+    if provider == "groq" and "chat" in endpoint:
+        from .providers.oai_ import GroqChatEndpoint
+
+        return GroqChatEndpoint(**kwargs)
+    if provider == "perplexity" and "chat" in endpoint:
+        from .providers.perplexity_ import PerplexityChatEndpoint
+
+        return PerplexityChatEndpoint(**kwargs)
+
+    return None

lionagi/service/connections/providers/__init__.py

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

lionagi/service/connections/providers/anthropic_.py

@@ -0,0 +1,87 @@
+# Copyright (c) 2025, HaiyangLi <quantocean.li at gmail dot com>
+#
+# SPDX-License-Identifier: Apache-2.0
+
+from pydantic import BaseModel
+
+from lionagi.config import settings
+from lionagi.service.connections.endpoint import Endpoint
+from lionagi.service.connections.endpoint_config import EndpointConfig
+from lionagi.service.third_party.anthropic_models import CreateMessageRequest
+
+ANTHROPIC_MESSAGES_ENDPOINT_CONFIG = EndpointConfig(
+    name="anthropic_messages",
+    provider="anthropic",
+    base_url="https://api.anthropic.com/v1",
+    endpoint="messages",
+    method="POST",
+    openai_compatible=False,
+    auth_type="x-api-key",
+    default_headers={"anthropic-version": "2023-06-01"},
+    api_key=settings.ANTHROPIC_API_KEY or "dummy-key-for-testing",
+    request_options=CreateMessageRequest,
+)
+
+
+class AnthropicMessagesEndpoint(Endpoint):
+    def __init__(
+        self,
+        config: EndpointConfig = ANTHROPIC_MESSAGES_ENDPOINT_CONFIG,
+        **kwargs,
+    ):
+        super().__init__(config, **kwargs)
+
+    def create_payload(
+        self,
+        request: dict | BaseModel,
+        extra_headers: dict | None = None,
+        **kwargs,
+    ):
+        # Extract system message before validation if present
+        request_dict = (
+            request if isinstance(request, dict) else request.model_dump()
+        )
+        system = None
+
+        if "messages" in request_dict and request_dict["messages"]:
+            first_message = request_dict["messages"][0]
+            if first_message.get("role") == "system":
+                system = first_message["content"]
+                # Remove system message before validation
+                request_dict["messages"] = request_dict["messages"][1:]
+                request = request_dict
+
+        payload, headers = super().create_payload(
+            request, extra_headers=extra_headers, **kwargs
+        )
+
+        # Remove api_key from payload if present
+        payload.pop("api_key", None)
+
+        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
+                )
+
+        # If we extracted a system message earlier, add it to payload
+        if system:
+            system = [{"type": "text", "text": system}]
+            payload["system"] = system
+
+        return (payload, headers)

lionagi/service/connections/providers/exa_.py

@@ -0,0 +1,33 @@
+# Copyright (c) 2025, HaiyangLi <quantocean.li at gmail dot com>
+#
+# SPDX-License-Identifier: Apache-2.0
+
+from __future__ import annotations
+
+from lionagi.config import settings
+from lionagi.service.connections.endpoint import Endpoint
+from lionagi.service.connections.endpoint_config import EndpointConfig
+from lionagi.service.third_party.exa_models import ExaSearchRequest
+
+__all__ = ("ExaSearchEndpoint",)
+
+
+ENDPOINT_CONFIG = EndpointConfig(
+    name="exa_search",
+    provider="exa",
+    base_url="https://api.exa.ai",
+    endpoint="search",
+    method="POST",
+    request_options=ExaSearchRequest,
+    api_key=settings.EXA_API_KEY or "dummy-key-for-testing",
+    timeout=120,
+    max_retries=3,
+    auth_type="x-api-key",
+    transport_type="http",
+    content_type="application/json",
+)
+
+
+class ExaSearchEndpoint(Endpoint):
+    def __init__(self, config=ENDPOINT_CONFIG, **kwargs):
+        super().__init__(config=config, **kwargs)

lionagi/service/connections/providers/oai_.py

@@ -0,0 +1,166 @@
+# Copyright (c) 2025, HaiyangLi <quantocean.li at gmail dot com>
+#
+# SPDX-License-Identifier: Apache-2.0
+
+from pydantic import BaseModel
+
+from lionagi.config import settings
+from lionagi.service.connections.endpoint import Endpoint
+from lionagi.service.connections.endpoint_config import EndpointConfig
+from lionagi.service.third_party.openai_models import (
+    CreateChatCompletionRequest,
+    CreateResponse,
+)
+
+__all__ = (
+    "OpenaiChatEndpoint",
+    "OpenaiResponseEndpoint",
+    "OpenrouterChatEndpoint",
+    "OPENROUTER_GEMINI_ENDPOINT_CONFIG",
+)
+
+
+OPENAI_CHAT_ENDPOINT_CONFIG = EndpointConfig(
+    name="openai_chat",
+    provider="openai",
+    base_url="https://api.openai.com/v1",
+    endpoint="chat/completions",
+    kwargs={"model": "gpt-4o"},
+    api_key=settings.OPENAI_API_KEY or "dummy-key-for-testing",
+    auth_type="bearer",
+    content_type="application/json",
+    method="POST",
+    requires_tokens=True,
+    request_options=CreateChatCompletionRequest,
+)
+
+OPENAI_RESPONSE_ENDPOINT_CONFIG = EndpointConfig(
+    name="openai_response",
+    provider="openai",
+    base_url="https://api.openai.com/v1",
+    endpoint="chat/completions",  # OpenAI responses API uses same endpoint
+    kwargs={"model": "gpt-4o"},
+    api_key=settings.OPENAI_API_KEY or "dummy-key-for-testing",
+    auth_type="bearer",
+    content_type="application/json",
+    method="POST",
+    requires_tokens=True,
+    request_options=CreateResponse,
+)
+
+OPENROUTER_CHAT_ENDPOINT_CONFIG = EndpointConfig(
+    name="openrouter_chat",
+    provider="openrouter",
+    base_url="https://openrouter.ai/api/v1",
+    endpoint="chat/completions",
+    kwargs={"model": "google/gemini-2.5-flash-preview-05-20"},
+    api_key=settings.OPENROUTER_API_KEY or "dummy-key-for-testing",
+    auth_type="bearer",
+    content_type="application/json",
+    method="POST",
+    request_options=CreateChatCompletionRequest,
+)
+
+OPENROUTER_GEMINI_ENDPOINT_CONFIG = EndpointConfig(
+    name="openrouter_gemini",
+    provider="openrouter",
+    base_url="https://openrouter.ai/api/v1",
+    endpoint="chat/completions",
+    kwargs={"model": "google/gemini-2.5-flash-preview-05-20"},
+    api_key=settings.OPENROUTER_API_KEY or "dummy-key-for-testing",
+    auth_type="bearer",
+    content_type="application/json",
+    method="POST",
+)
+
+OPENAI_EMBEDDING_ENDPOINT_CONFIG = EndpointConfig(
+    name="openai_embed",
+    provider="openai",
+    base_url="https://api.openai.com/v1",
+    endpoint="embeddings",
+    kwargs={"model": "text-embedding-3-small"},
+    api_key=settings.OPENAI_API_KEY or "dummy-key-for-testing",
+    auth_type="bearer",
+    content_type="application/json",
+    method="POST",
+)
+
+GROQ_CHAT_ENDPOINT_CONFIG = EndpointConfig(
+    name="groq_chat",
+    provider="groq",
+    base_url="https://api.groq.com/openai/v1",
+    endpoint="chat/completions",
+    api_key=settings.GROQ_API_KEY or "dummy-key-for-testing",
+    auth_type="bearer",
+    content_type="application/json",
+    method="POST",
+)
+
+
+REASONING_MODELS = (
+    "o3-mini-2025-01-31",
+    "o3-mini",
+    "o1",
+    "o1-2024-12-17",
+)
+
+REASONING_NOT_SUPPORT_PARAMS = (
+    "temperature",
+    "top_p",
+    "logit_bias",
+    "logprobs",
+    "top_logprobs",
+)
+
+
+class OpenaiChatEndpoint(Endpoint):
+    def __init__(self, config=OPENAI_CHAT_ENDPOINT_CONFIG, **kwargs):
+        super().__init__(config, **kwargs)
+
+    def create_payload(
+        self,
+        request: dict | BaseModel,
+        extra_headers: dict | None = None,
+        **kwargs,
+    ):
+        """Override to handle model-specific parameter filtering."""
+        payload, headers = super().create_payload(
+            request, extra_headers, **kwargs
+        )
+
+        # Handle reasoning models
+        model = payload.get("model")
+        if model in REASONING_MODELS:
+            # Remove unsupported parameters for reasoning models
+            for param in REASONING_NOT_SUPPORT_PARAMS:
+                payload.pop(param, None)
+
+            # Convert system role to developer role for reasoning models
+            if "messages" in payload and payload["messages"]:
+                if payload["messages"][0].get("role") == "system":
+                    payload["messages"][0]["role"] = "developer"
+        else:
+            # Remove reasoning_effort for non-reasoning models
+            payload.pop("reasoning_effort", None)
+
+        return (payload, headers)
+
+
+class OpenaiResponseEndpoint(Endpoint):
+    def __init__(self, config=OPENAI_RESPONSE_ENDPOINT_CONFIG, **kwargs):
+        super().__init__(config, **kwargs)
+
+
+class OpenrouterChatEndpoint(Endpoint):
+    def __init__(self, config=OPENROUTER_CHAT_ENDPOINT_CONFIG, **kwargs):
+        super().__init__(config, **kwargs)
+
+
+class GroqChatEndpoint(Endpoint):
+    def __init__(self, config=GROQ_CHAT_ENDPOINT_CONFIG, **kwargs):
+        super().__init__(config, **kwargs)
+
+
+class OpenaiEmbedEndpoint(Endpoint):
+    def __init__(self, config=OPENAI_EMBEDDING_ENDPOINT_CONFIG, **kwargs):
+        super().__init__(config, **kwargs)

lionagi/service/connections/providers/ollama_.py

@@ -0,0 +1,122 @@
+# Copyright (c) 2025, HaiyangLi <quantocean.li at gmail dot com>
+#
+# SPDX-License-Identifier: Apache-2.0
+
+from pydantic import BaseModel
+
+from lionagi.service.connections.endpoint import Endpoint
+from lionagi.service.connections.endpoint_config import EndpointConfig
+from lionagi.service.third_party.openai_models import (
+    CreateChatCompletionRequest,
+)
+from lionagi.utils import is_import_installed
+
+_HAS_OLLAMA = is_import_installed("ollama")
+
+OLLAMA_CHAT_ENDPOINT_CONFIG = EndpointConfig(
+    name="ollama_chat",
+    provider="ollama",
+    base_url="http://localhost:11434/v1",  # Ollama desktop client default
+    endpoint="chat/completions",  # Use full OpenAI-compatible endpoint
+    kwargs={},  # Empty kwargs, model will be provided at runtime
+    openai_compatible=False,  # Use HTTP transport
+    api_key=None,  # No API key needed
+    method="POST",
+    content_type="application/json",
+    auth_type="none",  # No authentication
+    default_headers={},  # No auth headers needed
+    request_options=CreateChatCompletionRequest,  # Use Pydantic model for validation
+)
+
+
+class OllamaChatEndpoint(Endpoint):
+    """
+    Documentation: https://platform.openai.com/docs/api-reference/chat/create
+    """
+
+    def __init__(self, config=OLLAMA_CHAT_ENDPOINT_CONFIG, **kwargs):
+        if not _HAS_OLLAMA:
+            raise ModuleNotFoundError(
+                "ollama is not installed, please install it with `pip install lionagi[ollama]`"
+            )
+
+        # Override api_key for Ollama (not needed)
+        if "api_key" in kwargs:
+            kwargs.pop("api_key")
+
+        super().__init__(config, **kwargs)
+
+        from ollama import list as ollama_list  # type: ignore[import]
+        from ollama import pull as ollama_pull  # type: ignore[import]
+
+        self._pull = ollama_pull
+        self._list = ollama_list
+
+    def create_payload(
+        self,
+        request: dict | BaseModel,
+        extra_headers: dict | None = None,
+        **kwargs,
+    ):
+        """Override to handle Ollama-specific needs."""
+        payload, headers = super().create_payload(
+            request, extra_headers, **kwargs
+        )
+
+        # Ollama doesn't support reasoning_effort
+        payload.pop("reasoning_effort", None)
+
+        return (payload, headers)
+
+    async def call(
+        self, request: dict | BaseModel, cache_control: bool = False, **kwargs
+    ):
+        payload, _ = self.create_payload(request, **kwargs)
+
+        # Check if model exists and pull if needed
+        model = payload["model"]
+        self._check_model(model)
+
+        # The parent call method will handle headers internally
+        return await super().call(
+            payload, cache_control=cache_control, **kwargs
+        )
+
+    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 _check_model(self, model: str):
+        try:
+            available_models = [i.model for i in self._list().models]
+
+            if model not in available_models:
+                print(
+                    f"Model '{model}' not found locally. Pulling from Ollama registry..."
+                )
+                self._pull_model(model)
+                print(f"Model '{model}' successfully pulled.")
+        except Exception as e:
+            print(f"Warning: Could not check/pull model '{model}': {e}")

lionagi/service/connections/providers/perplexity_.py

@@ -0,0 +1,29 @@
+# Copyright (c) 2025, HaiyangLi <quantocean.li at gmail dot com>
+#
+# SPDX-License-Identifier: Apache-2.0
+
+from lionagi.config import settings
+from lionagi.service.connections.endpoint import Endpoint
+from lionagi.service.connections.endpoint_config import EndpointConfig
+from lionagi.service.third_party.pplx_models import PerplexityChatRequest
+
+__all__ = ("PerplexityChatEndpoint",)
+
+
+ENDPOINT_CONFIG = EndpointConfig(
+    name="perplexity_chat",
+    provider="perplexity",
+    base_url="https://api.perplexity.ai",
+    endpoint="chat/completions",
+    method="POST",
+    kwargs={"model": "sonar"},
+    api_key=settings.PERPLEXITY_API_KEY or "dummy-key-for-testing",
+    auth_type="bearer",
+    content_type="application/json",
+    request_options=PerplexityChatRequest,
+)
+
+
+class PerplexityChatEndpoint(Endpoint):
+    def __init__(self, config=ENDPOINT_CONFIG, **kwargs):
+        super().__init__(config, **kwargs)