managed-deepagents 0.6.2.dev7__py3-none-win_amd64.whl → 0.6.2.dev9__py3-none-win_amd64.whl

managed_deepagents/__init__.py

@@ -9,19 +9,12 @@ This package provides two things:
 
 Resources use ``define_*`` factories while provider collections use namespaces:
 ``define_sandbox()``, ``channels.slack(...)``, ``connectors.mcp(...)``,
-``credentials.get(...)``, and ``auth.supabase(...)``. Contributing a *new*
+and ``auth.supabase(...)``. Contributing a *new*
 primitive is not part of the public surface.
 """
 
 from __future__ import annotations
 
-from managed_deepagents._credentials import (
-    CredentialAuthorizationRequiredError,
-    CredentialNotFoundError,
-    CredentialOwner,
-    CredentialStoreError,
-    credentials,
-)
 from managed_deepagents._managed_tools import (
     ManagedDeepAgentRuntime,
 )
@@ -38,10 +31,6 @@ from managed_deepagents.sandbox import SandboxDefinition
 from managed_deepagents.schedules import define_schedule
 
 __all__ = [
-    "CredentialAuthorizationRequiredError",
-    "CredentialNotFoundError",
-    "CredentialOwner",
-    "CredentialStoreError",
     "DeepAgentDefinition",
     "ManagedDeepAgentRuntime",
     "MemoryDefinition",
@@ -49,7 +38,6 @@ __all__ = [
     "auth",
     "channels",
     "connectors",
-    "credentials",
     "define_deep_agent",
     "define_identity",
     "define_memory",

managed_deepagents/_channels/schedule_delivery.py

@@ -2,30 +2,31 @@
 
 from __future__ import annotations
 
-import logging
 import os
+import uuid
 from collections.abc import Awaitable, Callable, Mapping
 from importlib import import_module
 from typing import TYPE_CHECKING, Any, Literal, TypedDict, cast
 
 from managed_deepagents._channels.assistant_text import extract_assistant_text
 from managed_deepagents._channels.binding import SLACK_BOT_TOKEN_ENV
+from managed_deepagents._channels.trigger.client import create_trigger_client
 from managed_deepagents._identity_runtime import (
     _ambient_configurable,
     _configurable_from_runtime,
 )
+from managed_deepagents._log import logger
 from managed_deepagents._memory.async_util import await_if_needed
 
 if TYPE_CHECKING:
     from langchain.agents.middleware.types import AgentMiddleware
 
+    from managed_deepagents._channels.trigger.types import TriggerChannelActionRequest
     from managed_deepagents._channels.types import ChannelAddress
 else:
     # Authoring-light installs may lack langchain; annotations stay deferred.
     AgentMiddleware = object
 
-_LOG = logging.getLogger("mda")
-
 _schedule_metadata_for_tests: Callable[[], Mapping[str, object] | None] | None = None
 
 
@@ -58,6 +59,16 @@ class NormalizedScheduleDeliverTo(TypedDict):
     auto_post: bool
 
 
+def get_deployment_id(env: Mapping[str, str] | None = None) -> str | None:
+    """Return the deployment ID supplied by the managed runtime."""
+    resolved_env = os.environ if env is None else env
+    for key in ("LANGSMITH_HOST_PROJECT_ID", "LANGGRAPH_CLOUD_ID"):
+        value = (resolved_env.get(key) or "").strip()
+        if value:
+            return value
+    return None
+
+
 def read_schedule_deliver_to(  # noqa: PLR0911 - validation short-circuits
     configurable: Mapping[str, object] | None,
 ) -> NormalizedScheduleDeliverTo | None:
@@ -122,7 +133,7 @@ def address_from_deliver_to(to: _ProviderConversation | _ProviderThread) -> Chan
     return {"conversation_id": to["conversation_id"]}
 
 
-async def deliver_schedule_result(  # noqa: PLR0911 - soft-fail outcomes
+async def deliver_schedule_result(  # noqa: C901, PLR0911 - soft-fail outcomes
     *,
     deliver_to: NormalizedScheduleDeliverTo,
     reply_text: str,
@@ -134,9 +145,9 @@ async def deliver_schedule_result(  # noqa: PLR0911 - soft-fail outcomes
     if not text or not deliver_to["auto_post"]:
         return "skipped"
     if deliver_to["channel"] != "slack":
-        _LOG.error(
-            "schedule deliver_to channel %r is not supported yet",
-            deliver_to["channel"],
+        logger.error(
+            'schedule deliver_to channel "%s" is not supported yet',
+            logger.log_identifier(deliver_to["channel"]),
         )
         return "failed"
 
@@ -151,15 +162,47 @@ async def deliver_schedule_result(  # noqa: PLR0911 - soft-fail outcomes
             if hasattr(result, "__await__"):
                 await cast("Awaitable[object]", result)
             return "posted"
-        except Exception:  # noqa: BLE001 - soft-fail schedule delivery
-            _LOG.exception("schedule Slack delivery failed")
+        except Exception as error:  # noqa: BLE001 - soft-fail schedule delivery
+            logger.error(
+                "schedule Slack delivery failed (%s)",
+                logger.safe_error_label(error),
+            )
+            return "failed"
+
+    deployment_id = get_deployment_id()
+    try:
+        client = create_trigger_client()
+    except ValueError:
+        client = None
+    if client is not None and deployment_id:
+        action: TriggerChannelActionRequest = {
+            "type": "post",
+            "action_id": str(uuid.uuid4()),
+            "address": dict(address),
+            "message": {"text": text},
+        }
+        try:
+            await client.post_deployment_action(
+                deployment_id,
+                deliver_to["channel"],
+                action,
+            )
+            return "posted"
+        except Exception as error:  # noqa: BLE001 - soft-fail schedule delivery
+            logger.error(
+                "schedule Trigger channel delivery failed (%s)",
+                logger.safe_error_label(error),
+            )
             return "failed"
 
     token = (
         bot_token if bot_token is not None else os.environ.get(SLACK_BOT_TOKEN_ENV) or ""
     ).strip()
     if not token:
-        _LOG.error("schedule deliver_to requires SLACK_BOT_TOKEN; skipping auto-post")
+        logger.error(
+            "schedule deliver_to requires Trigger channel configuration or "
+            "SLACK_BOT_TOKEN; skipping auto-post"
+        )
         return "failed"
 
     try:
@@ -176,8 +219,11 @@ async def deliver_schedule_result(  # noqa: PLR0911 - soft-fail outcomes
         if hasattr(posted, "__await__"):
             await cast("Awaitable[object]", posted)
         return "posted"
-    except Exception:  # noqa: BLE001 - soft-fail schedule delivery
-        _LOG.exception("schedule Slack delivery failed")
+    except Exception as error:  # noqa: BLE001 - soft-fail schedule delivery
+        logger.error(
+            "schedule Slack delivery failed (%s)",
+            logger.safe_error_label(error),
+        )
         return "failed"
 
 
@@ -297,6 +343,7 @@ __all__ = [
     "address_from_deliver_to",
     "create_schedule_delivery_middleware",
     "deliver_schedule_result",
+    "get_deployment_id",
     "is_trusted_schedule_delivery_run",
     "read_schedule_deliver_to",
 ]

managed_deepagents/_channels/trigger/client.py

@@ -93,18 +93,41 @@ class TriggerClient(TriggerClientLike):
         channel_id: str,
         body: TriggerChannelActionRequest,
     ) -> TriggerChannelActionResponse:
-        response = await self._post("actions", channel_id, body)
-        response_id = response.get("id") if isinstance(response, dict) else None
-        if not isinstance(response_id, str) or not response_id.strip():
-            raise TriggerClientError("actions")
-        return {"id": response_id}
+        encoded_channel_id = urllib.parse.quote(channel_id, safe="")
+        response = await self._post(
+            "actions",
+            f"{self._api_base}/channels/{encoded_channel_id}/actions",
+            body,
+        )
+        return _parse_action_response(response)
+
+    async def post_deployment_action(
+        self,
+        deployment_id: str,
+        channel_name: str,
+        body: TriggerChannelActionRequest,
+    ) -> TriggerChannelActionResponse:
+        query = urllib.parse.urlencode(
+            {"deployment_id": deployment_id, "channel_name": channel_name}
+        )
+        response = await self._post(
+            "actions",
+            f"{self._api_base}/channels/actions?{query}",
+            body,
+        )
+        return _parse_action_response(response)
 
     async def post_runtime_event(
         self,
         channel_id: str,
         body: TriggerChannelRuntimeEventRequest,
     ) -> TriggerChannelRuntimeEventResponse:
-        response = await self._post("events", channel_id, body)
+        encoded_channel_id = urllib.parse.quote(channel_id, safe="")
+        response = await self._post(
+            "events",
+            f"{self._api_base}/channels/{encoded_channel_id}/events",
+            body,
+        )
         status = response.get("status") if isinstance(response, dict) else None
         if not isinstance(status, str):
             raise TriggerClientError("events")
@@ -113,11 +136,9 @@ class TriggerClient(TriggerClientLike):
     async def _post(
         self,
         operation: TriggerClientOperation,
-        channel_id: str,
+        url: str,
         body: TriggerChannelActionRequest | TriggerChannelRuntimeEventRequest,
     ) -> object:
-        encoded_channel_id = urllib.parse.quote(channel_id, safe="")
-        url = f"{self._api_base}/channels/{encoded_channel_id}/{operation}"
         headers = {
             "content-type": "application/json",
             "x-api-key": self._api_key,
@@ -144,6 +165,13 @@ class TriggerClient(TriggerClientLike):
             raise TriggerClientError(operation) from None
 
 
+def _parse_action_response(response: object) -> TriggerChannelActionResponse:
+    response_id = response.get("id") if isinstance(response, dict) else None
+    if not isinstance(response_id, str) or not response_id.strip():
+        raise TriggerClientError("actions")
+    return {"id": response_id}
+
+
 def create_trigger_client(
     *,
     user_id: str | None = None,

managed_deepagents/_channels/trigger/types.py

@@ -66,14 +66,17 @@ class TriggerChannelActionMessage(TypedDict):
     text: str
 
 
-class TriggerChannelActionRequest(TypedDict):
+class TriggerChannelActionRequestRequired(TypedDict):
     type: Literal["post"]
     action_id: str
     address: TriggerChannelAddress
-    source_thread_key: str
     message: TriggerChannelActionMessage
 
 
+class TriggerChannelActionRequest(TriggerChannelActionRequestRequired, total=False):
+    source_thread_key: str
+
+
 class TriggerChannelActionResponse(TypedDict):
     id: str
 

managed_deepagents/_connectors/mcp/__init__.py

@@ -9,7 +9,7 @@ name, before any managed ``{server}__`` prefix is applied.
 Example::
 
     # connectors/mcp.py
-    from managed_deepagents import connectors, credentials
+    from managed_deepagents import connectors
 
     connector = connectors.mcp(
         use_standard_content_blocks=True,
@@ -21,11 +21,6 @@ Example::
                 "url": "https://docs.example.com/mcp",
                 "include_tools": ["search", "fetch"],
             },
-            "notion": {
-                "transport": "http",
-                "url": "https://mcp.notion.com/mcp",
-                "credential": credentials.get("notion", {"type": "user"}),
-            },
         },
     )
 """
@@ -47,7 +42,6 @@ from pydantic import (
 
 from managed_deepagents._connector import Connector
 from managed_deepagents._connectors.mcp.load import load_managed_mcp_tools
-from managed_deepagents._credentials import CredentialReference  # noqa: TC001
 from managed_deepagents._extension import define_extension
 
 
@@ -59,9 +53,6 @@ class McpToolSelectionConfig(TypedDict, total=False):
 class RemoteMcpServerBaseConfig(McpToolSelectionConfig, total=False):
     url: str
     headers: dict[str, str]
-    #: Bearer credential: an agent owner is a deployment-wide secret read once
-    #: at load, a user owner is the caller's OAuth grant loaded after the gate.
-    credential: CredentialReference
     #: Default timeout in seconds for tools loaded from this server.
     default_tool_timeout: float
 
@@ -151,7 +142,7 @@ class _RemoteMcpServer(BaseModel):
     ``default_tool_timeout``) are stripped before the client is constructed.
     """
 
-    model_config = ConfigDict(extra="allow", validate_default=True, arbitrary_types_allowed=True)
+    model_config = ConfigDict(extra="allow", validate_default=True)
 
     # Both default to a value the validators below reject, so a missing field
     # reports the same message a malformed one does — as it does in Zod.
@@ -163,7 +154,6 @@ class _RemoteMcpServer(BaseModel):
     default_tool_timeout: float | None = None
     include_tools: list[_ToolName] | None = None
     exclude_tools: list[_ToolName] | None = None
-    credential: CredentialReference | None = None
 
     @field_validator("default_tool_timeout")
     @classmethod

managed_deepagents/_connectors/mcp/load.py

@@ -10,13 +10,10 @@ from __future__ import annotations
 import asyncio
 import math
 import warnings
-from collections.abc import Awaitable, Callable, Iterable, Mapping, Sequence
-from functools import partial
+from collections.abc import Awaitable, Callable, Iterable, Mapping
 from typing import TYPE_CHECKING, Protocol, cast
 
 from managed_deepagents._connectors.tool_selection import select_tools
-from managed_deepagents._credential_gate import CredentialConsumer
-from managed_deepagents._credentials import CredentialReference, credentials
 from managed_deepagents._memory.async_util import await_if_needed
 from managed_deepagents._memory.deps import (
     optional_runtime_symbols,
@@ -53,10 +50,6 @@ class _TimedTool(Protocol):
 #: tools loaded once per declaration, and every subsequent run reuses them.
 #: Multiple ``connectors.mcp(...)`` modules each get their own entry (keyed by
 #: object identity).
-#:
-#: An agent-owned credential is read into this cache once, so rotating that
-#: secret takes a redeploy. Servers with a user-owned credential are omitted
-#: entirely; the credential gate loads those per caller.
 _managed_mcp_tools: dict[int, list[object]] = {}
 
 
@@ -80,83 +73,6 @@ def load_managed_mcp_tools(connectors: McpServersDefinition) -> list[object]:
     return tools
 
 
-def mcp_credential_consumers(
-    connectors: Sequence[object] | None,
-) -> list[CredentialConsumer]:
-    """The credential gate's view of the declared MCP connectors.
-
-    One consumer per declaration that names a user-owned credential; a
-    declaration that needs no grant never reaches the gate.
-    """
-    out: list[CredentialConsumer] = []
-    for connector in connectors or []:
-        if getattr(connector, "kind", None) != "mcp_servers":
-            continue
-        definition = cast("McpServersDefinition", connector)
-        references = _user_credential_references(definition)
-        if not references:
-            continue
-        out.append(
-            CredentialConsumer(
-                declaration=definition,
-                credentials=references,
-                load=partial(load_user_credential_mcp_tools, definition),
-            )
-        )
-    return out
-
-
-def _user_credential_references(
-    connectors: McpServersDefinition,
-) -> tuple[CredentialReference, ...]:
-    """The declared references themselves: the gate checks their owner."""
-    config = getattr(connectors, "config", None)
-    servers = config.get("mcp_servers") if isinstance(config, Mapping) else None
-    if not isinstance(servers, Mapping):
-        return ()
-    by_slug: dict[str, CredentialReference] = {}
-    for server_config in servers.values():
-        if _uses_user_credential(server_config):
-            credential = cast("CredentialReference", server_config["credential"])
-            by_slug.setdefault(credential.slug, credential)
-    return tuple(by_slug.values())
-
-
-def load_user_credential_mcp_tools(
-    connectors: McpServersDefinition,
-    access_tokens: Mapping[str, str],
-) -> list[object]:
-    """Load tools for user-credential servers, once the gate confirms grants.
-
-    Not process-cached here: the Authorization header is per caller, so the gate
-    owns the cache. Python's ``MultiServerMCPClient`` opens a session per call
-    and holds no transport, so there is nothing to close afterwards.
-    """
-    config = connectors.config
-    servers = config["mcp_servers"]
-    _eager, user_credential = _partition_mcp_servers(servers)
-    if not user_credential:
-        return []
-
-    connectable: dict[str, RemoteMcpServerConfig] = {}
-    for server_name in user_credential:
-        server_config = servers.get(server_name)
-        if not isinstance(server_config, dict):
-            continue
-        credential = server_config.get("credential")
-        if not isinstance(credential, CredentialReference):
-            continue
-        access_token = access_tokens.get(credential.slug)
-        if not access_token:
-            raise RuntimeError(f'MCP user credential "{credential.slug}" has no access token')
-        connectable[server_name] = _with_bearer(server_config, access_token)
-
-    if not connectable:
-        return []
-
-    return _load_tools_from_servers(connectors, connectable)
-
-
 def clear_managed_mcp_tools_cache_for_tests(
     connectors: McpServersDefinition | None = None,
 ) -> None:
@@ -167,92 +83,14 @@ def clear_managed_mcp_tools_cache_for_tests(
     _managed_mcp_tools.clear()
 
 
-def _uses_user_credential(server_config: RemoteMcpServerConfig | dict[str, object]) -> bool:
-    if isinstance(server_config, dict):
-        credential = server_config.get("credential")
-    else:
-        credential = getattr(server_config, "credential", None)
-    return isinstance(credential, CredentialReference) and credential.owner["type"] == "user"
-
-
-def _partition_mcp_servers(
-    servers: dict[str, RemoteMcpServerConfig],
-) -> tuple[dict[str, RemoteMcpServerConfig], list[str]]:
-    eager: dict[str, RemoteMcpServerConfig] = {}
-    user_credential: list[str] = []
-    for server_name, server_config in servers.items():
-        if _uses_user_credential(server_config):
-            user_credential.append(server_name)
-        else:
-            eager[server_name] = server_config
-    return eager, user_credential
-
-
-def _warn_deferred_user_credential_servers(server_names: list[str]) -> None:
-    if not server_names:
-        return
-    warnings.warn(
-        f"MCP server(s) {', '.join(server_names)} declare a user credential; "
-        "tools load after the pre-run credential gate confirms grants for the caller.",
-        RuntimeWarning,
-        stacklevel=3,
-    )
-
-
 def _create_client_and_load_tools(connectors: McpServersDefinition) -> list[object]:
-    """Create the ``langchain-mcp-adapters`` client and load its eager tools.
+    """Create the ``langchain-mcp-adapters`` client and load its tools.
 
     Python's ``MultiServerMCPClient`` does not prefix tool names itself, so when
     ``prefix_tool_name_with_server_name`` is set (the default) MDA loads each
     server's tools and namespaces them as ``{server}__{tool}``, matching the
     TypeScript adapter's format.
-
-    Servers with user credential references are omitted; the gate loads them
-    per caller after OAuth grants exist.
     """
-    config = connectors.config
-    servers = config["mcp_servers"]
-    eager, user_credential = _partition_mcp_servers(servers)
-    if user_credential:
-        _warn_deferred_user_credential_servers(user_credential)
-    if not eager:
-        return []
-    return _load_tools_from_servers(connectors, _with_agent_credentials(eager))
-
-
-def _with_agent_credentials(
-    servers: dict[str, RemoteMcpServerConfig],
-) -> dict[str, RemoteMcpServerConfig]:
-    """Resolve each agent-owned credential into a static bearer header."""
-    out: dict[str, RemoteMcpServerConfig] = {}
-    for server_name, server_config in servers.items():
-        credential = server_config.get("credential") if isinstance(server_config, dict) else None
-        if not isinstance(credential, CredentialReference):
-            out[server_name] = server_config
-            continue
-        secret = await_if_needed(credentials.resolve_deployment_secret(credential.slug))
-        out[server_name] = _with_bearer(server_config, cast("str", secret))
-    return out
-
-
-def _with_bearer(
-    server_config: RemoteMcpServerConfig,
-    token: str,
-) -> RemoteMcpServerConfig:
-    merged = dict(cast("Mapping[str, object]", server_config))
-    raw_headers = merged.get("headers")
-    headers: dict[str, str] = (
-        dict(cast("Mapping[str, str]", raw_headers)) if isinstance(raw_headers, Mapping) else {}
-    )
-    headers["Authorization"] = f"Bearer {token}"
-    merged["headers"] = headers
-    return cast("RemoteMcpServerConfig", merged)
-
-
-def _load_tools_from_servers(
-    connectors: McpServersDefinition,
-    connectable: dict[str, RemoteMcpServerConfig],
-) -> list[object]:
     client_cls = cast(
         "type",
         require_runtime_dependency(
@@ -263,13 +101,14 @@ def _load_tools_from_servers(
     )
 
     config = connectors.config
+    servers = config["mcp_servers"]
     prefix = config.get("prefix_tool_name_with_server_name", True)
     throw_on_load_error = config.get("throw_on_load_error", True)
 
-    client = client_cls(_strip_managed_tool_selection(connectable))
+    client = client_cls(_strip_managed_tool_selection(servers))
 
     tools: list[object] = []
-    for server_name, server_config in connectable.items():
+    for server_name, server_config in servers.items():
         try:
             server_tools = await_if_needed(client.get_tools(server_name=server_name))
         except Exception as exc:
@@ -304,12 +143,7 @@ def _load_tools_from_servers(
 
 #: Fields MDA owns. ``langchain-mcp-adapters`` unpacks the remaining dict into
 #: the transport session constructor, which does not accept these keys.
-_MDA_OWNED_SERVER_KEYS = (
-    "include_tools",
-    "exclude_tools",
-    "default_tool_timeout",
-    "credential",
-)
+_MDA_OWNED_SERVER_KEYS = ("include_tools", "exclude_tools", "default_tool_timeout")
 
 
 def _strip_managed_tool_selection(

managed_deepagents/_identity_auth.py

@@ -274,7 +274,7 @@ async def _authenticate(
 async def resolve_request_identity(
     cfg: IdentityConfig, request: HttpRequestLike
 ) -> RuntimeIdentity:
-    """Resolve the caller's frozen identity envelope from a raw HTTP request.
+    """Resolve the caller's frozen ``runtime.identity`` from a raw HTTP request.
 
     Uses the same ingress logic (``trusted_backend`` headers / ``validated_token``
     verification) as the managed auth handler, then builds the frozen identity