agenta 0.70.1__py3-none-any.whl → 0.75.0__py3-none-any.whl

agenta/sdk/middlewares/running/vault.py

@@ -36,7 +36,7 @@ _CACHE_ENABLED = (
 _cache = TTLLRUCache()
 
 
-async def get_secrets(api_url, credentials) -> list:
+async def get_secrets(api_url, credentials) -> tuple[list, list, list]:
     headers = None
     if credentials:
         headers = {"Authorization": credentials}
@@ -53,8 +53,13 @@ async def get_secrets(api_url, credentials) -> list:
 
         if secrets_cache:
             secrets = secrets_cache.get("secrets")
+            vault_secrets = secrets_cache.get("vault_secrets")
+            local_secrets = secrets_cache.get("local_secrets")
 
-            return secrets
+            if vault_secrets is None or local_secrets is None:
+                return secrets, [], []
+
+            return secrets, vault_secrets, local_secrets
 
     local_secrets: List[Dict[str, Any]] = []
 
@@ -76,7 +81,7 @@ async def get_secrets(api_url, credentials) -> list:
             )
 
             local_secrets.append(secret.model_dump())
-    except:  # pylint: disable=bare-except
+    except Exception:  # pylint: disable=bare-except
         display_exception("Vault: Local Secrets Exception")
 
     vault_secrets: List[Dict[str, Any]] = []
@@ -93,32 +98,38 @@ async def get_secrets(api_url, credentials) -> list:
 
             else:
                 vault_secrets = response.json()
-    except:  # pylint: disable=bare-except
+    except Exception:  # pylint: disable=bare-except
         display_exception("Vault: Vault Secrets Exception")
 
-    secrets = local_secrets + vault_secrets
-
-    standard_secrets = {}
-    custom_secrets = []
+    local_standard = {}
+    vault_standard = {}
+    vault_custom = []
 
     if local_secrets:
         for secret in local_secrets:
-            standard_secrets[secret["data"]["kind"]] = secret  # type: ignore
+            local_standard[secret["data"]["kind"]] = secret  # type: ignore
 
     if vault_secrets:
         for secret in vault_secrets:
             if secret["kind"] == "provider_key":  # type: ignore
-                standard_secrets[secret["data"]["kind"]] = secret  # type: ignore
+                vault_standard[secret["data"]["kind"]] = secret  # type: ignore
             elif secret["kind"] == "custom_provider":  # type: ignore
-                custom_secrets.append(secret)
+                vault_custom.append(secret)
 
-    standard_secrets = list(standard_secrets.values())
+    combined_standard = {**local_standard, **vault_standard}
+    combined_vault = list(vault_standard.values()) + vault_custom
+    secrets = list(combined_standard.values()) + vault_custom
 
-    secrets = standard_secrets + custom_secrets
-
-    _cache.put(_hash, {"secrets": secrets})
+    _cache.put(
+        _hash,
+        {
+            "secrets": secrets,
+            "vault_secrets": combined_vault,
+            "local_secrets": local_secrets,
+        },
+    )
 
-    return secrets
+    return secrets, combined_vault, local_secrets
 
 
 class VaultMiddleware:
@@ -133,8 +144,13 @@ class VaultMiddleware:
             ctx = RunningContext.get()
             credentials = ctx.credentials
 
-            secrets = await get_secrets(api_url, credentials)
+            secrets, vault_secrets, local_secrets = await get_secrets(
+                api_url,
+                credentials,
+            )
 
             ctx.secrets = secrets
+            ctx.vault_secrets = vault_secrets
+            ctx.local_secrets = local_secrets
 
         return await call_next(request)

agenta/sdk/router.py

@@ -1,8 +1,33 @@
-from fastapi import APIRouter
+from typing import TYPE_CHECKING, Optional
 
-router = APIRouter()
+if TYPE_CHECKING:
+    from fastapi import APIRouter
 
+from agenta.sdk.utils.lazy import _load_fastapi
 
-@router.get("/health")
-def health():
-    return {"status": "ok"}
+_router: Optional["APIRouter"] = None
+
+
+class _LazyRouter:
+    def __getattr__(self, name):
+        return getattr(get_router(), name)
+
+    def __call__(self, *args, **kwargs):
+        return get_router()(*args, **kwargs)
+
+
+def get_router() -> "APIRouter":
+    global _router  # pylint: disable=global-statement
+
+    if _router is None:
+        fastapi = _load_fastapi()
+        _router = fastapi.APIRouter()
+
+        @_router.get("/health")
+        def health():
+            return {"status": "ok"}
+
+    return _router
+
+
+router = _LazyRouter()

agenta/sdk/tracing/inline.py

@@ -949,9 +949,10 @@ def parse_to_agenta_span_dto(
 ########################################
 
 
-from litellm import cost_calculator
 from opentelemetry.sdk.trace import ReadableSpan
 
+from agenta.sdk.utils.lazy import _load_litellm
+
 from agenta.sdk.types import AgentaNodeDto, AgentaNodesResponse
 
 
@@ -1112,6 +1113,12 @@ TYPES_WITH_COSTS = [
 
 
 def calculate_costs(span_idx: Dict[str, SpanDTO]):
+    litellm = _load_litellm()
+    if not litellm:
+        return
+
+    cost_calculator = litellm.cost_calculator
+
     for span in span_idx.values():
         if (
             span.node.type

agenta/sdk/tracing/processors.py

@@ -1,13 +1,16 @@
-from typing import Optional, Dict, List
 from threading import Lock
+from typing import Dict, List, Optional
 
+
+from agenta.sdk.contexts.tracing import TracingContext
+from agenta.sdk.utils.logging import get_module_logger
 from opentelemetry.baggage import get_all as get_baggage
 from opentelemetry.context import Context
 from opentelemetry.sdk.trace import Span, SpanProcessor
 from opentelemetry.sdk.trace.export import (
-    SpanExporter,
-    ReadableSpan,
     BatchSpanProcessor,
+    ReadableSpan,
+    SpanExporter,
 )
 from opentelemetry.trace import SpanContext
 
@@ -88,6 +91,8 @@ class TraceProcessor(SpanProcessor):
                     if isinstance(ref, dict):
                         for field, val in ref.items():
                             span.set_attribute(f"{key}.{field}", str(val))
+                    elif isinstance(ref, (str, bool, int, float, bytes)):
+                        span.set_attribute(key, ref)
                 else:
                     # Not a reference - only set if it's a valid attribute type
                     if isinstance(value, (str, bool, int, float, bytes)):

agenta/sdk/tracing/propagation.py

@@ -1,14 +1,10 @@
-from typing import Tuple, Optional, Dict, Any
+from typing import Any, Dict, Optional, Tuple
 
-from opentelemetry.trace import Span, set_span_in_context, get_current_span
-from opentelemetry.baggage.propagation import W3CBaggagePropagator
-from opentelemetry.trace.propagation.tracecontext import TraceContextTextMapPropagator
+from agenta.sdk.contexts.tracing import TracingContext
 from opentelemetry.baggage import set_baggage
+from opentelemetry.baggage.propagation import W3CBaggagePropagator
 from opentelemetry.context import get_current
-
-from agenta.sdk.contexts.tracing import TracingContext
-
-import agenta as ag
+from opentelemetry.trace.propagation.tracecontext import TraceContextTextMapPropagator
 
 
 def extract(
@@ -47,11 +43,12 @@ def extract(
     baggage = {}
 
     try:
-        _carrier = {
-            "baggage": headers.get("Baggage")  # Uppercase
+        raw_baggage = (
+            headers.get("Baggage")  # Uppercase
             or headers.get("baggage")  # Lowercase
-            or "",
-        }
+            or ""
+        )
+        _carrier = {"baggage": raw_baggage}
 
         _context = W3CBaggagePropagator().extract(_carrier)
 

agenta/sdk/types.py

@@ -8,7 +8,7 @@ from pydantic import BaseModel, Field, model_validator, AliasChoices
 from starlette.responses import StreamingResponse
 
 
-from agenta.sdk.assets import supported_llm_models
+from agenta.sdk.assets import supported_llm_models, model_metadata
 from agenta.client.backend.types import AgentaNodesResponse, AgentaNodeDto
 
 
@@ -23,7 +23,11 @@ def MCField(  # pylint: disable=invalid-name
 ) -> Field:
     # Pydantic 2.12+ no longer allows post-creation mutation of field properties
     if isinstance(choices, dict):
-        json_extra = {"choices": choices, "x-parameter": "grouped_choice"}
+        json_extra = {
+            "choices": choices,
+            "x-parameter": "grouped_choice",
+            "x-model-metadata": model_metadata,
+        }
     elif isinstance(choices, list):
         json_extra = {"choices": choices, "x-parameter": "choice"}
     else:
@@ -492,17 +496,11 @@ class TemplateFormatError(PromptTemplateError):
         super().__init__(message)
 
 
-import json
 import re
 from typing import Any, Dict, Iterable, Tuple, Optional
 
-# --- Optional dependency: python-jsonpath (provides JSONPath + JSON Pointer) ---
-try:
-    import jsonpath  # ✅ use module API
-    from jsonpath import JSONPointer  # pointer class is fine to use
-except Exception:
-    jsonpath = None
-    JSONPointer = None
+from agenta.sdk.utils.lazy import _load_jinja2, _load_jsonpath
+
 
 # ========= Scheme detection =========
 
@@ -545,7 +543,8 @@ def resolve_dot_notation(expr: str, data: dict) -> object:
 
 
 def resolve_json_path(expr: str, data: dict) -> object:
-    if jsonpath is None:
+    json_path, _ = _load_jsonpath()
+    if json_path is None:
         raise ImportError("python-jsonpath is required for json-path ($...)")
 
     if not (expr == "$" or expr.startswith("$.") or expr.startswith("$[")):
@@ -555,15 +554,16 @@ def resolve_json_path(expr: str, data: dict) -> object:
         )
 
     # Use package-level APIf
-    results = jsonpath.findall(expr, data)  # always returns a list
+    results = json_path.findall(expr, data)  # always returns a list
     return results[0] if len(results) == 1 else results
 
 
 def resolve_json_pointer(expr: str, data: Dict[str, Any]) -> Any:
     """Resolve a JSON Pointer; returns a single value."""
-    if JSONPointer is None:
+    _, json_pointer = _load_jsonpath()
+    if json_pointer is None:
         raise ImportError("python-jsonpath is required for json-pointer (/...)")
-    return JSONPointer(expr).resolve(data)
+    return json_pointer(expr).resolve(data)
 
 
 def resolve_any(expr: str, data: Dict[str, Any]) -> Any:
@@ -631,12 +631,10 @@ def compute_truly_unreplaced(original: set, rendered: str) -> set:
 
 def missing_lib_hints(unreplaced: set) -> Optional[str]:
     """Suggest installing python-jsonpath if placeholders indicate json-path or json-pointer usage."""
-    if any(expr.startswith("$") or expr.startswith("/") for expr in unreplaced) and (
-        jsonpath is None or JSONPointer is None
-    ):
-        return (
-            "Install python-jsonpath to enable json-path ($...) and json-pointer (/...)"
-        )
+    if any(expr.startswith("$") or expr.startswith("/") for expr in unreplaced):
+        json_path, json_pointer = _load_jsonpath()
+        if json_path is None or json_pointer is None:
+            return "Install python-jsonpath to enable json-path ($...) and json-pointer (/...)"
     return None
 
 
@@ -688,7 +686,7 @@ class PromptTemplate(BaseModel):
                 return content.format(**kwargs)
 
             elif self.template_format == "jinja2":
-                from jinja2 import Template, TemplateError
+                Template, TemplateError = _load_jinja2()
 
                 try:
                     return Template(content).render(**kwargs)

agenta/sdk/utils/client.py

@@ -1,4 +1,4 @@
-import requests
+import httpx
 
 BASE_TIMEOUT = 10
 
@@ -11,7 +11,7 @@ log = get_module_logger(__name__)
 
 def authed_api():
     """
-    Preconfigured requests for authenticated endpoints (supports all methods).
+    Preconfigured httpx client for authenticated endpoints (supports all methods).
     """
 
     api_url = ag.DEFAULT_AGENTA_SINGLETON_INSTANCE.api_url
@@ -27,12 +27,13 @@ def authed_api():
         headers = kwargs.pop("headers", {})
         headers.setdefault("Authorization", f"ApiKey {api_key}")
 
-        return requests.request(
-            method=method,
-            url=url,
-            headers=headers,
-            timeout=BASE_TIMEOUT,
-            **kwargs,
-        )
+        with httpx.Client() as client:
+            return client.request(
+                method=method,
+                url=url,
+                headers=headers,
+                timeout=BASE_TIMEOUT,
+                **kwargs,
+            )
 
     return _request

agenta/sdk/utils/lazy.py

@@ -0,0 +1,253 @@
+from typing import Any, Callable, Optional, Protocol, Tuple, TYPE_CHECKING
+
+if TYPE_CHECKING:
+    from daytona import (
+        CreateSandboxFromSnapshotParams,
+        Daytona,
+        DaytonaConfig,
+        Sandbox,
+    )
+    from fastapi import APIRouter, Body, FastAPI, HTTPException, Request
+    from jinja2 import Template, TemplateError
+    from openai import AsyncOpenAI, OpenAIError
+    from starlette.responses import Response as StarletteResponse, StreamingResponse
+    from jsonpath import JSONPointer
+    import jsonpath as jsonpath_module
+    import yaml as yaml_module
+
+
+class _JsonpathModule(Protocol):
+    findall: Callable[..., Any]
+
+
+class _LitellmModule(Protocol):
+    cost_calculator: Any
+    acompletion: Callable[..., Any]
+
+
+class _FastAPIModule(Protocol):
+    FastAPI: type["FastAPI"]
+    APIRouter: type["APIRouter"]
+    Request: type["Request"]
+    HTTPException: type["HTTPException"]
+    Body: Any
+
+
+class _YamlModule(Protocol):
+    def safe_load(self, *args: Any, **kwargs: Any) -> Any: ...
+
+
+_litellm_module: Optional[_LitellmModule] = None
+_litellm_checked = False
+
+_jsonpath_module: Optional[_JsonpathModule] = None
+_jsonpath_pointer: Optional[type["JSONPointer"]] = None
+_jsonpath_checked = False
+
+_openai_cached: Optional[Tuple[type["AsyncOpenAI"], type["OpenAIError"]]] = None
+_openai_checked = False
+
+_yaml_module: Optional[_YamlModule] = None
+_yaml_checked = False
+
+_jinja_cached: Optional[Tuple[type["Template"], type["TemplateError"]]] = None
+_jinja_checked = False
+
+_fastapi_module: Optional[_FastAPIModule] = None
+_fastapi_checked = False
+
+_starlette_responses_cached: Optional[
+    Tuple[type["StarletteResponse"], type["StreamingResponse"]]
+] = None
+_starlette_responses_checked = False
+
+_daytona_cached: Optional[
+    Tuple[
+        type["Daytona"],
+        type["DaytonaConfig"],
+        type["Sandbox"],
+        type["CreateSandboxFromSnapshotParams"],
+    ]
+] = None
+_daytona_checked = False
+
+
+def _load_litellm(
+    injected: Optional[_LitellmModule] = None,
+) -> Optional[_LitellmModule]:
+    global _litellm_module, _litellm_checked  # pylint: disable=global-statement
+
+    if _litellm_checked:
+        return _litellm_module
+
+    if injected is not None:
+        _litellm_checked = True
+        _litellm_module = injected
+        return _litellm_module
+
+    _litellm_checked = True
+    try:
+        import litellm as _litellm
+    except Exception:
+        _litellm_module = None
+    else:
+        _litellm_module = _litellm
+
+    return _litellm_module
+
+
+def _load_jsonpath() -> Tuple[Optional[_JsonpathModule], Optional[type["JSONPointer"]]]:
+    global _jsonpath_module, _jsonpath_pointer, _jsonpath_checked  # pylint: disable=global-statement
+
+    if _jsonpath_checked:
+        return _jsonpath_module, _jsonpath_pointer
+
+    _jsonpath_checked = True
+    try:
+        import jsonpath as _jsonpath
+        from jsonpath import JSONPointer as _JSONPointer
+    except Exception:
+        _jsonpath_module = None
+        _jsonpath_pointer = None
+    else:
+        _jsonpath_module = _jsonpath
+        _jsonpath_pointer = _JSONPointer
+
+    return _jsonpath_module, _jsonpath_pointer
+
+
+def _load_openai() -> Tuple[type["AsyncOpenAI"], type["OpenAIError"]]:
+    global _openai_cached, _openai_checked  # pylint: disable=global-statement
+
+    if _openai_checked:
+        if _openai_cached is None:
+            raise ImportError(
+                "openai is required for semantic similarity evaluation. "
+                "Install it with `pip install openai`."
+            )
+        return _openai_cached
+
+    _openai_checked = True
+    try:
+        from openai import AsyncOpenAI, OpenAIError
+    except Exception as exc:
+        _openai_cached = None
+        raise ImportError(
+            "openai is required for semantic similarity evaluation. "
+            "Install it with `pip install openai`."
+        ) from exc
+
+    _openai_cached = (AsyncOpenAI, OpenAIError)
+    return _openai_cached
+
+
+def _load_yaml() -> _YamlModule:
+    global _yaml_module, _yaml_checked  # pylint: disable=global-statement
+
+    if _yaml_checked:
+        if _yaml_module is None:
+            raise ImportError("pyyaml is required to load YAML configs.")
+        return _yaml_module
+
+    _yaml_checked = True
+    try:
+        import yaml as _yaml
+    except Exception as exc:
+        _yaml_module = None
+        raise ImportError("pyyaml is required to load YAML configs.") from exc
+
+    _yaml_module = _yaml
+    return _yaml_module
+
+
+def _load_jinja2() -> Tuple[type["Template"], type["TemplateError"]]:
+    global _jinja_cached, _jinja_checked  # pylint: disable=global-statement
+
+    if _jinja_checked:
+        if _jinja_cached is None:
+            raise ImportError("jinja2 is required for jinja2 template rendering.")
+        return _jinja_cached
+
+    _jinja_checked = True
+    try:
+        from jinja2 import Template, TemplateError
+    except Exception as exc:
+        _jinja_cached = None
+        raise ImportError("jinja2 is required for jinja2 template rendering.") from exc
+
+    _jinja_cached = (Template, TemplateError)
+    return _jinja_cached
+
+
+def _load_fastapi() -> _FastAPIModule:
+    global _fastapi_module, _fastapi_checked  # pylint: disable=global-statement
+
+    if _fastapi_checked:
+        if _fastapi_module is None:
+            raise ImportError("fastapi is required for serving routes.")
+        return _fastapi_module
+
+    _fastapi_checked = True
+    try:
+        import fastapi as _fastapi
+    except Exception as exc:
+        _fastapi_module = None
+        raise ImportError("fastapi is required for serving routes.") from exc
+
+    _fastapi_module = _fastapi
+    return _fastapi_module
+
+
+def _load_starlette_responses() -> Tuple[
+    type["StarletteResponse"], type["StreamingResponse"]
+]:
+    global _starlette_responses_cached, _starlette_responses_checked  # pylint: disable=global-statement
+
+    if _starlette_responses_checked:
+        if _starlette_responses_cached is None:
+            raise ImportError("starlette is required for response handling.")
+        return _starlette_responses_cached
+
+    _starlette_responses_checked = True
+    try:
+        from starlette.responses import Response as StarletteResponse, StreamingResponse
+    except Exception as exc:
+        _starlette_responses_cached = None
+        raise ImportError("starlette is required for response handling.") from exc
+
+    _starlette_responses_cached = (StarletteResponse, StreamingResponse)
+    return _starlette_responses_cached
+
+
+def _load_daytona() -> Tuple[
+    type["Daytona"],
+    type["DaytonaConfig"],
+    type["Sandbox"],
+    type["CreateSandboxFromSnapshotParams"],
+]:
+    global _daytona_cached, _daytona_checked  # pylint: disable=global-statement
+
+    if _daytona_checked:
+        if _daytona_cached is None:
+            raise ImportError("daytona is required for Daytona sandbox execution.")
+        return _daytona_cached
+
+    _daytona_checked = True
+    try:
+        from daytona import (
+            Daytona,
+            DaytonaConfig,
+            Sandbox,
+            CreateSandboxFromSnapshotParams,
+        )
+    except Exception as exc:
+        _daytona_cached = None
+        raise ImportError("daytona is required for Daytona sandbox execution.") from exc
+
+    _daytona_cached = (
+        Daytona,
+        DaytonaConfig,
+        Sandbox,
+        CreateSandboxFromSnapshotParams,
+    )
+    return _daytona_cached

agenta/sdk/workflows/builtin.py

@@ -166,11 +166,13 @@ def auto_custom_code_run(
     #
     correct_answer_key: Optional[str] = "correct_answer",
     threshold: Optional[float] = 0.5,
+    runtime: Optional[str] = "python",
 ) -> Workflow:
     parameters = dict(
         code=code,
         correct_answer_key=correct_answer_key,
         threshold=threshold,
+        runtime=runtime,
     )
 
     return evaluator(

agenta/sdk/workflows/configurations.py

@@ -5,6 +5,7 @@ echo_v0_configuration = WorkflowServiceConfiguration()
 auto_exact_match_v0_configuration = WorkflowServiceConfiguration()
 auto_regex_test_v0_configuration = WorkflowServiceConfiguration()
 field_match_test_v0_configuration = WorkflowServiceConfiguration()
+json_multi_field_match_v0_configuration = WorkflowServiceConfiguration()
 auto_webhook_test_v0_configuration = WorkflowServiceConfiguration()
 auto_custom_code_run_v0_configuration = WorkflowServiceConfiguration()
 auto_ai_critique_v0_configuration = WorkflowServiceConfiguration()