diff --git a/src/kernels/jupyter/finder/remoteKernelFinder.unit.test.ts b/src/kernels/jupyter/finder/remoteKernelFinder.unit.test.ts
index c3858f231db..bb1919f0792 100644
--- a/src/kernels/jupyter/finder/remoteKernelFinder.unit.test.ts
+++ b/src/kernels/jupyter/finder/remoteKernelFinder.unit.test.ts
@@ -26,12 +26,7 @@ import { JupyterSessionManager } from '../session/jupyterSessionManager';
 import { JupyterSessionManagerFactory } from '../session/jupyterSessionManagerFactory';
 import { ILocalKernelFinder } from '../../raw/types';
 import { ActiveKernelIdList, PreferredRemoteKernelIdProvider } from '../preferredRemoteKernelIdProvider';
-import {
-    IJupyterKernel,
-    IJupyterRemoteCachedKernelValidator,
-    IJupyterSessionManager,
-    IServerConnectionType
-} from '../types';
+import { IJupyterKernel, IJupyterRemoteCachedKernelValidator, IJupyterSessionManager } from '../types';
 import { KernelFinder } from '../../kernelFinder';
 import { NotebookProvider } from '../launcher/notebookProvider';
 import { PythonExtensionChecker } from '../../../platform/api/pythonApi';
@@ -160,11 +155,10 @@ suite(`Remote Kernel Finder`, () => {
         };
         when(serverUriStorage.getUri()).thenResolve(serverEntry);
         when(serverUriStorage.getRemoteUri()).thenResolve(serverEntry);
-        const connectionType = mock<IServerConnectionType>();
-        when(connectionType.isLocalLaunch).thenReturn(false);
+        when(serverUriStorage.isLocalLaunch).thenReturn(false);
         const onDidChangeEvent = new EventEmitter<void>();
         disposables.push(onDidChangeEvent);
-        when(connectionType.onDidChange).thenReturn(onDidChangeEvent.event);
+        when(serverUriStorage.onDidChangeConnectionType).thenReturn(onDidChangeEvent.event);
         cachedRemoteKernelValidator = mock<IJupyterRemoteCachedKernelValidator>();
         when(cachedRemoteKernelValidator.isValid(anything())).thenResolve(true);
         const env = mock<IApplicationEnvironment>();
diff --git a/src/kernels/jupyter/jupyterConnection.ts b/src/kernels/jupyter/jupyterConnection.ts
index 7b9b248dab3..8c2a2b26860 100644
--- a/src/kernels/jupyter/jupyterConnection.ts
+++ b/src/kernels/jupyter/jupyterConnection.ts
@@ -19,8 +19,7 @@ import {
     IJupyterServerUriStorage,
     IJupyterSessionManager,
     IJupyterSessionManagerFactory,
-    IJupyterUriProviderRegistration,
-    IServerConnectionType
+    IJupyterUriProviderRegistration
 } from './types';
 
 /**
@@ -37,13 +36,12 @@ export class JupyterConnection implements IExtensionSyncActivationService {
         private readonly jupyterSessionManagerFactory: IJupyterSessionManagerFactory,
         @inject(IDisposableRegistry)
         private readonly disposables: IDisposableRegistry,
-        @inject(IServerConnectionType) private readonly serverConnectionType: IServerConnectionType,
         @inject(IJupyterServerUriStorage) private readonly serverUriStorage: IJupyterServerUriStorage
     ) {
         disposables.push(this);
     }
     public activate() {
-        this.serverConnectionType.onDidChange(
+        this.serverUriStorage.onDidChangeConnectionType(
             () =>
                 // When server URI changes, clear our pending URI timeouts
                 this.clearTimeouts(),
diff --git a/src/kernels/jupyter/launcher/notebookProvider.ts b/src/kernels/jupyter/launcher/notebookProvider.ts
index f517bee771d..11724958921 100644
--- a/src/kernels/jupyter/launcher/notebookProvider.ts
+++ b/src/kernels/jupyter/launcher/notebookProvider.ts
@@ -17,7 +17,7 @@ import {
 import { Cancellation } from '../../../platform/common/cancellation';
 import { DisplayOptions } from '../../displayOptions';
 import { IRawNotebookProvider } from '../../raw/types';
-import { IJupyterNotebookProvider, IServerConnectionType } from '../types';
+import { IJupyterNotebookProvider, IJupyterServerUriStorage } from '../types';
 
 /**
  * Generic class for connecting to a server. Probably could be renamed as it doesn't provide notebooks, but rather connections.
@@ -32,7 +32,7 @@ export class NotebookProvider implements INotebookProvider {
         @inject(IJupyterNotebookProvider)
         private readonly jupyterNotebookProvider: IJupyterNotebookProvider,
         @inject(IPythonExtensionChecker) private readonly extensionChecker: IPythonExtensionChecker,
-        @inject(IServerConnectionType) private readonly serverConnectionType: IServerConnectionType
+        @inject(IJupyterServerUriStorage) private readonly uriStorage: IJupyterServerUriStorage
     ) {}
 
     // Attempt to connect to our server provider, and if we do, return the connection info
@@ -49,7 +49,7 @@ export class NotebookProvider implements INotebookProvider {
         options.ui = this.startupUi;
         if (this.rawNotebookProvider?.isSupported && options.localJupyter) {
             throw new Error('Connect method should not be invoked for local Connections when Raw is supported');
-        } else if (this.extensionChecker.isPythonExtensionInstalled || !this.serverConnectionType.isLocalLaunch) {
+        } else if (this.extensionChecker.isPythonExtensionInstalled || !this.uriStorage.isLocalLaunch) {
             return this.jupyterNotebookProvider.connect(options).finally(() => handler.dispose());
         } else {
             handler.dispose();
diff --git a/src/kernels/jupyter/launcher/serverUriStorage.ts b/src/kernels/jupyter/launcher/serverUriStorage.ts
index 3ae56b68ce9..ea45214034d 100644
--- a/src/kernels/jupyter/launcher/serverUriStorage.ts
+++ b/src/kernels/jupyter/launcher/serverUriStorage.ts
@@ -19,12 +19,7 @@ import {
 } from '../../../platform/common/types';
 import { traceError, traceInfoIfCI, traceVerbose } from '../../../platform/logging';
 import { computeServerId, extractJupyterServerHandleAndId } from '../jupyterUtils';
-import {
-    IJupyterServerUriEntry,
-    IJupyterServerUriStorage,
-    IJupyterUriProviderRegistration,
-    IServerConnectionType
-} from '../types';
+import { IJupyterServerUriEntry, IJupyterServerUriStorage, IJupyterUriProviderRegistration } from '../types';
 
 export const mementoKeyToIndicateIfConnectingToLocalKernelsOnly = 'connectToLocalKernelsOnly';
 export const currentServerHashKey = 'currentServerHash';
@@ -33,7 +28,7 @@ export const currentServerHashKey = 'currentServerHash';
  * Class for storing Jupyter Server URI values
  */
 @injectable()
-export class JupyterServerUriStorage implements IJupyterServerUriStorage, IServerConnectionType {
+export class JupyterServerUriStorage implements IJupyterServerUriStorage {
     private lastSavedList?: Promise<IJupyterServerUriEntry[]>;
     private currentUriPromise: Promise<IJupyterServerUriEntry | undefined> | undefined;
     private _currentServerId: string | undefined;
@@ -53,9 +48,6 @@ export class JupyterServerUriStorage implements IJupyterServerUriStorage, IServe
     public get currentServerId(): string | undefined {
         return this._currentServerId;
     }
-    public get onDidChange(): Event<void> {
-        return this._onDidChangeUri.event;
-    }
     public get onDidChangeConnectionType(): Event<void> {
         return this._onDidChangeUri.event;
     }
diff --git a/src/kernels/jupyter/serviceRegistry.node.ts b/src/kernels/jupyter/serviceRegistry.node.ts
index 2cdffd9570d..72712ccf4c9 100644
--- a/src/kernels/jupyter/serviceRegistry.node.ts
+++ b/src/kernels/jupyter/serviceRegistry.node.ts
@@ -60,8 +60,7 @@ import {
     IJupyterRequestAgentCreator,
     INotebookServerFactory,
     ILiveRemoteKernelConnectionUsageTracker,
-    IJupyterRemoteCachedKernelValidator,
-    IServerConnectionType
+    IJupyterRemoteCachedKernelValidator
 } from './types';
 import { IJupyterCommandFactory, IJupyterSubCommandExecutionService } from './types.node';
 import { UniversalRemoteKernelFinderController } from './finder/universalRemoteKernelFinderController';
@@ -127,7 +126,6 @@ export function registerTypes(serviceManager: IServiceManager, _isDevMode: boole
         JupyterUriProviderRegistration
     );
     serviceManager.addSingleton<IJupyterServerUriStorage>(IJupyterServerUriStorage, JupyterServerUriStorage);
-    serviceManager.addBinding(IJupyterServerUriStorage, IServerConnectionType);
     serviceManager.addSingleton<INotebookStarter>(INotebookStarter, NotebookStarter);
     serviceManager.addSingleton<INotebookProvider>(INotebookProvider, NotebookProvider);
     serviceManager.addSingleton<IJupyterBackingFileCreator>(IJupyterBackingFileCreator, BackingFileCreator);
diff --git a/src/kernels/jupyter/serviceRegistry.web.ts b/src/kernels/jupyter/serviceRegistry.web.ts
index de0ba160d5e..ca99c44d6b3 100644
--- a/src/kernels/jupyter/serviceRegistry.web.ts
+++ b/src/kernels/jupyter/serviceRegistry.web.ts
@@ -38,8 +38,7 @@ import {
     IJupyterRequestCreator,
     INotebookServerFactory,
     ILiveRemoteKernelConnectionUsageTracker,
-    IJupyterRemoteCachedKernelValidator,
-    IServerConnectionType
+    IJupyterRemoteCachedKernelValidator
 } from './types';
 import { CellOutputMimeTypeTracker } from './jupyterCellOutputMimeTypeTracker';
 import { UniversalRemoteKernelFinderController } from './finder/universalRemoteKernelFinderController';
@@ -60,7 +59,6 @@ export function registerTypes(serviceManager: IServiceManager, _isDevMode: boole
         JupyterUriProviderRegistration
     );
     serviceManager.addSingleton<IJupyterServerUriStorage>(IJupyterServerUriStorage, JupyterServerUriStorage);
-    serviceManager.addBinding(IJupyterServerUriStorage, IServerConnectionType);
     serviceManager.addSingleton<INotebookProvider>(INotebookProvider, NotebookProvider);
     serviceManager.addSingleton<IJupyterBackingFileCreator>(IJupyterBackingFileCreator, BackingFileCreator);
     serviceManager.addSingleton<IExtensionSingleActivationService>(IExtensionSingleActivationService, CommandRegistry);
diff --git a/src/kernels/jupyter/types.ts b/src/kernels/jupyter/types.ts
index d731991fb9f..6ac3bdea05f 100644
--- a/src/kernels/jupyter/types.ts
+++ b/src/kernels/jupyter/types.ts
@@ -360,11 +360,4 @@ export interface IJupyterRemoteCachedKernelValidator {
     isValid(kernel: LiveRemoteKernelConnectionMetadata): Promise<boolean>;
 }
 
-export const IServerConnectionType = Symbol('IServerConnectionType');
-
-export interface IServerConnectionType {
-    isLocalLaunch: boolean;
-    onDidChange: Event<void>;
-}
-
 export interface IRemoteKernelFinder extends IContributedKernelFinder<RemoteKernelConnectionMetadata> {}
diff --git a/src/kernels/raw/finder/localKernelFinder.unit.test.ts b/src/kernels/raw/finder/localKernelFinder.unit.test.ts
index b9816c92946..e0ee99f6e91 100644
--- a/src/kernels/raw/finder/localKernelFinder.unit.test.ts
+++ b/src/kernels/raw/finder/localKernelFinder.unit.test.ts
@@ -53,7 +53,7 @@ import { PythonExtensionChecker } from '../../../platform/api/pythonApi';
 import { KernelFinder } from '../../../kernels/kernelFinder';
 import { PreferredRemoteKernelIdProvider } from '../../../kernels/jupyter/preferredRemoteKernelIdProvider';
 import { UniversalRemoteKernelFinder } from '../../../kernels/jupyter/finder/universalRemoteKernelFinder';
-import { IServerConnectionType } from '../../../kernels/jupyter/types';
+import { IJupyterServerUriStorage } from '../../../kernels/jupyter/types';
 import { IPythonExecutionFactory, IPythonExecutionService } from '../../../platform/common/process/types.node';
 import { getUserHomeDir } from '../../../platform/common/utils/platform.node';
 import { IApplicationEnvironment } from '../../../platform/common/application/types';
@@ -249,11 +249,11 @@ import { createEventHandler, TestEventHandler } from '../../../test/common';
             when(memento.update('JUPYTER_GLOBAL_KERNELSPECS_V2', anything())).thenResolve();
 
             preferredRemote = mock(PreferredRemoteKernelIdProvider);
-            const connectionType = mock<IServerConnectionType>();
-            when(connectionType.isLocalLaunch).thenReturn(true);
+            const uriStorage = mock<IJupyterServerUriStorage>();
+            when(uriStorage.isLocalLaunch).thenReturn(true);
             const onDidChangeEvent = new EventEmitter<void>();
             disposables.push(onDidChangeEvent);
-            when(connectionType.onDidChange).thenReturn(onDidChangeEvent.event);
+            when(uriStorage.onDidChangeConnectionType).thenReturn(onDidChangeEvent.event);
 
             const extensions = mock<IExtensions>();
             kernelFinder = new KernelFinder([]);
diff --git a/src/notebooks/controllers/controllerDefaultService.ts b/src/notebooks/controllers/controllerDefaultService.ts
index 1de0c68dbfc..89663a1e35b 100644
--- a/src/notebooks/controllers/controllerDefaultService.ts
+++ b/src/notebooks/controllers/controllerDefaultService.ts
@@ -5,7 +5,7 @@ import { inject, injectable } from 'inversify';
 import { NotebookDocument } from 'vscode';
 import { isPythonNotebook } from '../../kernels/helpers';
 import { PreferredRemoteKernelIdProvider } from '../../kernels/jupyter/preferredRemoteKernelIdProvider';
-import { IServerConnectionType } from '../../kernels/jupyter/types';
+import { IJupyterServerUriStorage } from '../../kernels/jupyter/types';
 import { IVSCodeNotebook } from '../../platform/common/application/types';
 import { InteractiveWindowView, JupyterNotebookView, PYTHON_LANGUAGE } from '../../platform/common/constants';
 import { IDisposableRegistry, IsWebExtension, Resource } from '../../platform/common/types';
@@ -27,7 +27,7 @@ import {
 @injectable()
 export class ControllerDefaultService implements IControllerDefaultService {
     private get isLocalLaunch(): boolean {
-        return this.serverConnectionType.isLocalLaunch;
+        return this.serverUriStorage.isLocalLaunch;
     }
     constructor(
         @inject(IControllerRegistration) private readonly registration: IControllerRegistration,
@@ -35,7 +35,7 @@ export class ControllerDefaultService implements IControllerDefaultService {
         @inject(IInterpreterService) private readonly interpreters: IInterpreterService,
         @inject(IVSCodeNotebook) private readonly notebook: IVSCodeNotebook,
         @inject(IDisposableRegistry) readonly disposables: IDisposableRegistry,
-        @inject(IServerConnectionType) private readonly serverConnectionType: IServerConnectionType,
+        @inject(IJupyterServerUriStorage) private readonly serverUriStorage: IJupyterServerUriStorage,
         @inject(PreferredRemoteKernelIdProvider)
         private readonly preferredRemoteFinder: PreferredRemoteKernelIdProvider,
         @inject(IsWebExtension) private readonly isWeb: boolean
diff --git a/src/notebooks/controllers/controllerPreferredService.ts b/src/notebooks/controllers/controllerPreferredService.ts
index e9307b2c25d..85b11520e50 100644
--- a/src/notebooks/controllers/controllerPreferredService.ts
+++ b/src/notebooks/controllers/controllerPreferredService.ts
@@ -14,7 +14,7 @@ import {
     workspace
 } from 'vscode';
 import { getKernelConnectionLanguage, getLanguageInNotebookMetadata, isPythonNotebook } from '../../kernels/helpers';
-import { IServerConnectionType } from '../../kernels/jupyter/types';
+import { IJupyterServerUriStorage } from '../../kernels/jupyter/types';
 import { trackKernelResourceInformation } from '../../kernels/telemetry/helper';
 import { KernelConnectionMetadata } from '../../kernels/types';
 import { IExtensionSyncActivationService } from '../../platform/activation/types';
@@ -63,7 +63,7 @@ export class ControllerPreferredService implements IControllerPreferredService,
     private preferredControllers = new WeakMap<NotebookDocument, IVSCodeNotebookController>();
     private preferredCancelTokens = new WeakMap<NotebookDocument, CancellationTokenSource>();
     private get isLocalLaunch(): boolean {
-        return this.serverConnectionType.isLocalLaunch;
+        return this.serverUriStorage.isLocalLaunch;
     }
     private disposables = new Set<IDisposable>();
     constructor(
@@ -74,7 +74,7 @@ export class ControllerPreferredService implements IControllerPreferredService,
         @inject(IVSCodeNotebook) private readonly notebook: IVSCodeNotebook,
         @inject(IDisposableRegistry) disposables: IDisposableRegistry,
         @inject(IPythonExtensionChecker) private readonly extensionChecker: IPythonExtensionChecker,
-        @inject(IServerConnectionType) private readonly serverConnectionType: IServerConnectionType,
+        @inject(IJupyterServerUriStorage) private readonly serverUriStorage: IJupyterServerUriStorage,
         @inject(IKernelRankingHelper) private readonly kernelRankHelper: IKernelRankingHelper,
         @inject(IControllerSelection) private readonly selection: IControllerSelection
     ) {
diff --git a/src/notebooks/controllers/controllerRegistration.ts b/src/notebooks/controllers/controllerRegistration.ts
index 2932fe9e7e7..484f0307f92 100644
--- a/src/notebooks/controllers/controllerRegistration.ts
+++ b/src/notebooks/controllers/controllerRegistration.ts
@@ -6,7 +6,7 @@ import { inject, injectable } from 'inversify';
 import { Event, EventEmitter } from 'vscode';
 import { getDisplayNameOrNameOfKernelConnection } from '../../kernels/helpers';
 import { computeServerId } from '../../kernels/jupyter/jupyterUtils';
-import { IJupyterServerUriEntry, IJupyterServerUriStorage, IServerConnectionType } from '../../kernels/jupyter/types';
+import { IJupyterServerUriEntry, IJupyterServerUriStorage } from '../../kernels/jupyter/types';
 import { IKernelProvider, isRemoteConnection, KernelConnectionMetadata } from '../../kernels/types';
 import { IPythonExtensionChecker } from '../../platform/api/types';
 import {
@@ -79,12 +79,11 @@ export class ControllerRegistration implements IControllerRegistration {
         @inject(IApplicationShell) private readonly appShell: IApplicationShell,
         @inject(IBrowserService) private readonly browser: IBrowserService,
         @inject(IServiceContainer) private readonly serviceContainer: IServiceContainer,
-        @inject(IServerConnectionType) private readonly serverConnectionType: IServerConnectionType,
         @inject(IJupyterServerUriStorage) private readonly serverUriStorage: IJupyterServerUriStorage,
         @inject(IPlatformService) private readonly platform: IPlatformService
     ) {
         this.kernelFilter.onDidChange(this.onDidChangeFilter, this, this.disposables);
-        this.serverConnectionType.onDidChange(this.onDidChangeFilter, this, this.disposables);
+        this.serverUriStorage.onDidChangeConnectionType(this.onDidChangeFilter, this, this.disposables);
         this.serverUriStorage.onDidChangeUri(this.onDidChangeUri, this, this.disposables);
         this.serverUriStorage.onDidRemoveUris(this.onDidRemoveUris, this, this.disposables);
     }
diff --git a/src/test/datascience/interactive-common/notebookProvider.unit.test.ts b/src/test/datascience/interactive-common/notebookProvider.unit.test.ts
index ba2ed6a986f..ccc1c0208f4 100644
--- a/src/test/datascience/interactive-common/notebookProvider.unit.test.ts
+++ b/src/test/datascience/interactive-common/notebookProvider.unit.test.ts
@@ -7,7 +7,7 @@ import { PythonExtensionChecker } from '../../../platform/api/pythonApi';
 import { IJupyterKernelConnectionSession, KernelConnectionMetadata } from '../../../kernels/types';
 import { NotebookProvider } from '../../../kernels/jupyter/launcher/notebookProvider';
 import { DisplayOptions } from '../../../kernels/displayOptions';
-import { IJupyterNotebookProvider, IServerConnectionType } from '../../../kernels/jupyter/types';
+import { IJupyterNotebookProvider, IJupyterServerUriStorage } from '../../../kernels/jupyter/types';
 import { IRawNotebookProvider } from '../../../kernels/raw/types';
 import { IDisposable } from '../../../platform/common/types';
 import { disposeAllDisposables } from '../../../platform/common/helpers';
@@ -31,17 +31,17 @@ suite('NotebookProvider', () => {
         when(rawNotebookProvider.isSupported).thenReturn(false);
         const extensionChecker = mock(PythonExtensionChecker);
         when(extensionChecker.isPythonExtensionInstalled).thenReturn(true);
-        const connectionType = mock<IServerConnectionType>();
-        when(connectionType.isLocalLaunch).thenReturn(true);
+        const uriStorage = mock<IJupyterServerUriStorage>();
+        when(uriStorage.isLocalLaunch).thenReturn(true);
         const onDidChangeEvent = new vscode.EventEmitter<void>();
         disposables.push(onDidChangeEvent);
-        when(connectionType.onDidChange).thenReturn(onDidChangeEvent.event);
+        when(uriStorage.onDidChangeConnectionType).thenReturn(onDidChangeEvent.event);
 
         notebookProvider = new NotebookProvider(
             instance(rawNotebookProvider),
             instance(jupyterNotebookProvider),
             instance(extensionChecker),
-            instance(connectionType)
+            instance(uriStorage)
         );
     });
     teardown(() => disposeAllDisposables(disposables));
diff --git a/src/test/datascience/jupyter/serverSelector.unit.test.ts b/src/test/datascience/jupyter/serverSelector.unit.test.ts
index bccef7061d9..6f24585547c 100644
--- a/src/test/datascience/jupyter/serverSelector.unit.test.ts
+++ b/src/test/datascience/jupyter/serverSelector.unit.test.ts
@@ -20,7 +20,10 @@ import { WorkspaceService } from '../../../platform/common/application/workspace
 import { CryptoUtils } from '../../../platform/common/crypto';
 import { ApplicationEnvironment } from '../../../platform/common/application/applicationEnvironment.node';
 import { MockEncryptedStorage } from '../mockEncryptedStorage';
-import { JupyterServerUriStorage } from '../../../kernels/jupyter/launcher/serverUriStorage';
+import {
+    JupyterServerUriStorage,
+    mementoKeyToIndicateIfConnectingToLocalKernelsOnly
+} from '../../../kernels/jupyter/launcher/serverUriStorage';
 import { JupyterServerSelector } from '../../../kernels/jupyter/serverSelector';
 import { JupyterUriProviderRegistration } from '../../../kernels/jupyter/jupyterUriProviderRegistration';
 import { Settings } from '../../../platform/common/constants';
@@ -28,8 +31,8 @@ import { DataScienceErrorHandler } from '../../../kernels/errors/kernelErrorHand
 import { IConfigurationService, IDisposable, IWatchableJupyterSettings } from '../../../platform/common/types';
 import { disposeAllDisposables } from '../../../platform/common/helpers';
 import { JupyterConnection } from '../../../kernels/jupyter/jupyterConnection';
-import { IServerConnectionType } from '../../../kernels/jupyter/types';
 import { JupyterSettings } from '../../../platform/common/configSettings';
+import { noop } from '../../../platform/common/utils/misc';
 
 /* eslint-disable , @typescript-eslint/no-explicit-any */
 suite('Jupyter Server URI Selector', () => {
@@ -69,18 +72,16 @@ suite('Jupyter Server URI Selector', () => {
         connection = mock<JupyterConnection>();
         when(connection.createConnectionInfo(anything())).thenResolve({ displayName: '' } as any);
         const handler = mock(DataScienceErrorHandler);
-        const connectionType = mock<IServerConnectionType>();
-        when(connectionType.isLocalLaunch).thenReturn(false);
         when(connection.validateRemoteUri(anything())).thenResolve();
-        const onDidChangeEvent = new EventEmitter<void>();
-        disposables.push(onDidChangeEvent);
-        when(connectionType.onDidChange).thenReturn(onDidChangeEvent.event);
         when(configService.updateSetting(anything(), anything(), anything(), anything())).thenResolve();
         when(configService.getSettings(anything())).thenReturn(instance(settings));
         when(configService.getSettings()).thenReturn(instance(settings));
         when(settings.kernelPickerType).thenReturn('Stable');
         onDidChangeSettings = sinon.stub();
         when(settings.onDidChange).thenReturn(onDidChangeSettings);
+        const memento = new MockMemento();
+        // local launch false
+        memento.update(mementoKeyToIndicateIfConnectingToLocalKernelsOnly, false).then(noop, noop);
         const jupyterUriProviderRegistration = mock(JupyterUriProviderRegistration);
         const storage = new JupyterServerUriStorage(
             instance(workspaceService),
diff --git a/src/test/datascience/notebook/controllers/controllerPreferredService.unit.test.ts b/src/test/datascience/notebook/controllers/controllerPreferredService.unit.test.ts
index e546b92246f..c05a484031c 100644
--- a/src/test/datascience/notebook/controllers/controllerPreferredService.unit.test.ts
+++ b/src/test/datascience/notebook/controllers/controllerPreferredService.unit.test.ts
@@ -7,7 +7,7 @@ import { INotebookMetadata } from '@jupyterlab/nbformat';
 import { assert } from 'chai';
 import { anything, instance, mock, when } from 'ts-mockito';
 import { EventEmitter, NotebookControllerAffinity, NotebookDocument, Uri } from 'vscode';
-import { IServerConnectionType } from '../../../../kernels/jupyter/types';
+import { IJupyterServerUriStorage } from '../../../../kernels/jupyter/types';
 import {
     KernelConnectionMetadata,
     LocalKernelSpecConnectionMetadata,
@@ -37,7 +37,7 @@ suite('Preferred Controller', () => {
     let controllerLoader: IControllerLoader;
     let vscNotebook: IVSCodeNotebook;
     let extensionChecker: IPythonExtensionChecker;
-    let serverConnectionType: IServerConnectionType;
+    let uriStorage: IJupyterServerUriStorage;
     let defaultControllerService: IControllerDefaultService;
     let interpreters: IInterpreterService;
     setup(() => {
@@ -45,7 +45,7 @@ suite('Preferred Controller', () => {
         controllerLoader = mock<IControllerLoader>();
         vscNotebook = mock<IVSCodeNotebook>();
         extensionChecker = mock<IPythonExtensionChecker>();
-        serverConnectionType = mock<IServerConnectionType>();
+        uriStorage = mock<IJupyterServerUriStorage>();
         defaultControllerService = mock<IControllerDefaultService>();
         interpreters = mock<IInterpreterService>();
         kernelRankHelper = mock<IKernelRankingHelper>();
@@ -66,7 +66,7 @@ suite('Preferred Controller', () => {
             instance(vscNotebook),
             disposables,
             instance(extensionChecker),
-            instance(serverConnectionType),
+            instance(uriStorage),
             instance(kernelRankHelper),
             instance(selection)
         );
@@ -130,7 +130,7 @@ suite('Preferred Controller', () => {
         return document;
     }
     function setupData(kernels: KernelConnectionMetadata[]) {
-        when(serverConnectionType.isLocalLaunch).thenReturn(true);
+        when(uriStorage.isLocalLaunch).thenReturn(true);
         when(
             kernelRankHelper.rankKernels(anything(), anything(), anything(), anything(), anything(), anything())
         ).thenResolve(kernels);
diff --git a/src/test/datascience/notebook/helper.ts b/src/test/datascience/notebook/helper.ts
index dfe3556d39a..6f1e761594e 100644
--- a/src/test/datascience/notebook/helper.ts
+++ b/src/test/datascience/notebook/helper.ts
@@ -98,8 +98,7 @@ import { openAndShowNotebook } from '../../../platform/common/utils/notebooks';
 import {
     IJupyterServerUriStorage,
     IJupyterSessionManager,
-    IJupyterSessionManagerFactory,
-    IServerConnectionType
+    IJupyterSessionManagerFactory
 } from '../../../kernels/jupyter/types';
 import { IInterpreterService } from '../../../platform/interpreter/contracts';
 import { getDisplayPath } from '../../../platform/common/platform/fs-paths';
@@ -301,7 +300,7 @@ export async function createEmptyPythonNotebook(
     traceInfoIfCI('Creating an empty notebook');
     const { serviceContainer } = await getServices();
     const vscodeNotebook = serviceContainer.get<IVSCodeNotebook>(IVSCodeNotebook);
-    const serverConnectionType = serviceContainer.get<IServerConnectionType>(IServerConnectionType);
+    const serverUriStorage = serviceContainer.get<IJupyterServerUriStorage>(IJupyterServerUriStorage);
     // Don't use same file (due to dirty handling, we might save in dirty.)
     // Coz we won't save to file, hence extension will backup in dirty file and when u re-open it will open from dirty.
     const nbFile = await createTemporaryNotebook(
@@ -319,7 +318,7 @@ export async function createEmptyPythonNotebook(
         await waitForKernelToGetAutoSelected(
             vscodeNotebook.activeNotebookEditor!,
             PYTHON_LANGUAGE,
-            !serverConnectionType.isLocalLaunch
+            !serverUriStorage.isLocalLaunch
         );
         await verifySelectedControllerIsRemoteForRemoteTests();
     }
diff --git a/src/test/kernels/jupyter/jupyterConnection.unit.test.ts b/src/test/kernels/jupyter/jupyterConnection.unit.test.ts
index b41c497e818..0091be55468 100644
--- a/src/test/kernels/jupyter/jupyterConnection.unit.test.ts
+++ b/src/test/kernels/jupyter/jupyterConnection.unit.test.ts
@@ -12,8 +12,7 @@ import {
     IJupyterServerUriStorage,
     IJupyterSessionManager,
     IJupyterSessionManagerFactory,
-    IJupyterUriProviderRegistration,
-    IServerConnectionType
+    IJupyterUriProviderRegistration
 } from '../../../kernels/jupyter/types';
 import { disposeAllDisposables } from '../../../platform/common/helpers';
 import { IDisposable } from '../../../platform/common/types';
@@ -23,21 +22,18 @@ suite('Jupyter Connection', async () => {
     let jupyterConnection: JupyterConnection;
     let registrationPicker: IJupyterUriProviderRegistration;
     let sessionManagerFactory: IJupyterSessionManagerFactory;
-    let serverConnectionType: IServerConnectionType;
     let sessionManager: IJupyterSessionManager;
     let serverUriStorage: IJupyterServerUriStorage;
     const disposables: IDisposable[] = [];
     setup(() => {
         registrationPicker = mock<IJupyterUriProviderRegistration>();
         sessionManagerFactory = mock<IJupyterSessionManagerFactory>();
-        serverConnectionType = mock<IServerConnectionType>();
         sessionManager = mock<IJupyterSessionManager>();
         serverUriStorage = mock<IJupyterServerUriStorage>();
         jupyterConnection = new JupyterConnection(
             instance(registrationPicker),
             instance(sessionManagerFactory),
             disposables,
-            instance(serverConnectionType),
             instance(serverUriStorage)
         );
 
@@ -46,7 +42,7 @@ suite('Jupyter Connection', async () => {
         const serverConnectionChangeEvent = new EventEmitter<void>();
         disposables.push(serverConnectionChangeEvent);
 
-        when(serverConnectionType.onDidChange).thenReturn(serverConnectionChangeEvent.event);
+        when(serverUriStorage.onDidChangeConnectionType).thenReturn(serverConnectionChangeEvent.event);
 
         jupyterConnection.activate();
     });
@@ -55,7 +51,7 @@ suite('Jupyter Connection', async () => {
     });
 
     test('Ensure event handler is added', () => {
-        verify(serverConnectionType.onDidChange).once();
+        verify(serverUriStorage.onDidChangeConnectionType).once();
     });
     test('Validation will result in fetching kernels and kernelspecs', async () => {
         const uri = 'http://localhost:8888/?token=1234';