handle the case kernelinfo si deserialised as dicittionary

src/Microsoft.DotNet.Interactive.Documents.Tests/CodeSubmissionFormatTests.dib_file_can_be_round_tripped_through_read_and_write_without_the_content_changing.approved.dib

@@ -1,6 +1,6 @@
 #!meta
 
-{"kernelInfo":{"defaultKernelName":"csharp","items":[{"aliases":["cs","C#","c#"],"name":"csharp"},{"aliases":["fs","F#","f#"],"name":"fsharp"},{"aliases":["powershell"],"name":"pwsh"},{"name":"mermaid"},{"name":"javascript"}]}}
+{"kernelInfo":{"defaultKernelName":"csharp","items":[{"name":"csharp","aliases":["cs","C#","c#"]},{"name":"fsharp","aliases":["fs","F#","f#"]},{"name":"pwsh","aliases":["powershell"]},{"name":"mermaid"},{"name":"javascript"}]}}
 
 #!markdown
 

src/Microsoft.DotNet.Interactive.Documents.Tests/NotebookParserServerTests_ObjectInterface.cs

@@ -6,6 +6,9 @@
 using System.Linq;
 using System.Text;
 using FluentAssertions;
+using FSharp.Compiler.Text;
+
+using Microsoft.DotNet.Interactive.Connection;
 using Microsoft.DotNet.Interactive.Documents.ParserServer;
 using Newtonsoft.Json;
 
@@ -131,6 +134,129 @@ public void Notebook_parser_server_can_parse_a_dib_file_with_not_well_known_kern
             .Be("snake-language");
     }
 
+    [Fact]
+    public void Notebook_parser_server_can_handle_serialize_requests()
+    {
+        var request = @"{
+  ""type"": ""serialize"",
+  ""id"": ""2"",
+  ""serializationType"": ""dib"",
+  ""defaultLanguage"": ""csharp"",
+  ""newLine"": ""\r\n"",
+  ""document"": {
+    ""elements"": [      
+      {
+        ""executionOrder"": 0,
+        ""kernelName"": ""csharp"",
+        ""contents"": ""#r \""nuget: DotLanguage.InteractiveExtension, *-*\"""",
+        ""outputs"": [
+        ]
+      },
+      {
+        ""executionOrder"": 0,
+        ""kernelName"": ""dot"",
+        ""contents"": ""digraph Blah {\r\n    rankdir=\""LR\""\r\n    node [shape=\""box\""];\r\n    A -> B -> C;\r\n    B -> D;\r\n  }"",
+        ""outputs"": []
+      }
+    ],
+    ""metadata"": {
+      ""kernelInfo"": {
+        ""defaultKernelName"": ""csharp"",
+        ""items"": [
+          {
+            ""name"": ""csharp"",
+            ""languageName"": ""C#"",
+            ""aliases"": [
+              ""c#"",
+              ""cs""
+            ]
+          },
+          {
+            ""name"": ""fsharp"",
+            ""languageName"": ""F#"",
+            ""aliases"": [
+              ""f#"",
+              ""fs""
+            ]
+          },
+          {
+            ""name"": ""pwsh"",
+            ""languageName"": ""PowerShell"",
+            ""aliases"": [
+              ""powershell""
+            ]
+          },
+          {
+            ""name"": ""javascript"",
+            ""languageName"": ""JavaScript"",
+            ""aliases"": [
+              ""js""
+            ]
+          },
+          {
+            ""name"": ""html"",
+            ""languageName"": ""HTML"",
+            ""aliases"": [ ]
+          },
+          {
+            ""name"": ""sql"",
+            ""languageName"": ""SQL"",
+            ""aliases"": []
+          },
+          {
+            ""name"": ""kql"",
+            ""languageName"": ""KQL"",
+            ""aliases"": []
+          },
+          {
+            ""name"": ""mermaid"",
+            ""languageName"": ""Mermaid"",
+            ""aliases"": []
+          },
+          {
+            ""name"": ""value"",
+            ""aliases"": []
+          },
+          {
+            ""name"": ""dot"",
+            ""languageName"": ""dotlang"",
+            ""aliases"": []
+          }
+        ]
+      }
+    }
+  }
+}
+";
+
+
+        var response = NotebookParserServer.HandleRequest(NotebookParseOrSerializeRequest.FromJson(request));
+
+        var raw = response
+            .Should()
+            .BeOfType<NotebookSerializeResponse>()
+            .Which
+            .RawData;
+
+        var parseRequest = new NotebookParseRequest(
+            "the-id",
+            DocumentSerializationType.Dib,
+            defaultLanguage: "csharp",
+            rawData: raw);
+
+        var parseResponse = NotebookParserServer.HandleRequest(parseRequest);
+
+        var kernelInfos = parseResponse
+            .Should()
+            .BeOfType<NotebookParseResponse>()
+            .Which
+            .Document.Metadata["kernelInfo"] as KernelInfoCollection;
+
+        kernelInfos
+            .Should()
+            .NotBeNull();
+    }
+
 
     [Fact]
     public void Notebook_parser_server_can_parse_a_dib_file_with_merged_kernel_metadata()

src/Microsoft.DotNet.Interactive.Documents/CodeSubmission.cs

@@ -5,7 +5,6 @@
 using System.Collections.Generic;
 using System.IO;
 using System.Linq;
-using System.Runtime.InteropServices.ComTypes;
 using System.Text;
 using System.Text.Json;
 using System.Threading.Tasks;
@@ -58,12 +57,13 @@ public static InteractiveDocument Parse(
                 if (InteractiveDocument.TryGetKernelInfoFromMetadata(metadata, out var kernelInfoFromMetadata))
                 {
                     InteractiveDocument.MergeKernelInfos(kernelInfo, kernelInfoFromMetadata);
+                    document.Metadata["kernelInfo"] = kernelInfoFromMetadata;
                 }
             }
 
             if (line.StartsWith(MagicCommandPrefix))
             {
-                var cellKernelName = line.Substring(MagicCommandPrefix.Length);
+                var cellKernelName = line[MagicCommandPrefix.Length..];
 
                 if (kernelInfo.TryGetByAlias(cellKernelName, out var name))
                 {
@@ -100,6 +100,7 @@ public static InteractiveDocument Parse(
             document.Metadata.MergeWith(metadata);
         }
 
+
         return document;
 
         void AddElement()

src/Microsoft.DotNet.Interactive.Documents/InteractiveDocument.cs

@@ -241,13 +241,68 @@ internal static bool TryGetKernelInfoFromMetadata(
     {
         if (metadata is not null)
         {
-            if (metadata.TryGetValue("kernelInfo", out var kernelInfoObj) &&
-                kernelInfoObj is JsonElement kernelInfoJson && kernelInfoJson.Deserialize<KernelInfoCollection>(ParserServerSerializer.JsonSerializerOptions) is
-                    { } kernelInfoDeserialized)
+            if (metadata.TryGetValue("kernelInfo", out var kernelInfoObj) )
             {
-                kernelInfo = kernelInfoDeserialized;
-                return true;
+                if (kernelInfoObj is JsonElement kernelInfoJson &&
+                    kernelInfoJson.Deserialize<KernelInfoCollection>(ParserServerSerializer.JsonSerializerOptions) is
+                        { } kernelInfoDeserialized)
+                {
+                    kernelInfo = kernelInfoDeserialized;
+                    return true;
+                }
+
+                // todo: the kernelInfo should not deserialize as a dictionary
+                if (kernelInfoObj is Dictionary<string,object> kernelInfoAsDictionary)
+                {
+                    var deserializedKernelInfo  = new KernelInfoCollection();
+                    if (kernelInfoAsDictionary.TryGetValue("defaultKernelName", out var defaultKernelNameObj) &&
+                       defaultKernelNameObj is string defaultKernelName)
+                    {
+                        deserializedKernelInfo.DefaultKernelName = defaultKernelName;
+                    }
+
+                    if (kernelInfoAsDictionary.TryGetValue("items",
+                            out var items))
+                    {
+                        if (items is IEnumerable<object> itemList)
+                        {
+                            foreach (var item in itemList.Cast<IDictionary<string,object>>())
+                            {
+                                if (item.TryGetValue("name", out var nameObj) &&
+                                    nameObj is string name)
+                                {
+                                    string? language = null;
+                                    if (
+                                    item.TryGetValue("language", out var languageObj) &&
+                                        languageObj is string deserializedLanguage)
+                                    {
+                                        language = deserializedLanguage;
+                                    }
+
+                                    IReadOnlyCollection<string>? aliases = null;
+                                    if (
+                                        item.TryGetValue("aliases", out var aliasesObj) &&
+                                        aliasesObj is object[] deserializedAliases)
+                                    {
+                                        aliases = deserializedAliases.Select(a => a.ToString()).ToArray();
+                                    }
+
+                                    deserializedKernelInfo.Add(new KernelInfo(name, language, aliases));
+                                }
+                            }
+                            kernelInfo = deserializedKernelInfo;
+                            return true;
+                        }
+                    }
+                }
+
+                if (kernelInfoObj is KernelInfoCollection kernelInfoCollection)
+                {
+                    kernelInfo = kernelInfoCollection;
+                    return true;
+                }
             }
+
 
             if (metadata.TryGetValue("dotnet_interactive", out var dotnetInteractiveObj))
             {