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

agenta/__init__.py

@@ -8,7 +8,7 @@ from .sdk import assets as assets
 # evaluations
 from .sdk import testsets as testsets
 from .sdk import tracer
-from .sdk.agenta_init import AgentaSingleton, Config
+from .sdk.agenta_init import AgentaSingleton
 from .sdk.agenta_init import init as _init
 from .sdk.context.running import workflow_mode_enabled
 from .sdk.decorators.running import (
@@ -18,7 +18,6 @@ from .sdk.decorators.running import (
 )
 from .sdk.decorators.serving import app, route
 from .sdk.decorators.tracing import instrument
-from .sdk.litellm import litellm as callbacks
 from .sdk.managers.apps import AppManager
 from .sdk.managers.config import ConfigManager
 from .sdk.managers.deployment import DeploymentManager
@@ -46,7 +45,6 @@ from .sdk.utils.costs import calculate_token_usage
 from .sdk.utils.logging import get_module_logger
 from .sdk.utils.preinit import PreInitObject
 
-config = PreInitObject("agenta.config", Config)
 DEFAULT_AGENTA_SINGLETON_INSTANCE = AgentaSingleton()
 
 types = client_types
@@ -58,6 +56,14 @@ tracing = DEFAULT_AGENTA_SINGLETON_INSTANCE.tracing  # type: ignore
 tracer = get_tracer(tracing)
 
 
+def __getattr__(name: str):
+    if name == "callbacks":
+        from .sdk.litellm import litellm as callbacks
+
+        return callbacks
+    raise AttributeError(f"module '{__name__}' has no attribute '{name}'")
+
+
 def init(
     host: Optional[str] = None,
     api_url: Optional[str] = None,

agenta/sdk/__init__.py

@@ -73,7 +73,7 @@ from agenta.sdk.decorators.running import (
 )
 from agenta.sdk.decorators.serving import route, app
 from .tracing.conventions import Reference
-from .agenta_init import Config, AgentaSingleton, init as _init
+from .agenta_init import AgentaSingleton, init as _init
 from .utils.costs import calculate_token_usage
 from .managers.apps import AppManager
 from .managers.vault import VaultManager
@@ -83,9 +83,7 @@ from .managers.variant import VariantManager
 from .managers.deployment import DeploymentManager
 from .managers import testsets as testsets
 
-
-config = PreInitObject("agenta.config", Config)
-DEFAULT_AGENTA_SINGLETON_INSTANCE = AgentaSingleton()
+DEFAULT_AGENTA_SINGLETON_INSTANCE: AgentaSingleton = AgentaSingleton()
 
 types = client_types
 

agenta/sdk/agenta_init.py

@@ -2,8 +2,7 @@ from importlib.metadata import version
 from os import getenv
 from typing import Any, Callable, Optional
 
-import requests
-import toml
+import httpx
 from agenta.client.client import AgentaApi, AsyncAgentaApi
 from agenta.sdk.contexts.routing import RoutingContext
 from agenta.sdk.tracing import Tracing
@@ -86,22 +85,13 @@ class AgentaSingleton:
 
         log.info("Agenta -     SDK ver: %s", version("agenta"))
 
-        config = {}
-        if config_fname:
-            config = toml.load(config_fname)
-
-        _host = (
-            host
-            or getenv("AGENTA_HOST")
-            or config.get("host")
-            or "https://cloud.agenta.ai"
-        )
+        _host = host or getenv("AGENTA_HOST") or "https://cloud.agenta.ai"
 
         _api_url = (
             api_url
+            #
             or getenv("AGENTA_API_INTERNAL_URL")
             or getenv("AGENTA_API_URL")
-            or config.get("api_url")
             or None  # NO FALLBACK
         )
 
@@ -127,29 +117,29 @@ class AgentaSingleton:
 
         self.api_key = (
             api_key
+            #
             or getenv("AGENTA_API_KEY")
-            or config.get("api_key")
             or None  # NO FALLBACK
         )
 
         if self.api_key is None:
-            log.error(
-                "API key is required. Please set AGENTA_API_KEY environment variable or pass api_key parameter in ag.init()."
+            log.warning(
+                "API key is required (in most cases). Please set AGENTA_API_KEY environment variable or pass api_key parameter in ag.init()."
             )
 
         log.info("Agenta -     API URL: %s", self.api_url)
 
         self.scope_type = (
             scope_type
+            #
             or getenv("AGENTA_SCOPE_TYPE")
-            or config.get("scope_type")
             or None  # NO FALLBACK
         )
 
         self.scope_id = (
             scope_id
+            #
             or getenv("AGENTA_SCOPE_ID")
-            or config.get("scope_id")
             or None  # NO FALLBACK
         )
 
@@ -173,11 +163,6 @@ class AgentaSingleton:
             api_key=self.api_key if self.api_key else "",
         )
 
-        self.config = Config(
-            host=self.host,
-            api_key=self.api_key,
-        )
-
         # Reset cached scope info on re-init
         self.organization_id = None
         self.workspace_id = None
@@ -190,21 +175,21 @@ class AgentaSingleton:
             and self.workspace_id is not None
             and self.project_id is not None
         ):
-            return
+            return None
 
         if self.api_url is None or self.api_key is None:
             log.error("API URL or API key is not set. Please call ag.init() first.")
-            return
+            return None
 
         try:
-            response = requests.get(
-                f"{self.api_url}/projects/current",
-                headers={"Authorization": f"ApiKey {self.api_key}"},
-                timeout=10,
-            )
-            response.raise_for_status()
-
-            project_info = response.json()
+            with httpx.Client() as client:
+                response = client.get(
+                    f"{self.api_url}/projects/current",
+                    headers={"Authorization": f"ApiKey {self.api_key}"},
+                    timeout=10,
+                )
+                response.raise_for_status()
+                project_info = response.json()
 
             if not project_info:
                 log.error(
@@ -226,7 +211,7 @@ class AgentaSingleton:
 
         except Exception as e:
             log.error(f"Failed to fetch scope information: {e}")
-            return
+            return None
 
         if self.organization_id and self.workspace_id and self.project_id:
             return (
@@ -238,50 +223,16 @@ class AgentaSingleton:
         return None
 
 
-class Config:
-    def __init__(
-        self,
-        **kwargs,
-    ):
-        self.default_parameters = {**kwargs}
-
-    def set_default(self, **kwargs):
-        self.default_parameters.update(kwargs)
-
-    def get_default(self):
-        return self.default_parameters
-
-    def __getattr__(self, key):
-        context = RoutingContext.get()
-
-        parameters = context.parameters
-
-        if not parameters:
-            return None
-
-        if key in parameters:
-            value = parameters[key]
-
-            if isinstance(value, dict):
-                nested_config = Config()
-                nested_config.set_default(**value)
-
-                return nested_config
-
-            return value
-
-        return None
-
-
 def init(
     host: Optional[str] = None,
     api_url: Optional[str] = None,
     api_key: Optional[str] = None,
-    config_fname: Optional[str] = None,
     redact: Optional[Callable[..., Any]] = None,
     redact_on_error: Optional[bool] = True,
     scope_type: Optional[str] = None,
     scope_id: Optional[str] = None,
+    # DEPRECATED
+    config_fname: Optional[str] = None,
 ):
     """Main function to initialize the agenta sdk.
 
@@ -306,14 +257,10 @@ def init(
         host=host,
         api_url=api_url,
         api_key=api_key,
-        config_fname=config_fname,
         redact=redact,
         redact_on_error=redact_on_error,
         scope_type=scope_type,
         scope_id=scope_id,
     )
 
-    set_global(
-        config=singleton.config,
-        tracing=singleton.tracing,
-    )
+    set_global(tracing=singleton.tracing)

agenta/sdk/context/serving.py

@@ -9,6 +9,8 @@ from pydantic import BaseModel
 class RoutingContext(BaseModel):
     parameters: Optional[Dict[str, Any]] = None
     secrets: Optional[List[Any]] = None
+    local_secrets: Optional[List[Any]] = None
+    vault_secrets: Optional[List[Any]] = None
     mock: Optional[str] = None
 
     @classmethod

agenta/sdk/contexts/routing.py

@@ -8,6 +8,8 @@ from pydantic import BaseModel
 class RoutingContext(BaseModel):
     parameters: Optional[dict] = None
     secrets: Optional[list] = None
+    local_secrets: Optional[list] = None
+    vault_secrets: Optional[list] = None
     mock: Optional[str] = None
 
     @classmethod

agenta/sdk/contexts/running.py

@@ -2,7 +2,6 @@ from typing import Optional, Union, Callable
 from contextvars import Token, ContextVar
 from contextlib import contextmanager
 
-
 from pydantic import BaseModel
 
 from agenta.sdk.models.workflows import (
@@ -24,8 +23,10 @@ class RunningContext(BaseModel):
     parameters: Optional[dict] = None
     schemas: Optional[dict] = None
 
-    secrets: Optional[list] = None
     credentials: Optional[str] = None
+    secrets: Optional[list] = None
+    local_secrets: Optional[list] = None
+    vault_secrets: Optional[list] = None
 
     handler: Optional[Callable] = None
 

agenta/sdk/decorators/running.py

@@ -321,10 +321,14 @@ class workflow:
         _tags = {**(self.tags or {}), **(request.tags or {})}
         _meta = {**(self.meta or {}), **(request.meta or {})}
 
-        credentials = credentials or (
-            f"ApiKey {ag.DEFAULT_AGENTA_SINGLETON_INSTANCE.api_key}"
-            if ag.DEFAULT_AGENTA_SINGLETON_INSTANCE.api_key
-            else None
+        credentials = (
+            credentials
+            or request.credentials
+            or (
+                f"ApiKey {ag.DEFAULT_AGENTA_SINGLETON_INSTANCE.api_key}"
+                if ag.DEFAULT_AGENTA_SINGLETON_INSTANCE.api_key
+                else None
+            )
         )
 
         with tracing_context_manager(TracingContext.get()):

agenta/sdk/decorators/serving.py

@@ -1,62 +1,81 @@
-from asyncio import sleep
-from functools import wraps
+from typing import Type, Any, Callable, Dict, Optional, Tuple, List, TYPE_CHECKING
 from inspect import (
-    Parameter,
-    Signature,
-    isasyncgen,
     iscoroutinefunction,
     isgenerator,
+    isasyncgen,
     signature,
+    Signature,
+    Parameter,
 )
-from os import environ
+from functools import wraps
 from traceback import format_exception
-from typing import Any, Callable, Dict, List, Optional, Tuple, Type
+from asyncio import sleep
 from uuid import UUID
+from pydantic import BaseModel, HttpUrl, ValidationError
+from os import environ
+
+if TYPE_CHECKING:
+    from fastapi import Request, HTTPException, Body
+    from starlette.responses import Response as StarletteResponse, StreamingResponse
+else:
+    # Lazy imports - only loaded when @entrypoint or @route is used
+    Request = None
+    HTTPException = None
+    Body = None
 
-import agenta as ag
 from agenta.sdk.contexts.routing import (
-    RoutingContext,
     routing_context_manager,
+    RoutingContext,
 )
 from agenta.sdk.contexts.tracing import (
-    TracingContext,
     tracing_context_manager,
+    TracingContext,
 )
-from agenta.sdk.middleware.auth import AuthHTTPMiddleware
-from agenta.sdk.middleware.config import ConfigMiddleware
-from agenta.sdk.middleware.cors import CORSMiddleware
-from agenta.sdk.middleware.inline import InlineMiddleware
-from agenta.sdk.middleware.mock import MockMiddleware
-from agenta.sdk.middleware.otel import OTelMiddleware
-from agenta.sdk.middleware.vault import VaultMiddleware
 from agenta.sdk.router import router
+from agenta.sdk.utils.exceptions import suppress, display_exception
+from agenta.sdk.utils.logging import get_module_logger
+from agenta.sdk.utils.helpers import get_current_version
+from agenta.sdk.utils.lazy import _load_fastapi, _load_starlette_responses
 from agenta.sdk.types import (
-    BaseResponse,
     MultipleChoice,
+    BaseResponse,
     StreamResponse,
-)
-from agenta.sdk.utils.exceptions import display_exception, suppress
-from agenta.sdk.utils.helpers import get_current_version
-from agenta.sdk.utils.logging import get_module_logger
-from fastapi import Body, FastAPI, HTTPException, Request
-from pydantic import BaseModel, HttpUrl, ValidationError
-from starlette.responses import (
-    Response as StarletteResponse,
-)
-from starlette.responses import (
-    StreamingResponse,
+    MCField,
 )
 
+import agenta as ag
+
 log = get_module_logger(__name__)
 
 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)
+# Lazy FastAPI initialization
+class _LazyApp:
+    """Lazy wrapper for FastAPI app - only imported when accessed."""
+
+    _app = None
+
+    def _get_app(self):
+        if self._app is None:
+            fastapi = _load_fastapi()
+            from agenta.sdk.router import get_router
+
+            self._app = fastapi.FastAPI(
+                docs_url=f"{AGENTA_RUNTIME_PREFIX}/docs",  # Swagger UI
+                openapi_url=f"{AGENTA_RUNTIME_PREFIX}/openapi.json",  # OpenAPI schema
+            )
+            self._app.include_router(get_router(), prefix=AGENTA_RUNTIME_PREFIX)
+        return self._app
+
+    def __getattr__(self, name):
+        return getattr(self._get_app(), name)
+
+    async def __call__(self, scope, receive, send):
+        return await self._get_app()(scope, receive, send)
+
+
+app = _LazyApp()  # type: ignore
 
 
 class PathValidator(BaseModel):
@@ -140,16 +159,32 @@ class entrypoint:
         route_path: str = "",
         config_schema: Optional[BaseModel] = None,
     ):
+        # Lazy import fastapi components - only loaded when decorator is used
+        fastapi = _load_fastapi()
+
         self.func = func
         self.route_path = route_path
         self.config_schema = config_schema
 
+        # Store for use in methods
+        self._Request = fastapi.Request
+        self._HTTPException = fastapi.HTTPException
+        self._Body = fastapi.Body
+
         signature_parameters = signature(func).parameters
         config, default_parameters = self.parse_config()
 
         ### --- Middleware --- #
         if not entrypoint._middleware:
             entrypoint._middleware = True
+            from agenta.sdk.middleware.mock import MockMiddleware
+            from agenta.sdk.middleware.inline import InlineMiddleware
+            from agenta.sdk.middleware.vault import VaultMiddleware
+            from agenta.sdk.middleware.config import ConfigMiddleware
+            from agenta.sdk.middleware.otel import OTelMiddleware
+            from agenta.sdk.middleware.auth import AuthHTTPMiddleware
+            from agenta.sdk.middleware.cors import CORSMiddleware
+
             app.add_middleware(MockMiddleware)
             app.add_middleware(InlineMiddleware)
             app.add_middleware(VaultMiddleware)
@@ -177,7 +212,7 @@ class entrypoint:
                 request.state.config["parameters"] is None
                 or request.state.config["references"] is None
             ):
-                raise HTTPException(
+                raise self._HTTPException(
                     status_code=400,
                     detail="Config not found based on provided references.",
                 )
@@ -318,12 +353,12 @@ class entrypoint:
 
     async def execute_wrapper(
         self,
-        request: Request,
+        request: "Request",  # type: ignore
         *args,
         **kwargs,
     ):
         if not request:
-            raise HTTPException(status_code=500, detail="Missing 'request'.")
+            raise self._HTTPException(status_code=500, detail="Missing 'request'.")
 
         state = request.state
         traceparent = state.otel.get("traceparent")
@@ -332,6 +367,8 @@ class entrypoint:
         parameters = state.config.get("parameters")
         references = state.config.get("references")
         secrets = state.vault.get("secrets")
+        local_secrets = state.vault.get("local_secrets")
+        vault_secrets = state.vault.get("vault_secrets")
         inline = state.inline
         mock = state.mock
 
@@ -339,6 +376,8 @@ class entrypoint:
             context=RoutingContext(
                 parameters=parameters,
                 secrets=secrets,
+                local_secrets=local_secrets,
+                vault_secrets=vault_secrets,
                 mock=mock,
             )
         ):
@@ -368,6 +407,8 @@ class entrypoint:
         result: Any,
         inline: bool,
     ):
+        StarletteResponse, StreamingResponse = _load_starlette_responses()
+
         data = None
         content_type = "text/plain"
 
@@ -472,7 +513,7 @@ class entrypoint:
                 span_id,
             ) = await self.fetch_inline_trace(inline)
 
-        raise HTTPException(
+        raise self._HTTPException(
             status_code=status_code,
             detail=dict(
                 message=str(error),
@@ -584,7 +625,7 @@ class entrypoint:
             Parameter(
                 "request",
                 kind=Parameter.POSITIONAL_OR_KEYWORD,
-                annotation=Request,
+                annotation=self._Request,
             ),
             *original_sig.parameters.values(),
         ]
@@ -647,7 +688,7 @@ class entrypoint:
                 name=self._config_key,
                 kind=Parameter.KEYWORD_ONLY,
                 annotation=type(config_instance),  # Get the actual class type
-                default=Body(config_instance),  # Use the instance directly
+                default=self._Body(config_instance),  # Use the instance directly
             )
         )
 
@@ -661,7 +702,7 @@ class entrypoint:
                 Parameter(
                     name,
                     Parameter.KEYWORD_ONLY,
-                    default=Body(..., embed=True),
+                    default=self._Body(..., embed=True),
                     annotation=param.default.__class__.__bases__[
                         0
                     ],  # determines and get the base (parent/inheritance) type of the sdk-type at run-time. \

agenta/sdk/engines/tracing/inline.py

@@ -957,9 +957,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
 
 
@@ -1120,6 +1121,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/evaluations/preview/evaluate.py

@@ -126,10 +126,11 @@ async def _upsert_entities(
                 for testcases_data in simple_evaluation_data.testset_steps:
                     if isinstance(testcases_data, List):
                         if all(isinstance(step, Dict) for step in testcases_data):
-                            testset_revision_id = await acreate_testset(
+                            created_revision = await acreate_testset(
                                 data=testcases_data,
                             )
-                            testset_steps[str(testset_revision_id)] = "custom"
+                            if created_revision and created_revision.id:
+                                testset_steps[str(created_revision.id)] = "custom"
 
             simple_evaluation_data.testset_steps = testset_steps
 
@@ -215,15 +216,16 @@ async def _retrieve_entities(
     Dict[UUID, EvaluatorRevision],
 ]:
     testset_revisions: Dict[UUID, TestsetRevision] = {}
-    # for testset_revision_id, origin in simple_evaluation_data.testset_steps.items():
-    #     testset_revision = await retrieve_testset(
-    #         testset_revision_id=testset_revision_id,
-    #     )
-    for testset_id, origin in simple_evaluation_data.testset_steps.items():
+    for testset_ref, origin in simple_evaluation_data.testset_steps.items():
         testset_revision = await aretrieve_testset(
-            testset_id=testset_id,
+            testset_revision_id=testset_ref,
         )
 
+        if not testset_revision or not testset_revision.id:
+            testset_revision = await aretrieve_testset(
+                testset_id=testset_ref,
+            )
+
         if not testset_revision or not testset_revision.id:
             continue
 
@@ -308,6 +310,32 @@ async def aevaluate(
         "────────────────────────────────────────────────────────────────────────────"
     )
 
+    # Normalize testset_steps to revision ids (no JIT transfers in backend)
+    if simple_evaluation_data.testset_steps and isinstance(
+        simple_evaluation_data.testset_steps, dict
+    ):
+        normalized_testset_steps: Dict[str, Origin] = {}
+        for testset_id_str, origin in simple_evaluation_data.testset_steps.items():
+            try:
+                testset_uuid = UUID(str(testset_id_str))
+            except Exception:
+                continue
+
+            testset_revision = await aretrieve_testset(
+                testset_revision_id=testset_uuid,
+            )
+
+            if not testset_revision or not testset_revision.id:
+                # Fallback: treat as testset_id (latest revision)
+                testset_revision = await aretrieve_testset(
+                    testset_id=testset_uuid,
+                )
+
+            if testset_revision and testset_revision.id:
+                normalized_testset_steps[str(testset_revision.id)] = origin
+
+        simple_evaluation_data.testset_steps = normalized_testset_steps
+
     suffix = _timestamp_suffix()
     name = f"{name}{suffix}"
 

agenta/sdk/evaluations/runs.py

@@ -68,7 +68,8 @@ async def acreate(
                 repeats=repeats,
             ),
             #
-            jit={"testsets": True, "evaluators": False},
+            # Default: expect callers to pass testset revision ids; no JIT migration
+            jit={"testsets": False, "evaluators": False},
         )
     )
 

agenta/sdk/litellm/mockllm.py

@@ -2,9 +2,8 @@ from typing import Optional, Protocol, Any
 from os import environ
 from contextlib import contextmanager
 
-import litellm
-
 from agenta.sdk.utils.logging import get_module_logger
+from agenta.sdk.utils.lazy import _load_litellm
 
 from agenta.sdk.litellm.mocks import MOCKS
 from agenta.sdk.contexts.routing import RoutingContext
@@ -81,6 +80,7 @@ async def acompletion(*args, **kwargs):
 
         return MOCKS[mock](*args, **kwargs)
 
+    litellm = _load_litellm(injected=globals().get("litellm"))
     if not litellm:
         raise ValueError("litellm not found")
 

agenta/sdk/managers/config.py

@@ -2,10 +2,10 @@ import json
 from pathlib import Path
 from typing import Optional, Type, TypeVar, Dict, Any, Union
 
-import yaml
 from pydantic import BaseModel
 
 from agenta.sdk.utils.logging import get_module_logger
+from agenta.sdk.utils.lazy import _load_yaml
 from agenta.sdk.managers.shared import SharedManager
 from agenta.sdk.contexts.routing import RoutingContext
 
@@ -174,6 +174,8 @@ class ConfigManager:
         """
         file_path = Path(filename)
 
+        yaml = _load_yaml()
+
         with open(file_path, "r", encoding="utf-8") as file:
             parameters = yaml.safe_load(file)