fix(web): remove connector reconnect continuation

Author: jsourcebot

packages/web/src/ee/features/chat/components/chatThread/chatThread.tsx

@@ -311,9 +311,6 @@ export const ChatThread = ({
         messages,
         isTurnInProgress,
         addToolApprovalResponse,
-        sendMessage,
-        selectedSearchScopes,
-        disabledMcpServerIds,
     });
 
     useEffect(() => {

packages/web/src/ee/features/chat/components/chatThread/mcpFailedServersBanner.test.tsx

@@ -20,9 +20,7 @@ const createContext = (
         },
     },
     isReconnectAllowed,
-    isContinueAllowed: false,
     reconnect,
-    continueAfterReconnect: vi.fn(),
 });
 
 const renderBanner = (context: McpReconnectContextValue) => render(

packages/web/src/ee/features/chat/components/chatThread/mcpReconnectBanner.test.tsx

@@ -24,9 +24,7 @@ const createReconnectContext = (
 ): McpReconnectContextValue => ({
     reconnectStates: { [state.serverId]: state },
     isReconnectAllowed: true,
-    isContinueAllowed: false,
     reconnect: vi.fn(),
-    continueAfterReconnect: vi.fn(),
     ...overrides,
 });
 
@@ -68,35 +66,18 @@ describe('McpReconnectBanner', () => {
         expect(button.disabled).toBe(true);
     });
 
-    test('shows the continue action after reconnecting', () => {
-        const contextValue = createReconnectContext(
-            createReconnectState({ status: 'reconnected' }),
-            { isContinueAllowed: true },
-        );
-        renderBanner(contextValue);
-
-        expect(screen.getByRole('status')).toBeTruthy();
-        expect(screen.getByText('Linear reconnected')).toBeTruthy();
-
-        fireEvent.click(screen.getByRole('button', { name: 'Continue' }));
-        expect(contextValue.continueAfterReconnect).toHaveBeenCalledWith('server-1');
-    });
-
-    test('does not offer Continue when automatic continuation is unavailable', () => {
+    test('does not render a success banner after reconnecting', () => {
         const contextValue = createReconnectContext(createReconnectState({ status: 'reconnected' }));
-        renderBanner(contextValue);
+        const { container } = renderBanner(contextValue);
 
-        expect(screen.getByText('Connection restored.')).toBeTruthy();
-        expect(screen.queryByRole('button', { name: 'Continue' })).toBeNull();
+        expect(container.childElementCount).toBe(0);
     });
 
     test('does not render without a reconnect failure', () => {
         const contextValue: McpReconnectContextValue = {
             reconnectStates: {},
             isReconnectAllowed: true,
-            isContinueAllowed: false,
             reconnect: vi.fn(),
-            continueAfterReconnect: vi.fn(),
         };
         const { container } = renderBanner(contextValue);
 

packages/web/src/ee/features/chat/components/chatThread/mcpReconnectBanner.tsx

@@ -2,12 +2,12 @@
 
 import { Button } from '@/components/ui/button';
 import { useMcpReconnect } from '@/ee/features/chat/mcpReconnectContext';
-import { AlertCircle, CheckCircle, Loader2 } from 'lucide-react';
+import { AlertCircle, Loader2 } from 'lucide-react';
 
 export const McpReconnectBanner = () => {
     const reconnectContext = useMcpReconnect();
     const reconnectStates = Object.values(reconnectContext?.reconnectStates ?? {})
-        .filter((state) => state.source !== 'tool-load');
+        .filter((state) => state.source !== 'tool-load' && state.status !== 'reconnected');
 
     if (!reconnectContext || reconnectStates.length === 0) {
         return null;
@@ -16,41 +16,6 @@ export const McpReconnectBanner = () => {
     return (
         <div>
             {reconnectStates.map((state) => {
-                if (state.status === 'reconnected') {
-                    return (
-                        <div
-                            key={state.serverId}
-                            role="status"
-                            className="border-b border-green-200 bg-green-50 dark:border-green-800 dark:bg-green-950/20"
-                        >
-                            <div className="mx-auto flex max-w-3xl flex-col gap-3 px-4 py-3 sm:flex-row sm:items-center sm:justify-center sm:gap-6">
-                                <div className="flex min-w-0 items-start gap-2">
-                                    <CheckCircle className="mt-0.5 h-4 w-4 flex-shrink-0 text-green-600 dark:text-green-400" />
-                                    <div>
-                                        <p className="text-sm font-medium text-green-800 dark:text-green-200">
-                                            {state.serverName} reconnected
-                                        </p>
-                                        <p className="text-sm text-green-700 dark:text-green-300">
-                                            {reconnectContext.isContinueAllowed
-                                                ? 'Continue to retry your request.'
-                                                : 'Connection restored.'}
-                                        </p>
-                                    </div>
-                                </div>
-                                {reconnectContext.isContinueAllowed && (
-                                    <Button
-                                        size="sm"
-                                        className="ml-6 self-start sm:ml-0 sm:self-auto"
-                                        onClick={() => reconnectContext.continueAfterReconnect(state.serverId)}
-                                    >
-                                        Continue
-                                    </Button>
-                                )}
-                            </div>
-                        </div>
-                    );
-                }
-
                 const isReconnecting = state.status === 'reconnecting';
                 return (
                     <div

packages/web/src/ee/features/chat/components/chatThread/tools/mcpToolComponent.test.tsx

@@ -71,9 +71,7 @@ const createReconnectContext = (
 ): McpReconnectContextValue => ({
     reconnectStates: { [state.serverId]: state },
     isReconnectAllowed: true,
-    isContinueAllowed: false,
     reconnect: vi.fn(),
-    continueAfterReconnect: vi.fn(),
     ...overrides,
 });
 

packages/web/src/ee/features/chat/components/chatThread/useMcpReconnectController.test.tsx

@@ -5,7 +5,6 @@ import { ReactNode } from 'react';
 import { afterEach, beforeEach, describe, expect, test, vi } from 'vitest';
 import { MCP_RECONNECT_SESSION_STORAGE_KEY } from '@/features/chat/constants';
 import { SBChatMessage } from '@/features/chat/types';
-import { getUserMessageText } from '@/features/chat/utils';
 import { useMcpReconnectController } from './useMcpReconnectController';
 
 const mocks = vi.hoisted(() => ({
@@ -44,16 +43,12 @@ const createWrapper = () => {
 };
 
 const addToolApprovalResponse = vi.fn();
-const sendMessage = vi.fn();
 
 const renderController = (initialProps: HookProps) =>
     renderHook(
         (props: HookProps) => useMcpReconnectController({
             ...props,
             addToolApprovalResponse,
-            sendMessage,
-            selectedSearchScopes: [],
-            disabledMcpServerIds: [],
         }),
         { initialProps, wrapper: createWrapper() },
     );
@@ -189,6 +184,28 @@ describe('useMcpReconnectController', () => {
         expect(mocks.connectMcpToAsk).not.toHaveBeenCalled();
     });
 
+    test('shows a success toast when reconnection completes without an OAuth redirect', async () => {
+        mocks.connectMcpToAsk.mockResolvedValue({ authorizationUrl: null });
+        mocks.getMcpServersWithStatus.mockResolvedValue([
+            { id: 'server-1', name: 'Linear', isConnected: true, isAuthExpired: false },
+        ]);
+        const { result } = renderController({ status: 'ready', messages: [], isTurnInProgress: false });
+
+        act(() => {
+            result.current.onAuthRequired(AUTH_FAILURE);
+        });
+
+        await act(async () => {
+            result.current.contextValue.reconnect('server-1');
+        });
+
+        await waitFor(() => {
+            expect(mocks.toast).toHaveBeenCalledWith({
+                description: 'Successfully reconnected to Linear.',
+            });
+        });
+    });
+
     test('tracks a failed tool load without treating it as a failed tool call', () => {
         const { result } = renderController({ status: 'ready', messages: [], isTurnInProgress: false });
 
@@ -202,7 +219,6 @@ describe('useMcpReconnectController', () => {
             source: 'tool-load',
             status: 'authentication-required',
         });
-        expect(result.current.contextValue.isContinueAllowed).toBe(false);
         expect(addToolApprovalResponse).not.toHaveBeenCalled();
     });
 
@@ -224,7 +240,6 @@ describe('useMcpReconnectController', () => {
             expect(result.current.contextValue.reconnectStates['server-1']?.status).toBe('reconnected');
         });
         expect(window.sessionStorage.getItem(MCP_RECONNECT_SESSION_STORAGE_KEY)).toBeNull();
-        expect(result.current.contextValue.isContinueAllowed).toBe(true);
     });
 
     test('restores the source of a failed tool-load reconnect after OAuth', async () => {
@@ -245,7 +260,6 @@ describe('useMcpReconnectController', () => {
             expect(result.current.contextValue.reconnectStates['server-1']?.status).toBe('reconnected');
         });
         expect(result.current.contextValue.reconnectStates['server-1']?.source).toBe('tool-load');
-        expect(result.current.contextValue.isContinueAllowed).toBe(false);
     });
 
     test('falls back to authentication-required when the OAuth return did not reconnect the connector', async () => {
@@ -265,53 +279,5 @@ describe('useMcpReconnectController', () => {
         await waitFor(() => {
             expect(result.current.contextValue.reconnectStates['server-1']?.status).toBe('authentication-required');
         });
-        expect(result.current.contextValue.isContinueAllowed).toBe(false);
-    });
-
-    test('Continue sends a visible user turn naming the reconnected connector and resets the state', async () => {
-        window.sessionStorage.setItem(MCP_RECONNECT_SESSION_STORAGE_KEY, JSON.stringify({
-            serverId: 'server-1',
-            serverName: 'Linear',
-            toolCallId: 'tool-call-1',
-            returnTo: '/chat/abc123',
-            createdAt: Date.now(),
-        }));
-        mocks.getMcpServersWithStatus.mockResolvedValue([
-            { id: 'server-1', name: 'Linear', isConnected: true, isAuthExpired: false },
-        ]);
-
-        const { result } = renderController({ status: 'ready', messages: [], isTurnInProgress: false });
-        await waitFor(() => {
-            expect(result.current.contextValue.isContinueAllowed).toBe(true);
-        });
-
-        act(() => {
-            result.current.contextValue.continueAfterReconnect('server-1');
-        });
-
-        expect(sendMessage).toHaveBeenCalledTimes(1);
-        const sentMessage = sendMessage.mock.calls[0][0];
-        expect(sentMessage.role).toBe('user');
-        expect(getUserMessageText(sentMessage as SBChatMessage)).toBe(
-            'Continue the previous request now that Linear is reconnected. Do not repeat operations that already completed.'
-        );
-        expect(result.current.contextValue.reconnectStates).toEqual({});
-    });
-
-    test('Continue is unavailable when more than one connector failed authentication', () => {
-        const { result, rerender } = renderController({ status: 'streaming', messages: [], isTurnInProgress: true });
-
-        act(() => {
-            result.current.onAuthRequired(AUTH_FAILURE);
-            result.current.onAuthRequired({ serverId: 'server-2', serverName: 'Jira', toolCallId: 'tool-call-3' });
-        });
-        rerender({ status: 'ready', messages: [], isTurnInProgress: false });
-
-        expect(result.current.contextValue.isContinueAllowed).toBe(false);
-
-        act(() => {
-            result.current.contextValue.continueAfterReconnect('server-1');
-        });
-        expect(sendMessage).not.toHaveBeenCalled();
     });
 });

packages/web/src/ee/features/chat/components/chatThread/useMcpReconnectController.ts

@@ -14,9 +14,9 @@ import {
     consumeMcpPendingReconnectForPath,
     saveMcpPendingReconnect,
 } from '@/features/chat/mcpReconnect';
-import { CreateUIMessage, ChatStatus, ChatAddToolApproveResponseFunction } from 'ai';
-import { SBChatMessage, SearchScope } from '@/features/chat/types';
-import { createUIMessage, getLastStepParts, isSBChatToolPart } from '@/features/chat/utils';
+import { ChatStatus, ChatAddToolApproveResponseFunction } from 'ai';
+import { SBChatMessage } from '@/features/chat/types';
+import { getLastStepParts, isSBChatToolPart } from '@/features/chat/utils';
 import { isServiceError } from '@/lib/utils';
 import { useQueryClient } from '@tanstack/react-query';
 import { useCallback, useEffect, useMemo, useRef, useState } from 'react';
@@ -37,25 +37,19 @@ interface UseMcpReconnectControllerOptions {
     messages: SBChatMessage[];
     isTurnInProgress: boolean;
     addToolApprovalResponse: ChatAddToolApproveResponseFunction;
-    sendMessage: (message: CreateUIMessage<SBChatMessage>) => void;
-    selectedSearchScopes: SearchScope[];
-    disabledMcpServerIds: string[];
 }
 
 // Orchestrates the client side of MCP connector reauthentication for a chat
 // thread: tracks per-connector reconnect state from tool-call authentication
 // failures and tool-load failures, automatically denies tool approvals still
 // pending in an interrupted response, gates the Reconnect action until the
 // response has settled, restores pending reconnect metadata after the OAuth
-// round trip, and sends the follow-up user turn on Continue when applicable.
+// round trip, and confirms that the connector is usable again.
 export function useMcpReconnectController({
     status,
     messages,
     isTurnInProgress,
     addToolApprovalResponse,
-    sendMessage,
-    selectedSearchScopes,
-    disabledMcpServerIds,
 }: UseMcpReconnectControllerOptions): {
     contextValue: McpReconnectContextValue;
     onAuthRequired: (data: McpAuthRequiredData) => void;
@@ -168,7 +162,8 @@ export function useMcpReconnectController({
     // Restore pending reconnect metadata after returning from the OAuth
     // redirect, then confirm the connector actually reconnected via the
     // status endpoint. Runs once per mount; reads only sessionStorage, so it
-    // does not race the OAuth status toast's query-parameter cleanup.
+    // does not race the OAuth status toast's query-parameter cleanup. The
+    // app-level OAuth status toast owns the success feedback for this path.
     useEffect(() => {
         if (hasRestoredPendingReconnect.current) {
             return;
@@ -278,6 +273,7 @@ export function useMcpReconnectController({
 
         if (server?.isConnected && !server.isAuthExpired) {
             setReconnectStatus(serverId, 'reconnected');
+            toast({ description: `Successfully reconnected to ${state.serverName}.` });
         } else {
             setReconnectStatus(serverId, 'authentication-required');
             toast({
@@ -287,45 +283,11 @@ export function useMcpReconnectController({
         }
     }, [queryClient, setReconnectStatus, toast]);
 
-    const stateList = useMemo(
-        () => Object.values(reconnectStates).filter((state) => state.source !== 'tool-load'),
-        [reconnectStates],
-    );
-    // Continue is only supported when exactly one connector failed
-    // authentication in the response, and it has been reconnected.
-    const isContinueAllowed =
-        isReconnectAllowed &&
-        stateList.length === 1 &&
-        stateList[0].status === 'reconnected';
-    const isContinueAllowedRef = useRef(isContinueAllowed);
-    useEffect(() => {
-        isContinueAllowedRef.current = isContinueAllowed;
-    }, [isContinueAllowed]);
-
-    const continueAfterReconnect = useCallback((serverId: string) => {
-        const state = reconnectStatesRef.current[serverId];
-        if (!state || state.status !== 'reconnected' || !isContinueAllowedRef.current) {
-            return;
-        }
-
-        sendMessage(createUIMessage(
-            `Continue the previous request now that ${state.serverName} is reconnected. Do not repeat operations that already completed.`,
-            [],
-            selectedSearchScopes,
-            disabledMcpServerIds,
-        ));
-
-        setReconnectStates({});
-        deniedApprovalIdsRef.current.clear();
-    }, [sendMessage, selectedSearchScopes, disabledMcpServerIds]);
-
     const contextValue = useMemo<McpReconnectContextValue>(() => ({
         reconnectStates,
         isReconnectAllowed,
-        isContinueAllowed,
         reconnect,
-        continueAfterReconnect,
-    }), [reconnectStates, isReconnectAllowed, isContinueAllowed, reconnect, continueAfterReconnect]);
+    }), [reconnectStates, isReconnectAllowed, reconnect]);
 
     return { contextValue, onAuthRequired, onServerLoadFailed };
 }

packages/web/src/ee/features/chat/mcpReconnectContext.tsx

@@ -25,11 +25,7 @@ export interface McpReconnectContextValue {
     // (started tool calls finished, pending approvals denied, the final
     // tools-disabled step streamed and persisted).
     isReconnectAllowed: boolean;
-    // True only in the supported case: exactly one failed connector, and it
-    // has been reconnected.
-    isContinueAllowed: boolean;
     reconnect: (serverId: string) => void;
-    continueAfterReconnect: (serverId: string) => void;
 }
 
 export const McpReconnectContext = createContext<McpReconnectContextValue | undefined>(undefined);