refactor(mcp): let the SDK finish HTTP auth and SSE reconnect

Drop the extra probe on the ordinary path, finish auth on the transport
that already dialed, and remove MCPClient.call. After an OAuth error
that arrives before redirect, wipe credentials and dial once: a silent
connect lets the real client retry, and a redirect prompts once.

Author: TheGreatAxios

docs/MCP.md

@@ -130,14 +130,19 @@ list is in effect, these actions edit that local file; add remains blocked.
 
 ## Dropped Transports Reconnect in the Background
 
-When a connected server's transport dies unexpectedly, the row goes
-**reconnecting** instead of failed: the redial attempt and the retained tool
-count stay on the row (for example, `acme — reconnecting · attempt 3 · 2
-tools`), and backoff redials behind the scenes with a jittered delay that
-grows per attempt and caps at 30 seconds. While reconnecting, the server's
-tools stay mounted but fail fast — calling one returns "MCP server is
-reconnecting; retry the call once it reports connected." rather than hanging
-or dispatching against a dead transport.
+Stdio and HTTP do not share a redial. A stdio child that exits is respawned
+here: the row goes **reconnecting** instead of failed, the redial attempt and
+the retained tool count stay on the row (for example, `acme — reconnecting ·
+attempt 3 · 2 tools`), and backoff redials behind the scenes with a jittered
+delay that grows per attempt and caps at 30 seconds. While that redial is in
+progress, the server's tools stay mounted but fail fast — calling one returns
+"MCP server is reconnecting; retry the call once it reports connected." rather
+than hanging or dispatching against a dead transport.
+
+An HTTP SSE drop does not start that second dial. The Streamable HTTP
+transport resumes the stream itself (`reconnectionOptions`: 1s start, doubling,
+30s cap). The row stays connected and tools stay live; only a real stdio death
+uses the fail-fast stubs and attempt count above.
 
 Pressing Enter on a failed or reconnecting row retries now with a single dial
 instead of waiting for backoff, reusing the saved settings row — it never

e2e/mcp-late-dispatch.test.ts

@@ -43,8 +43,13 @@ function permissionGate() {
 
 function linearClient(opts: {
   inputSchema?: MCPClient["tools"][number]["inputSchema"];
-  call?: MCPClient["call"];
+  call?: (
+    toolName: string,
+    args: Record<string, unknown>,
+    signal: AbortSignal,
+  ) => Promise<string>;
 }): MCPClient {
+  const invoke = opts.call ?? (async () => "ISSUE-1");
   return {
     serverName: "linear",
     tools: [
@@ -54,13 +59,8 @@ function linearClient(opts: {
         inputSchema: opts.inputSchema ?? LATE_MCP_SCHEMA,
       },
     ],
-    call: opts.call ?? (async () => "ISSUE-1"),
     async callResult(toolName, args, signal) {
-      const text = await (opts.call ?? (async () => "ISSUE-1"))(
-        toolName,
-        args,
-        signal,
-      );
+      const text = await invoke(toolName, args, signal);
       return {
         blocks: [{ type: "text", text }],
         isError: false,

e2e/subagent-permission.test.ts

@@ -296,7 +296,6 @@ test.serial(
               inputSchema: { type: "object", properties: {} },
             },
           ],
-          call: async () => "changed",
           callResult: async () => {
             calls++;
             return {
@@ -354,7 +353,6 @@ test.serial(
               inputSchema: { type: "object", properties: {} },
             },
           ],
-          call: async () => "changed",
           callResult: async () => {
             calls++;
             return {
@@ -488,7 +486,6 @@ test.serial(
               inputSchema: { type: "object", properties: {} },
             },
           ],
-          call: async () => "changed",
           callResult: async () => {
             calls++;
             return {
@@ -573,7 +570,6 @@ test("storing parent-gated MCP tools then wrapping again denies without requestA
           inputSchema: { type: "object", properties: {} },
         },
       ],
-      call: async () => "changed",
       callResult: async () => {
         calls++;
         return {

src/mcp/client-auth-policy.test.ts

@@ -143,7 +143,8 @@ await mockMcpOAuthProviderModule(async (options: { serverURL: string }) => {
   return authProvider;
 });
 
-const { connectMCPServer, fetchWithConnectAbort } = await import("./client.js");
+const { connectMCPServer, fetchWithConnectAbort, MCP_HTTP_RECONNECTION_OPTIONS } =
+  await import("./client.js");
 
 describe("HTTP MCP auth policy", () => {
   beforeEach(() => {
@@ -186,7 +187,9 @@ describe("HTTP MCP auth policy", () => {
     expect(providerCreates).toBe(0);
     // No signal and no provider: leave redirectPolicy unset so the SDK
     // default `same-origin` applies. Do not pin `follow`.
-    expect(transportOptions).toEqual([{}]);
+    expect(transportOptions).toEqual([
+      { reconnectionOptions: MCP_HTTP_RECONNECTION_OPTIONS },
+    ]);
   });
 
   test("closes a bound OAuth callback server when provider setup fails", async () => {
@@ -262,13 +265,14 @@ describe("HTTP MCP auth policy", () => {
     if (!result.ok) return;
     expect(transportOptions).toEqual([
       {
+        reconnectionOptions: MCP_HTTP_RECONNECTION_OPTIONS,
         authProvider,
         requestInit: { signal: expect.any(AbortSignal) },
         fetch: expect.any(Function),
       },
     ]);
 
-    const call = result.client.call("ping", {}, abort.signal);
+    const call = result.client.callResult("ping", {}, abort.signal);
     while (tokenRefreshSignals.length === 0) await Promise.resolve();
     expect(tokenRefreshSignals[0]).toBeDefined();
     expect(tokenRefreshSignals[0]?.aborted).toBe(false);
@@ -298,6 +302,7 @@ describe("HTTP MCP auth policy", () => {
     expect(providerServerURL).toBe("https://custom.example/mcp?mode=full");
     expect(transportOptions).toEqual([
       {
+        reconnectionOptions: MCP_HTTP_RECONNECTION_OPTIONS,
         authProvider,
         requestInit: { signal: expect.any(AbortSignal) },
         fetch: expect.any(Function),
@@ -322,7 +327,11 @@ describe("HTTP MCP auth policy", () => {
     expect(transport.requestInit?.signal).not.toBe(connectAbort.signal);
     expect(transport.fetch).toBeTypeOf("function");
 
-    const call = result.client.call("ping", {}, new AbortController().signal);
+    const call = result.client.callResult(
+      "ping",
+      {},
+      new AbortController().signal,
+    );
     while (tokenRefreshSignals.length === 0) await Promise.resolve();
     expect(tokenRefreshSignals[0]).not.toBe(connectAbort.signal);
     expect(tokenRefreshSignals[0]?.aborted).toBe(false);