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

managed_deepagents/_agent_auth.py

@@ -35,21 +35,48 @@ __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."""
 
@@ -116,6 +143,49 @@ 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():
@@ -176,14 +246,17 @@ class AgentAuth:
         """
         if connection.kind != "secret":
             return None
-        from_agent = self._credential_id_for_owner(
-            connection.connection_id, "agent", self.context.agent_id
-        )
+        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)
         if from_agent is not None:
             return from_agent
         return self.find_credential_id(
             owner_type="agent",
-            owner_id=self.context.agent_id,
+            owner_id=agent_id,
             kind="secret",
             slug=slug,
         )
@@ -278,8 +351,8 @@ class AgentAuth:
             "/v1/agent-auth/oauth-authorization-sessions",
             body={
                 "connection_id": connection.connection_id,
-                "principal_id": self.context.principal_id,
-                "agent_id": self.context.agent_id,
+                "owner_type": "user",
+                "owner_id": self.context.principal_id,
             },
         )
         if status >= _HTTP_BAD_REQUEST:

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.
+reads Agent Auth on every await and never caches material.
 
 ``mda dev`` substitutes local values for agent opaque secrets via ``MDA_DEV_*``.
-User-owned connections need a deployment; opaque user grants use the same
-pre-run gate as OAuth.
+User-owned connections talk to Agent Auth in every environment (including
+``mda dev``) after resolving the caller's Agent Auth principal.
 """
 
 from __future__ import annotations
@@ -24,7 +24,9 @@ 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,
@@ -49,10 +51,12 @@ __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",
 ]
 
@@ -108,19 +112,7 @@ class ConnectionNotFoundError(LookupError):
 _SLUG_PATTERN = re.compile(r"[a-z0-9]+(?:-[a-z0-9]+)*")
 _MAX_SLUG_LENGTH = 64
 _DEV_CREDENTIAL_PREFIX = "MDA_DEV_"
-
-
-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'
-    )
+_TRUSTED_BACKEND_PROVIDER = "trusted_backend"
 
 
 #: Env var naming the LangSmith platform API that serves Agent Auth.
@@ -131,6 +123,8 @@ _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):
@@ -157,6 +151,7 @@ class _AgentAuthConfig:
     api_key: str
     deployment_id: str | None
     workspace_id: str
+    local_dev_principal_id: str | None
 
 
 class AgentAuthConnectionStore:
@@ -176,15 +171,30 @@ 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":
-            return _fetch_local_dev_connection(resolved, request["slug"], owner)
+        if resolved.get("MDA_LOCAL_DEV") == "1" and owner["type"] == "agent":
+            return _fetch_local_dev_agent_connection(resolved, request["slug"])
         config = _resolve_agent_auth_config(self._env)
-        owner_id = resolve_owner_id(owner, request["identity"], config.deployment_id)
+        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 = await asyncio.to_thread(
+                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)
         client = AgentAuth(
             AgentAuthContext(
                 base_url=config.base_url,
-                agent_id=config.deployment_id or owner_id,
-                principal_id=owner_id,
+                agent_id=config.deployment_id,
+                principal_id=principal_id,
                 api_key=config.api_key,
                 workspace_id=config.workspace_id,
             ),
@@ -208,12 +218,14 @@ 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"")
@@ -227,13 +239,7 @@ class AgentAuthConnectionStore:
         return request
 
 
-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))
+def _fetch_local_dev_agent_connection(resolved: Mapping[str, str], slug: str) -> str:
     value = resolved.get(agent_connection_env_key(slug))
     if value is not None and value.strip():
         return value
@@ -410,24 +416,104 @@ 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)
-    if not config.deployment_id:
-        raise CredentialStoreError(
-            f"connections are not configured: {DEPLOYMENT_ID_ENV} is not set"
-        )
+    principal_id = resolve_credential_principal_id(
+        identity, config, request_fn=request_fn, timeout=timeout
+    )
     return AgentAuthContext(
         base_url=config.base_url,
         agent_id=config.deployment_id,
-        principal_id=resolve_owner_id({"type": "user"}, identity, config.deployment_id),
+        principal_id=principal_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:
+    provider = identity.get("identity_provider")
+    issuer = identity.get("identity_issuer")
+    subject = identity.get("identity_subject")
+    if (
+        isinstance(provider, str)
+        and provider.strip()
+        and isinstance(issuer, str)
+        and issuer.strip()
+        and isinstance(subject, str)
+        and subject.strip()
+    ):
+        return {
+            "provider": provider.strip(),
+            "issuer": issuer.strip(),
+            "subject": subject.strip(),
+        }
+    user = identity.get("user") or {}
+    trusted_subject = user.get("id") if isinstance(user, Mapping) else None
+    if not isinstance(trusted_subject, str) or not trusted_subject.strip():
+        return None
+    workspace = (workspace_id or "").strip()
+    if not workspace:
+        return None
+    return {
+        "provider": _TRUSTED_BACKEND_PROVIDER,
+        "issuer": workspace,
+        "subject": trusted_subject.strip(),
+    }
+
+
 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()
@@ -443,6 +529,11 @@ 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

@@ -106,7 +106,7 @@ def create_credential_gate_middleware(
             _gate(consumers, caller.context, payload)
 
         async def abefore_agent(self, _state: object, runtime: object | None = None) -> None:
-            caller = _require_auth_context(runtime)
+            caller = await asyncio.to_thread(_require_auth_context, runtime)
             payload = await asyncio.to_thread(_pending_interrupt, consumers, caller)
             _gate(consumers, caller.context, payload)
 

managed_deepagents/_identity_auth.py

@@ -58,6 +58,14 @@ 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
+    #: Verified IdP issuer (``iss``) for Agent Auth principal resolve.
+    mda_identity_issuer: str
+    #: Verified IdP subject (``sub``) for Agent Auth principal resolve.
+    mda_identity_subject: str
+    #: Agent Auth principal UUID when Trigger ``identity_context`` already resolved one.
+    mda_agent_auth_principal_id: str
 
 
 if TYPE_CHECKING:
@@ -88,6 +96,8 @@ 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
@@ -477,6 +487,9 @@ 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
 
 
@@ -497,7 +510,13 @@ 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)
+        header in headers
+        for header in (
+            USER_HEADER,
+            SOURCE_PROVIDER_HEADER,
+            SOURCE_THREAD_HEADER,
+            AGENT_AUTH_PRINCIPAL_HEADER,
+        )
     )
 
 

managed_deepagents/_identity_runtime.py

@@ -455,10 +455,27 @@ 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))
+    _stamp_agent_auth_identity(identity, user)
     # Immutable: tools/middleware get a read-only view they cannot tamper with.
     return cast("RuntimeIdentity", _freeze(identity))
 
 
+def _stamp_agent_auth_identity(identity: RuntimeIdentity, user: object) -> None:
+    """Copy validated-token / channel Agent Auth stamps onto the envelope."""
+    provider = _field(user, "mda_identity_provider")
+    if isinstance(provider, str) and provider.strip():
+        identity["identity_provider"] = provider.strip()
+    issuer = _field(user, "mda_identity_issuer")
+    if isinstance(issuer, str) and issuer.strip():
+        identity["identity_issuer"] = issuer.strip()
+    subject = _field(user, "mda_identity_subject")
+    if isinstance(subject, str) and subject.strip():
+        identity["identity_subject"] = subject.strip()
+    principal_id = _field(user, "mda_agent_auth_principal_id")
+    if isinstance(principal_id, str) and principal_id.strip():
+        identity["agent_auth_principal_id"] = principal_id.strip()
+
+
 def _is_studio_auth_user(user: object) -> bool:
     """True when LangGraph Platform / Studio supplied the auth user."""
     if not isinstance(user, Mapping):

managed_deepagents/_ingress.py

@@ -19,6 +19,7 @@ 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,
@@ -355,6 +356,7 @@ 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

@@ -258,11 +258,17 @@ def claims_to_user(provider: ValidatedTokenProvider, claims: Mapping[str, object
     caller = claims.get(user_claim)
     if caller in (None, ""):
         raise ManagedAuthError(401, f'token missing user claim "{user_claim}"')
+    subject = _verified_identity_subject(claims)
+    issuer = _verified_identity_issuer(provider, claims)
     user: ManagedUser = {
         "identity": str(caller),
         "permissions": [],
         "mda_user_id": str(caller),
         "mda_claims": dict(claims),
+        # Provider id + verified iss/sub drive Agent Auth POST /principals.
+        "mda_identity_provider": (provider.get("id") or "").strip() or "oidc",
+        "mda_identity_issuer": issuer,
+        "mda_identity_subject": subject,
     }
     groups = normalize_groups(claims.get(claim_map["groups"])) if claim_map.get("groups") else []
     if groups:
@@ -273,6 +279,35 @@ def claims_to_user(provider: ValidatedTokenProvider, claims: Mapping[str, object
     return user
 
 
+def _verified_identity_subject(claims: Mapping[str, object]) -> str:
+    """OIDC ``sub``, or Supabase introspection ``id`` (same stable value)."""
+    raw_sub = claims.get("sub")
+    if isinstance(raw_sub, str) and raw_sub.strip():
+        return raw_sub.strip()
+    raw_id = claims.get("id")
+    if isinstance(raw_id, str) and raw_id.strip():
+        return raw_id.strip()
+    raise ManagedAuthError(401, 'token missing "sub" claim')
+
+
+def _verified_identity_issuer(
+    provider: ValidatedTokenProvider, claims: Mapping[str, object]
+) -> str:
+    """Token ``iss``, else the provider's configured issuer / first ``issuers`` entry."""
+    raw_iss = claims.get("iss")
+    if isinstance(raw_iss, str) and raw_iss.strip():
+        return raw_iss.strip()
+    configured = provider.get("issuer")
+    if isinstance(configured, str) and configured.strip():
+        return configured.strip()
+    issuers = provider.get("issuers")
+    if isinstance(issuers, Sequence) and not isinstance(issuers, (str, bytes)):
+        for entry in issuers:
+            if isinstance(entry, str) and entry.strip():
+                return entry.strip()
+    raise ManagedAuthError(401, 'token missing "iss" claim')
+
+
 def _verify_provider_claims(
     provider: ValidatedTokenProvider, token: str, headers: Mapping[str, object]
 ) -> Mapping[str, object]:

managed_deepagents/identity/__init__.py

@@ -177,6 +177,16 @@ 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
+    #: Verified IdP issuer (``iss``) for Agent Auth principal resolve.
+    identity_issuer: str
+    #: Verified IdP subject (``sub``) for Agent Auth principal resolve.
+    #: Stamped so grants match other LangSmith clients even when ``claims.user``
+    #: maps to email. Thread ownership still uses ``user.id``.
+    identity_subject: str
+    #: Agent Auth principal UUID when channel ingress already resolved one.
+    agent_auth_principal_id: str
 
 
 class PrincipalRequired(TypedDict):

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: managed-deepagents
-Version: 0.6.2.dev50
+Version: 0.6.2.dev52
 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,10 +277,14 @@ 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 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.
+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.
 
 Deploy the project first, then provision its connections with
 `mda connections create`. Agent-owned opaque secrets are scoped to that

{managed_deepagents-0.6.2.dev50.dist-info → managed_deepagents-0.6.2.dev52.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=DCGZNfMUpUEwLQT7tIODywmtzO3XjF4a1dixuDR_Fzs,17266
+managed_deepagents/_agent_auth.py,sha256=8QiCiGxYjbk3BTrOeCGVkQTLh6IzTUia18-_Mry9NWI,20018
 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=VwVBwM4T0rp1MgYu9D8QjGj1ireYeEuP3VIAFN5urFY,16246
+managed_deepagents/_connections.py,sha256=B0mrBbh0dhFxFMkdkYVAM5Q5WaKUcYJryizZh_Hxg3A,19963
 managed_deepagents/_connector.py,sha256=Syp0SRs1oFCUUltIUmZbSNi1Ys_PxObVdiAi-I9GBzs,8040
 managed_deepagents/_cors.py,sha256=V96RPrqewdRWG5RpEMEBnPuRq9_zF8nf4vf99k5dkuI,7597
-managed_deepagents/_credential_gate.py,sha256=thc9dqWphPKbNqWYEZ1P63mpMDyUPDTw4uPA_qqnW28,12262
+managed_deepagents/_credential_gate.py,sha256=VLjSc7k1MoZdMI8juZpdeOK7lYyvbb9OsFZGAhoj6t4,12287
 managed_deepagents/_eval_filesystem.py,sha256=1nuD0yn3gh19JrWNocWyPFyeJW42E7Gse3XRWCUSTAA,1399
 managed_deepagents/_extension.py,sha256=x2H1S8inkvTZQ_dr7kq0M8o8rre1FjzCDvMzItw4iyk,5318
-managed_deepagents/_identity_auth.py,sha256=l0t0Xx-J1-z_Zw4K5D-B2yV6lNdeJgOw7UvxODxUxZQ,32798
+managed_deepagents/_identity_auth.py,sha256=mQ-4pVFZRc9uweFqi7LEzAUtzhuz5fcUHVak0LSzz64,33620
 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=vsshj0TNWd-rXUhVsPAqXIkANunQT7jI94CWgzq-1cY,24409
-managed_deepagents/_ingress.py,sha256=iqsGm2jZKKn0FqjNn2nJAlR7d-IqCpVKWo6NbMEhjxw,12323
+managed_deepagents/_identity_runtime.py,sha256=URaYgx7ef5ihxySWrQBDI_KnP0sB1WXNfK55PnB3imI,25287
+managed_deepagents/_ingress.py,sha256=8vJqIuyKI3dxC5wbyRPL9ES71xsXgxiTWJqYPpG7Wt0,12402
 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=BY-66bgAOxhhRS3tfkDWVVU2l9HFHAuYXXCKV1pZ-nE,17232
+managed_deepagents/_validated_token.py,sha256=On96IOQTDz1KE_ZZmuTqY8IPw-cJ3J2tXkkmrfyvbB4,18762
 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=MKHDoU4yrPlrylogVcQ8MmsJKXs7r6MzRI3OPV6z5fg,3904512
+managed_deepagents/_binaries/mda.exe,sha256=b51_ocM9YjizSP3IFh0105T7lXdFD8BxK3ZDYxe3nJk,3911680
 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
@@ -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=Slm-oEqKxbaZEQsMqHfD3LbG5M4vH2lKUmralVPB_Zs,16137
+managed_deepagents/identity/__init__.py,sha256=RKuFKCN3Ui2ggUzdntYhnEdZRf-vT1khU4e-8Me2XIY,16680
 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.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,,
+managed_deepagents-0.6.2.dev52.dist-info/licenses/LICENSE,sha256=WnPZQQ608ojZUkXl7BW6VbKloIAibZiGm1K6cjeZOL8,1066
+managed_deepagents-0.6.2.dev52.dist-info/METADATA,sha256=hJuiAgthvUvvFJlQ7Yj43cnbE1mgwjzIBlKVJMJ1T_c,14048
+managed_deepagents-0.6.2.dev52.dist-info/WHEEL,sha256=3I5VVWZdsFlU417aCS2bMRuerS8wsfvBq99MyatBV3A,97
+managed_deepagents-0.6.2.dev52.dist-info/entry_points.txt,sha256=ziZqkKuaDO3qHCjKmBhrx9cm3ok8bZ9xcEDpUTj4unM,53
+managed_deepagents-0.6.2.dev52.dist-info/top_level.txt,sha256=fdBo4O0Hlol_w022tTLB5ftZpamb4yJoQ3MUvjgTGfA,19
+managed_deepagents-0.6.2.dev52.dist-info/RECORD,,