managed-deepagents 0.6.2.dev48__py3-none-win_amd64.whl → 0.6.2.dev50__py3-none-win_amd64.whl

managed_deepagents/_agent_auth.py

@@ -16,6 +16,7 @@ from managed_deepagents._agent_auth_http import (
     CredentialStoreError,
     agent_auth_credential_query,
     agent_auth_headers,
+    missing_workspace_connection_error,
     request_agent_auth_json,
 )
 
@@ -34,48 +35,21 @@ __all__ = [
     "AgentAuthUnknownProviderError",
     "CredentialAuthorizationRequiredError",
     "PendingAuthorization",
-    "ResolvePrincipalIdentity",
     "WorkspaceConnection",
-    "clear_principal_resolve_cache_for_tests",
 ]
 
 
 @dataclass(frozen=True)
 class AgentAuthContext:
     base_url: str
+    #: Deployment id, passed to oauth-authorization-sessions as ``agent_id``.
+    agent_id: str
     #: Authenticated caller, used as ``owner_id`` for user credentials.
     principal_id: str
-    #: Deployment id when present. Required for agent-owned lookups; optional for user OAuth.
-    agent_id: str | None = None
     api_key: str | None = None
     workspace_id: str | None = None
 
 
-class ResolvePrincipalIdentity(TypedDict):
-    provider: str
-    issuer: str
-    subject: str
-
-
-_principal_resolve_cache: dict[str, str] = {}
-
-
-def clear_principal_resolve_cache_for_tests() -> None:
-    """Drop cached principal resolutions. Test-only."""
-    _principal_resolve_cache.clear()
-
-
-def _principal_resolve_cache_key(
-    context: AgentAuthContext, identity: ResolvePrincipalIdentity
-) -> str:
-    origin = context.base_url.rstrip("/")
-    workspace = (context.workspace_id or "").strip()
-    return (
-        f"{origin}\0{workspace}\0"
-        f"{identity['provider']}\0{identity['issuer']}\0{identity['subject']}"
-    )
-
-
 class PendingAuthorization(TypedDict):
     """One connection slug the caller has not granted, with its connect URL."""
 
@@ -142,49 +116,6 @@ class AgentAuth:
         self._timeout = timeout
         self._request: AgentAuthRequest = request if request is not None else self._urlopen_json
 
-    def resolve_principal(self, identity: ResolvePrincipalIdentity) -> str:
-        """Resolve a verified external identity to an Agent Auth principal UUID."""
-        provider = identity["provider"].strip()
-        issuer = identity["issuer"].strip()
-        subject = identity["subject"].strip()
-        if not provider or not issuer or not subject:
-            raise CredentialStoreError(
-                "Agent Auth principal resolve requires provider, issuer, and subject"
-            )
-        key = _principal_resolve_cache_key(
-            self.context, {"provider": provider, "issuer": issuer, "subject": subject}
-        )
-        cached = _principal_resolve_cache.get(key)
-        if cached is not None:
-            return cached
-        principal_id = self._resolve_principal_uncached(
-            {"provider": provider, "issuer": issuer, "subject": subject}
-        )
-        _principal_resolve_cache[key] = principal_id
-        return principal_id
-
-    def _resolve_principal_uncached(self, identity: ResolvePrincipalIdentity) -> str:
-        status, body = self._request(
-            "POST",
-            "/v1/agent-auth/principals",
-            body={
-                "provider": identity["provider"],
-                "issuer": identity["issuer"],
-                "subject": identity["subject"],
-            },
-        )
-        if status >= _HTTP_BAD_REQUEST:
-            raise CredentialStoreError("Agent Auth resolve principal failed", status, body)
-        principal = body.get("principal")
-        principal_id = ""
-        if isinstance(principal, Mapping):
-            raw = principal.get("id")
-            if isinstance(raw, str):
-                principal_id = raw.strip()
-        if not principal_id:
-            raise CredentialStoreError("Agent Auth resolve principal returned no principal id")
-        return principal_id
-
     def find_workspace_connection(self, slug: str) -> WorkspaceConnection | None:
         """List workspace connections and return the row for ``slug``, if any."""
         if not (self.context.workspace_id or "").strip():
@@ -245,17 +176,14 @@ class AgentAuth:
         """
         if connection.kind != "secret":
             return None
-        agent_id = (self.context.agent_id or "").strip()
-        if not agent_id:
-            raise CredentialStoreError(
-                "connections are not configured: LANGSMITH_HOST_PROJECT_ID is not set"
-            )
-        from_agent = self._credential_id_for_owner(connection.connection_id, "agent", agent_id)
+        from_agent = self._credential_id_for_owner(
+            connection.connection_id, "agent", self.context.agent_id
+        )
         if from_agent is not None:
             return from_agent
         return self.find_credential_id(
             owner_type="agent",
-            owner_id=agent_id,
+            owner_id=self.context.agent_id,
             kind="secret",
             slug=slug,
         )
@@ -342,7 +270,7 @@ class AgentAuth:
         """Start an OAuth session for a slug the caller has not granted."""
         connection = self.find_workspace_connection(slug)
         if connection is None:
-            raise CredentialStoreError(f"workspace connection {slug!r} is not configured")
+            raise missing_workspace_connection_error(slug)
         if connection.kind != "oauth2":
             raise CredentialStoreError(f"connection {slug!r} is not an OAuth connection")
         status, body = self._request(
@@ -350,8 +278,8 @@ class AgentAuth:
             "/v1/agent-auth/oauth-authorization-sessions",
             body={
                 "connection_id": connection.connection_id,
-                "owner_type": "user",
-                "owner_id": self.context.principal_id,
+                "principal_id": self.context.principal_id,
+                "agent_id": self.context.agent_id,
             },
         )
         if status >= _HTTP_BAD_REQUEST:

managed_deepagents/_agent_auth_http.py

@@ -7,6 +7,7 @@ API with the same headers, redirect policy, and page walker.
 from __future__ import annotations
 
 import json
+import re
 import urllib.error
 import urllib.parse
 import urllib.request
@@ -66,6 +67,27 @@ class CredentialStoreError(RuntimeError):
         super().__init__(with_status if hint is None else f"{with_status}: {hint}")
 
 
+# Each runtime quotes the slug its own way: repr() here, JSON.stringify in npm.
+_MISSING_WORKSPACE_CONNECTION = re.compile(
+    r"""workspace connection ['"]([A-Za-z0-9][A-Za-z0-9._-]*)['"] is not configured"""
+)
+
+
+def missing_workspace_connection_error(slug: str) -> CredentialStoreError:
+    """Return the error for a declared slug that has no workspace connection row."""
+    return CredentialStoreError(f"workspace connection {slug!r} is not configured")
+
+
+def missing_workspace_connection_slug(text: str) -> str | None:
+    """Read the slug back out of a missing-connection message.
+
+    A run that fails in the gate reaches a channel as a plain string, so this is
+    the only way back to the slug. It must move with the message it parses.
+    """
+    match = _MISSING_WORKSPACE_CONNECTION.search(text)
+    return None if match is None else match.group(1)
+
+
 __all__ = [
     "AGENT_AUTH_PROBLEM_HINT_MAX_CHARS",
     "AGENT_AUTH_TIMEOUT_SECONDS",
@@ -73,6 +95,8 @@ __all__ = [
     "agent_auth_credential_query",
     "agent_auth_headers",
     "agent_auth_problem_hint",
+    "missing_workspace_connection_error",
+    "missing_workspace_connection_slug",
     "request_agent_auth_json",
 ]
 

managed_deepagents/_channels/trigger/http.py

@@ -9,6 +9,7 @@ from collections.abc import Awaitable, Callable, Mapping
 from importlib import import_module
 from typing import Protocol, TypeVar
 
+from managed_deepagents._agent_auth_http import missing_workspace_connection_slug
 from managed_deepagents._channels.assistant_text import extract_assistant_text
 from managed_deepagents._channels.trigger.client import (
     LANGSMITH_MDA_TRIGGER_SERVER_URL_ENV,
@@ -242,6 +243,7 @@ async def _observe_accepted_run(
     async def lifecycle(
         event_type: TriggerChannelRuntimeEventType,
         interrupts: list[TriggerChannelInterrupt] | None = None,
+        message: str | None = None,
     ) -> None:
         logger.info(
             "Channel outgoing event (type=%s, delivery_id=%s, channel_id=%s, run_id=%s)",
@@ -253,7 +255,7 @@ async def _observe_accepted_run(
         await _best_effort(
             client.post_runtime_event(
                 event["channel_id"],
-                _runtime_event(event_type, event, started, interrupts),
+                _runtime_event(event_type, event, started, interrupts, message),
             )
         )
 
@@ -266,8 +268,8 @@ async def _observe_accepted_run(
             source_thread_key=source_thread_key,
             user_id=user_id,
         )
-    except Exception:  # noqa: BLE001 - observation details stay internal
-        await lifecycle("run.failed")
+    except Exception as error:  # noqa: BLE001 - only known-safe details leave runtime
+        await lifecycle("run.failed", message=_missing_connection_failure_message(error))
         return
 
     if _is_interrupted_run(observed):
@@ -391,6 +393,7 @@ def _runtime_event(
     event: TriggerChannelEvent,
     started: StartedIngressRun,
     interrupts: list[TriggerChannelInterrupt] | None = None,
+    message: str | None = None,
 ) -> TriggerChannelRuntimeEventRequest:
     request: TriggerChannelRuntimeEventRequest = {
         "id": str(uuid.uuid4()),
@@ -401,11 +404,24 @@ def _runtime_event(
         "run_thread_id": started["thread_id"],
         "run_id": started["run_id"],
     }
+    if message:
+        request["message"] = {"text": message}
     if interrupts:
         request["interrupts"] = interrupts
     return request
 
 
+def _missing_connection_failure_message(error: Exception) -> str | None:
+    slug = missing_workspace_connection_slug(str(error))
+    if slug is None:
+        return None
+    return (
+        f"This agent can't respond because the `{slug}` connection isn't configured. "
+        "An agent developer can configure it with "
+        f"`mda connections create {slug} --project <project>`, then try again."
+    )
+
+
 def _thread_id(source_thread_key: str) -> str:
     return str(uuid.uuid5(uuid.NAMESPACE_URL, source_thread_key))
 

managed_deepagents/_channels/trigger/types.py

@@ -119,6 +119,8 @@ class TriggerChannelRuntimeEventRequestRequired(TypedDict):
 
 
 class TriggerChannelRuntimeEventRequest(TriggerChannelRuntimeEventRequestRequired, total=False):
+    # Safe, user-facing status text. Raw runtime exceptions must never be sent.
+    message: TriggerChannelActionMessage
     # Present on `run.interrupted`. The Trigger Server cannot read the
     # deployment's threads, so pending interrupts travel on the event itself.
     interrupts: list[TriggerChannelInterrupt]

managed_deepagents/_connections.py

@@ -2,11 +2,11 @@
 
 ``{ type: "agent" }`` resolves material owned by the current deployment.
 ``{ type: "user" }`` resolves per-caller grants (OAuth or opaque). Resolution
-reads Agent Auth on every await and never caches material.
+reads Agent Auth on every await and never caches.
 
 ``mda dev`` substitutes local values for agent opaque secrets via ``MDA_DEV_*``.
-User-owned connections talk to Agent Auth in every environment (including
-``mda dev``) after resolving the caller's Agent Auth principal.
+User-owned connections need a deployment; opaque user grants use the same
+pre-run gate as OAuth.
 """
 
 from __future__ import annotations
@@ -24,9 +24,7 @@ from managed_deepagents._agent_auth import (
     AgentAuth,
     AgentAuthContext,
     CredentialAuthorizationRequiredError,
-    ResolvePrincipalIdentity,
     WorkspaceConnection,
-    clear_principal_resolve_cache_for_tests,
 )
 from managed_deepagents._agent_auth_http import (
     AGENT_AUTH_TIMEOUT_SECONDS,
@@ -51,12 +49,10 @@ __all__ = [
     "CredentialStoreError",
     "InvalidAgentAuthEndpointError",
     "agent_connection_env_key",
-    "clear_principal_resolve_cache_for_tests",
     "connections",
     "is_connection_reference",
     "resolve_agent_auth_base_url",
     "resolve_agent_auth_context",
-    "resolve_credential_principal_id",
     "resolve_owner_id",
 ]
 
@@ -112,7 +108,19 @@ class ConnectionNotFoundError(LookupError):
 _SLUG_PATTERN = re.compile(r"[a-z0-9]+(?:-[a-z0-9]+)*")
 _MAX_SLUG_LENGTH = 64
 _DEV_CREDENTIAL_PREFIX = "MDA_DEV_"
-_TRUSTED_BACKEND_PROVIDER = "trusted_backend"
+
+
+def _local_user_connection_unsupported(slug: str | None = None) -> str:
+    local_hint = (
+        f"set {agent_connection_env_key(slug)}"
+        if slug
+        else "set the corresponding MDA_DEV_<slug> variable"
+    )
+    return (
+        "user-owned connections need a deployment, so they do not resolve in `mda dev`: "
+        "deploy with `mda deploy` to exercise this connection, or declare it as "
+        f'{{"type": "agent"}} and {local_hint} for local runs'
+    )
 
 
 #: Env var naming the LangSmith platform API that serves Agent Auth.
@@ -123,8 +131,6 @@ _DEFAULT_LANGSMITH_ENDPOINT = "https://api.smith.langchain.com"
 DEPLOYMENT_ID_ENV = "LANGSMITH_HOST_PROJECT_ID"
 _API_KEY_ENV = "LANGSMITH_API_KEY"
 _WORKSPACE_ID_ENV = "LANGSMITH_WORKSPACE_ID"
-_LOCAL_DEV_USER = "mda:local-dev"
-_LOCAL_DEV_PRINCIPAL_ENV = "MDA_AGENT_AUTH_PRINCIPAL_ID"
 
 
 class InvalidAgentAuthEndpointError(CredentialStoreError):
@@ -151,7 +157,6 @@ class _AgentAuthConfig:
     api_key: str
     deployment_id: str | None
     workspace_id: str
-    local_dev_principal_id: str | None
 
 
 class AgentAuthConnectionStore:
@@ -171,29 +176,15 @@ class AgentAuthConnectionStore:
     async def fetch(self, request: ConnectionRequest) -> str | None:
         owner = request["owner"]
         resolved = os.environ if self._env is None else self._env
-        if resolved.get("MDA_LOCAL_DEV") == "1" and owner["type"] == "agent":
-            return _fetch_local_dev_agent_connection(resolved, request["slug"])
+        if resolved.get("MDA_LOCAL_DEV") == "1":
+            return _fetch_local_dev_connection(resolved, request["slug"], owner)
         config = _resolve_agent_auth_config(self._env)
-        if owner["type"] == "agent" and not config.deployment_id:
-            raise CredentialStoreError(
-                f"connections are not configured: {DEPLOYMENT_ID_ENV} is not set"
-            )
-        # Source-identity match still uses JWT sub / channel actor.
-        resolve_owner_id(owner, request["identity"], config.deployment_id)
-        if owner["type"] == "user":
-            principal_id = resolve_credential_principal_id(
-                request["identity"],
-                config,
-                request_fn=self._bind_request(config),
-                timeout=self._timeout,
-            )
-        else:
-            principal_id = resolve_owner_id(owner, request["identity"], config.deployment_id)
+        owner_id = resolve_owner_id(owner, request["identity"], config.deployment_id)
         client = AgentAuth(
             AgentAuthContext(
                 base_url=config.base_url,
-                agent_id=config.deployment_id,
-                principal_id=principal_id,
+                agent_id=config.deployment_id or owner_id,
+                principal_id=owner_id,
                 api_key=config.api_key,
                 workspace_id=config.workspace_id,
             ),
@@ -217,14 +208,12 @@ class AgentAuthConnectionStore:
             *,
             body: dict[str, object] | None = None,
         ) -> tuple[int, dict[str, object]]:
+            del method, body
             url = f"{config.base_url}{path}"
             headers = agent_auth_headers(
                 api_key=config.api_key,
                 workspace_id=config.workspace_id,
             )
-            # Test injects only support GET-shaped responses; path still distinguishes
-            # principals vs connections for mock routers.
-            del method, body
             response = http_get(url, headers, timeout)
             status = response.get("status")
             raw_body = response.get("body", b"")
@@ -238,7 +227,13 @@ class AgentAuthConnectionStore:
         return request
 
 
-def _fetch_local_dev_agent_connection(resolved: Mapping[str, str], slug: str) -> str:
+def _fetch_local_dev_connection(
+    resolved: Mapping[str, str],
+    slug: str,
+    owner: ConnectionOwner,
+) -> str:
+    if owner["type"] == "user":
+        raise CredentialStoreError(_local_user_connection_unsupported(slug))
     value = resolved.get(agent_connection_env_key(slug))
     if value is not None and value.strip():
         return value
@@ -415,105 +410,24 @@ def resolve_owner_id(
 def resolve_agent_auth_context(
     identity: RuntimeIdentity | None,
     env: Mapping[str, str] | None = None,
-    *,
-    request_fn: Callable[..., tuple[int, dict[str, object]]] | None = None,
-    timeout: float = AGENT_AUTH_TIMEOUT_SECONDS,
 ) -> AgentAuthContext:
+    resolved = os.environ if env is None else env
+    if resolved.get("MDA_LOCAL_DEV") == "1":
+        raise CredentialStoreError(_local_user_connection_unsupported())
     config = _resolve_agent_auth_config(env)
-    principal_id = resolve_credential_principal_id(
-        identity, config, request_fn=request_fn, timeout=timeout
-    )
+    if not config.deployment_id:
+        raise CredentialStoreError(
+            f"connections are not configured: {DEPLOYMENT_ID_ENV} is not set"
+        )
     return AgentAuthContext(
         base_url=config.base_url,
         agent_id=config.deployment_id,
-        principal_id=principal_id,
+        principal_id=resolve_owner_id({"type": "user"}, identity, config.deployment_id),
         api_key=config.api_key,
         workspace_id=config.workspace_id,
     )
 
 
-def resolve_credential_principal_id(
-    identity: RuntimeIdentity | None,
-    config: _AgentAuthConfig,
-    *,
-    request_fn: Callable[..., tuple[int, dict[str, object]]] | None = None,
-    timeout: float = AGENT_AUTH_TIMEOUT_SECONDS,
-) -> str:
-    """Map a runtime identity to the Agent Auth principal used for user grants."""
-    if identity is None:
-        raise CredentialStoreError("user connections require an authenticated user principal")
-    user = identity.get("user") or {}
-    user_id = user.get("id") if isinstance(user, Mapping) else None
-    if not isinstance(user_id, str) or not user_id.strip():
-        raise CredentialStoreError("user connections require an authenticated user principal")
-    kind = user.get("kind") if isinstance(user, Mapping) else None
-    if kind == "service":
-        if (
-            user_id.strip() == _LOCAL_DEV_USER
-            and config.local_dev_principal_id is not None
-        ):
-            return config.local_dev_principal_id
-        raise CredentialStoreError(
-            "user-owned connections require a person principal; "
-            "Studio and other service callers cannot own OAuth grants"
-        )
-    stamped = identity.get("agent_auth_principal_id")
-    if isinstance(stamped, str) and stamped.strip():
-        return stamped.strip()
-
-    subject = user_id.strip()
-    external = _external_identity_for_resolve(identity, config.workspace_id)
-    if external is None:
-        raise CredentialStoreError(
-            "user-owned connections need a resolvable identity "
-            "(validated-token issuer/subject, channel identity_context, or trusted backend)"
-        )
-    bootstrap = AgentAuth(
-        AgentAuthContext(
-            base_url=config.base_url,
-            principal_id=subject,
-            api_key=config.api_key,
-            workspace_id=config.workspace_id,
-            agent_id=config.deployment_id,
-        ),
-        request=request_fn,
-        timeout=timeout,
-    )
-    return bootstrap.resolve_principal(external)
-
-
-def _external_identity_for_resolve(
-    identity: RuntimeIdentity,
-    workspace_id: str | None,
-) -> ResolvePrincipalIdentity | None:
-    user = identity.get("user") or {}
-    subject = user.get("id") if isinstance(user, Mapping) else None
-    if not isinstance(subject, str) or not subject.strip():
-        return None
-    subject = subject.strip()
-    provider = identity.get("identity_provider")
-    claims = identity.get("claims")
-    issuer = None
-    if isinstance(claims, Mapping):
-        raw_iss = claims.get("iss")
-        if isinstance(raw_iss, str) and raw_iss.strip():
-            issuer = raw_iss.strip()
-    if isinstance(provider, str) and provider.strip() and issuer:
-        return {
-            "provider": provider.strip(),
-            "issuer": issuer,
-            "subject": subject,
-        }
-    workspace = (workspace_id or "").strip()
-    if not workspace:
-        return None
-    return {
-        "provider": _TRUSTED_BACKEND_PROVIDER,
-        "issuer": workspace,
-        "subject": subject,
-    }
-
-
 def _resolve_agent_auth_config(env: Mapping[str, str] | None) -> _AgentAuthConfig:
     resolved = os.environ if env is None else env
     api_key = (resolved.get(_API_KEY_ENV) or "").strip()
@@ -529,11 +443,6 @@ def _resolve_agent_auth_config(env: Mapping[str, str] | None) -> _AgentAuthConfi
         api_key=api_key,
         deployment_id=(resolved.get(DEPLOYMENT_ID_ENV) or "").strip() or None,
         workspace_id=workspace_id,
-        local_dev_principal_id=(
-            (resolved.get(_LOCAL_DEV_PRINCIPAL_ENV) or "").strip() or None
-            if resolved.get("MDA_LOCAL_DEV") == "1"
-            else None
-        ),
     )
 
 

managed_deepagents/_credential_gate.py

@@ -20,8 +20,8 @@ from managed_deepagents._agent_auth import (
     AgentAuth,
     AgentAuthContext,
     CredentialAuthorizationRequiredError,
-    CredentialStoreError,
     PendingAuthorization,
+    missing_workspace_connection_error,
 )
 from managed_deepagents._connections import (
     ConnectionReference,
@@ -187,7 +187,7 @@ def _read_user_connection_grants(
         slug = reference.slug
         row = agent_auth.find_workspace_connection(slug)
         if row is None:
-            raise CredentialStoreError(f"workspace connection {slug!r} is not configured")
+            raise missing_workspace_connection_error(slug)
         kind: Literal["oauth2", "secret"] = "secret" if row.kind == "secret" else "oauth2"
         token = (
             agent_auth.read_user_secret_for_connection(row)

managed_deepagents/_identity_auth.py

@@ -58,10 +58,6 @@ class ManagedUser(ManagedUserRequired, total=False):
     mda_source_provider: str
     mda_source_thread_id: str
     mda_user_kind: Literal["user", "service"]
-    #: Validated-token provider id for Agent Auth principal resolve.
-    mda_identity_provider: str
-    #: Agent Auth principal UUID when Trigger ``identity_context`` already resolved one.
-    mda_agent_auth_principal_id: str
 
 
 if TYPE_CHECKING:
@@ -92,8 +88,6 @@ INGRESS_SECRET_HEADER = "x-mda-ingress-secret"  # noqa: S105 - header name, not
 #: Internal handoff headers — accepted after a server API key or legacy ingress secret validates.
 SOURCE_PROVIDER_HEADER = "x-mda-source-provider"
 SOURCE_THREAD_HEADER = "x-mda-source-thread-id"
-#: Trigger loopback stamp for a verified identity_context principal UUID.
-AGENT_AUTH_PRINCIPAL_HEADER = "x-mda-agent-auth-principal-id"
 
 #: Deployment env var carrying the shared secret the trusted backend presents.
 INGRESS_SECRET_ENV = "MDA_INGRESS_SECRET"  # noqa: S105 - env var name, not a secret
@@ -483,9 +477,6 @@ def _trusted_headers_user(headers: Mapping[str, object]) -> ManagedUser:
     if source_provider is not None and source_thread is not None:
         user["mda_source_provider"] = str(source_provider)
         user["mda_source_thread_id"] = str(source_thread)
-        principal = str(headers.get(AGENT_AUTH_PRINCIPAL_HEADER) or "").strip()
-        if principal:
-            user["mda_agent_auth_principal_id"] = principal
     return user
 
 
@@ -506,13 +497,7 @@ def _has_valid_handoff_secret(headers: Mapping[str, object]) -> bool:
 
 def _has_handoff_headers(headers: Mapping[str, object]) -> bool:
     return any(
-        header in headers
-        for header in (
-            USER_HEADER,
-            SOURCE_PROVIDER_HEADER,
-            SOURCE_THREAD_HEADER,
-            AGENT_AUTH_PRINCIPAL_HEADER,
-        )
+        header in headers for header in (USER_HEADER, SOURCE_PROVIDER_HEADER, SOURCE_THREAD_HEADER)
     )
 
 

managed_deepagents/_identity_runtime.py

@@ -455,12 +455,6 @@ def build_runtime_identity(configurable: Mapping[str, object] | None) -> Runtime
     claims = _field(user, "mda_claims")
     if isinstance(claims, Mapping):
         identity["claims"] = dict(cast("Mapping[str, object]", claims))
-    identity_provider = _field(user, "mda_identity_provider")
-    if isinstance(identity_provider, str) and identity_provider.strip():
-        identity["identity_provider"] = identity_provider.strip()
-    agent_auth_principal_id = _field(user, "mda_agent_auth_principal_id")
-    if isinstance(agent_auth_principal_id, str) and agent_auth_principal_id.strip():
-        identity["agent_auth_principal_id"] = agent_auth_principal_id.strip()
     # Immutable: tools/middleware get a read-only view they cannot tamper with.
     return cast("RuntimeIdentity", _freeze(identity))
 

managed_deepagents/_ingress.py

@@ -19,7 +19,6 @@ from managed_deepagents._channels.assistant_text import extract_assistant_text
 from managed_deepagents._channels.binding import CHANNEL_BINDING_KEY, ChannelBinding
 from managed_deepagents._channels.types import ChannelError
 from managed_deepagents._identity_auth import (
-    AGENT_AUTH_PRINCIPAL_HEADER,
     HANDOFF_SECRET_ENV,
     HANDOFF_SECRET_HEADER,
     INGRESS_SECRET_ENV,
@@ -356,7 +355,6 @@ def _create_trigger_ingress_loopback_client(
         )
     headers = {
         USER_HEADER: user_id,
-        AGENT_AUTH_PRINCIPAL_HEADER: user_id,
         SOURCE_PROVIDER_HEADER: source["provider"],
         SOURCE_THREAD_HEADER: source["thread_key"],
     }

managed_deepagents/_validated_token.py

@@ -263,8 +263,6 @@ def claims_to_user(provider: ValidatedTokenProvider, claims: Mapping[str, object
         "permissions": [],
         "mda_user_id": str(caller),
         "mda_claims": dict(claims),
-        # Provider id drives Agent Auth POST /principals (provider, issuer, subject).
-        "mda_identity_provider": (provider.get("id") or "").strip() or "oidc",
     }
     groups = normalize_groups(claims.get(claim_map["groups"])) if claim_map.get("groups") else []
     if groups:

managed_deepagents/identity/__init__.py

@@ -177,10 +177,6 @@ class RuntimeIdentity(RuntimeIdentityRequired, total=False):
     #: tools and middleware.
     groups: tuple[str, ...]
     claims: JsonObject
-    #: Validated-token provider id for Agent Auth principal resolve.
-    identity_provider: str
-    #: Agent Auth principal UUID when channel ingress already resolved one.
-    agent_auth_principal_id: str
 
 
 class PrincipalRequired(TypedDict):

{managed_deepagents-0.6.2.dev48.dist-info → managed_deepagents-0.6.2.dev50.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: managed-deepagents
-Version: 0.6.2.dev48
+Version: 0.6.2.dev50
 Summary: Managed Deep Agents — the define_deep_agent authoring interface plus the CLI that compiles and deploys a code-first Deep Agent repository to a managed LangGraph runtime.
 Author: LangChain
 License: MIT
@@ -277,19 +277,16 @@ connector = connectors.mcp(
 For this example, set `MDA_DEV_DOCS_TOKEN`.
 
 A user-owned connection — `connections.get(slug, {"type": "user"})` — resolves
-per caller (OAuth or opaque). The runtime maps the verified ingress identity to
-an Agent Auth principal, then the pre-run credential gate interrupts the run
-when a grant is missing. That path works in `mda deploy` and `mda dev` when
-`LANGSMITH_API_KEY` and `LANGSMITH_WORKSPACE_ID` are set and the workspace
-connection rows exist — use a person principal (for example a Supabase JWT),
-not Studio’s synthetic service user. OAuth completes on LangSmith’s platform
-callback URL; the local UI must surface `credential_authorization_required`
-and resume after the user connects.
+per caller (OAuth or opaque). The pre-run credential gate interrupts the run
+when a grant is missing. `mda dev` has no deployment to hold user grants, so
+a user-owned connection fails there with an actionable error; deploy the agent
+to exercise one.
 
 Deploy the project first, then provision its connections with
 `mda connections create`. Agent-owned opaque secrets are scoped to that
 deployment, so the command refuses to create one before `mda deploy`.
-`mda connections check` verifies manifest slugs exist in the workspace.
+`mda deploy` fails when a slug a project declares is missing from the
+workspace.
 
 Use `include_tools` or `exclude_tools` inside a server config to select a
 subset. Tool names are raw MCP tool names before the managed `{server}__` prefix

{managed_deepagents-0.6.2.dev48.dist-info → managed_deepagents-0.6.2.dev50.dist-info}/RECORD

@@ -1,26 +1,26 @@
 managed_deepagents/__init__.py,sha256=RezkpgYxCcywj6_W7Nk3PN9TMBfYyFgIatxGrIeY8V4,1862
 managed_deepagents/__main__.py,sha256=GcjmqN0Ea5v8OHKMxYToasm3eCX_doSLOlpEzAi1tAw,67
-managed_deepagents/_agent_auth.py,sha256=TUZJgc1TyjEFNZX3E97VV30igM_bC9rDZ-pmKpUSExA,20010
-managed_deepagents/_agent_auth_http.py,sha256=aCYn7Rrtw3cnK3r4ir4JWxwzFkb7cF7nBgPpNdydxDw,5108
+managed_deepagents/_agent_auth.py,sha256=DCGZNfMUpUEwLQT7tIODywmtzO3XjF4a1dixuDR_Fzs,17266
+managed_deepagents/_agent_auth_http.py,sha256=d-Fg62m-_5qBXj-d9xgfA3KGiPRfs7T2g6Q2nrhCetc,6065
 managed_deepagents/_channel.py,sha256=-Og7QOM1yvV-yeTDOfv2CxXpR2HLY4xdX1bLrIsPi5k,5272
 managed_deepagents/_cli.py,sha256=jVaw2i1ysdRoWziMdPFmRXtKry_baYGRspyzyIeGWoU,1688
-managed_deepagents/_connections.py,sha256=MlrmkVJTogZdDmh_vbj0aBzlZqliysTVTBKsYfEpqnU,19919
+managed_deepagents/_connections.py,sha256=VwVBwM4T0rp1MgYu9D8QjGj1ireYeEuP3VIAFN5urFY,16246
 managed_deepagents/_connector.py,sha256=Syp0SRs1oFCUUltIUmZbSNi1Ys_PxObVdiAi-I9GBzs,8040
 managed_deepagents/_cors.py,sha256=V96RPrqewdRWG5RpEMEBnPuRq9_zF8nf4vf99k5dkuI,7597
-managed_deepagents/_credential_gate.py,sha256=SNxXunqmHgjBsZpiZu8yp49YkRIO0amkl0-7GHLGnIg,12280
+managed_deepagents/_credential_gate.py,sha256=thc9dqWphPKbNqWYEZ1P63mpMDyUPDTw4uPA_qqnW28,12262
 managed_deepagents/_eval_filesystem.py,sha256=1nuD0yn3gh19JrWNocWyPFyeJW42E7Gse3XRWCUSTAA,1399
 managed_deepagents/_extension.py,sha256=x2H1S8inkvTZQ_dr7kq0M8o8rre1FjzCDvMzItw4iyk,5318
-managed_deepagents/_identity_auth.py,sha256=sykxsL2wzcJI7I0MFs4xkcoviQhfNQGIBFQ0rfP3cXU,33418
+managed_deepagents/_identity_auth.py,sha256=l0t0Xx-J1-z_Zw4K5D-B2yV6lNdeJgOw7UvxODxUxZQ,32798
 managed_deepagents/_identity_http.py,sha256=aVQfZr7UKQoXF1Dry3p9fzXIj1882sEa668rvhn37i0,16029
 managed_deepagents/_identity_links.py,sha256=Z1H2Seo2KaI-vcdU3_PGM-F06wOz0IQqUP-28wqiQsA,9172
-managed_deepagents/_identity_runtime.py,sha256=FJeJkhCg0Wo8x8hwiLB-9MUS-VBsGVzBzk3JJaDqH0o,24847
-managed_deepagents/_ingress.py,sha256=8vJqIuyKI3dxC5wbyRPL9ES71xsXgxiTWJqYPpG7Wt0,12402
+managed_deepagents/_identity_runtime.py,sha256=vsshj0TNWd-rXUhVsPAqXIkANunQT7jI94CWgzq-1cY,24409
+managed_deepagents/_ingress.py,sha256=iqsGm2jZKKn0FqjNn2nJAlR7d-IqCpVKWo6NbMEhjxw,12323
 managed_deepagents/_log.py,sha256=oYwOO0ZL4-INkge9YJvtLuCxL9zAtgjSPIggVbkcyc8,2932
 managed_deepagents/_loopback.py,sha256=hQ1oNi77XpdUjzZURSBRoMvJ1mGCs-STobfBftGmXuE,2409
 managed_deepagents/_managed_middleware.py,sha256=cfInVHTVjWoy_DBoFlnslfrDf2_n6llGnTGasta4AIo,10295
 managed_deepagents/_managed_tools.py,sha256=KsFDULbv5fv0RY3Nj0zbv6z0Y80_o5YazhqeiQ9PnPk,9105
 managed_deepagents/_memory_instructions.py,sha256=lyxKfNuXrWih574gmy3NHhIq_hIpJIM5zl3P8V69mUs,6678
-managed_deepagents/_validated_token.py,sha256=d13DiRReoxSK5Q2kIPTLeXCFx2tjCIHJOi5DZexr7fk,17397
+managed_deepagents/_validated_token.py,sha256=BY-66bgAOxhhRS3tfkDWVVU2l9HFHAuYXXCKV1pZ-nE,17232
 managed_deepagents/define_deep_agent.py,sha256=17VfiiBINyhlqlATHrlJRPihKVlBsDGDP8K4-fxjxU8,5611
 managed_deepagents/define_memory.py,sha256=n7Ya20dWGvwbZOkPIXoa68nTnJie8tpKEkRwfJQt_fU,5036
 managed_deepagents/namespaces.py,sha256=GS76G19-V5Svfpbca-9xhQfJ6vel52jcJyfj6loLt_Y,4199
@@ -28,7 +28,7 @@ managed_deepagents/py.typed,sha256=AbpHGcgLb-kRsJGnwFEktk7uzpZOCcBY74-YBdrKVGs,1
 managed_deepagents/runtime.py,sha256=B4iKTJZD0zXx_MZ09pqQFOkVo07tqJDT3qvOBr-0iOk,65782
 managed_deepagents/sandbox.py,sha256=xlpcWa6CoVX6GKip2nK-0Lw-HBCoFGFYm0r4x9eYwcY,2530
 managed_deepagents/schedules.py,sha256=MtTQN4tlm1NizFDCjZZv_huGfbQx-dj9WP1dIBybCug,5237
-managed_deepagents/_binaries/mda.exe,sha256=4aHz0or2mqRkLdwT4W6RoaWnUoQ16_NLQE-Tbz5vbbg,3912704
+managed_deepagents/_binaries/mda.exe,sha256=MKHDoU4yrPlrylogVcQ8MmsJKXs7r6MzRI3OPV6z5fg,3904512
 managed_deepagents/_channels/__init__.py,sha256=Z6eXmzaLxG09DSyJoY_CX34axcsBo9gSJ0G7pRm2D6M,1216
 managed_deepagents/_channels/assistant_text.py,sha256=f-Z3J3PlQFXZHztgBxlRoqB2LigU1Hj1YpwoXBMTR18,2171
 managed_deepagents/_channels/binding.py,sha256=6vAKbWpg-eyLErJ0SsozH4mZc50hA1NhquM63mVmWDQ,3423
@@ -50,9 +50,9 @@ managed_deepagents/_channels/slack/transport.py,sha256=_xQmzK2hBpPOoY3zKFhzc3vvl
 managed_deepagents/_channels/trigger/__init__.py,sha256=bWj66XoPbDdrztPUCKBuSJBBS2pBocn4EA8FDE3WeBA,48
 managed_deepagents/_channels/trigger/channel.py,sha256=rKSvOABOZX58ZIvZ3hKcYxvTx9npQ0YXPQWk9JEy6XE,5108
 managed_deepagents/_channels/trigger/client.py,sha256=cM97gzYWUTFC9o3uoveFe9-HxZc6_VqiqC8u4fKqjXc,8572
-managed_deepagents/_channels/trigger/http.py,sha256=O8yMleioXj3s5QXj7jK-HpUpiSFppjfRjHJ2tdfX0Is,16205
+managed_deepagents/_channels/trigger/http.py,sha256=75ROtdT7PacKAFa-KFFRPATkHDgC7Pu48AUcipTYXY0,16903
 managed_deepagents/_channels/trigger/identity_context.py,sha256=oo6sgtNDLGGkZCzrkrifMHkkAqxj7ui2HgUUdjNA1iU,7701
-managed_deepagents/_channels/trigger/types.py,sha256=42JMOFXP9MfqwQ66SFlAiwC7q_AnNIJXBts3sAujxac,6625
+managed_deepagents/_channels/trigger/types.py,sha256=9nlArhLf-KgYidxwzrtBVjcpPlV6ytriPX3lJvPR3fE,6746
 managed_deepagents/_connectors/__init__.py,sha256=c_SdH3T7T6bgX7-I5jxAqDzHojmqVUCX0AXRI7g5Ovs,575
 managed_deepagents/_connectors/tool_selection.py,sha256=xMvohEvg_rguQvziUXzxKn4V140mmearZHel97F8tVs,2978
 managed_deepagents/_connectors/mcp/__init__.py,sha256=3AL429g5djYEYuiuSqsxj2VESpTkyU2NeBIJsHlWVk4,11162
@@ -65,13 +65,13 @@ managed_deepagents/_memory/mounts.py,sha256=b2KtaTX3apTkmoqQxG2ENtkO86avSt1Nvrv3
 managed_deepagents/_memory/paths.py,sha256=gHI-9KyawUv1ftX1K0kjaBbM4IYLeP7S-_WCaS2gVBM,353
 managed_deepagents/_memory/slices.py,sha256=ljL78ECmDZ27xc3ajzkLliOfUln_bNr-d1ycC1wlS38,3559
 managed_deepagents/_memory/types.py,sha256=scSk6mH0k2OC59wzUCa67szvXylSjWDrfzWWRIU9tZA,4336
-managed_deepagents/identity/__init__.py,sha256=3KHXJca8w9Xu99_QhJX9iV1xMHTa34NS1cRPKVRx408,16342
+managed_deepagents/identity/__init__.py,sha256=Slm-oEqKxbaZEQsMqHfD3LbG5M4vH2lKUmralVPB_Zs,16137
 managed_deepagents/identity/claims.py,sha256=prby7r_8Lww3MmoBm8PX6PsSGE3GwSHkr8mVIz_08nU,1180
 managed_deepagents/identity/options.py,sha256=x_yMbXEFR7zXyehEjDHG2qjAlukXjrRBcQLcM6IndLM,2550
 managed_deepagents/identity/supabase.py,sha256=8uobl3WCrQL_ieSXG8KTLf1th7Qjim9liZT50HeaJE0,6026
-managed_deepagents-0.6.2.dev48.dist-info/licenses/LICENSE,sha256=WnPZQQ608ojZUkXl7BW6VbKloIAibZiGm1K6cjeZOL8,1066
-managed_deepagents-0.6.2.dev48.dist-info/METADATA,sha256=anU1lZ3Ci1d9Afm2DO_vN-Si7XTAJUHSc6v6P6YN6M0,14039
-managed_deepagents-0.6.2.dev48.dist-info/WHEEL,sha256=3I5VVWZdsFlU417aCS2bMRuerS8wsfvBq99MyatBV3A,97
-managed_deepagents-0.6.2.dev48.dist-info/entry_points.txt,sha256=ziZqkKuaDO3qHCjKmBhrx9cm3ok8bZ9xcEDpUTj4unM,53
-managed_deepagents-0.6.2.dev48.dist-info/top_level.txt,sha256=fdBo4O0Hlol_w022tTLB5ftZpamb4yJoQ3MUvjgTGfA,19
-managed_deepagents-0.6.2.dev48.dist-info/RECORD,,
+managed_deepagents-0.6.2.dev50.dist-info/licenses/LICENSE,sha256=WnPZQQ608ojZUkXl7BW6VbKloIAibZiGm1K6cjeZOL8,1066
+managed_deepagents-0.6.2.dev50.dist-info/METADATA,sha256=jGDCHaAI4JMsFMrZ_fhKDqt6PVYObwGB3vD_HoY_fxU,13718
+managed_deepagents-0.6.2.dev50.dist-info/WHEEL,sha256=3I5VVWZdsFlU417aCS2bMRuerS8wsfvBq99MyatBV3A,97
+managed_deepagents-0.6.2.dev50.dist-info/entry_points.txt,sha256=ziZqkKuaDO3qHCjKmBhrx9cm3ok8bZ9xcEDpUTj4unM,53
+managed_deepagents-0.6.2.dev50.dist-info/top_level.txt,sha256=fdBo4O0Hlol_w022tTLB5ftZpamb4yJoQ3MUvjgTGfA,19
+managed_deepagents-0.6.2.dev50.dist-info/RECORD,,