lumera 0.41.0.dev1__tar.gz → 0.41.0.dev2026090401__tar.gz

{lumera-0.41.0.dev1 → lumera-0.41.0.dev2026090401}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: lumera
-Version: 0.41.0.dev1
+Version: 0.41.0.dev2026090401
 Summary: SDK for building on Lumera platform
 Requires-Python: >=3.11
 Requires-Dist: requests

{lumera-0.41.0.dev1 → lumera-0.41.0.dev2026090401}/lumera/_utils.py

@@ -9,6 +9,7 @@ import mimetypes
 import os
 import pathlib
 import time as _time
+from contextvars import ContextVar, Token
 from dataclasses import dataclass
 from functools import wraps as _wraps
 from typing import IO, Any, Callable, Iterable, Mapping, MutableMapping, Sequence, TypeVar
@@ -27,6 +28,33 @@ ENV_PATH = "/root/.env"
 LOCAL_CREDS_PATH = ".lumera/credentials.json"
 GLOBAL_CREDS_PATH = os.path.join(os.path.expanduser("~"), ".config", "lumera", "credentials.json")
 
+_runtime_actor_user_id: ContextVar[str] = ContextVar("lumera_runtime_actor_user_id", default="")
+_runtime_lumera_token: ContextVar[str] = ContextVar("lumera_runtime_lumera_token", default="")
+
+
+def _set_runtime_actor_user_id(user_id: str) -> Token[str]:
+    """Bind an authenticated runtime actor to the current async request."""
+
+    return _runtime_actor_user_id.set(user_id.strip())
+
+
+def _reset_runtime_actor_user_id(token: Token[str]) -> None:
+    """Restore the runtime actor context after a request completes."""
+
+    _runtime_actor_user_id.reset(token)
+
+
+def _set_runtime_lumera_token(value: str) -> Token[str]:
+    """Bind an execution-scoped credential to one runtime invocation."""
+
+    return _runtime_lumera_token.set(value.strip())
+
+
+def _reset_runtime_lumera_token(token: Token[str]) -> None:
+    """Restore the credential active before the runtime invocation."""
+
+    _runtime_lumera_token.reset(token)
+
 
 def _credentials_paths() -> tuple[str, ...]:
     explicit = os.getenv(CREDENTIALS_PATH_ENV, "").strip()
@@ -117,27 +145,36 @@ def _read_token_from_creds_file(path: str) -> str | None:
 
 
 def get_lumera_token() -> str:
-    """Get Lumera API token from environment or credentials files.
+    """Get Lumera API token from runtime context, environment, or credentials files.
 
     Priority:
-    1. LUMERA_TOKEN environment variable
-    2. LUMERA_CREDENTIALS_PATH (sandbox runtime credentials)
-    3. .lumera/credentials.json (project-local, from CLI login --local)
-    4. ~/.config/lumera/credentials.json (global, from CLI login)
-    5. /root/.env (legacy, for automations in sandbox)
+    1. Execution-scoped runtime credential
+    2. LUMERA_TOKEN environment variable
+    3. LUMERA_CREDENTIALS_PATH (sandbox runtime credentials)
+    4. .lumera/credentials.json (project-local, from CLI login --local)
+    5. ~/.config/lumera/credentials.json (global, from CLI login)
+    6. /root/.env (legacy, for automations in sandbox)
     """
-    # 1. Check environment variable (highest priority)
+    # The warmed API process handles different invocation identities over its
+    # lifetime, so changing the process environment would leak credentials
+    # across requests. Context variables follow async tasks and are explicitly
+    # copied into the runtime's sync-function threads.
+    token = _runtime_lumera_token.get().strip()
+    if token:
+        return token
+
+    # 2. Check environment variable.
     token = os.getenv(TOKEN_ENV)
     if token:
         return token
 
-    # 2-4. Check explicit runtime, project-local, then global credentials.
+    # 3-5. Check explicit runtime, project-local, then global credentials.
     for path in _credentials_paths():
         token = _read_token_from_creds_file(path)
         if token:
             return token
 
-    # 5. /root/.env is already loaded via dotenv at module load time
+    # 6. /root/.env is already loaded via dotenv at module load time
     # so if we get here, no token was found anywhere
     raise RuntimeError(
         f"{TOKEN_ENV} not found. Checked: environment, {_credentials_paths()}, "
@@ -205,7 +242,7 @@ def _parse_expiry(expires_at: int | float | str | None) -> float:
     raise TypeError(f"Unsupported expires_at format: {type(expires_at)!r}")
 
 
-def _fetch_access_token(provider: str) -> tuple[str, float, str]:
+def _fetch_access_token(provider: str) -> tuple[str, float]:
     provider = provider.lower().strip()
     if not provider:
         raise ValueError("provider is required")
@@ -218,16 +255,15 @@ def _fetch_access_token(provider: str) -> tuple[str, float, str]:
     data = resp.json()
     access_token = data.get("access_token")
     expires_at = data.get("expires_at")
-    credential_scope = str(data.get("credential_scope") or "")
 
     if not access_token:
         raise RuntimeError(f"Malformed response from Lumera when fetching {provider} access token")
 
     expiry_ts = _parse_expiry(expires_at)
-    return access_token, expiry_ts, credential_scope
+    return access_token, expiry_ts
 
 
-def get_access_token(provider: str, min_valid_seconds: int = 900, *, cache: bool = True) -> str:
+def get_access_token(provider: str, min_valid_seconds: int = 900) -> str:
     """Get the raw access token string for *provider*.
 
     .. deprecated::
@@ -240,8 +276,8 @@ def get_access_token(provider: str, min_valid_seconds: int = 900, *, cache: bool
     providers this is the token itself; for basic-auth providers it is the
     base64-encoded ``username:password``.
 
-    Shared results are cached in-process; delegated results are never cached.
-    Pass ``cache=False`` to bypass and avoid populating shared caches.
+    Results are cached in-process; a fresh fetch is performed when the cached
+    token is within *min_valid_seconds* of expiry (default 15 min).
     """
     global _token_cache
 
@@ -251,22 +287,19 @@ def get_access_token(provider: str, min_valid_seconds: int = 900, *, cache: bool
 
     now = _time.time()
 
-    cached = _token_cache.get(provider) if cache else None
+    cached = _token_cache.get(provider)
     if cached is not None:
         access_token, expiry_ts = cached
         if (expiry_ts - now) >= min_valid_seconds:
             return access_token
 
-    access_token, expiry_ts, credential_scope = _fetch_access_token(provider)
-    if credential_scope == "delegated":
-        _evict_credential_caches(provider)
-    elif cache:
-        _token_cache[provider] = (access_token, expiry_ts)
+    access_token, expiry_ts = _fetch_access_token(provider)
+    _token_cache[provider] = (access_token, expiry_ts)
     return access_token
 
 
-def get_google_access_token(min_valid_seconds: int = 900, *, cache: bool = True) -> str:
-    return get_access_token("google", min_valid_seconds=min_valid_seconds, cache=cache)
+def get_google_access_token(min_valid_seconds: int = 900) -> str:
+    return get_access_token("google", min_valid_seconds=min_valid_seconds)
 
 
 @dataclass(frozen=True)
@@ -309,9 +342,6 @@ class Credentials:
     extra_headers: dict[str, str] | None = None
     """Additional provider-required HTTP headers."""
 
-    credential_scope: str = ""
-    """Credential isolation mode. ``"delegated"`` values are never cached."""
-
     def as_header_dict(self) -> dict[str, str]:
         """Return headers suitable for ``requests.get(headers=...)``."""
         headers = {self.header_name: self.header_value}
@@ -323,13 +353,6 @@ class Credentials:
 _credentials_cache: dict[tuple[str, str], tuple[Credentials, float]] = {}
 
 
-def _evict_credential_caches(api_name: str) -> None:
-    _token_cache.pop(api_name, None)
-    for key in tuple(_credentials_cache):
-        if key[0] == api_name:
-            _credentials_cache.pop(key, None)
-
-
 def _fetch_credentials(api_name: str, provider: str | None = None) -> Credentials:
     api_name = api_name.lower().strip()
     if not api_name:
@@ -354,7 +377,6 @@ def _fetch_credentials(api_name: str, provider: str | None = None) -> Credential
     # Collect provider-specific extra fields (anything beyond the standard set).
     _standard_keys = {
         "access_token",
-        "credential_scope",
         "auth_type",
         "header_name",
         "header_value",
@@ -377,7 +399,6 @@ def _fetch_credentials(api_name: str, provider: str | None = None) -> Credential
         token=access_token,
         provider=str(data.get("provider") or provider_hint or api_name),
         header_name=data.get("header_name", "Authorization"),
-        credential_scope=str(data.get("credential_scope") or ""),
         header_value=data.get("header_value", f"Bearer {access_token}"),
         username=data.get("username"),
         expires_at=expiry_ts if expiry_ts != float("inf") else None,
@@ -390,16 +411,14 @@ def get_credentials(
     api_name: str | None = None,
     provider: str | None = None,
     min_valid_seconds: int = 900,
-    *,
-    cache: bool = True,
 ) -> Credentials:
     """Get a :class:`Credentials` object for *api_name*.
 
     This is the recommended way to obtain integration credentials.  The
     returned object includes the auth type, ready-to-use HTTP headers, and
-    (where applicable) the username. Shared results are cached in-process;
-    delegated results are never cached. Pass ``cache=False`` to bypass and
-    avoid populating shared caches.
+    (where applicable) the username.  Results are cached in-process; a
+    fresh fetch is performed when the cached credential is within
+    *min_valid_seconds* of expiry (default 15 min).
 
     Works with any auth type configured in the Lumera integrations page
     (bearer token, basic auth, etc.).
@@ -450,7 +469,7 @@ def get_credentials(
 
     now = _time.time()
     cache_key = (api_name, provider_hint)
-    cached = _credentials_cache.get(cache_key) if cache else None
+    cached = _credentials_cache.get(cache_key)
     if cached is not None:
         creds, expiry_ts = cached
         if (expiry_ts - now) >= min_valid_seconds:
@@ -458,12 +477,10 @@ def get_credentials(
 
     creds = _fetch_credentials(api_name, provider=provider_hint or None)
     expiry_ts = creds.expires_at if creds.expires_at is not None else float("inf")
-    if creds.credential_scope == "delegated":
-        _evict_credential_caches(api_name)
-    elif cache:
-        _credentials_cache[cache_key] = (creds, expiry_ts)
-        # Keep the legacy _token_cache in sync so get_access_token stays fast.
-        _token_cache[api_name] = (creds.token, expiry_ts)
+    _credentials_cache[cache_key] = (creds, expiry_ts)
+
+    # Keep the legacy _token_cache in sync so get_access_token stays fast.
+    _token_cache[api_name] = (creds.token, expiry_ts)
 
     return creds
 
@@ -787,7 +804,7 @@ def _api_headers(
     # User context: forward the human driving an agent turn so the backend
     # attributes mutations to the user (with the agent preserved). Honored only
     # for agent tokens; ignored otherwise. Mirrors the CLI and the lumera_api tool.
-    _user_id = os.getenv("LUMERA_USER_ID", "").strip()
+    _user_id = _runtime_actor_user_id.get().strip() or os.getenv("LUMERA_USER_ID", "").strip()
     if _user_id:
         headers["X-Lumera-User-Id"] = _user_id
 
@@ -802,10 +819,13 @@ def _api_request(
     json_body: Mapping[str, Any] | None = None,
     data: Mapping[str, Any] | None = None,
     files: Mapping[str, Any] | None = None,
+    request_headers: Mapping[str, str] | None = None,
     timeout: int = 30,
 ) -> object | None:
     url = _api_url(path)
     headers = _api_headers()
+    if request_headers:
+        headers.update(request_headers)
 
     session = _get_session()
     resp = session.request(

{lumera-0.41.0.dev1 → lumera-0.41.0.dev2026090401}/lumera/function_resources.py

@@ -114,17 +114,25 @@ def list_function_executions(
     return _list("function-executions", project, cursor=cursor, limit=limit)
 
 
-def get_function_execution(project: str, execution: str) -> dict[str, Any]:
+def get_function_execution(
+    project: str,
+    execution: str,
+    *,
+    wait_seconds: int | None = None,
+) -> dict[str, Any]:
     project_ref = _required_ref(project, "project")
     execution_ref = _required_ref(execution, "execution")
     path = (
         f"projects/{quote(project_ref, safe='')}/function-executions/"
         f"{quote(execution_ref, safe='')}"
     )
-    payload = _api_request(
-        "GET",
-        path,
-    )
+    options: dict[str, Any] = {}
+    if wait_seconds is not None:
+        if isinstance(wait_seconds, bool) or not 1 <= wait_seconds <= 30:
+            raise ValueError("wait_seconds must be between 1 and 30")
+        options["request_headers"] = {"Prefer": f"wait={wait_seconds}"}
+        options["timeout"] = wait_seconds + 5
+    payload = _api_request("GET", path, **options)
     return _mapping(payload, "Function execution")
 
 

{lumera-0.41.0.dev1 → lumera-0.41.0.dev2026090401}/lumera/functions/_remote.py

@@ -11,6 +11,7 @@ from ._context import FunctionContext
 from ._execution import DurableFunctionTransport, ExecutionHandle, ExecutionStatus, StartedExecution
 
 _TERMINAL = {"succeeded", "failed", "indeterminate", "timed_out", "cancelled"}
+_MAX_LONG_POLL_SECONDS = 20
 
 
 class RemoteFunctionTransport(DurableFunctionTransport):
@@ -39,10 +40,18 @@ class RemoteFunctionTransport(DurableFunctionTransport):
         return StartedExecution(execution_id=str(execution["id"]), status=str(execution["status"]))
 
     async def get_status(self, execution_id: str) -> ExecutionStatus:
+        return await self._get_status(execution_id)
+
+    async def _get_status(
+        self, execution_id: str, *, wait_seconds: int | None = None
+    ) -> ExecutionStatus:
         from lumera import function_resources
 
         response = await asyncio.to_thread(
-            function_resources.get_function_execution, self.project, execution_id
+            function_resources.get_function_execution,
+            self.project,
+            execution_id,
+            wait_seconds=wait_seconds,
         )
         execution = _execution(response)
         error = None
@@ -61,7 +70,15 @@ class RemoteFunctionTransport(DurableFunctionTransport):
     async def get_result(self, execution_id: str, *, timeout: float) -> object:
         deadline = time.monotonic() + timeout
         while True:
-            status = await self.get_status(execution_id)
+            remaining = deadline - time.monotonic()
+            if remaining <= 0:
+                raise TimeoutError(f"Function execution {execution_id} did not finish in time")
+            wait_seconds = min(_MAX_LONG_POLL_SECONDS, int(remaining))
+            request_started = time.monotonic()
+            status = await self._get_status(
+                execution_id,
+                wait_seconds=wait_seconds if wait_seconds >= 1 else None,
+            )
             if status.status in _TERMINAL:
                 if status.status != "succeeded":
                     raise RuntimeError(
@@ -72,7 +89,11 @@ class RemoteFunctionTransport(DurableFunctionTransport):
             remaining = deadline - time.monotonic()
             if remaining <= 0:
                 raise TimeoutError(f"Function execution {execution_id} did not finish in time")
-            await asyncio.sleep(min(1.0, remaining))
+            # An older backend may ignore Prefer and return immediately. Preserve
+            # coarse one-second polling in that case instead of hammering its status
+            # endpoint; completion-aware backends normally hold this request.
+            request_elapsed = time.monotonic() - request_started
+            await asyncio.sleep(min(max(0.0, 1.0 - request_elapsed), remaining))
 
 
 def invoke_remote(

{lumera-0.41.0.dev1 → lumera-0.41.0.dev2026090401}/lumera/functions/_runtime.py

@@ -3,6 +3,7 @@
 from __future__ import annotations
 
 import asyncio
+import contextvars
 import json
 import threading
 import uuid
@@ -106,10 +107,12 @@ class _InvocationSyncLane:
             self._thread_counter += 1
             thread_number = self._thread_counter
 
+        request_context = contextvars.copy_context()
+
         def invoke() -> None:
             outcome: tuple[object | None, BaseException | None]
             try:
-                result = callable_(*args)
+                result = request_context.run(callable_, *args)
             except BaseException as exc:
                 outcome = (None, exc)
             else:

{lumera-0.41.0.dev1 → lumera-0.41.0.dev2026090401}/lumera/releases/_api_child.py

@@ -10,14 +10,31 @@ import sys
 import tempfile
 import threading
 import time
+from dataclasses import dataclass
 from pathlib import Path
 from typing import Any
 from urllib.parse import urlparse
 from urllib.request import Request, urlopen
 
-from ._projection import ASGIApp, ASGIReceive, ASGISend, create_runtime_app
+from lumera.functions._registry import FunctionRegistry
+
+from ._durable_event import execute_durable_event
+from ._projection import ASGIApp, ASGIReceive, ASGISend, create_release_runtime
 
 MAX_RELEASE_BYTES = 250 * 1024 * 1024
+MAX_EVENT_INPUT = 1_000_000
+WARMED_DURABLE_EVENTS_FEATURE = "durable_function_events_v2"
+
+
+@dataclass(frozen=True)
+class _LoadedRelease:
+    app: ASGIApp
+    temporary_root: Path
+    registry: FunctionRegistry | None = None
+
+    @property
+    def root(self) -> Path:
+        return self.temporary_root / "release"
 
 
 class LazyReleaseApp:
@@ -25,7 +42,7 @@ class LazyReleaseApp:
 
     def __init__(self) -> None:
         self._lock = threading.Lock()
-        self._app: ASGIApp | None = None
+        self._release: _LoadedRelease | None = None
         self._startup_lock: asyncio.Lock | None = None
         self._started = False
         self._lifespan_input: asyncio.Queue[dict[str, object]] | None = None
@@ -46,28 +63,79 @@ class LazyReleaseApp:
             await _json_response(
                 send,
                 200,
-                {"status": "healthy", "release_loaded": self._app is not None},
+                {"status": "healthy", "release_loaded": self._release is not None},
             )
             return
-        app = await self._ready_app()
+        method = str(scope.get("method", "GET")).upper()
+        if scope.get("type") == "http" and method == "POST" and path == "/__lumera/events":
+            await self._serve_durable_event(receive, send)
+            return
+        app = (await self._ready_release()).app
         if scope.get("type") == "http" and path == "/__lumera/warm":
             scope = {**scope, "path": "/__lumera/health", "raw_path": b"/__lumera/health"}
         await app(scope, receive, send)
 
-    async def _ready_app(self) -> ASGIApp:
-        if self._started and self._app is not None:
-            return self._app
+    async def _ready_release(self) -> _LoadedRelease:
+        if self._started and self._release is not None:
+            return self._release
         if self._startup_lock is None:
             self._startup_lock = asyncio.Lock()
         async with self._startup_lock:
-            if self._started and self._app is not None:
-                return self._app
-            app = self._app
-            if app is None:
-                app = await asyncio.to_thread(self._load)
-            await self._start_project_lifespan(app)
+            if self._started and self._release is not None:
+                return self._release
+            release = self._release
+            if release is None:
+                release = await asyncio.to_thread(self._load)
+            await self._start_project_lifespan(release.app)
             self._started = True
-            return app
+            return release
+
+    async def _serve_durable_event(self, receive: ASGIReceive, send: ASGISend) -> None:
+        body = bytearray()
+        more = True
+        while more:
+            event = await receive()
+            if event.get("type") == "http.disconnect":
+                return
+            if event.get("type") != "http.request":
+                continue
+            body.extend(event.get("body", b""))
+            if len(body) > MAX_EVENT_INPUT:
+                await _json_response(send, 413, {"error": "event too large"})
+                return
+            more = bool(event.get("more_body"))
+
+        async def ready_registry() -> FunctionRegistry:
+            release = await self._ready_release()
+            if release.registry is None:
+                raise RuntimeError("release has no Functions")
+            return release.registry
+
+        try:
+            message = json.loads(body or b"{}")
+            if not isinstance(message, dict):
+                raise ValueError("event must be an object")
+            status, response = await execute_durable_event(
+                message,
+                ready_registry=ready_registry,
+            )
+        except ValueError as exc:
+            status, response = 400, {"error": str(exc)}
+        except BaseException as exc:
+            correlation_id = f"fn_{os.urandom(16).hex()}"
+            _log_event(
+                "functions.app.dispatch_failed",
+                error_type=type(exc).__name__,
+                correlation_id=correlation_id,
+            )
+            status, response = (
+                500,
+                {
+                    "error": "durable Function dispatch failed",
+                    "correlation_id": correlation_id,
+                },
+            )
+        await _json_response(send, status, response)
 
     async def _start_project_lifespan(self, app: ASGIApp) -> None:
         input_queue: asyncio.Queue[dict[str, object]] = asyncio.Queue()
@@ -127,12 +195,12 @@ class LazyReleaseApp:
                 await self._lifespan_task
         await send({"type": "lifespan.shutdown.complete"})
 
-    def _load(self) -> ASGIApp:
+    def _load(self) -> _LoadedRelease:
         with self._lock:
-            if self._app is not None:
-                return self._app
-            self._app = _load_release_app()
-            return self._app
+            if self._release is not None:
+                return self._release
+            self._release = _load_release_app()
+            return self._release
 
 
 def _fresh_release_url(expected_digest: str) -> str:
@@ -182,7 +250,7 @@ def _download_release(url: str, destination: Path) -> int:
     return total
 
 
-def _load_release_app() -> ASGIApp:
+def _load_release_app() -> _LoadedRelease:
     started = time.perf_counter()
     digest = os.environ.get("LUMERA_RELEASE_DIGEST", "").strip()
     if len(digest) != 64 or any(character not in "0123456789abcdef" for character in digest):
@@ -236,14 +304,10 @@ def _load_release_app() -> ASGIApp:
             await send({"type": "http.response.start", "status": 404, "headers": []})
             await send({"type": "http.response.body", "body": b""})
 
-    app = create_runtime_app(
+    runtime = create_release_runtime(
         project_app,  # type: ignore[arg-type]
         manifest,
-        health={
-            "release_digest": digest,
-            "runtime_abi": expected_abi,
-            "image_digest": os.environ.get("FUNCTIONS_RUNTIME_IMAGE_DIGEST", ""),
-        },
+        health=_runtime_health(digest, expected_abi),
     )
     imported_ms = _elapsed_ms(import_started)
     _log_event(
@@ -256,7 +320,20 @@ def _load_release_app() -> ASGIApp:
         imported_ms=round(imported_ms, 1),
         total_ms=round(_elapsed_ms(started), 1),
     )
-    return app
+    return _LoadedRelease(
+        app=runtime.app,
+        temporary_root=temporary_root,
+        registry=runtime.registry,
+    )
+
+
+def _runtime_health(release_digest: str, runtime_abi: str) -> dict[str, object]:
+    return {
+        "release_digest": release_digest,
+        "runtime_abi": runtime_abi,
+        "image_digest": os.environ.get("FUNCTIONS_RUNTIME_IMAGE_DIGEST", ""),
+        "runtime_features": [WARMED_DURABLE_EVENTS_FEATURE],
+    }
 
 
 def _elapsed_ms(started: float) -> float: