agenta 0.36.5__py3-none-any.whl → 0.37.0__py3-none-any.whl

agenta/sdk/managers/secrets.py

@@ -1,13 +1,13 @@
-from typing import Optional, Dict, Any
+import re
+from typing import Optional, Dict, Any, List
 
 from agenta.sdk.context.routing import routing_context
-
-from agenta.sdk.assets import model_to_provider_mapping
+from agenta.sdk.assets import model_to_provider_mapping as _standard_providers
 
 
 class SecretsManager:
     @staticmethod
-    def get_from_route() -> Optional[Dict[str, Any]]:
+    def get_from_route() -> Optional[List[Dict[str, Any]]]:
         context = routing_context.get()
 
         secrets = context.secrets
@@ -18,21 +18,185 @@ class SecretsManager:
         return secrets
 
     @staticmethod
-    def get_api_key_for_model(model: str) -> str:
-        secrets = SecretsManager.get_from_route()
+    def _parse_standard_secrets(
+        secret: Dict[str, Any], standard_secrets: List[Dict[str, Any]]
+    ):
+        standard_secrets.append(
+            {
+                "kind": secret.get("kind", ""),
+                "data": secret.get("data", {}),
+            }
+        )
+
+    @staticmethod
+    def _parse_custom_secrets(
+        secret: Dict[str, Any],
+        custom_secrets: List[Dict[str, Any]],
+    ):
+        data = secret.get("data", {})
+        custom_secrets.append(
+            {
+                "kind": secret.get("kind", ""),
+                "data": {
+                    "provider_slug": data.get("provider_slug"),
+                    "provider": {
+                        "kind": data.get("kind", ""),
+                        "extras": (
+                            {
+                                **data["provider"]["extras"],
+                                "api_base": data["provider"]["url"],
+                                "api_version": data["provider"].get("version"),
+                            }
+                            if all(
+                                k in data.get("provider", {}) for k in ["extras", "url"]
+                            )
+                            else data.get("provider", {}).get("extras", {})
+                        ),
+                    },
+                    "models": data.get("model_keys", []),
+                },
+            }
+        )
+
+    @staticmethod
+    def _parse_secrets(secrets: List[Dict[str, Any]]) -> List[Dict[str, Any]]:
+        standard_secrets: List[dict] = []
+        custom_secrets: List[dict] = []
+
+        for secret in secrets:
+            if secret.get("kind") == "provider_key":
+                SecretsManager._parse_standard_secrets(
+                    secret=secret,
+                    standard_secrets=standard_secrets,
+                )  # append secret to standard_secrets
+            elif secret.get("kind") == "custom_provider":
+                SecretsManager._parse_custom_secrets(
+                    secret=secret,
+                    custom_secrets=custom_secrets,
+                )  # append secret to custom_secrets
+
+        secrets = standard_secrets + custom_secrets
+
+        return secrets
+
+    @staticmethod
+    def _custom_provider_get_value(
+        *, model: str, secrets: list[dict], key: str, from_provider: bool = True
+    ):
+        for secret in secrets:
+            models = secret.get("data", {}).get("models", [])
+            if model in models:
+                if from_provider:
+                    return secret.get("data", {}).get("provider", {}).get(key)
+                return secret.get("data", {}).get(key)
+        return None
+
+    @staticmethod
+    def _custom_providers_get(*, model: str, secrets: list[dict]):
+        return SecretsManager._custom_provider_get_value(
+            model=model, secrets=secrets, key="kind", from_provider=True
+        )
+
+    @staticmethod
+    def _custom_provider_slug_get(*, model: str, secrets: list[dict]):
+        return SecretsManager._custom_provider_get_value(
+            model=model, secrets=secrets, key="provider_slug", from_provider=False
+        )
 
+    @staticmethod
+    def _get_compatible_model(*, model: str, provider_slug: str):
+        """Return the model string used by litellm.
+
+        Args:
+            model (str): The complete model string (e.g. `mybedrock/bedrock/model_name`).
+                         In the format provider_slug/kind/model_name (See SecretResponseDTO)
+            provider_slug (str): The provider slug (e.g. `mybedrock`)
+
+        Returns:
+            str: The model string used by litellm
+        """
+        # First replace provider_slug/custom with openai.
+        # The reason is that custom providers are in fact openai compatible providers
+        # They need to be passed in litellm as openai/modelname
+
+        if "custom" in model:
+            modified_model = model.replace(f"{provider_slug}/custom/", "openai/")
+            return modified_model.replace(f"{provider_slug}/", "")
+
+        return model.replace(f"{provider_slug}/", "")
+
+    @staticmethod
+    def get_provider_settings(model: str) -> Optional[Dict]:
+        """
+        Builds the LLM request with appropriate kwargs based on the custom provider/model
+
+        Args:
+            model (str): The name of the model
+
+        Returns:
+            Dict: A dictionary containing all parameters needed for litellm.completion
+        """
+
+        # STEP 1: get vault secrets from route context and transform it
+        secrets = SecretsManager.get_from_route()
         if not secrets:
             return None
 
-        provider = model_to_provider_mapping.get(model)
+        # STEP 1b: Parse secrets into usable format
+        secrets = SecretsManager._parse_secrets(secrets=secrets)
+
+        # STEP 2: check model exists in supported standard models
+        provider = _standard_providers.get(model)
+        if not provider:
+            # check and get provider kind if model exists in custom provider models
+            provider = SecretsManager._custom_providers_get(
+                model=model,
+                secrets=secrets,
+            )
 
+        # STEP 2b: return None in the case provider is None
         if not provider:
             return None
 
-        provider = provider.lower().replace(" ", "")
+        # STEP 2c: get litellm compatible model
+        provider_slug = SecretsManager._custom_provider_slug_get(
+            model=model, secrets=secrets
+        )
+        model = SecretsManager._get_compatible_model(
+            model=model, provider_slug=provider_slug
+        )
 
+        # STEP 3: initialize provider settings and simplify provider name
+        provider_settings = {"model": model}
+        provider_name = re.sub(
+            r"[\s-]+", "", provider.lower()
+        )  # normalizing other special characters too (azure-openai)
+
+        # STEP 4: get credentials for model
         for secret in secrets:
-            if secret["data"]["provider"] == provider:
-                return secret["data"]["key"]
+            secret_data = secret.get("data", {})
+            provider_info = secret_data.get("provider", {})
 
-        return None
+            # i). Extract API key if present
+            # (for standard models -- openai/anthropic/gemini, etc)
+            if secret.get("kind") == "provider_key":
+                provider_kind = secret_data.get("kind", "")
+
+                if provider_kind == provider_name:
+                    if "key" in provider_info:
+                        provider_settings["api_key"] = provider_info["key"]
+                continue
+
+            # ii). Extract Credentials if present
+            # (for custom providers -- aws bedrock/sagemaker, vertexai, etc)
+            elif secret.get("kind") == "custom_provider":
+                provider_kind = provider_info.get("kind", "").lower().replace(" ", "")
+                provider_slug = secret_data.get("provider_slug", "")
+                provider_extras = provider_info.get("extras", {})
+
+                if provider_kind == provider_name or provider_slug == provider_name:
+                    if provider_extras:
+                        provider_settings.update(provider_extras)
+                continue
+
+        return provider_settings

agenta/sdk/managers/shared.py

@@ -7,9 +7,9 @@ from agenta.sdk.types import (
     ConfigurationResponse,
     DeploymentResponse,
 )
-from agenta.client.types.config_dto import ConfigDto as ConfigRequest
-from agenta.client.types.config_response_model import ConfigResponseModel
-from agenta.client.types.reference_request_model import ReferenceRequestModel
+from agenta.client.backend.types.config_dto import ConfigDto as ConfigRequest
+from agenta.client.backend.types.config_response_model import ConfigResponseModel
+from agenta.client.backend.types.reference_request_model import ReferenceRequestModel
 
 import agenta as ag
 

agenta/sdk/middleware/vault.py

@@ -7,22 +7,23 @@ from fastapi import FastAPI, Request
 from starlette.middleware.base import BaseHTTPMiddleware
 
 from agenta.sdk.utils.constants import TRUTHY
-from agenta.client.types.provider_kind import ProviderKind
+from agenta.sdk.utils.cache import TTLLRUCache
 from agenta.sdk.utils.exceptions import suppress, display_exception
-from agenta.client.types.secret_dto import SecretDto as SecretDTO
-from agenta.client.types.provider_key_dto import (
-    ProviderKeyDto as ProviderKeyDTO,
+from agenta.client.backend.types import SecretDto as SecretDTO
+from agenta.client.backend.types import (
+    StandardProviderKind,
+    StandardProviderDto as StandardProviderDTO,
+    StandardProviderSettingsDto as StandardProviderSettingsDTO,
 )
-from agenta.sdk.utils.cache import TTLLRUCache
 
 import agenta as ag
 
 
 _PROVIDER_KINDS = []
 
-for arg in ProviderKind.__args__:  # type: ignore
-    if hasattr(arg, "__args__"):
-        _PROVIDER_KINDS.extend(arg.__args__)
+for provider_kind in StandardProviderKind.__args__[0].__args__:  # type: ignore
+    if hasattr(provider_kind, "__args__"):
+        _PROVIDER_KINDS.extend(provider_kind.__args__)
 
 _CACHE_ENABLED = getenv("AGENTA_MIDDLEWARE_CACHE_ENABLED", "false").lower() in TRUTHY
 
@@ -35,18 +36,6 @@ class VaultMiddleware(BaseHTTPMiddleware):
 
         self.host = ag.DEFAULT_AGENTA_SINGLETON_INSTANCE.host
 
-    def _transform_secrets_response_to_secret_dto(
-        self, secrets_list: List[Dict[str, Any]]
-    ) -> List[Dict[str, Any]]:
-        secrets_dto_dict = [
-            {
-                "kind": secret.get("secret", {}).get("kind"),
-                "data": secret.get("secret", {}).get("data", {}),
-            }
-            for secret in secrets_list
-        ]
-        return secrets_dto_dict
-
     async def dispatch(
         self,
         request: Request,
@@ -83,7 +72,7 @@ class VaultMiddleware(BaseHTTPMiddleware):
 
                 return secrets
 
-        local_secrets: List[SecretDTO] = []
+        local_secrets: List[Dict[str, Any]] = []
 
         try:
             for provider_kind in _PROVIDER_KINDS:
@@ -95,18 +84,18 @@ class VaultMiddleware(BaseHTTPMiddleware):
                     continue
 
                 secret = SecretDTO(
-                    # kind=...  # defaults to 'provider_kind'
-                    data=ProviderKeyDTO(
-                        provider=provider,
-                        key=key,
+                    kind="provider_kind",  # type: ignore
+                    data=StandardProviderDTO(
+                        kind=provider,
+                        provider=StandardProviderSettingsDTO(key=key),
                     ),
                 )
 
-                local_secrets.append(secret.model_dump())  # type: ignore
+                local_secrets.append(secret.model_dump())
         except:  # pylint: disable=bare-except
             display_exception("Vault: Local Secrets Exception")
 
-        vault_secrets: List[SecretDTO] = []
+        vault_secrets: List[Dict[str, Any]] = []
 
         try:
             async with httpx.AsyncClient() as client:
@@ -119,26 +108,29 @@ class VaultMiddleware(BaseHTTPMiddleware):
                     vault_secrets = []
 
                 else:
-                    secrets = response.json()
-                    vault_secrets = self._transform_secrets_response_to_secret_dto(
-                        secrets_list=secrets  # type: ignore
-                    )
+                    vault_secrets = response.json()
         except:  # pylint: disable=bare-except
             display_exception("Vault: Vault Secrets Exception")
 
-        merged_secrets = {}
+        secrets = local_secrets + vault_secrets
+
+        standard_secrets = {}
+        custom_secrets = []
 
         if local_secrets:
             for secret in local_secrets:
-                provider = secret["data"]["provider"]  # type: ignore
-                merged_secrets[provider] = secret
+                standard_secrets[secret["data"]["kind"]] = secret  # type: ignore
 
         if vault_secrets:
             for secret in vault_secrets:
-                provider = secret["data"]["provider"]  # type: ignore
-                merged_secrets[provider] = secret
+                if secret["kind"] == "provider_key":  # type: ignore
+                    standard_secrets[secret["data"]["kind"]] = secret  # type: ignore
+                elif secret["kind"] == "custom_provider":  # type: ignore
+                    custom_secrets.append(secret)
+
+        standard_secrets = list(standard_secrets.values())
 
-        secrets = list(merged_secrets.values())
+        secrets = standard_secrets + custom_secrets
 
         _cache.put(_hash, {"secrets": secrets})
 

agenta/sdk/types.py

@@ -1,14 +1,12 @@
 import json
 from dataclasses import dataclass
-from typing import Dict, List, Optional, Any, Union
+from typing import List, Union, Optional, Dict, Literal, Any
 
 from pydantic import ConfigDict, BaseModel, HttpUrl
-
-from agenta.client.types.agenta_node_dto import AgentaNodeDto
-from agenta.client.types.agenta_nodes_response import AgentaNodesResponse
-from typing import Annotated, List, Union, Optional, Dict, Literal, Any
 from pydantic import BaseModel, Field, model_validator
+
 from agenta.sdk.assets import supported_llm_models
+from agenta.client.backend.types import AgentaNodesResponse, AgentaNodeDto
 
 
 @dataclass
@@ -543,8 +541,7 @@ class PromptTemplate(BaseModel):
     def to_openai_kwargs(self) -> dict:
         """Convert the prompt template to kwargs compatible with litellm/openai"""
         kwargs = {
-            "model": self.llm_config.model,
-            "messages": [msg.dict(exclude_none=True) for msg in self.messages],
+            "messages": [msg.model_dump(exclude_none=True) for msg in self.messages],
         }
 
         # Add optional parameters only if they are set

{agenta-0.36.5.dist-info → agenta-0.37.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: agenta
-Version: 0.36.5
+Version: 0.37.0
 Summary: The SDK for agenta is an open-source LLMOps platform.
 Keywords: LLMOps,LLM,evaluation,prompt engineering
 Author: Mahmoud Mabrouk
@@ -15,20 +15,16 @@ Classifier: Programming Language :: Python :: 3.11
 Classifier: Programming Language :: Python :: 3.12
 Classifier: Programming Language :: Python :: 3.13
 Classifier: Topic :: Software Development :: Libraries
-Requires-Dist: cachetools (>=5.3.3,<6.0.0)
-Requires-Dist: docker (>=6.1.1,<8.0.0)
 Requires-Dist: fastapi (>=0.100.0)
 Requires-Dist: httpx (>=0.24,<0.28)
 Requires-Dist: importlib-metadata (>=8.0.0,<9.0)
 Requires-Dist: litellm (>=1.48.0,<2.0.0)
 Requires-Dist: opentelemetry-api (==1.27.0)
-Requires-Dist: opentelemetry-exporter-otlp (==1.27.0)
+Requires-Dist: opentelemetry-exporter-otlp-proto-http (==1.27.0)
 Requires-Dist: opentelemetry-sdk (==1.27.0)
-Requires-Dist: posthog (>=3.1.0,<4.0.0)
 Requires-Dist: pydantic (>=2)
 Requires-Dist: python-dotenv (>=1.0.0,<2.0.0)
 Requires-Dist: pyyaml (>=6.0.2,<7.0.0)
-Requires-Dist: questionary (>=1.10,<3.0)
 Requires-Dist: toml (>=0.10.2,<0.11.0)
 Project-URL: Documentation, https://docs.agenta.ai
 Project-URL: Homepage, https://agenta.ai