managed-deepagents 0.6.2.dev44__py3-none-win_amd64.whl → 0.6.2.dev45__py3-none-win_amd64.whl

managed_deepagents/_agent_auth.py

@@ -34,41 +34,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(identity: ResolvePrincipalIdentity) -> str:
-    return f"{identity['provider']}\0{identity['issuer']}\0{identity['subject']}"
-
-
 class PendingAuthorization(TypedDict):
     """One connection slug the caller has not granted, with its connect URL."""
 
@@ -135,52 +115,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(
-            {"provider": provider, "issuer": issuer, "subject": subject}
-        )
-        cached = _principal_resolve_cache.get(key)
-        if cached is not None:
-            return cached
-        try:
-            principal_id = self._resolve_principal_uncached(
-                {"provider": provider, "issuer": issuer, "subject": subject}
-            )
-        except Exception:
-            raise
-        _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():
@@ -241,17 +175,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,
         )
@@ -346,8 +277,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/_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
@@ -25,7 +25,6 @@ from managed_deepagents._agent_auth import (
     AgentAuthContext,
     CredentialAuthorizationRequiredError,
     WorkspaceConnection,
-    clear_principal_resolve_cache_for_tests,
 )
 from managed_deepagents._agent_auth_http import (
     AGENT_AUTH_TIMEOUT_SECONDS,
@@ -50,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",
 ]
 
@@ -111,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.
@@ -167,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,
             ),
@@ -213,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"")
@@ -234,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
@@ -411,100 +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":
-        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,
-) -> dict[str, str] | 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()

managed_deepagents/_identity_auth.py

@@ -16,7 +16,6 @@ import asyncio
 import hmac
 import json
 import os
-import re
 from collections.abc import Callable, Iterable, Mapping
 from http import HTTPStatus
 from importlib import import_module
@@ -59,21 +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
-
-
-_AGENT_AUTH_PRINCIPAL_ID = re.compile(
-    r"^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$",
-    re.IGNORECASE,
-)
-
-
-def is_agent_auth_principal_id(value: str) -> bool:
-    """True when ``value`` is shaped like an Agent Auth principal UUID."""
-    return bool(_AGENT_AUTH_PRINCIPAL_ID.fullmatch(value.strip()))
 
 
 if TYPE_CHECKING:
@@ -493,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)
-        # Trigger loopback stamps the identity_context principal UUID.
-        if is_agent_auth_principal_id(str(actor)):
-            user["mda_agent_auth_principal_id"] = str(actor)
     return user
 
 

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/_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.dev44.dist-info → managed_deepagents-0.6.2.dev45.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: managed-deepagents
-Version: 0.6.2.dev44
+Version: 0.6.2.dev45
 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.dev44.dist-info → managed_deepagents-0.6.2.dev45.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=u9qvBjC1FM1U4M96M_juGqR7XI_0VtGEr6GgF9lcZJ0,19886
+managed_deepagents/_agent_auth.py,sha256=bOxTT1ZX9BZZyvgIaxd9SZycbEaQl-HuCrPieCAv6G0,17258
 managed_deepagents/_agent_auth_http.py,sha256=aCYn7Rrtw3cnK3r4ir4JWxwzFkb7cF7nBgPpNdydxDw,5108
 managed_deepagents/_channel.py,sha256=-Og7QOM1yvV-yeTDOfv2CxXpR2HLY4xdX1bLrIsPi5k,5272
 managed_deepagents/_cli.py,sha256=jVaw2i1ysdRoWziMdPFmRXtKry_baYGRspyzyIeGWoU,1688
-managed_deepagents/_connections.py,sha256=rZnt9CI5BY16N66kR-bgx4pPoAmhNgtV73ejl7IkXhc,19378
+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/_eval_filesystem.py,sha256=1nuD0yn3gh19JrWNocWyPFyeJW42E7Gse3XRWCUSTAA,1399
 managed_deepagents/_extension.py,sha256=x2H1S8inkvTZQ_dr7kq0M8o8rre1FjzCDvMzItw4iyk,5318
-managed_deepagents/_identity_auth.py,sha256=TvZLzab47LIkLOps3c5yrVuuoekkTc8Mn4bbWOc4zXk,33546
+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/_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=DAmmuhOtkqW4j92gqsKuXvseKHNVHSJR4SZTPOEeTWA,3905536
+managed_deepagents/_binaries/mda.exe,sha256=4V3cKtTKLxZ5XptKKAuUWjbcMlOB2fznFXLcQToy-gY,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
@@ -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.dev44.dist-info/licenses/LICENSE,sha256=WnPZQQ608ojZUkXl7BW6VbKloIAibZiGm1K6cjeZOL8,1066
-managed_deepagents-0.6.2.dev44.dist-info/METADATA,sha256=4mbNB9mNXciy5VVqWTsrBUBFC-3LtWDOiK_MJ1w37Ec,14039
-managed_deepagents-0.6.2.dev44.dist-info/WHEEL,sha256=3I5VVWZdsFlU417aCS2bMRuerS8wsfvBq99MyatBV3A,97
-managed_deepagents-0.6.2.dev44.dist-info/entry_points.txt,sha256=ziZqkKuaDO3qHCjKmBhrx9cm3ok8bZ9xcEDpUTj4unM,53
-managed_deepagents-0.6.2.dev44.dist-info/top_level.txt,sha256=fdBo4O0Hlol_w022tTLB5ftZpamb4yJoQ3MUvjgTGfA,19
-managed_deepagents-0.6.2.dev44.dist-info/RECORD,,
+managed_deepagents-0.6.2.dev45.dist-info/licenses/LICENSE,sha256=WnPZQQ608ojZUkXl7BW6VbKloIAibZiGm1K6cjeZOL8,1066
+managed_deepagents-0.6.2.dev45.dist-info/METADATA,sha256=79n2x0_csFlDwyCA9y95PRNCCbajRUOhAqTyPe5iOjI,13718
+managed_deepagents-0.6.2.dev45.dist-info/WHEEL,sha256=3I5VVWZdsFlU417aCS2bMRuerS8wsfvBq99MyatBV3A,97
+managed_deepagents-0.6.2.dev45.dist-info/entry_points.txt,sha256=ziZqkKuaDO3qHCjKmBhrx9cm3ok8bZ9xcEDpUTj4unM,53
+managed_deepagents-0.6.2.dev45.dist-info/top_level.txt,sha256=fdBo4O0Hlol_w022tTLB5ftZpamb4yJoQ3MUvjgTGfA,19
+managed_deepagents-0.6.2.dev45.dist-info/RECORD,,