Function handleKernelError

src/kernels/errors/kernelErrorHandler.ts:320–514

(
        err: Error,
        errorContext: KernelAction,
        kernelConnection: KernelConnectionMetadata,
        resource: Resource,
        actionSource: KernelActionSource
    )

        }
    }
    public async handleKernelError(
        err: Error,
        errorContext: KernelAction,
        kernelConnection: KernelConnectionMetadata,
        resource: Resource,
        actionSource: KernelActionSource
    ): Promise<KernelInterpreterDependencyResponse> {
        if (!isCancellationError(err)) {
            logger.warn(`Kernel Error, context = ${errorContext}`, err);
        }
        err = WrappedError.unwrap(err);

        // Jupyter kernels, non zmq actually do the dependency install themselves
        if (isCancellationError(err)) {
            this.sendKernelTelemetry(err, errorContext, resource, 'cancelled');
            return KernelInterpreterDependencyResponse.cancel;
        } else if (err instanceof JupyterKernelDependencyError) {
            logger.warn(`Jupyter Kernel Dependency Error, reason=${err.reason}`, err);
            this.sendKernelTelemetry(err, errorContext, resource, err.category);
            if (err.reason === KernelInterpreterDependencyResponse.uiHidden && this.kernelDependency) {
                // At this point we're handling the error, and if the error was initially swallowed due to
                // auto start (ui hidden), now we need to display the error to the user.
                const tokenSource = new CancellationTokenSource();
                try {
                    const cannotChangeKernels = actionSource === '3rdPartyExtension';
                    return this.kernelDependency.installMissingDependencies({
                        resource,
                        kernelConnection,
                        ui: new DisplayOptions(false),
                        token: tokenSource.token,
                        ignoreCache: true,
                        cannotChangeKernels
                    });
                } finally {
                    tokenSource.dispose();
                }
            } else {
                return err.reason;
            }
            // Use the kernel dependency service to first determine if this is because dependencies are missing or not
        } else if ((errorContext === 'start' || errorContext === 'restart') && err instanceof JupyterInstallError) {
            this.sendKernelTelemetry(err, errorContext, resource, err.category);
            const response = this.dependencyManager
                ? await this.dependencyManager.installMissingDependencies(err)
                : JupyterInterpreterDependencyResponse.cancel;
            return response === JupyterInterpreterDependencyResponse.ok
                ? KernelInterpreterDependencyResponse.ok
                : KernelInterpreterDependencyResponse.cancel;
        } else if (
            err instanceof RemoteJupyterServerConnectionError ||
            err instanceof RemoteJupyterServerUriProviderError ||
            err instanceof InvalidRemoteJupyterServerUriHandleError
        ) {
            this.sendKernelTelemetry(err, errorContext, resource, err.category);
            const message =
                err instanceof InvalidRemoteJupyterServerUriHandleError
                    ? ''
                    : err instanceof RemoteJupyterServerConnectionError