PyPI - dreadnode - Versions diffs - 2.0.26__py3-none-any.whl → 2.0.28__py3-none-any.whl - Mend

dreadnode 2.0.26py3-none-any.whl → 2.0.28py3-none-any.whl

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (42) hide show

dreadnode/agents/mcp/auth.py CHANGED Viewed

@@ -1,16 +1,26 @@
 """
 MCP OAuth authentication support.
-Provides file-based token storage and helpers for building OAuth providers
-using the MCP SDK's built-in OAuthClientProvider.
+Provides file-based token storage, a localhost callback server for catching
+OAuth redirects, a browser-opening redirect handler, and a factory that wires
+those defaults onto the MCP SDK's :class:`OAuthClientProvider`.
+Together they enable native HTTP MCP servers (e.g. Linear, Atlassian) to be
+authenticated end-to-end by the Dreadnode runtime without going through the
+``npx mcp-remote`` stdio bridge.
 """
 import asyncio
+import contextlib
 import json
 import os
+import socket
+import sys
 import typing as t
+import webbrowser
 from collections.abc import Awaitable, Callable
 from pathlib import Path
+from urllib.parse import parse_qs, urlparse
 from loguru import logger
@@ -22,6 +32,21 @@ from dreadnode.agents.mcp.config import OAuthConfig
 DEFAULT_AUTH_PATH = Path.home() / ".dreadnode" / "mcp-auth.json"
+# Default time (seconds) the local callback server waits for the user to
+# complete the OAuth flow in their browser before giving up.
+_DEFAULT_CALLBACK_TIMEOUT = 300.0
+class MCPOAuthRequiredError(Exception):
+    """Raised when a connect would need to open a browser to complete OAuth
+    but the runtime isn't allowed to (a non-interactive / background connect).
+    Signals the lifecycle to classify the server as ``needs_auth`` and defer
+    the browser-open to a user-initiated Authenticate, rather than popping a
+    window during startup (CAP-MCP-010 — the runtime owns the browser-open
+    moment).
+    """
 class FileTokenStorage:
     """Persist OAuth tokens to disk, keyed by server URL.
@@ -57,6 +82,17 @@ class FileTokenStorage:
     def _get_entry(self) -> dict[str, t.Any]:
         return self._read_store().get(self._server_url, {})
+    def has_tokens(self) -> bool:
+        """Synchronously report whether this server has stored OAuth tokens.
+        Used by the runtime to decide, *before* a background connect, whether
+        to wire up an OAuth provider at all. With no stored token a background
+        connect attaches no provider — a 401 then surfaces as ``needs_auth``
+        without any discovery/DCR traffic or browser-open. A small local file
+        read is cheap enough to do inline on the connect path.
+        """
+        return bool(self._get_entry().get("tokens"))
     def _set_entry(self, entry: dict[str, t.Any]) -> None:
         store = self._read_store()
         store[self._server_url] = entry
@@ -104,42 +140,343 @@ class FileTokenStorage:
         await asyncio.to_thread(_update)
+    async def clear(self) -> None:
+        """Remove this server's stored tokens + client_info from the file.
+        Targeted by server URL — other servers' entries are untouched.
+        Used by the user-initiated re-authenticate flow so a fresh OAuth
+        round-trip runs on the next connect without wiping the whole
+        cache (other authenticated capabilities keep working).
+        """
+        def _clear() -> None:
+            store = self._read_store()
+            if self._server_url in store:
+                del store[self._server_url]
+                self._write_store(store)
+        await asyncio.to_thread(_clear)
+# --- Localhost OAuth callback server -----------------------------------------
+_SUCCESS_HTML = (
+    b"<!doctype html><html><head><meta charset='utf-8'>"
+    b"<title>Dreadnode \xe2\x80\x94 Authentication complete</title>"
+    b"<style>body{font:14px/1.5 system-ui,sans-serif;max-width:32rem;"
+    b"margin:6rem auto;padding:0 1rem;color:#222;}h2{margin-bottom:.5rem}</style>"
+    b"</head><body><h2>Authentication complete \xe2\x9c\x93</h2>"
+    b"<p>You can close this tab and return to the Dreadnode TUI.</p>"
+    b"</body></html>"
+)
+_ERROR_HTML = (
+    b"<!doctype html><html><head><meta charset='utf-8'>"
+    b"<title>Dreadnode \xe2\x80\x94 Authentication failed</title></head>"
+    b"<body><h2>Authentication failed</h2>"
+    b"<p>The authorization server didn't return a code parameter. "
+    b"Return to the Dreadnode TUI and retry.</p></body></html>"
+)
+class LocalCallbackServer:
+    """One-shot HTTP server on a 127.0.0.1 ephemeral port for OAuth redirects.
+    Binds a socket eagerly in ``__init__`` so ``redirect_uri`` is known
+    before the OAuth flow needs it (the authorization server has to be
+    told the redirect URI at the start of the authorization request, well
+    before the user actually completes the flow). ``start()`` converts
+    the bound socket into a running ``asyncio.Server``; ``wait_for_callback()``
+    blocks until the redirect arrives, then tears the server down.
+    Single-use by design — a fresh instance per OAuth flow, no recycling.
+    The redirect URI is always ``http://127.0.0.1:<port>/callback``.
+    """
+    def __init__(
+        self,
+        *,
+        host: str = "127.0.0.1",
+        timeout: float = _DEFAULT_CALLBACK_TIMEOUT,
+    ) -> None:
+        self._host = host
+        self._timeout = timeout
+        sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
+        sock.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
+        sock.bind((host, 0))
+        self._socket: socket.socket | None = sock
+        self._port: int = sock.getsockname()[1]
+        self._result: tuple[str, str | None] | None = None
+        self._error: str | None = None
+        self._received = asyncio.Event()
+        self._server: asyncio.Server | None = None
+    @property
+    def port(self) -> int:
+        return self._port
+    @property
+    def redirect_uri(self) -> str:
+        return f"http://{self._host}:{self._port}/callback"
+    async def start(self) -> None:
+        """Begin listening for the OAuth callback. Idempotent."""
+        if self._server is not None:
+            return
+        if self._socket is None:
+            msg = "LocalCallbackServer socket is already released — cannot start"
+            raise RuntimeError(msg)
+        self._server = await asyncio.start_server(self._handle_request, sock=self._socket)
+        # Server now owns the socket.
+        self._socket = None
+        logger.debug("OAuth callback server listening on {}", self.redirect_uri)
+    async def _handle_request(
+        self, reader: asyncio.StreamReader, writer: asyncio.StreamWriter
+    ) -> None:
+        try:
+            request_line = await reader.readline()
+            line = request_line.decode("latin-1", errors="replace").strip()
+            # Drain headers — we only need the request line.
+            while True:
+                hdr = await reader.readline()
+                if not hdr or hdr in (b"\r\n", b"\n"):
+                    break
+            _method, _, rest = line.partition(" ")
+            target, _, _ = rest.partition(" ")
+            parsed = urlparse(target)
+            params = parse_qs(parsed.query)
+            code = params.get("code", [""])[0]
+            state_list = params.get("state")
+            state = state_list[0] if state_list else None
+            err = params.get("error", [""])[0]
+            err_desc = params.get("error_description", [""])[0]
+            if code:
+                self._result = (code, state)
+                self._received.set()
+                self._respond(writer, b"200 OK", _SUCCESS_HTML)
+            else:
+                self._error = err_desc or err or "missing 'code' parameter"
+                logger.warning("OAuth callback returned error: {}", self._error)
+                self._respond(writer, b"400 Bad Request", _ERROR_HTML)
+                self._received.set()
+        except Exception as exc:
+            logger.warning("OAuth callback handler error: {}", exc)
+            self._error = f"callback handler error: {exc}"
+            self._received.set()
+        finally:
+            with contextlib.suppress(Exception):
+                writer.close()
+                await writer.wait_closed()
+    @staticmethod
+    def _respond(writer: asyncio.StreamWriter, status: bytes, body: bytes) -> None:
+        writer.write(b"HTTP/1.1 " + status + b"\r\n")
+        writer.write(b"Content-Type: text/html; charset=utf-8\r\n")
+        writer.write(f"Content-Length: {len(body)}\r\n".encode())
+        writer.write(b"Connection: close\r\n\r\n")
+        writer.write(body)
+    async def wait_for_callback(self) -> tuple[str, str | None]:
+        """Block until the OAuth callback arrives. Returns (code, state).
+        Raises ``TimeoutError`` if the user doesn't complete the flow
+        within the configured timeout, or ``RuntimeError`` if the
+        callback arrived with an error parameter instead of a code.
+        Always tears the server down before returning.
+        """
+        try:
+            await asyncio.wait_for(self._received.wait(), timeout=self._timeout)
+        finally:
+            await self.aclose()
+        if self._result is not None:
+            return self._result
+        err = self._error or "no callback received"
+        raise RuntimeError(f"OAuth callback failed: {err}")
+    async def aclose(self) -> None:
+        """Shut down the server and release the socket. Idempotent."""
+        if self._server is not None:
+            self._server.close()
+            with contextlib.suppress(Exception):
+                await self._server.wait_closed()
+            self._server = None
+        if self._socket is not None:
+            with contextlib.suppress(Exception):
+                self._socket.close()
+            self._socket = None
+    def __del__(self) -> None:  # pragma: no cover - best-effort GC cleanup
+        # Close the held socket if start() was never called (e.g. the
+        # OAuth flow never actually needed auth because a cached token
+        # was used). asyncio.Server cleanup is async and not reachable
+        # from __del__; rely on the loop's own teardown there.
+        if self._socket is not None:
+            with contextlib.suppress(Exception):
+                self._socket.close()
+# --- Redirect handler --------------------------------------------------------
+def _is_headless() -> bool:
+    """Best-effort detection of environments where opening a browser fails.
+    Honors the ``DREADNODE_HEADLESS`` opt-out for users who'd prefer to
+    complete OAuth manually even on a desktop machine. On Linux,
+    absence of ``DISPLAY`` and ``WAYLAND_DISPLAY`` is taken as a strong
+    signal (SSH, container, headless CI). On macOS/Windows we trust
+    ``webbrowser.open``'s return value instead.
+    """
+    if os.environ.get("DREADNODE_HEADLESS", "").strip().lower() in ("1", "true", "yes", "on"):
+        return True
+    if sys.platform.startswith("linux"):
+        if not os.environ.get("DISPLAY") and not os.environ.get("WAYLAND_DISPLAY"):
+            return True
+    return False
+async def _browser_open_redirect_handler(url: str) -> None:
+    """Open the user's browser to *url*, or log it prominently if we can't.
+    The localhost callback server is the user's only way to deliver the
+    OAuth code back to us, so this handler must succeed *or* surface a
+    very clear manual fallback. ``DREADNODE_HEADLESS=1`` forces the
+    fallback path even on a desktop, which is useful for SSH sessions
+    that forward a port but no display.
+    """
+    if _is_headless():
+        logger.warning(
+            "MCP OAuth: browser disabled (DREADNODE_HEADLESS or no display). "
+            "Visit this URL to authorize:\n  {}",
+            url,
+        )
+        return
+    try:
+        opened = webbrowser.open(url, new=1, autoraise=True)
+    except Exception as exc:
+        logger.debug("webbrowser.open raised: {}", exc)
+        opened = False
+    if opened:
+        logger.info("MCP OAuth: opened browser for authorization. Complete the flow to continue.")
+    else:
+        logger.warning(
+            "MCP OAuth: could not open a browser. Visit this URL manually:\n  {}",
+            url,
+        )
 async def _default_redirect_handler(url: str) -> None:
+    """Backwards-compat shim — log-only handler, kept for external callers
+    that explicitly pass it. New defaults use ``_browser_open_redirect_handler``.
+    """
     logger.info("MCP OAuth: Visit this URL to authorize:\n  {}", url)
+async def _deferred_redirect_handler(url: str) -> None:
+    """Non-interactive redirect handler: refuse to open a browser.
+    Used by background connects (CAP-MCP-010). When the OAuth flow reaches
+    the point of opening the authorization URL, we raise instead — the
+    lifecycle classifies the server ``needs_auth`` and the user opens the
+    browser later via an explicit Authenticate. The URL is logged at debug
+    so it's recoverable for diagnostics, never auto-opened.
+    """
+    logger.debug("MCP OAuth: authorization required (deferred, non-interactive): {}", url)
+    raise MCPOAuthRequiredError(f"OAuth authorization required for {url}")
+async def _deferred_callback_handler() -> tuple[str, str | None]:
+    """Non-interactive callback handler — never reached.
+    The deferred redirect handler raises before any callback is awaited;
+    this exists only to satisfy the provider's handler-pair contract.
+    """
+    raise MCPOAuthRequiredError("OAuth authorization required (non-interactive)")
 def create_oauth_provider(
     server_url: str,
     config: OAuthConfig | None = None,
     storage: "TokenStorage | None" = None,
     redirect_handler: Callable[[str], Awaitable[None]] | None = None,
     callback_handler: Callable[[], Awaitable[tuple[str, str | None]]] | None = None,
+    *,
+    interactive: bool = True,
+    callback_server: LocalCallbackServer | None = None,
 ) -> "OAuthClientProvider":
-    """Build an OAuthClientProvider from our config types.
+    """Build an :class:`OAuthClientProvider` wired with working defaults.
+    If neither ``redirect_handler`` nor ``callback_handler`` is provided,
+    the function wires the pair according to ``interactive``:
+    - ``interactive=True`` (user-initiated): spin up a
+      :class:`LocalCallbackServer`, open the user's browser (falling back to
+      a logged URL when headless), and block on the callback server until the
+      redirect arrives. The OAuth flow completes end-to-end.
+    - ``interactive=False`` (background/startup): never open a browser. A
+      valid stored token is still used/refreshed transparently; if the flow
+      would actually need to authorize, the deferred redirect handler raises
+      :class:`MCPOAuthRequiredError` so the runtime classifies ``needs_auth`` and
+      defers the browser to a user-initiated Authenticate (CAP-MCP-010).
+    Passing a custom ``redirect_handler`` *and* ``callback_handler``
+    bypasses the defaults entirely — useful for custom UIs (in-TUI
+    overlay, IDE picker, etc.).
     Args:
         server_url: The MCP server URL.
         config: OAuth configuration. Uses defaults if None.
-        storage: Token storage. Defaults to FileTokenStorage.
-        redirect_handler: Called with auth URL. Defaults to logging the URL.
-        callback_handler: Called to get (code, state). None by default
-            (Layer 3/TUI provides this for interactive flows).
+        storage: Token storage. Defaults to :class:`FileTokenStorage`.
+        redirect_handler: Called with the authorization URL. Defaults per
+            ``interactive`` (browser-open, or deferred raise).
+        callback_handler: Called to retrieve ``(code, state)`` from the
+            redirect. Defaults to blocking on a localhost callback server.
+        interactive: Whether this connect may open a browser. Defaults True.
+        callback_server: Inject a pre-built callback server (testing).
     """
     from mcp.client.auth.oauth2 import OAuthClientProvider
     from mcp.shared.auth import OAuthClientMetadata
     config = config or OAuthConfig()
+    if storage is None:
+        storage = FileTokenStorage(server_url)
+    # If the caller didn't fully customize the handlers, set up the default
+    # pair. We do this even when only one side is overridden — that path is
+    # symmetric, both halves must come from the caller.
+    redirect_uris: list[t.Any] | None = None
+    if redirect_handler is None and callback_handler is None:
+        if not interactive:
+            # Background connect: stored tokens still work, but never pop a
+            # browser. The deferred handler raises if authorization is needed.
+            redirect_handler = _deferred_redirect_handler
+            callback_handler = _deferred_callback_handler
+        else:
+            if callback_server is None:
+                callback_server = LocalCallbackServer()
+            captured_server = callback_server  # bind for closures + type narrowing
+            async def _redirect(url: str) -> None:
+                await captured_server.start()
+                await _browser_open_redirect_handler(url)
+            redirect_handler = _redirect
+            callback_handler = captured_server.wait_for_callback
+            redirect_uris = [captured_server.redirect_uri]
     client_metadata = OAuthClientMetadata(
-        redirect_uris=None,
+        redirect_uris=redirect_uris,
         client_name=config.client_name,
         scope=config.scope,
     )
-    if storage is None:
-        storage = FileTokenStorage(server_url)
     return OAuthClientProvider(
         server_url=server_url,
         client_metadata=client_metadata,

dreadnode/agents/mcp/client.py CHANGED Viewed

@@ -39,6 +39,13 @@ if t.TYPE_CHECKING:
     from dreadnode.generators.message import Content
+# An interactive (user-initiated) OAuth connect blocks on a human browser
+# round-trip, so the per-step init timeout must comfortably exceed the
+# localhost callback server's wait (_DEFAULT_CALLBACK_TIMEOUT = 300s).
+# Background connects keep the normal, tight init timeout.
+_INTERACTIVE_AUTH_INIT_TIMEOUT = 330.0
 class _StderrCapture:
     """Async reader that buffers the last N lines from a pipe fd.
@@ -221,6 +228,12 @@ class MCPClient:
         self._exit_stack = AsyncExitStack()
         self._session = None
         self._oauth_config = oauth
+        # Whether the in-flight connect may open a browser for OAuth. Set by
+        # connect(); defaults to the conservative non-interactive mode so a
+        # browser only opens when a caller explicitly opts in (the runtime does
+        # this on a user-initiated reconnect) — not from a background/startup
+        # connect (CAP-MCP-010: the runtime owns the browser-open moment).
+        self._auth_interactive = False
         self._init_timeout = init_timeout
         # Only meaningful for stdio transports — the stderr capture wires it
         # into _StderrCapture on connect. HTTP transports ignore it.
@@ -342,15 +355,54 @@ class MCPClient:
         return cause
     def _set_error_status(self, exc: BaseException) -> BaseException:
+        from dreadnode.agents.mcp.auth import MCPOAuthRequiredError
         cause = self._unwrap_exception(exc)
         error_msg = str(cause)
+        # A background connect that hit the deferred OAuth handler: the server
+        # needs fresh authorization but we declined to open a browser. This is
+        # needs_auth, not a failure — the user authenticates explicitly later.
+        if isinstance(cause, MCPOAuthRequiredError):
+            self._status = MCPStatus.NEEDS_AUTH
+            self._error = error_msg
+            return cause
+        # The user-facing error report keeps the last 10 lines of stderr
+        # so operators can see why the server died at a glance.
         if self._stderr_capture and self._stderr_capture.last_lines:
             stderr_tail = "\n".join(self._stderr_capture.last_lines[-10:])
             error_msg = f"{error_msg}\n\nServer stderr:\n{stderr_tail}"
-        error_lower = error_msg.lower()
-        if any(kw in error_lower for kw in ("unauthorized", "forbidden", "401", "403", "oauth")):
+        # Auth classification scans the *full* captured buffer (capped at
+        # 50 lines by _StderrCapture), not just the report tail. Reason:
+        # mcp-remote prints "Please authorize…" / "Authentication required"
+        # *once*, near the start, then polls a `/wait-for-auth` callback
+        # every couple of seconds. By the time the lifecycle hits its
+        # init_timeout (60s) and we classify, those early markers have
+        # been pushed out of the last-10 window — but they're still in
+        # the 50-line buffer. Matching the full buffer makes the
+        # classification robust to polling chatter (ENG-6989).
+        scan_text = error_msg
+        if self._stderr_capture and self._stderr_capture.last_lines:
+            scan_text = "\n".join([str(cause), *self._stderr_capture.last_lines])
+        scan_lower = scan_text.lower()
+        auth_keywords = (
+            "unauthorized",
+            "forbidden",
+            "401",
+            "403",
+            "oauth",
+            "please authorize",
+            "authorize this client",
+            # mcp-remote-specific markers that survive the buffer even
+            # after the bridge polls /wait-for-auth for 60s.
+            "authentication required",
+            "waiting for authentication",
+            "wait-for-auth",
+        )
+        if any(kw in scan_lower for kw in auth_keywords):
             self._status = MCPStatus.NEEDS_AUTH
         else:
             self._status = MCPStatus.FAILED
@@ -382,8 +434,15 @@ class MCPClient:
                 )
                 raise TypeError(msg)  # noqa: TRY301
-            await asyncio.wait_for(self.session.initialize(), timeout=self._init_timeout)
-            await asyncio.wait_for(self._load_tools(), timeout=self._init_timeout)
+            # An interactive OAuth connect blocks on a human browser round-trip
+            # during initialize(), so widen the timeout for that case only.
+            init_timeout = (
+                max(self._init_timeout, _INTERACTIVE_AUTH_INIT_TIMEOUT)
+                if self._auth_interactive and self.transport == "streamable-http"
+                else self._init_timeout
+            )
+            await asyncio.wait_for(self.session.initialize(), timeout=init_timeout)
+            await asyncio.wait_for(self._load_tools(), timeout=init_timeout)
             self._status = MCPStatus.CONNECTED
             self._error = None
@@ -455,6 +514,8 @@ class MCPClient:
         headers: dict[str, str] | None,
         http_timeout: float,
         auth: t.Any,
+        *,
+        allow_auth_challenge: bool = False,
     ) -> bool:
         """Probe whether a URL supports streamable HTTP (POST).
@@ -462,6 +523,11 @@ class MCPClient:
         clearly doesn't. Connectivity errors also return False (server
         unreachable via POST, try SSE). Auth and SSL errors are allowed to
         propagate — they would affect SSE equally.
+        When ``allow_auth_challenge`` is set (an OAuth provider is attached to
+        the real connect), a 401/403 is treated as a streamable-http server
+        that simply needs authentication: the probe returns True so the
+        authenticated connect runs, instead of raising or routing to SSE.
         """
         try:
             probe_headers = dict(headers) if headers else {}
@@ -473,9 +539,19 @@ class MCPClient:
             )
             async with httpx.AsyncClient(timeout=min(http_timeout, 5), auth=auth) as probe:
                 r = await probe.post(url, content=b"{}", headers=probe_headers)
-                # Auth errors affect both transports equally — propagate so
+                # Auth errors affect both transports equally. With a provider
+                # attached the authenticated connect will handle the challenge,
+                # so treat the server as streamable-http; otherwise propagate so
                 # callers can classify as NEEDS_AUTH instead of falling through.
                 if r.status_code in (401, 403):
+                    if allow_auth_challenge:
+                        logger.debug(
+                            "Streamable HTTP probe got {} for {}, deferring to "
+                            "authenticated connect",
+                            r.status_code,
+                            url,
+                        )
+                        return True
                     r.raise_for_status()
                 if r.status_code == 400 and self._looks_like_jsonrpc_probe_rejection(r):
                     logger.debug(
@@ -535,7 +611,19 @@ class MCPClient:
         # upstream MCP SDK's streamable-http transport crashes during cleanup
         # with an uncatchable BaseExceptionGroup. Skip straight to SSE when
         # the server clearly doesn't accept POST.
-        if not await self._probe_supports_streamable_http(url, headers, timeout, auth):
+        #
+        # The probe always runs with ``auth=None`` so it stays cheap and never
+        # drags the interactive OAuth flow through the short-timeout probe
+        # client. When a provider is attached we still need the probe to tell
+        # an SSE-only server (4xx POST rejection → SSE) apart from an
+        # OAuth-protected streamable-http server (401/403 → proceed to the
+        # authenticated connect). ``allow_auth_challenge`` makes the probe
+        # treat a 401/403 as "streamable-http, just needs auth" instead of
+        # raising, so the authenticated connect runs and the provider handles
+        # the challenge.
+        if not await self._probe_supports_streamable_http(
+            url, headers, timeout, None, allow_auth_challenge=auth is not None
+        ):
             return await self._connect_via_sse_internal(connection)
         try:
@@ -563,30 +651,65 @@ class MCPClient:
         headers = connection.get("headers")
         timeout = connection.get("timeout", DEFAULT_HTTP_TIMEOUT)
         sse_read_timeout = connection.get("sse_read_timeout", DEFAULT_SSE_READ_TIMEOUT)
+        # Mirror the streamable-http path: forward the OAuth provider so an
+        # SSE-fallback connect to an authenticated server still completes
+        # the auth flow rather than 401'ing silently.
+        auth = self._build_auth_provider(url)
         ctx = sse_client(
             url=url,
             headers=headers,
             timeout=timeout,
             sse_read_timeout=sse_read_timeout,
+            auth=auth,
         )
         read, write = await self._exit_stack.enter_async_context(ctx)
         return await self._exit_stack.enter_async_context(ClientSession(read, write))
     def _build_auth_provider(self, url: str) -> t.Any:
-        """Build an httpx.Auth provider if OAuth is configured."""
-        if self._oauth_config is None:
-            return None
+        """Build an httpx.Auth OAuth provider for a streamable-http server.
+        Reactive-by-default (CAP-MCP-011): every HTTP server gets a provider so
+        a 401 can drive RFC 9728 / RFC 8414 discovery + DCR + PKCE without the
+        manifest pre-declaring anything. The provider stays dormant unless the
+        server actually challenges with a 401 — it only adds an auth header
+        when it holds a valid token — so it's a no-op for public servers and
+        for servers using static header / API-key auth (their headers win).
+        A declared ``auth:`` block (``self._oauth_config``) is an optional
+        refinement carrying ``scope`` / ``client_name``; it's no longer a
+        precondition for OAuth.
+        In a background (non-interactive) connect we attach a provider only
+        when a token is already stored: with one it's used/refreshed silently;
+        without one we return ``None`` so a 401 surfaces as ``needs_auth`` with
+        no discovery traffic and no browser. The user then authenticates via
+        an interactive reconnect.
+        """
+        from dreadnode.agents.mcp.auth import FileTokenStorage, create_oauth_provider
+        from dreadnode.agents.mcp.config import OAuthConfig
-        from dreadnode.agents.mcp.auth import create_oauth_provider
+        if not self._auth_interactive and not FileTokenStorage(url).has_tokens():
+            return None
-        return create_oauth_provider(server_url=url, config=self._oauth_config)
+        config = self._oauth_config or OAuthConfig()
+        return create_oauth_provider(
+            server_url=url, config=config, interactive=self._auth_interactive
+        )
-    async def connect(self) -> None:
+    async def connect(self, *, interactive: bool = False) -> None:
         """Connect to the MCP server and discover tools.
         Sets status to CONNECTED on success, FAILED or NEEDS_AUTH on error.
+        ``interactive`` controls OAuth behavior for streamable-http servers.
+        It defaults to False (the safe, non-interactive mode): a stored token
+        is still used/refreshed, but a server that needs fresh authorization
+        is left in ``needs_auth`` rather than opening a browser. Pass
+        ``interactive=True`` for a user-initiated connect (the runtime does
+        this on reconnect) to open the user's browser and complete OAuth.
         """
+        self._auth_interactive = interactive
         async with self._get_lifecycle_lock():
             if self._owner_task is not None and not self._owner_task.done():
                 ready_future = self._ready_future

dreadnode/app/api/client.py CHANGED Viewed

@@ -363,9 +363,13 @@ class ApiClient:
         response = self.request("GET", "/user/preferences", params=params)
         return t.cast("dict[str, t.Any]", response.json())
-    def provision_inference_key(self, org_key: str) -> dict[str, t.Any]:
+    def provision_inference_key(self, org_key: str, client_id: str) -> dict[str, t.Any]:
         """POST /api/v1/org/{org}/inference/keys - Provision a litellm virtual key."""
-        response = self.request("POST", f"/org/{org_key}/inference/keys")
+        response = self.request(
+            "POST",
+            f"/org/{org_key}/inference/keys",
+            json_data={"client_id": client_id},
+        )
         return t.cast("dict[str, t.Any]", response.json())
     # =========================================================================

dreadnode 2.0.26__py3-none-any.whl → 2.0.28__py3-none-any.whl

dreadnode 2.0.26py3-none-any.whl → 2.0.28py3-none-any.whl