agenta 0.33.0a1__py3-none-any.whl → 0.33.0a3__py3-none-any.whl

agenta/sdk/decorators/routing.py

@@ -1,4 +1,3 @@
-from sre_parse import NOT_LITERAL_UNI_IGNORE
 from typing import Type, Any, Callable, Dict, Optional, Tuple, List
 from inspect import signature, iscoroutinefunction, Signature, Parameter
 from functools import wraps
@@ -6,6 +5,7 @@ from traceback import format_exception
 from asyncio import sleep
 from uuid import UUID
 from pydantic import BaseModel, HttpUrl, ValidationError
+from os import environ
 
 from fastapi import Body, FastAPI, HTTPException, Request
 
@@ -38,12 +38,18 @@ from agenta.sdk.types import (
 
 import agenta as ag
 
-
-app = FastAPI()
 log.setLevel("DEBUG")
 
+AGENTA_RUNTIME_PREFIX = environ.get("AGENTA_RUNTIME_PREFIX", "")
+
+app = FastAPI(
+    docs_url=f"{AGENTA_RUNTIME_PREFIX}/docs",  # Swagger UI
+    openapi_url=f"{AGENTA_RUNTIME_PREFIX}/openapi.json",  # OpenAPI schema
+)
+
+app.include_router(router, prefix=AGENTA_RUNTIME_PREFIX)
 
-app.include_router(router, prefix="")
+log.error("Agenta - Runtime Prefix:" + AGENTA_RUNTIME_PREFIX)
 
 
 class PathValidator(BaseModel):
@@ -114,13 +120,13 @@ class entrypoint:
     routes = list()
 
     _middleware = False
-    _run_path = "/run"
-    _test_path = "/test"
+    _run_path = f"{AGENTA_RUNTIME_PREFIX}/run"
+    _test_path = f"{AGENTA_RUNTIME_PREFIX}/test"
     _config_key = "ag_config"
     # LEGACY
-    _legacy_playground_run_path = "/playground/run"
-    _legacy_generate_path = "/generate"
-    _legacy_generate_deployed_path = "/generate_deployed"
+    _legacy_playground_run_path = f"{AGENTA_RUNTIME_PREFIX}/playground/run"
+    _legacy_generate_path = f"{AGENTA_RUNTIME_PREFIX}/generate"
+    _legacy_generate_deployed_path = f"{AGENTA_RUNTIME_PREFIX}/generate_deployed"
 
     def __init__(
         self,
@@ -269,17 +275,18 @@ class entrypoint:
             )
         # LEGACY
 
-        app.openapi_schema = None  # Forces FastAPI to re-generate the schema
-        openapi_schema = app.openapi()
-        openapi_schema["agenta_sdk"] = {"version": get_current_version()}
+        openapi_schema = self.openapi()
+
         for _route in entrypoint.routes:
             if _route["config"] is not None:
                 self.override_config_in_schema(
                     openapi_schema=openapi_schema,
                     func_name=_route["func"],
-                    endpoint=_route["endpoint"],
+                    endpoint=_route["endpoint"].replace(AGENTA_RUNTIME_PREFIX, ""),
                     config=_route["config"],
                 )
+
+        app.openapi_schema = openapi_schema
         ### --------------- #
 
     def parse_config(self) -> Tuple[Optional[Type[BaseModel]], Dict[str, Any]]:
@@ -566,6 +573,82 @@ class entrypoint:
                 )
             )
 
+    def openapi(self):
+        app.openapi_schema = None  # Forces FastAPI to re-generate the schema
+
+        openapi_schema = app.openapi()
+
+        # ✅ Fix paths by removing the prefix
+        updated_paths = {}
+        for path, methods in openapi_schema["paths"].items():
+            new_path = (
+                path[len(AGENTA_RUNTIME_PREFIX) :]
+                if path.startswith(AGENTA_RUNTIME_PREFIX)
+                else path
+            )
+            updated_paths[new_path] = methods
+        openapi_schema["paths"] = updated_paths  # Replace paths
+
+        # ✅ Fix schema names and update `$ref` references
+        if "components" in openapi_schema and "schemas" in openapi_schema["components"]:
+            updated_schemas = {}
+            schema_name_map = {}  # Map old schema names to new schema names
+
+            for schema_name, schema_value in openapi_schema["components"][
+                "schemas"
+            ].items():
+                if AGENTA_RUNTIME_PREFIX and AGENTA_RUNTIME_PREFIX != "":
+                    new_schema_name = schema_name.replace(
+                        AGENTA_RUNTIME_PREFIX.lstrip("/").replace("/", "_") + "_", ""
+                    ).strip("_")
+                else:
+                    new_schema_name = schema_name
+                updated_schemas[new_schema_name] = schema_value
+                schema_name_map[schema_name] = new_schema_name  # Store mapping
+
+            # ✅ Fix `$ref` references
+            for path, methods in updated_paths.items():
+                for method in methods.values():
+                    if "requestBody" in method and "content" in method["requestBody"]:
+                        for content_type, content in method["requestBody"][
+                            "content"
+                        ].items():
+                            if "$ref" in content["schema"]:
+                                old_ref = content["schema"]["$ref"]
+                                schema_name = old_ref.split("/")[
+                                    -1
+                                ]  # Extract schema name
+                                if schema_name in schema_name_map:
+                                    content["schema"][
+                                        "$ref"
+                                    ] = f"#/components/schemas/{schema_name_map[schema_name]}"
+
+                    if "responses" in method:
+                        for status_code, response in method["responses"].items():
+                            if "content" in response:
+                                for content_type, content in response[
+                                    "content"
+                                ].items():
+                                    if "$ref" in content["schema"]:
+                                        old_ref = content["schema"]["$ref"]
+                                        schema_name = old_ref.split("/")[
+                                            -1
+                                        ]  # Extract schema name
+                                        if schema_name in schema_name_map:
+                                            content["schema"][
+                                                "$ref"
+                                            ] = f"#/components/schemas/{schema_name_map[schema_name]}"
+
+            # ✅ Update OpenAPI schema with fixed schemas
+            openapi_schema["components"]["schemas"] = updated_schemas
+
+            # ✅ Add Agenta SDK version info
+            openapi_schema["agenta_sdk"] = {"version": get_current_version()}
+
+            print(openapi_schema)
+
+        return openapi_schema
+
     def override_config_in_schema(
         self,
         openapi_schema: dict,
@@ -575,6 +658,7 @@ class entrypoint:
     ):
         """Override config in OpenAPI schema to add agenta-specific metadata."""
         endpoint = endpoint[1:].replace("/", "_")
+
         schema_key = f"Body_{func_name}_{endpoint}_post"
         schema_to_override = openapi_schema["components"]["schemas"][schema_key]
 

agenta/sdk/managers/apps.py

@@ -0,0 +1,64 @@
+import logging
+
+from agenta.sdk.utils.exceptions import handle_exceptions
+
+import agenta as ag
+
+
+logger = logging.getLogger(__name__)
+
+
+class AppManager:
+    @classmethod
+    @handle_exceptions()
+    def create(cls, *, app_slug: str, template_key: str):
+        app_response = ag.api.apps.create_app(
+            app_name=app_slug, template_key=template_key
+        )
+        return app_response
+
+    @classmethod
+    @handle_exceptions()
+    async def acreate(cls, *, app_slug: str, template_key: str):
+        app_response = await ag.async_api.apps.create_app(
+            app_name=app_slug, template_key=template_key
+        )
+        return app_response
+
+    @classmethod
+    @handle_exceptions()
+    def list(cls):
+        apps_response = ag.api.apps.list_apps()
+        return apps_response
+
+    @classmethod
+    @handle_exceptions()
+    async def alist(cls):
+        apps_response = await ag.async_api.apps.list_apps()
+        return apps_response
+
+    @classmethod
+    @handle_exceptions()
+    def update(cls, *, app_id: str, app_slug: str):
+        app_response = ag.api.apps.update_app(app_id=app_id, app_name=app_slug)
+        return app_response
+
+    @classmethod
+    @handle_exceptions()
+    async def aupdate(cls, *, app_id: str, app_slug: str):
+        app_response = await ag.async_api.apps.update_app(
+            app_id=app_id, app_name=app_slug
+        )
+        return app_response
+
+    @classmethod
+    @handle_exceptions()
+    def delete(cls, *, app_id: str):
+        ag.api.apps.remove_app(app_id=app_id)
+        return None
+
+    @classmethod
+    @handle_exceptions()
+    async def adelete(cls, *, app_id: str):
+        await ag.async_api.apps.remove_app(app_id=app_id)
+        return None

agenta/sdk/managers/shared.py

@@ -505,12 +505,12 @@ class SharedManager:
                     slug=variant_slug,
                     version=None,
                     id=None,
-                ),
+                ).model_dump(),
                 application_ref=SharedManager._ref_or_none(  # type: ignore  # type: ignore
                     slug=app_slug,
                     version=None,
                     id=app_id,
-                ),
+                ).model_dump(),
             )
         )
 

agenta/sdk/middleware/auth.py

@@ -11,16 +11,16 @@ from fastapi.responses import JSONResponse
 from agenta.sdk.middleware.cache import TTLLRUCache, CACHE_CAPACITY, CACHE_TTL
 from agenta.sdk.utils.constants import TRUTHY
 from agenta.sdk.utils.exceptions import display_exception
+from agenta.sdk.utils.logging import log
 
 import agenta as ag
 
+AGENTA_RUNTIME_PREFIX = getenv("AGENTA_RUNTIME_PREFIX", "")
 
-_SHARED_SERVICE = getenv("AGENTA_SHARED_SERVICE", "false").lower() in TRUTHY
-_CACHE_ENABLED = getenv("AGENTA_MIDDLEWARE_CACHE_ENABLED", "true").lower() in TRUTHY
-_UNAUTHORIZED_ALLOWED = (
-    getenv("AGENTA_UNAUTHORIZED_EXECUTION_ALLOWED", "false").lower() in TRUTHY
-)
-_ALWAYS_ALLOW_LIST = ["/health"]
+
+_CACHE_ENABLED = getenv("AGENTA_MIDDLEWARE_CACHE_ENABLED", "false").lower() in TRUTHY
+
+_ALWAYS_ALLOW_LIST = [f"{AGENTA_RUNTIME_PREFIX}/health"]
 
 _cache = TTLLRUCache(capacity=CACHE_CAPACITY, ttl=CACHE_TTL)
 
@@ -54,15 +54,49 @@ class AuthMiddleware(BaseHTTPMiddleware):
         super().__init__(app)
 
         self.host = ag.DEFAULT_AGENTA_SINGLETON_INSTANCE.host
-        self.resource_id = (
-            ag.DEFAULT_AGENTA_SINGLETON_INSTANCE.service_id
-            if not _SHARED_SERVICE
-            else None
-        )
+        self.resource_id = ag.DEFAULT_AGENTA_SINGLETON_INSTANCE.service_id
 
     async def dispatch(self, request: Request, call_next: Callable):
+        # Extract request details
+        host = request.client.host if request.client else "unknown"
+        path = request.url.path
+        query = dict(request.query_params)
+        headers = dict(request.headers)
+
+        import logging
+        import json
+
+        # Log the request details
+        logging.error(
+            json.dumps(
+                {
+                    "host": host,
+                    "method": request.method,
+                    "path": path,
+                    "query_params": query,
+                    "headers": headers,
+                },
+                indent=2,
+                ensure_ascii=False,
+            )
+        )
+
+        print(
+            json.dumps(
+                {
+                    "host": host,
+                    "method": request.method,
+                    "path": path,
+                    "query_params": query,
+                    "headers": headers,
+                },
+                indent=2,
+                ensure_ascii=False,
+            )
+        )
+
         try:
-            if _UNAUTHORIZED_ALLOWED or request.url.path in _ALWAYS_ALLOW_LIST:
+            if request.url.path in _ALWAYS_ALLOW_LIST:
                 request.state.auth = {}
 
             else:
@@ -98,11 +132,10 @@ class AuthMiddleware(BaseHTTPMiddleware):
 
             cookies = {"sAccessToken": access_token} if access_token else None
 
-            baggage = (
-                getattr(request.state.otel, "baggage")
-                if hasattr(request.state, "otel")
-                else {}
-            )
+            if not headers and not cookies:
+                log.debug("No auth header nor auth cookie found in the request")
+
+            baggage = request.state.otel["baggage"]
 
             project_id = (
                 # CLEANEST
@@ -111,6 +144,9 @@ class AuthMiddleware(BaseHTTPMiddleware):
                 or request.query_params.get("project_id")
             )
 
+            if not project_id:
+                log.debug("No project ID found in request")
+
             params = {"action": "run_service", "resource_type": "service"}
 
             if self.resource_id:
@@ -132,53 +168,116 @@ class AuthMiddleware(BaseHTTPMiddleware):
                 credentials = _cache.get(_hash)
 
                 if credentials:
+                    log.debug("Using cached credentials")
                     return credentials
 
-            async with httpx.AsyncClient() as client:
-                response = await client.get(
-                    f"{self.host}/api/permissions/verify",
-                    headers=headers,
-                    cookies=cookies,
-                    params=params,
-                )
-
-                if response.status_code == 401:
-                    raise DenyException(
-                        status_code=401,
-                        content="Invalid credentials",
-                    )
-                elif response.status_code == 403:
-                    raise DenyException(
-                        status_code=403,
-                        content="Service execution not allowed.",
-                    )
-                elif response.status_code != 200:
-                    raise DenyException(
-                        status_code=400,
-                        content="Auth: Unexpected Error.",
-                    )
-
-                auth = response.json()
+            try:
+                async with httpx.AsyncClient() as client:
+                    try:
+                        response = await client.get(
+                            f"{self.host}/api/permissions/verify",
+                            headers=headers,
+                            cookies=cookies,
+                            params=params,
+                            timeout=30.0,
+                        )
+                    except httpx.TimeoutException as exc:
+                        log.debug(f"Timeout error while verify credentials: {exc}")
+                        raise DenyException(
+                            status_code=504,
+                            content="Could not verify credentials: connection to {self.host} timed out. Please check your network connection.",
+                        ) from exc
+                    except httpx.ConnectError as exc:
+                        log.debug(f"Connection error while verify credentials: {exc}")
+                        raise DenyException(
+                            status_code=503,
+                            content=f"Could not verify credentials: connection to {self.host} failed. Please check if agenta is available.",
+                        ) from exc
+                    except httpx.NetworkError as exc:
+                        log.debug(f"Network error while verify credentials: {exc}")
+                        raise DenyException(
+                            status_code=503,
+                            content="Could not verify credentials: connection to {self.host} failed. Please check your network connection.",
+                        ) from exc
+                    except httpx.HTTPError as exc:
+                        log.debug(f"HTTP error while verify credentials: {exc}")
+                        raise DenyException(
+                            status_code=502,
+                            content=f"Could not verify credentials: connection to {self.host} failed. Please check if agenta is available.",
+                        ) from exc
+
+                    if response.status_code == 401:
+                        log.debug("Agenta returned 401 - Invalid credentials")
+                        raise DenyException(
+                            status_code=401,
+                            content="Invalid credentials. Please check your credentials or login again.",
+                        )
+                    elif response.status_code == 403:
+                        log.debug("Agenta returned 403 - Permission denied")
+                        raise DenyException(
+                            status_code=403,
+                            content="Permission denied. Please check your permissions or contact your administrator.",
+                        )
+                    elif response.status_code != 200:
+                        log.debug(
+                            f"Agenta returned {response.status_code} - Unexpected status code"
+                        )
+                        raise DenyException(
+                            status_code=500,
+                            content=f"Could no verify credentials: {self.host} returned unexpected status code {response.status_code}. Please try again later or contact support if the issue persists.",
+                        )
+
+                    try:
+                        auth = response.json()
+                    except ValueError as exc:
+                        log.debug(f"Agenta returned invalid JSON response: {exc}")
+                        raise DenyException(
+                            status_code=500,
+                            content=f"Could no verify credentials: {self.host} returned unexpected invalid JSON response. Please try again later or contact support if the issue persists.",
+                        ) from exc
+
+                    if not isinstance(auth, dict):
+                        log.debug(
+                            f"Agenta returned invalid response format: {type(auth)}"
+                        )
+                        raise DenyException(
+                            status_code=500,
+                            content=f"Could no verify credentials: {self.host} returned unexpected invalid response format. Please try again later or contact support if the issue persists.",
+                        )
+
+                    effect = auth.get("effect")
+                    if effect != "allow":
+                        log.debug("Access denied by Agenta - effect: {effect}")
+                        raise DenyException(
+                            status_code=403,
+                            content="Permission denied. Please check your permissions or contact your administrator.",
+                        )
+
+                    credentials = auth.get("credentials")
+
+                    if not credentials:
+                        log.debug("No credentials found in the response")
+
+                    _cache.put(_hash, credentials)
 
-                if auth.get("effect") != "allow":
-                    raise DenyException(
-                        status_code=403,
-                        content="Service execution not allowed.",
-                    )
-
-                credentials = auth.get("credentials")
-
-                _cache.put(_hash, credentials)
+                    return credentials
 
-                return credentials
+            except DenyException as deny:
+                raise deny
+            except Exception as exc:  # pylint: disable=bare-except
+                log.debug(
+                    f"Unexpected error while verifying credentials (remote): {exc}"
+                )
+                raise DenyException(
+                    status_code=500,
+                    content=f"Could no verify credentials: unexpected error - {str(exc)}. Please try again later or contact support if the issue persists.",
+                ) from exc
 
         except DenyException as deny:
             raise deny
-
-        except Exception as exc:  # pylint: disable=bare-except
-            display_exception("Auth Middleware Exception (suppressed)")
-
+        except Exception as exc:
+            log.debug(f"Unexpected error while verifying credentials (local): {exc}")
             raise DenyException(
                 status_code=500,
-                content="Auth: Unexpected Error.",
+                content=f"Could no verify credentials: unexpected error - {str(exc)}. Please try again later or contact support if the issue persists.",
             ) from exc

agenta/sdk/middleware/config.py

@@ -17,7 +17,7 @@ from agenta.sdk.utils.exceptions import suppress
 import agenta as ag
 
 
-_CACHE_ENABLED = getenv("AGENTA_MIDDLEWARE_CACHE_ENABLED", "true").lower() in TRUTHY
+_CACHE_ENABLED = getenv("AGENTA_MIDDLEWARE_CACHE_ENABLED", "false").lower() in TRUTHY
 
 _cache = TTLLRUCache(capacity=CACHE_CAPACITY, ttl=CACHE_TTL)
 
@@ -92,7 +92,7 @@ class ConfigMiddleware(BaseHTTPMiddleware):
 
                 return parameters, references
 
-        config = None
+        config = {}
         async with httpx.AsyncClient() as client:
             response = await client.post(
                 f"{self.host}/api/variants/configs/fetch",
@@ -100,21 +100,25 @@ class ConfigMiddleware(BaseHTTPMiddleware):
                 json=refs,
             )
 
-            if response.status_code != 200:
-                return None, None
-
-            config = response.json()
+            if response.status_code == 200:
+                config = response.json()
 
         if not config:
-            _cache.put(_hash, {"parameters": None, "references": None})
+            config["application_ref"] = refs[
+                "application_ref"
+            ]  # by default, application_ref will always have an id
+            parameters = None
+        else:
+            parameters = config.get("params")
 
-            return None, None
+        references = {}
 
-        parameters = config.get("params")
+        ref_keys = ["application_ref"]
 
-        references = {}
+        if config:
+            ref_keys.extend(["variant_ref", "environment_ref"])
 
-        for ref_key in ["application_ref", "variant_ref", "environment_ref"]:
+        for ref_key in ref_keys:
             refs = config.get(ref_key)
             if refs:
                 ref_prefix = ref_key.split("_", maxsplit=1)[0]
@@ -133,7 +137,7 @@ class ConfigMiddleware(BaseHTTPMiddleware):
         self,
         request: Request,
     ) -> Optional[Reference]:
-        baggage = request.state.otel.get("baggage") if request.state.otel else {}
+        baggage = request.state.otel["baggage"]
 
         body = {}
         try:
@@ -180,7 +184,7 @@ class ConfigMiddleware(BaseHTTPMiddleware):
         self,
         request: Request,
     ) -> Optional[Reference]:
-        baggage = request.state.otel.get("baggage") if request.state.otel else {}
+        baggage = request.state.otel["baggage"]
 
         body = {}
         try:
@@ -223,7 +227,7 @@ class ConfigMiddleware(BaseHTTPMiddleware):
         self,
         request: Request,
     ) -> Optional[Reference]:
-        baggage = request.state.otel.get("baggage") if request.state.otel else {}
+        baggage = request.state.otel["baggage"]
 
         body = {}
         try:

agenta/sdk/middleware/inline.py

@@ -21,7 +21,7 @@ class InlineMiddleware(BaseHTTPMiddleware):
         request.state.inline = False
 
         with suppress():
-            baggage = request.state.otel.get("baggage") if request.state.otel else {}
+            baggage = request.state.otel["baggage"]
 
             inline = (
                 str(

agenta/sdk/middleware/mock.py

@@ -19,7 +19,7 @@ class MockMiddleware(BaseHTTPMiddleware):
         request.state.mock = None
 
         with suppress():
-            baggage = request.state.otel.get("baggage") if request.state.otel else {}
+            baggage = request.state.otel["baggage"]
 
             mock = (
                 # CLEANEST

agenta/sdk/middleware/otel.py

@@ -13,7 +13,7 @@ class OTelMiddleware(BaseHTTPMiddleware):
         super().__init__(app)
 
     async def dispatch(self, request: Request, call_next: Callable):
-        request.state.otel = {}
+        request.state.otel = {"baggage": {}}
 
         with suppress():
             baggage = await self._get_baggage(request)

agenta/sdk/middleware/vault.py

@@ -24,7 +24,7 @@ for arg in ProviderKind.__args__:  # type: ignore
     if hasattr(arg, "__args__"):
         _PROVIDER_KINDS.extend(arg.__args__)
 
-_CACHE_ENABLED = getenv("AGENTA_MIDDLEWARE_CACHE_ENABLED", "true").lower() in TRUTHY
+_CACHE_ENABLED = getenv("AGENTA_MIDDLEWARE_CACHE_ENABLED", "false").lower() in TRUTHY
 
 _cache = TTLLRUCache(capacity=CACHE_CAPACITY, ttl=CACHE_TTL)