lionagi 0.12.3__py3-none-any.whl → 0.12.5__py3-none-any.whl

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)