mainsequence 9.0.8.dev43__tar.gz → 9.0.8.dev45__tar.gz

{mainsequence-9.0.8.dev43 → mainsequence-9.0.8.dev45}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: mainsequence
-Version: 9.0.8.dev43
+Version: 9.0.8.dev45
 Summary: Main Sequence SDK
 Author-email: Main Sequence GmbH <dev@main-sequence.io>
 License-Expression: MIT

{mainsequence-9.0.8.dev43 → mainsequence-9.0.8.dev45}/agent_scaffold/skills/application_surfaces/api_surfaces/SKILL.md

@@ -92,46 +92,71 @@ Record:
 - whether the API uses backend transport or a contract-defined direct
   development transport
 
-Authenticated FastAPI routes receive the human caller from the Main Sequence
-platform through injected request state. No SDK authentication setup is
-required in repository code:
+Install the SDK's request-identity integration once when creating the FastAPI
+application. Inspect the existing application factory first: the generated
+platform template already calls `install_request_identity(app)`, and a second
+installation raises an error. For an application without that setup:
 
 ```python
-from fastapi import FastAPI, Request
+from fastapi import FastAPI
+from mainsequence.client import User
+from mainsequence.server.fastapi import install_request_identity
 
 
 app = FastAPI()
+install_request_identity(app)
 
 
 @app.get("/me")
-def get_me(request: Request) -> dict[str, str | None]:
-    return {
-        "uid": request.state.user_uid,
-        "username": request.state.user.username,
-    }
+def get_me() -> dict[str, str | None]:
+    user = User.get_logged_user()
+    return {"uid": user.uid, "username": user.username}
 ```
 
-Protected route code must not detect local versus deployed execution, parse
-authentication headers, or resolve the request user itself. Consume the
-platform-injected human caller identity:
+Use `User.get_logged_user()` in authenticated synchronous or asynchronous
+handlers and their shared services. The middleware verifies the caller before
+the handler, binds one isolated request context, and invalidates it on
+completion, errors, or cancellation. Repeated getter calls do not perform
+additional authentication requests.
 
-- `request.state.user` contains canonical `uid` and optional `username`
-- `request.state.user_uid` is the canonical public user UUID
-- `request.state.user_id` does not exist
+The same installation handles both HTTP execution modes:
+
+- Local execution without hosted deployment markers validates the incoming
+  Bearer token against `MAINSEQUENCE_ENDPOINT/api/v1/users/me/`.
+- Platform-hosted execution verifies the gateway's signed caller assertion
+  using deployment-owned issuer, public-key, release, and Environment settings.
+  Hosted configuration cannot select local mode, and failed proof never falls
+  back to UID headers or the process's credentials.
+
+Route code must not select the mode, parse authentication headers, or implement
+another caller resolver. The launcher checks the application's installation
+declaration before serving; it does not install the middleware itself.
+
+The identity contains canonical `uid` and optional `username`; signed HTTP
+proofs contain no username. `request.state.user` and `request.state.user_uid`
+remain projections of the same identity, not a separate resolver. Outside an
+authenticated request, including public routes, `User.get_logged_user()` raises
+`RequestIdentityError`.
 
 On a protected route, this identity is the human making the current HTTP
 request. It is not the release creator, deployment owner, runtime workload
-principal, or runtime target. Pass request state explicitly to shared services;
-do not use `User.get_logged_user()` as a FastAPI entry point. Platform-injected identity is
-not resource authorization; use `request.state.user_uid` when applying the
-endpoint's authorization policy.
+principal, or the process account returned by `User.get_authenticated_user_details()`.
+Caller authentication is not resource authorization; apply the endpoint's
+application policy using the verified user UID.
+
+WebSockets retain the platform's gateway ticket/header contract rather than
+the HTTP Bearer/assertion flow; the getter is available while the authenticated
+connection is active. See the version-matched
+[FastAPI identity documentation](https://mainsequence-sdk.github.io/mainsequence-sdk/knowledge/fastapi/)
+for the lifecycle and trust contract.
 
 ### Public provider callbacks and webhooks
 
 An external OAuth redirect or webhook cannot supply a Main Sequence Bearer token.
 For a FastAPI release that needs one, use the platform's exact `public_ingress`
 policy. CORS configuration and an app-declared route alone do not make a path
-public. Ordinary routes remain Bearer authenticated.
+public. Ordinary routes still require an authenticated caller through the
+request-identity integration.
 
 1. Implement the provider handler in the FastAPI app loaded by the workflow's
    `source_path`. Declare only its exact `GET` or `POST` method and literal
@@ -166,7 +191,9 @@ public. Ordinary routes remain Bearer authenticated.
 4. Send a provider-style request without a Main Sequence Bearer token to the
    exact public pair. Check that an unlisted path or wrong method is denied.
    An admitted request has `request.state.user` and `user_uid` set to `None`
-   and `request.state.auth_outcome == "public_ingress"`. The handler must verify
+   and `request.state.auth_outcome == "public_ingress"`;
+   `User.get_logged_user()` raises `RequestIdentityError` in that anonymous
+   scope. The handler must verify
    OAuth state and exchange codes, or verify the webhook signature against the
    original body and reject replays. Public admission supplies no User or
    provider identity. Keep provider secrets and live codes out of workflow YAML,

{mainsequence-9.0.8.dev43 → mainsequence-9.0.8.dev45}/mainsequence/cli/config.py

@@ -29,6 +29,7 @@ from keyring import core as keyring_core
 from keyring import errors as keyring_errors
 
 from mainsequence.defaults import CANONICAL_BACKEND_ENV, STANDARD_BACKEND_URL
+from mainsequence.runtime_credential_exchange import runtime_credential_configured
 
 APP_NAME = "MainSequenceCLI"
 
@@ -804,13 +805,8 @@ def session_report() -> dict:
     refresh_expires_at = token_expiry(refresh)
 
     if auth_mode == "runtime_credential":
-        authenticated = bool(
-            access
-            or (
-                (os.environ.get("MAINSEQUENCE_RUNTIME_CREDENTIAL_ID") or "").strip()
-                and (os.environ.get("MAINSEQUENCE_RUNTIME_CREDENTIAL_SECRET") or "").strip()
-            )
-        )
+        # The credential is an ID with a bootstrap secret or an identity token file.
+        authenticated = bool(access or runtime_credential_configured())
         session_expires_at = None
     elif refresh:
         authenticated = refresh_expires_at is None or refresh_expires_at > now

{mainsequence-9.0.8.dev43 → mainsequence-9.0.8.dev45}/mainsequence/client/models_user.py

@@ -37,6 +37,22 @@ class RequestUserIdentity(BaseModel):
         title="Username",
         description="Optional display name authenticated by the runtime gateway.",
     )
+    team_uids: tuple[str, ...] = Field(
+        (),
+        title="Team UIDs",
+        description=(
+            "Canonical UIDs of the caller's active teams, as signed by the platform "
+            "in the caller assertion. Empty when the request carries no such facts."
+        ),
+    )
+    is_organization_admin: bool = Field(
+        False,
+        title="Organization admin",
+        description=(
+            "Whether the platform signed the caller as an admin of the application's "
+            "Organization. False when the request carries no such facts."
+        ),
+    )
 
     @field_validator("uid", mode="before")
     @classmethod
@@ -46,6 +62,14 @@ class RequestUserIdentity(BaseModel):
         except (AttributeError, TypeError, ValueError) as exc:
             raise ValueError("Request user UID must be a valid UUID.") from exc
 
+    @field_validator("team_uids", mode="before")
+    @classmethod
+    def _canonicalize_team_uids(cls, value: Any) -> tuple[str, ...]:
+        try:
+            return tuple(str(UUID(str(item).strip())) for item in value or ())
+        except (AttributeError, TypeError, ValueError) as exc:
+            raise ValueError("Team UIDs must be valid UUIDs.") from exc
+
     @field_validator("username", mode="before")
     @classmethod
     def _normalize_username(cls, value: Any) -> str | None:

{mainsequence-9.0.8.dev43 → mainsequence-9.0.8.dev45}/mainsequence/client/utils.py

@@ -21,6 +21,14 @@ from requests.structures import CaseInsensitiveDict
 
 from mainsequence.defaults import resolve_backend_endpoint
 from mainsequence.logconf import logger
+from mainsequence.runtime_credential_exchange import (
+    RUNTIME_CREDENTIAL_ID_ENV,
+    RUNTIME_CREDENTIAL_SECRET_ENV,
+    RUNTIME_IDENTITY_TOKEN_FILE_ENV,
+    RuntimeIdentityTokenError,
+    exchange_runtime_credential,
+    identity_token_file_from_environment,
+)
 
 from ._transport import DEFAULT_ALLOWED_METHODS as DEFAULT_ALLOWED_METHODS
 from ._transport import DEFAULT_STATUS_FORCELIST as DEFAULT_STATUS_FORCELIST
@@ -309,6 +317,17 @@ class SessionJWTAuthProvider(BaseAuthProvider):
 
 @dataclass
 class RuntimeCredentialAuthProvider(BaseAuthProvider):
+    """
+    Exchange the runtime credential the platform injected for short-lived access tokens.
+
+    The proof is the projected workload identity token when
+    `MAINSEQUENCE_RUNTIME_IDENTITY_TOKEN_FILE` is set: the file is read for every
+    exchange, and `MAINSEQUENCE_RUNTIME_CREDENTIAL_SECRET` is never read or sent.
+    Otherwise the proof is that bootstrap secret. The token is never kept on the
+    provider. Throttled (`429`) and temporarily unavailable (`503`) exchanges are
+    retried within the timeout budget; a rejected one (`401`) fails at once.
+    """
+
     credential_id: str | None = None
     credential_secret: str | None = None
     token_url: str | None = None
@@ -316,13 +335,18 @@ class RuntimeCredentialAuthProvider(BaseAuthProvider):
     refresh_skew_seconds: int = 30
     timeout: tuple[float, float] = DEFAULT_TIMEOUT
     expires_at: float | None = None
+    identity_token_file: str | None = None
     _lock: threading.RLock = field(default_factory=threading.RLock, init=False, repr=False)
 
     def __post_init__(self):
         if self.credential_id is None:
-            self.credential_id = os.getenv("MAINSEQUENCE_RUNTIME_CREDENTIAL_ID")
-        if self.credential_secret is None:
-            self.credential_secret = os.getenv("MAINSEQUENCE_RUNTIME_CREDENTIAL_SECRET")
+            self.credential_id = os.getenv(RUNTIME_CREDENTIAL_ID_ENV)
+        if self.identity_token_file is None:
+            self.identity_token_file = identity_token_file_from_environment()
+        else:
+            self.identity_token_file = str(self.identity_token_file).strip() or None
+        if self.credential_secret is None and not self.identity_token_file:
+            self.credential_secret = os.getenv(RUNTIME_CREDENTIAL_SECRET_ENV)
         if not self.token_url:
             self.token_url = f"{API_ENDPOINT}/runtime-credentials/token/"
 
@@ -344,20 +368,48 @@ class RuntimeCredentialAuthProvider(BaseAuthProvider):
 
         return exp <= int(time.time()) + self.refresh_skew_seconds
 
-    def _require_credentials(self) -> tuple[str, str]:
+    @staticmethod
+    def _log_exchange_retry(status: int, delay: float) -> None:
+        logger.warning(f"Runtime credential exchange returned {status}; retrying in {delay:.1f} s.")
+
+    def _exchange(self) -> requests.Response:
         credential_id = (self.credential_id or "").strip()
-        credential_secret = (self.credential_secret or "").strip()
+        identity_token_file = self.identity_token_file
+        credential_secret = None if identity_token_file else (self.credential_secret or "").strip()
         if not credential_id:
             raise AuthError(
                 "MAINSEQUENCE_RUNTIME_CREDENTIAL_ID is required when "
                 "MAINSEQUENCE_AUTH_MODE=runtime_credential."
             )
-        if not credential_secret:
+        if not identity_token_file and not credential_secret:
             raise AuthError(
                 "MAINSEQUENCE_RUNTIME_CREDENTIAL_SECRET is required when "
-                "MAINSEQUENCE_AUTH_MODE=runtime_credential."
+                "MAINSEQUENCE_AUTH_MODE=runtime_credential and "
+                f"{RUNTIME_IDENTITY_TOKEN_FILE_ENV} is not set."
             )
-        return credential_id, credential_secret
+        try:
+            # One budget for every attempt and wait, inside the caller's budget if any.
+            with request_budget(self.timeout) as budget:
+
+                def post(body: dict[str, str]) -> requests.Response:
+                    return requests.post(
+                        self.token_url,
+                        json=body,
+                        headers={"Content-Type": "application/json"},
+                        timeout=budget.timeout(),
+                        allow_redirects=False,
+                    )
+
+                return exchange_runtime_credential(
+                    post,
+                    credential_id=credential_id,
+                    credential_secret=credential_secret,
+                    identity_token_file=identity_token_file,
+                    deadline=budget.deadline,
+                    on_retry=self._log_exchange_retry,
+                )
+        except RuntimeIdentityTokenError as exc:
+            raise AuthError(str(exc)) from None
 
     def refresh(
         self,
@@ -370,17 +422,7 @@ class RuntimeCredentialAuthProvider(BaseAuthProvider):
             if not force and not self._needs_exchange():
                 return
 
-            credential_id, credential_secret = self._require_credentials()
-            response = requests.post(
-                self.token_url,
-                json={
-                    "credential_id": credential_id,
-                    "credential_secret": credential_secret,
-                },
-                headers={"Content-Type": "application/json"},
-                timeout=remaining_timeout(self.timeout),
-                allow_redirects=False,
-            )
+            response = self._exchange()
             if response.status_code < 200 or response.status_code >= 300:
                 raise AuthError(
                     f"Runtime credential exchange failed with status {response.status_code}."

{mainsequence-9.0.8.dev43 → mainsequence-9.0.8.dev45}/mainsequence/code_repository_context.py

@@ -10,6 +10,8 @@ from dataclasses import dataclass, replace
 from typing import Any, Literal
 from urllib.parse import urlsplit
 
+from mainsequence.runtime_credential_exchange import runtime_credential_configured
+
 CodeRepositoryContextStatus = Literal[
     "resolved",
     "code_repository_branch_not_registered",
@@ -204,9 +206,7 @@ def _exchange_authenticated_runtime_context_if_configured() -> None:
         return
     if (os.getenv("MAINSEQUENCE_AUTH_MODE") or "").strip().lower() != "runtime_credential":
         return
-    if not (os.getenv("MAINSEQUENCE_RUNTIME_CREDENTIAL_ID") or "").strip():
-        return
-    if not (os.getenv("MAINSEQUENCE_RUNTIME_CREDENTIAL_SECRET") or "").strip():
+    if not runtime_credential_configured():
         return
 
     from mainsequence.client.utils import AuthError, loaders

{mainsequence-9.0.8.dev43 → mainsequence-9.0.8.dev45}/mainsequence/logconf.py

@@ -5,6 +5,7 @@ import logging
 import logging.config
 import os
 import sys
+import time
 import traceback
 from collections.abc import Mapping
 from importlib.metadata import PackageNotFoundError
@@ -22,6 +23,13 @@ from structlog.stdlib import BoundLogger
 from .defaults import resolve_backend_endpoint
 from .instrumentation import OTelJSONRenderer
 from .repository_identity_security import UNSUPPORTED_SOURCE_IDENTITY_ENV_NAMES
+from .runtime_credential_exchange import (
+    RUNTIME_CREDENTIAL_ID_ENV,
+    RUNTIME_CREDENTIAL_SECRET_ENV,
+    exchange_runtime_credential,
+    identity_token_file_from_environment,
+    runtime_credential_configured,
+)
 from .runtime_flags import is_running_in_pod
 
 logger = None
@@ -94,20 +102,31 @@ def _request_job_startup_state(*, timeout_s: float = 10.0) -> dict[str, Any]:
         return headers, False
 
     def _exchange_runtime_credential() -> bool:
-        credential_id = (os.getenv("MAINSEQUENCE_RUNTIME_CREDENTIAL_ID") or "").strip()
-        credential_secret = (os.getenv("MAINSEQUENCE_RUNTIME_CREDENTIAL_SECRET") or "").strip()
-        if not credential_id or not credential_secret:
+        if not runtime_credential_configured():
             return False
+        identity_token_file = identity_token_file_from_environment()
+        token_url = f"{_backend_base_url()}/api/v1/runtime-credentials/token/"
 
-        try:
-            token_resp = requests.post(
-                f"{_backend_base_url()}/api/v1/runtime-credentials/token/",
+        def _post(body: dict[str, str]) -> requests.Response:
+            return requests.post(
+                token_url,
                 headers={"Content-Type": "application/json"},
-                json={
-                    "credential_id": credential_id,
-                    "credential_secret": credential_secret,
-                },
+                json=body,
                 timeout=timeout_s,
+                allow_redirects=False,
+            )
+
+        try:
+            token_resp = exchange_runtime_credential(
+                _post,
+                credential_id=(os.getenv(RUNTIME_CREDENTIAL_ID_ENV) or "").strip(),
+                credential_secret=(
+                    None
+                    if identity_token_file
+                    else (os.getenv(RUNTIME_CREDENTIAL_SECRET_ENV) or "").strip()
+                ),
+                identity_token_file=identity_token_file,
+                deadline=time.monotonic() + timeout_s,
             )
         except Exception:
             return False

mainsequence-9.0.8.dev45/mainsequence/runtime_credential_exchange.py

@@ -0,0 +1,168 @@
+"""
+The runtime credential exchange, shared by the auth provider and the logger.
+
+A runtime started with ``MAINSEQUENCE_AUTH_MODE=runtime_credential`` exchanges its
+credential at ``POST /api/v1/runtime-credentials/token/`` for a short-lived access
+token. The request carries ``credential_id`` and exactly one proof:
+
+* ``workload_identity_token`` when ``MAINSEQUENCE_RUNTIME_IDENTITY_TOKEN_FILE`` is
+  set: the projected token read from that file for every exchange, because the
+  file is rotated. The bootstrap secret is then never read or sent, and a missing,
+  unreadable or empty file is an error, never a fallback to the secret.
+* ``credential_secret`` otherwise: ``MAINSEQUENCE_RUNTIME_CREDENTIAL_SECRET``.
+
+The token exists only inside one exchange request. It is not kept on any object,
+written to the environment or a file, logged, or included in an error message.
+
+The logger exchanges a runtime credential while it is being configured, so this
+module imports nothing from the SDK.
+"""
+
+from __future__ import annotations
+
+import os
+import time
+from collections.abc import Callable
+from typing import Any
+
+from urllib3.exceptions import InvalidHeader
+from urllib3.util import Retry
+
+RUNTIME_CREDENTIAL_ID_ENV = "MAINSEQUENCE_RUNTIME_CREDENTIAL_ID"
+RUNTIME_CREDENTIAL_SECRET_ENV = "MAINSEQUENCE_RUNTIME_CREDENTIAL_SECRET"
+RUNTIME_IDENTITY_TOKEN_FILE_ENV = "MAINSEQUENCE_RUNTIME_IDENTITY_TOKEN_FILE"
+
+# 429: the exchange is throttled. 503: verification is temporarily unavailable.
+# Neither exchanged anything, so the same request may be sent again.
+RETRYABLE_EXCHANGE_STATUSES = frozenset({429, 503})
+EXCHANGE_RETRIES = 3
+EXCHANGE_BACKOFF_FACTOR = 0.5
+
+_RETRY_AFTER = Retry(total=0)
+
+
+class RuntimeIdentityTokenError(Exception):
+    """The runtime identity token file cannot be used. The message never holds its content."""
+
+
+def _environment_value(name: str) -> str:
+    return (os.getenv(name) or "").strip()
+
+
+def identity_token_file_from_environment() -> str | None:
+    """Return the path in ``MAINSEQUENCE_RUNTIME_IDENTITY_TOKEN_FILE``, or None when unset."""
+    return _environment_value(RUNTIME_IDENTITY_TOKEN_FILE_ENV) or None
+
+
+def runtime_credential_configured() -> bool:
+    """
+    Say whether the environment holds a runtime credential to exchange.
+
+    That is a credential ID and one proof: the identity token file, or else the
+    bootstrap secret. Only the presence of the setting is checked. The token file
+    is read by the exchange itself, which reports a missing or empty file.
+    """
+    if not _environment_value(RUNTIME_CREDENTIAL_ID_ENV):
+        return False
+    if identity_token_file_from_environment():
+        return True
+    return bool(_environment_value(RUNTIME_CREDENTIAL_SECRET_ENV))
+
+
+def _read_identity_token(path: str) -> str:
+    source = f"The runtime identity token file {path} ({RUNTIME_IDENTITY_TOKEN_FILE_ENV})"
+    try:
+        with open(path, "rb") as token_file:
+            raw = token_file.read()
+    except FileNotFoundError:
+        raise RuntimeIdentityTokenError(f"{source} does not exist.") from None
+    except OSError as exc:
+        raise RuntimeIdentityTokenError(
+            f"{source} could not be read ({type(exc).__name__})."
+        ) from None
+    try:
+        token = raw.decode("utf-8").strip()
+    except UnicodeDecodeError:
+        # Raised below, outside this handler: the decode error holds the bytes.
+        token = None
+    if token is None:
+        raise RuntimeIdentityTokenError(f"{source} does not hold a token.")
+    if not token:
+        raise RuntimeIdentityTokenError(f"{source} is empty.")
+    return token
+
+
+def _request_body(
+    credential_id: str,
+    credential_secret: str | None,
+    identity_token_file: str | None,
+) -> dict[str, str]:
+    if identity_token_file:
+        return {
+            "credential_id": credential_id,
+            "workload_identity_token": _read_identity_token(identity_token_file),
+        }
+    return {"credential_id": credential_id, "credential_secret": credential_secret or ""}
+
+
+def _retry_delay(response: Any, attempt: int) -> float:
+    delay = min(EXCHANGE_BACKOFF_FACTOR * 2**attempt, Retry.DEFAULT_BACKOFF_MAX)
+    retry_after = (getattr(response, "headers", None) or {}).get("Retry-After")
+    if retry_after is not None:
+        try:
+            delay = max(delay, _RETRY_AFTER.parse_retry_after(str(retry_after)))
+        except InvalidHeader:
+            pass
+    return delay
+
+
+def exchange_runtime_credential(
+    send: Callable[[dict[str, str]], Any],
+    *,
+    credential_id: str,
+    credential_secret: str | None,
+    identity_token_file: str | None,
+    deadline: float,
+    on_retry: Callable[[int, float], None] | None = None,
+) -> Any:
+    """
+    Send one runtime credential exchange and return the last response.
+
+    Parameters
+    ----------
+    send:
+        Posts the JSON body it is given to the exchange route and returns the
+        response. It is called once per attempt.
+    credential_id:
+        The runtime credential ID.
+    credential_secret:
+        The bootstrap secret. Ignored when ``identity_token_file`` is set.
+    identity_token_file:
+        The projected token file. It is read again for every attempt.
+    deadline:
+        ``time.monotonic()`` value after which no retry starts.
+    on_retry:
+        Called with the status and the delay before each retry.
+
+    A ``429`` or ``503`` answer is retried up to ``EXCHANGE_RETRIES`` times. The
+    wait is the exponential backoff or the answer's ``Retry-After``, whichever is
+    longer; a wait that would not end before ``deadline`` ends the retries. Any
+    other answer, ``401`` included, is returned at once and the proof is never
+    switched. ``RuntimeIdentityTokenError`` is raised when the token file cannot
+    be used.
+    """
+    for attempt in range(EXCHANGE_RETRIES + 1):
+        response = send(_request_body(credential_id, credential_secret, identity_token_file))
+        status = response.status_code
+        if status not in RETRYABLE_EXCHANGE_STATUSES or attempt == EXCHANGE_RETRIES:
+            return response
+        delay = _retry_delay(response, attempt)
+        if delay >= deadline - time.monotonic():
+            return response
+        if on_retry is not None:
+            on_retry(status, delay)
+        close = getattr(response, "close", None)
+        if callable(close):
+            close()
+        time.sleep(delay)
+    raise AssertionError("Unreachable retry state")

{mainsequence-9.0.8.dev43 → mainsequence-9.0.8.dev45}/mainsequence/server/caller_assertions.py

@@ -33,6 +33,10 @@ REQUIRED_CLAIMS = frozenset(
         "exp",
     }
 )
+# What the platform states about the caller: active team UIDs and the
+# Organization-admin flag. Sent together, or not at all by a platform that
+# predates them; then the caller has no teams and is not an admin.
+CALLER_FACT_CLAIMS = frozenset({"team_uids", "is_organization_admin"})
 
 
 class InvalidCallerAssertion(ValueError):
@@ -59,6 +63,25 @@ class AuthenticatedCaller:
     environment_uid: str
     issued_at: int
     expires_at: int
+    team_uids: tuple[str, ...] = ()
+    is_organization_admin: bool = False
+
+
+def _caller_facts(payload: dict) -> tuple[tuple[str, ...], bool]:
+    facts = set(payload) & CALLER_FACT_CLAIMS
+    if set(payload) - facts != REQUIRED_CLAIMS or facts not in (set(), set(CALLER_FACT_CLAIMS)):
+        raise InvalidCallerAssertion("Caller assertion claims are invalid.")
+    if not facts:
+        return (), False
+    raw_team_uids = payload["team_uids"]
+    if not isinstance(raw_team_uids, list):
+        raise InvalidCallerAssertion("Caller team UIDs are invalid.")
+    team_uids = tuple(_canonical_uid(value) for value in raw_team_uids)
+    if list(team_uids) != sorted(set(team_uids)):
+        raise InvalidCallerAssertion("Caller team UIDs must be sorted and unique.")
+    if type(payload["is_organization_admin"]) is not bool:
+        raise InvalidCallerAssertion("Caller admin flag is invalid.")
+    return team_uids, payload["is_organization_admin"]
 
 
 class CallerAssertionVerifier:
@@ -206,8 +229,7 @@ class CallerAssertionVerifier:
                 audience=f"urn:mainsequence:fapi:{self.release_uid}",
                 options={"require": list(REQUIRED_CLAIMS)},
             )
-            if set(payload) != REQUIRED_CLAIMS:
-                raise InvalidCallerAssertion("Caller assertion claims are invalid.")
+            team_uids, is_organization_admin = _caller_facts(payload)
             if (
                 payload["aud"] != f"urn:mainsequence:fapi:{self.release_uid}"
                 or _canonical_uid(payload["resource_release_uid"]) != self.release_uid
@@ -226,6 +248,8 @@ class CallerAssertionVerifier:
                 environment_uid=self.environment_uid,
                 issued_at=iat,
                 expires_at=exp,
+                team_uids=team_uids,
+                is_organization_admin=is_organization_admin,
             )
         except (InvalidTokenError, KeyError, TypeError, ValueError) as exc:
             raise InvalidCallerAssertion("Caller assertion is invalid.") from exc

{mainsequence-9.0.8.dev43 → mainsequence-9.0.8.dev45}/mainsequence/server/fastapi.py

@@ -213,7 +213,11 @@ class _RequestIdentityMiddleware:
                     elif self.mode == "assertion":
                         assertion = _header(scope, ASSERTION_HEADER.lower().encode()) or ""
                         caller = await asyncio.to_thread(self.verifier.verify, assertion)
-                        user = RequestUserIdentity(uid=caller.user_uid)
+                        user = RequestUserIdentity(
+                            uid=caller.user_uid,
+                            team_uids=caller.team_uids,
+                            is_organization_admin=caller.is_organization_admin,
+                        )
                         state["resource_release_uid"] = caller.release_uid
                         state["organization_environment_uid"] = caller.environment_uid
                     else:

{mainsequence-9.0.8.dev43 → mainsequence-9.0.8.dev45}/mainsequence.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: mainsequence
-Version: 9.0.8.dev43
+Version: 9.0.8.dev45
 Summary: Main Sequence SDK
 Author-email: Main Sequence GmbH <dev@main-sequence.io>
 License-Expression: MIT

{mainsequence-9.0.8.dev43 → mainsequence-9.0.8.dev45}/mainsequence.egg-info/SOURCES.txt

@@ -20,6 +20,7 @@ mainsequence/code_repository_skills.py
 mainsequence/defaults.py
 mainsequence/logconf.py
 mainsequence/repository_identity_security.py
+mainsequence/runtime_credential_exchange.py
 mainsequence/runtime_flags.py
 mainsequence/scaffold_skills.py
 mainsequence.egg-info/PKG-INFO
@@ -90,6 +91,7 @@ tests/test_logconf.py
 tests/test_models_user_request_bound_auth.py
 tests/test_notification_uid_contract.py
 tests/test_observability_client.py
+tests/test_runtime_credential_exchange.py
 tests/test_scaffold_skills.py
 tests/test_secret_client_model.py
 tests/test_source_ownership.py

{mainsequence-9.0.8.dev43 → mainsequence-9.0.8.dev45}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "mainsequence"
-version = "9.0.8.dev43"
+version = "9.0.8.dev45"
 description = "Main Sequence SDK"
 readme = "README.md"
 requires-python = ">=3.13"