API updates for new untitled notebooks and outputs

src/dotnet-interactive-vscode/common/clientMapper.ts

@@ -2,24 +2,31 @@
 // Licensed under the MIT license. See LICENSE file in the project root for full license information.
 
 import { KernelTransport } from './interfaces/contracts';
-import { InteractiveClient } from "./interactiveClient";
+import { ErrorOutputCreator, InteractiveClient } from "./interactiveClient";
 import { ReportChannel, Uri } from "./interfaces/vscode-like";
+import { vsCodeCellOutputToContractCellOutput } from './vscode/vscodeUtilities';
+
+export interface ClientMapperConfiguration {
+    kernelTransportCreator: (notebookUri: Uri) => Promise<KernelTransport>,
+    createErrorOutput: ErrorOutputCreator,
+    diagnosticChannel?: ReportChannel,
+}
 
 export class ClientMapper {
     private clientMap: Map<string, Promise<InteractiveClient>> = new Map();
     private clientCreationCallbackMap: Map<string, (client: InteractiveClient) => Promise<void>> = new Map();
 
-    constructor(readonly kernelTransportCreator: (notebookPath: string) => Promise<KernelTransport>, readonly diagnosticChannel?: ReportChannel) {
+    constructor(readonly config: ClientMapperConfiguration) {
     }
 
     private writeDiagnosticMessage(message: string) {
-        if (this.diagnosticChannel) {
-            this.diagnosticChannel.appendLine(message);
+        if (this.config.diagnosticChannel) {
+            this.config.diagnosticChannel.appendLine(message);
         }
     }
 
     static keyFromUri(uri: Uri): string {
-        return uri.fsPath;
+        return uri.toString();
     }
 
     tryGetClient(uri: Uri): Promise<InteractiveClient | undefined> {
@@ -41,8 +48,12 @@ export class ClientMapper {
             this.writeDiagnosticMessage(`creating client for '${key}'`);
             clientPromise = new Promise<InteractiveClient>(async (resolve, reject) => {
                 try {
-                    const transport = await this.kernelTransportCreator(uri.fsPath);
-                    const client = new InteractiveClient(transport);
+                    const transport = await this.config.kernelTransportCreator(uri);
+                    const config = {
+                        transport,
+                        createErrorOutput: this.config.createErrorOutput,
+                    };
+                    const client = new InteractiveClient(config);
 
                     let onCreate = this.clientCreationCallbackMap.get(key);
                     if (onCreate) {
@@ -98,6 +109,7 @@ export class ClientMapper {
     }
 
     isDotNetClient(uri: Uri): boolean {
-        return this.clientMap.has(uri.fsPath);
+        const key = ClientMapper.keyFromUri(uri);
+        return this.clientMap.has(key);
     }
 }

src/dotnet-interactive-vscode/common/interactiveClient.ts

@@ -52,24 +52,33 @@ import {
     Cancel
 } from './interfaces/contracts';
 import { Eol } from './interfaces';
-import { clearDebounce, createErrorOutput, createOutput } from './utilities';
+import { clearDebounce, createOutput } from './utilities';
 
 import * as vscodeLike from './interfaces/vscode-like';
 
+export interface ErrorOutputCreator {
+    (message: string, outputId?: string): vscodeLike.NotebookCellOutput;
+}
+
+export interface InteractiveClientConfiguration {
+    readonly transport: KernelTransport,
+    readonly createErrorOutput: ErrorOutputCreator,
+}
+
 export class InteractiveClient {
     private nextOutputId: number = 1;
     private nextToken: number = 1;
     private tokenEventObservers: Map<string, Array<KernelEventEnvelopeObserver>> = new Map<string, Array<KernelEventEnvelopeObserver>>();
     private deferredOutput: Array<vscodeLike.NotebookCellOutput> = [];
     private valueIdMap: Map<string, { idx: number, outputs: Array<vscodeLike.NotebookCellOutput>, observer: { (outputs: Array<vscodeLike.NotebookCellOutput>): void } }> = new Map<string, { idx: number, outputs: Array<vscodeLike.NotebookCellOutput>, observer: { (outputs: Array<vscodeLike.NotebookCellOutput>): void } }>();
 
-    constructor(readonly kernelTransport: KernelTransport) {
-        kernelTransport.subscribeToKernelEvents(eventEnvelope => this.eventListener(eventEnvelope));
+    constructor(readonly config: InteractiveClientConfiguration) {
+        config.transport.subscribeToKernelEvents(eventEnvelope => this.eventListener(eventEnvelope));
     }
 
     public tryGetProperty<T>(propertyName: string): T | null {
         try {
-            return <T>((<any>this.kernelTransport)[propertyName]);
+            return <T>((<any>this.config.transport)[propertyName]);
         }
         catch {
             return null;
@@ -134,7 +143,7 @@ export class InteractiveClient {
                     case CommandFailedType:
                         {
                             const err = <CommandFailed>eventEnvelope.event;
-                            const errorOutput = createErrorOutput(err.message, this.getNextOutputId());
+                            const errorOutput = this.config.createErrorOutput(err.message, this.getNextOutputId());
                             outputs.push(errorOutput);
                             reportOutputs();
                             reject(err);
@@ -190,7 +199,7 @@ export class InteractiveClient {
                         break;
                 }
             }, configuration?.token).catch(e => {
-                const errorOutput = createErrorOutput('' + e, this.getNextOutputId());
+                const errorOutput = this.config.createErrorOutput('' + e, this.getNextOutputId());
                 outputs.push(errorOutput);
                 reportOutputs();
                 reject(e);
@@ -251,7 +260,7 @@ export class InteractiveClient {
         };
         token = token || this.getNextToken();
         let disposable = this.subscribeToKernelTokenEvents(token, observer);
-        await this.kernelTransport.submitCommand(command, SubmitCodeType, token);
+        await this.config.transport.submitCommand(command, SubmitCodeType, token);
         return disposable;
     }
 
@@ -266,7 +275,7 @@ export class InteractiveClient {
     }
 
     dispose() {
-        this.kernelTransport.dispose();
+        this.config.transport.dispose();
     }
 
     private submitCommandAndGetResult<TEvent extends KernelEvent>(command: KernelCommand, commandType: KernelCommandType, expectedEventType: KernelEventType, token: string | undefined): Promise<TEvent> {
@@ -300,7 +309,7 @@ export class InteractiveClient {
                         break;
                 }
             });
-            await this.kernelTransport.submitCommand(command, commandType, token);
+            await this.config.transport.submitCommand(command, commandType, token);
         });
     }
 
@@ -322,7 +331,7 @@ export class InteractiveClient {
                         break;
                 }
             });
-            await this.kernelTransport.submitCommand(command, commandType, token);
+            await this.config.transport.submitCommand(command, commandType, token);
         });
     }
 

src/dotnet-interactive-vscode/common/interactiveNotebook.ts

@@ -41,8 +41,10 @@ export function isDotnetInteractiveLanguage(language: string): boolean {
     return language.startsWith(notebookLanguagePrefix);
 }
 
+export const jupyterViewType = 'jupyter-notebook';
+
 export function isJupyterNotebookViewType(viewType: string): boolean {
-    return viewType === 'jupyter-notebook';
+    return viewType === jupyterViewType;
 }
 
 export function languageToCellKind(language: string): NotebookCellKind {

src/dotnet-interactive-vscode/common/interfaces/vscode-like.ts

@@ -8,17 +8,18 @@ export enum NotebookCellKind {
     Code = 2
 }
 
-export const ErrorOutputMimeType = 'application/x.notebook.error-traceback';
+export const ErrorOutputMimeType = 'application/vnd.code.notebook.error';
 
 export interface NotebookCellOutputItem {
     readonly mime: string;
-    readonly value: unknown;
-    readonly metadata?: Record<string, string | number | boolean | unknown>;
+    readonly value: Uint8Array | unknown;
+    readonly metadata?: { [key: string]: any };
 }
 
 export interface NotebookCellOutput {
-    readonly id: string;
-    readonly outputs: NotebookCellOutputItem[];
+    id: string;
+    outputs: NotebookCellOutputItem[];
+    metadata?: { [key: string]: any };
 }
 
 export enum NotebookCellRunState {
@@ -45,6 +46,7 @@ export interface NotebookCellMetadata {
 
 export interface Uri {
     fsPath: string;
+    scheme: string;
     toString: () => string;
 }
 

src/dotnet-interactive-vscode/common/ipynbUtilities.ts

@@ -63,7 +63,7 @@ export function getLanguageInfoMetadata(metadata: any): LanguageInfoMetadata {
     return languageMetadata;
 }
 
-function mapIpynbLanguageName(name: string | undefined): string | undefined {
+export function mapIpynbLanguageName(name: string | undefined): string | undefined {
     if (name) {
         // The .NET Interactive Jupyter kernel serializes the language names as "C#", "F#", and "PowerShell"; these
         // need to be normalized to .NET Interactive kernel language names.