agenta 0.50.6__py3-none-any.whl → 0.51.1__py3-none-any.whl

agenta/sdk/middleware/adapt.py

@@ -0,0 +1,253 @@
+from typing import Callable
+from inspect import signature
+from uuid import uuid4
+
+from agenta.sdk.utils.logging import get_module_logger
+
+from agenta.sdk.middleware.base import (
+    WorkflowMiddleware,
+    middleware_as_decorator,
+)
+from agenta.sdk.workflows.types import (
+    WorkflowServiceRequest,
+    WorkflowServiceResponse,
+    WorkflowServiceData,
+    WorkflowRevision,
+    Status,
+)
+
+log = get_module_logger(__name__)
+
+DEFAULT_INPUTS_MAPPINGS = {
+    "request": "request",
+    "revision": "revision",
+    "parameters": "revision.data.parameters",
+    "inputs": "request.data.inputs",
+    "outputs": "request.data.traces.0.attributes.ag.data.outputs",
+    "trace": "request.data.traces.0",
+    "trace_outputs": "request.data.traces.0.attributes.ag.data.outputs",
+    "traces": "request.data.traces",
+    "traces_outputs": "request.data.traces.{}.attributes.ag.data.outputs",
+}
+
+ALLOWED_INPUTS_KEYS = set(DEFAULT_INPUTS_MAPPINGS.keys())
+
+ALLOWED_OUTPUTS_KEYS = {
+    "outputs",
+    "trace",
+}
+
+DEFAULT_MAPPINGS = {}
+
+CURRENT_VERSION = "2025.07.14"
+
+
+@middleware_as_decorator
+class AdaptMiddleware(WorkflowMiddleware):
+    def __init__(self):
+        pass
+
+    async def __call__(
+        self,
+        request: WorkflowServiceRequest,
+        revision: WorkflowRevision,
+        handler: Callable,
+    ) -> WorkflowServiceResponse:
+        request_data_dict = request.data.model_dump(
+            mode="json",
+            exclude_none=True,
+        )
+
+        revision_data_dict = revision.data.model_dump(
+            mode="json",
+            exclude_none=True,
+        )
+
+        provided_request_keys = sorted(
+            {"request", "revision", "parameters"} | set(request_data_dict.keys())
+        )
+
+        handler_signature = signature(handler)
+
+        requested_inputs_keys = sorted(set(handler_signature.parameters.keys()))
+
+        kwargs = dict()
+
+        try:
+            for requested_input_key in requested_inputs_keys:
+                if requested_input_key not in ALLOWED_INPUTS_KEYS:
+                    kwargs[requested_input_key] = None
+                    continue
+
+                if requested_input_key in provided_request_keys:
+                    if requested_input_key == "parameters":
+                        kwargs[requested_input_key] = (
+                            revision.data.parameters
+                            if revision.data.parameters
+                            else None
+                        )
+                    elif requested_input_key == "request":
+                        kwargs[requested_input_key] = request
+                    elif requested_input_key == "revision":
+                        kwargs[requested_input_key] = revision
+                    else:
+                        kwargs[requested_input_key] = request_data_dict[
+                            requested_input_key
+                        ]
+
+                else:
+                    kwargs[requested_input_key] = self._apply_request_mapping(
+                        request=request_data_dict,
+                        revision=revision_data_dict,
+                        key=requested_input_key,
+                    )
+
+        except:  # pylint: disable=bare-except
+            # handle the error
+            pass
+
+        try:
+            # inputs = kwargs.get("inputs", None)
+
+            # inputs_schema =
+
+            # self._check_request_schema(
+            #     inputs,
+            #     inputs_schema,
+            # )
+
+            # parameters = kwargs.get("parameters", None)
+
+            # parameters_schema =
+
+            # self._check_request_schema(
+            #     parameters,
+            #     parameters_schema,
+            # )
+
+            pass
+
+        except:  # pylint: disable=bare-except
+            # handle the error
+            pass
+
+        try:
+            handler_signature.bind(**kwargs)
+
+        except:  # pylint: disable=bare-except
+            # handle the error
+            pass
+
+        try:
+            outputs = await handler(**kwargs)
+
+            trace = None  # get trace
+
+        except:  # pylint: disable=bare-except
+            # handle the error
+            log.debug()
+            raise
+
+        try:
+            # outputs_schema =
+
+            # self._check_request_schema(
+            #     outputs,
+            #     outputs_schema,
+            # )
+
+            pass
+
+        except:  # pylint: disable=bare-except
+            # handle the error
+            pass
+
+        return WorkflowServiceResponse(
+            id=uuid4(),
+            version=CURRENT_VERSION,
+            # status=Status(code=200, message="Success"),
+            data=WorkflowServiceData(
+                outputs=outputs,
+                trace=trace,
+            ),
+        )
+
+    def _apply_request_mapping(
+        self,
+        request: dict,
+        revision: dict,
+        key: str,
+    ):
+        mapping = DEFAULT_INPUTS_MAPPINGS[key]
+
+        parts = mapping.split(".")
+
+        base_part = parts.pop(0)
+        data_part = parts.pop(0)
+
+        base = (
+            request
+            if base_part == "request" and data_part == "data"
+            else (revision if base_part == "revision" and data_part == "data" else {})
+        )
+
+        scalar = True
+        is_list = False
+        is_dict = False
+
+        for part in parts:
+            _is_index = part.isdigit()
+            _is_list = part == "[]"
+            _is_dict = part == "{}"
+
+            _scalar = not (_is_list or _is_dict)
+
+            if not scalar and not _scalar:
+                # handle error once we start using mappings
+                pass
+
+            if _is_index:
+                if isinstance(base, list):
+                    base = base[int(part)]
+                elif isinstance(base, dict):
+                    base = base[list(base.keys())[int(part)]]
+                else:
+                    # handle error once we start using mappings
+                    pass
+
+            elif _is_list:
+                if not isinstance(base, list):
+                    # handle error once we start using mappings
+                    pass
+            elif _is_dict:
+                if not isinstance(base, dict):
+                    # handle error once we start using mappings
+                    pass
+
+            else:
+                if isinstance(base, dict):
+                    if is_list:
+                        base = [
+                            (item.get(part, None) if isinstance(item, dict) else None)
+                            for item in base
+                        ]
+                    elif is_dict:
+                        base = {
+                            key: (
+                                value.get(part, None)
+                                if isinstance(value, dict)
+                                else None
+                            )
+                            for key, value in base.items()
+                        }
+                    else:
+                        base = base.get(part, None)
+                else:
+                    # handle error once we start using mappings
+                    pass
+
+            scalar = _scalar
+            is_list = _is_list
+            is_dict = _is_dict
+
+        return base

agenta/sdk/middleware/auth.py

@@ -15,6 +15,17 @@ from agenta.sdk.utils.logging import get_module_logger
 
 import agenta as ag
 
+from agenta.sdk.middleware.base import (
+    WorkflowMiddleware,
+    middleware_as_decorator,
+)
+from agenta.sdk.workflows.types import (
+    WorkflowServiceRequest,
+    WorkflowServiceResponse,
+    WorkflowRevision,
+    WorkflowServiceHandler,
+)
+
 log = get_module_logger(__name__)
 
 AGENTA_RUNTIME_PREFIX = getenv("AGENTA_RUNTIME_PREFIX", "")
@@ -53,7 +64,7 @@ class DenyException(Exception):
         self.content = content
 
 
-class AuthMiddleware(BaseHTTPMiddleware):
+class AuthHTTPMiddleware(BaseHTTPMiddleware):
     def __init__(self, app: FastAPI):
         super().__init__(app)
 
@@ -157,7 +168,7 @@ class AuthMiddleware(BaseHTTPMiddleware):
                         # 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.",
+                            content=f"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}")
@@ -169,7 +180,7 @@ class AuthMiddleware(BaseHTTPMiddleware):
                         # 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.",
+                            content=f"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}")
@@ -253,3 +264,168 @@ class AuthMiddleware(BaseHTTPMiddleware):
                 status_code=500,
                 content=f"Could not verify credentials: unexpected error - {str(exc)}. Please try again later or contact support if the issue persists.",
             ) from exc
+
+
+from agenta.sdk.context.tracing import (
+    tracing_context_manager,
+    tracing_context,
+    TracingContext,
+)
+
+
+@middleware_as_decorator
+class AuthMiddleware(WorkflowMiddleware):
+    def __init__(self):
+        pass
+
+    async def __call__(
+        self,
+        request: WorkflowServiceRequest,
+        revision: WorkflowRevision,
+        handler: WorkflowServiceHandler,
+    ) -> WorkflowServiceResponse:
+        ctx = tracing_context.get()
+
+        ctx.credentials = request.credentials
+
+        with tracing_context_manager(context=ctx):
+            return await handler(request, revision)
+
+
+# @middleware_as_decorator
+# class AuthMiddleware(WorkflowMiddleware):
+#     def __init__(self):
+#         self.host = ag.DEFAULT_AGENTA_SINGLETON_INSTANCE.host
+#         self.scope_type = ag.DEFAULT_AGENTA_SINGLETON_INSTANCE.scope_type
+#         self.scope_id = ag.DEFAULT_AGENTA_SINGLETON_INSTANCE.scope_id
+
+#     async def __call__(
+#         self,
+#         request: WorkflowServiceRequest,
+#         revision: WorkflowRevision,
+#         handler: WorkflowServiceHandler,
+#     ) -> WorkflowServiceResponse:
+#         try:
+#             request.credentials = await self._get_credentials(request)
+
+#         except DenyException as deny:
+#             display_exception("Auth Middleware Exception")
+
+#             raise deny
+
+#         except Exception as exc:
+#             display_exception("Auth Middleware Exception")
+
+#             raise DenyException(
+#                 status_code=500,
+#                 content="Auth Middleware Unexpected Error.",
+#             ) from exc
+
+#         return await handler(request, revision)
+
+#     async def _get_credentials(
+#         self,
+#         request: WorkflowServiceRequest,
+#     ) -> Optional[str]:
+#         credentials = request.credentials
+
+#         headers = {"Authorization": credentials} if credentials else None
+
+#         params = {
+#             "action": "run_workflow",
+#             "resource_type": "workflow",
+#         }
+#         if self.scope_type and self.scope_id:
+#             params["scope_type"] = self.scope_type
+#             params["scope_id"] = self.scope_id
+
+#         _hash = dumps(
+#             {
+#                 "headers": headers,
+#                 "params": params,
+#             },
+#             sort_keys=True,
+#         )
+
+#         if _CACHE_ENABLED:
+#             cached = _cache.get(_hash)
+#             if cached:
+#                 return cached
+
+#         try:
+#             async with httpx.AsyncClient() as client:
+#                 response = await client.get(
+#                     f"{self.host}/api/permissions/verify",
+#                     params=params,
+#                     headers=headers,
+#                     timeout=5 * 60,
+#                 )
+
+#         except httpx.TimeoutException as exc:
+#             raise DenyException(
+#                 status_code=504,
+#                 content=f"Could not verify credentials: connection to {self.host} timed out. Please check your network connection.",
+#             ) from exc
+#         except httpx.ConnectError as 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:
+#             raise DenyException(
+#                 status_code=503,
+#                 content=f"Could not verify credentials: connection to {self.host} failed. Please check your network connection.",
+#             ) from exc
+#         except httpx.HTTPError as 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
+#         except Exception as exc:
+#             raise DenyException(
+#                 500,
+#                 f"Could not verify credentials: unexpected error.\n {exc}",
+#             ) from exc
+
+#         if response.status_code == 401:
+#             raise DenyException(
+#                 status_code=401,
+#                 content="Invalid credentials. Please check your credentials or login again.",
+#             )
+#         if response.status_code == 403:
+#             raise DenyException(
+#                 status_code=403,
+#                 content="Permission denied. Please check your permissions or contact your administrator.",
+#             )
+#         if response.status_code != 200:
+#             raise DenyException(
+#                 status_code=500,
+#                 content=f"Could not 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:
+#             raise DenyException(
+#                 status_code=500,
+#                 content=f"Could not 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):
+#             raise DenyException(
+#                 status_code=500,
+#                 content=f"Could not verify credentials: {self.host} returned unexpected invalid response format. Please try again later or contact support if the issue persists.",
+#             )
+
+#         if auth.get("effect") != "allow":
+#             raise DenyException(
+#                 status_code=403,
+#                 content="Permission denied. Please check your permissions or contact your administrator.",
+#             )
+
+#         credentials: str = auth.get("credentials")
+
+#         if credentials is not None:
+#             _cache.put(_hash, credentials)
+
+#         return credentials

agenta/sdk/middleware/base.py

@@ -0,0 +1,40 @@
+from typing import Protocol, Callable, Any
+
+from agenta.sdk.workflows.types import (
+    WorkflowServiceRequest,
+    WorkflowServiceResponse,
+    WorkflowRevision,
+    WorkflowServiceHandler,
+)
+
+
+class WorkflowMiddleware(Protocol):
+    async def __call__(
+        self,
+        request: WorkflowServiceRequest,
+        revision: WorkflowRevision,
+        handler: Callable,
+    ) -> Any:
+        ...
+
+
+WorkflowMiddlewareDecorator = Callable[[WorkflowServiceHandler], WorkflowServiceHandler]
+
+
+def middleware_as_decorator(
+    middleware: WorkflowMiddleware | type[WorkflowMiddleware],
+) -> WorkflowMiddlewareDecorator:
+    middleware = middleware() if isinstance(middleware, type) else middleware
+
+    def decorator(
+        handler: WorkflowServiceHandler,
+    ) -> WorkflowServiceHandler:
+        async def wrapped(
+            request: WorkflowServiceRequest,
+            revision: WorkflowRevision,
+        ) -> WorkflowServiceResponse:
+            return await middleware(request, revision, handler)
+
+        return wrapped
+
+    return decorator

agenta/sdk/middleware/flags.py

@@ -0,0 +1,40 @@
+from agenta.sdk.utils.logging import get_module_logger
+
+from agenta.sdk.middleware.base import (
+    WorkflowMiddleware,
+    middleware_as_decorator,
+)
+from agenta.sdk.workflows.types import (
+    WorkflowServiceRequest,
+    WorkflowServiceResponse,
+    WorkflowRevision,
+    WorkflowServiceHandler,
+)
+
+from agenta.sdk.context.tracing import (
+    tracing_context_manager,
+    tracing_context,
+)
+
+
+log = get_module_logger(__name__)
+
+
+@middleware_as_decorator
+class FlagsMiddleware(WorkflowMiddleware):
+    def __init__(self):
+        pass
+
+    async def __call__(
+        self,
+        request: WorkflowServiceRequest,
+        revision: WorkflowRevision,
+        handler: WorkflowServiceHandler,
+    ) -> WorkflowServiceResponse:
+        ctx = tracing_context.get()
+
+        if isinstance(request.flags, dict) and request.flags.get("is_annotation"):
+            ctx.type = "annotation"
+
+        with tracing_context_manager(context=ctx):
+            return await handler(request, revision)

agenta/sdk/tracing/exporters.py

@@ -8,15 +8,15 @@ from opentelemetry.sdk.trace.export import (
     ReadableSpan,
 )
 
+from agenta.sdk.utils.logging import get_module_logger
 from agenta.sdk.utils.exceptions import suppress
-from agenta.sdk.context.exporting import (
-    exporting_context_manager,
-    exporting_context,
-    ExportingContext,
-)
 from agenta.sdk.utils.cache import TTLLRUCache
+from agenta.sdk.context.tracing import (
+    tracing_exporter_context_manager,
+    tracing_exporter_context,
+    TracingExporterContext,
+)
 
-from agenta.sdk.utils.logging import get_module_logger
 
 log = get_module_logger(__name__)
 
@@ -101,8 +101,8 @@ class OTLPExporter(OTLPSpanExporter):
         serialized_spans = []
 
         for credentials, _spans in grouped_spans.items():
-            with exporting_context_manager(
-                context=ExportingContext(
+            with tracing_exporter_context_manager(
+                context=TracingExporterContext(
                     credentials=credentials,
                 )
             ):
@@ -114,7 +114,7 @@ class OTLPExporter(OTLPSpanExporter):
             return SpanExportResult.FAILURE
 
     def _export(self, serialized_data: bytes, timeout_sec: Optional[float] = None):
-        credentials = exporting_context.get().credentials
+        credentials = tracing_exporter_context.get().credentials
 
         if credentials:
             self._session.headers.update({"Authorization": credentials})

agenta/sdk/tracing/inline.py

@@ -62,6 +62,7 @@ Attributes = Dict[str, AttributeValueType]
 class TreeType(Enum):
     # --- VARIANTS --- #
     INVOCATION = "invocation"
+    ANNOTATION = "annotation"
     # --- VARIANTS --- #
 
 

agenta/sdk/tracing/tracing.py

@@ -1,9 +1,7 @@
 from typing import Optional, Any, Dict, Callable
 from enum import Enum
-from uuid import UUID
 
 from pydantic import BaseModel
-from httpx import get as check
 
 
 from opentelemetry.trace import (
@@ -33,7 +31,6 @@ from agenta.sdk.tracing.conventions import Reference, is_valid_attribute_key
 from agenta.sdk.tracing.propagation import extract, inject
 from agenta.sdk.utils.cache import TTLLRUCache
 
-from agenta.sdk.context.tracing import tracing_context
 
 log = get_module_logger(__name__)
 
@@ -120,11 +117,6 @@ class Tracing(metaclass=Singleton):
         # TRACE PROCESSORS -- OTLP
         try:
             log.info("Agenta - OLTP URL: %s", self.otlp_url)
-            # check(
-            #     self.otlp_url,
-            #     headers=self.headers,
-            #     timeout=1,
-            # )
 
             _otlp = TraceProcessor(
                 OTLPExporter(

agenta/sdk/utils/cache.py

@@ -5,7 +5,7 @@ from collections import OrderedDict
 from threading import Lock
 
 CACHE_CAPACITY = int(getenv("AGENTA_MIDDLEWARE_CACHE_CAPACITY", "512"))
-CACHE_TTL = int(getenv("AGENTA_MIDDLEWARE_CACHE_TTL", str(60)))  # 1 minute
+CACHE_TTL = int(getenv("AGENTA_MIDDLEWARE_CACHE_TTL", str(5 * 60)))  # 5 minutes
 
 
 class TTLLRUCache:
@@ -38,7 +38,7 @@ class TTLLRUCache:
 
             return value
 
-    def put(self, key, value):
+    def put(self, key, value, ttl: Optional[int] = None):
         with self.lock:
             try:
                 # LRU update
@@ -50,4 +50,4 @@ class TTLLRUCache:
                     self.cache.popitem(last=False)
 
             # Put
-            self.cache[key] = (value, time() + self.ttl)
+            self.cache[key] = (value, time() + (ttl if ttl is not None else self.ttl))

agenta/sdk/workflows/registry.py

@@ -0,0 +1,32 @@
+from json import dumps
+
+from agenta.sdk.utils.logging import get_module_logger
+from agenta.sdk.workflows.types import Data
+
+
+log = get_module_logger(__name__)
+
+
+async def exact_match_v1(
+    *,
+    parameters: Data,
+    inputs: Data,
+    outputs: Data | str,
+) -> Data:
+    success = False
+
+    try:
+        reference_key = parameters.get("reference_key", None)
+        reference_outputs = inputs.get(reference_key, None)
+
+        if isinstance(outputs, str) and isinstance(reference_outputs, str):
+            success = outputs == reference_outputs
+        elif isinstance(outputs, dict) and isinstance(reference_outputs, dict):
+            outputs = dumps(outputs, sort_keys=True)
+            reference_outputs = dumps(reference_outputs, sort_keys=True)
+            success = outputs == reference_outputs
+
+    except:  # pylint: disable=bare-except
+        log.error("Error in exact_match_v1", exc_info=True)
+
+    return {"success": success}