handle multiple #!set commands in sungle submission

src/Microsoft.DotNet.Interactive.Tests/VariableSharingTests.SetMagicCommand.cs

@@ -32,9 +32,10 @@ public async Task can_set_value_prompting_user()
         {
             var kernel = CreateKernel(Language.CSharp);
 
-            using var composite = new CompositeKernel();
-
-            composite.Add(kernel);
+            using var composite = new CompositeKernel
+            {
+                kernel
+            };
 
             composite.RegisterCommandHandler<RequestInput>((requestInput, context) =>
             {
@@ -50,10 +51,43 @@ public async Task can_set_value_prompting_user()
             valueProduced.Value.Should().BeEquivalentTo("hello!");
         }
 
+        [Fact]
+        public async Task can_handle_multiple_set_commands_in_single_submission()
+        {
+            using var kernel = CreateCompositeKernel();
+
+            kernel.RegisterCommandHandler<RequestInput>((requestInput, context) =>
+            {
+                context.Publish(new InputProduced("hello!", requestInput));
+                return Task.CompletedTask;
+            });
+
+            await kernel.SendAsync( new SubmitCode("""
+                let var1 = "a"
+                let var2 = "b"
+                """, targetKernelName:"fsharp"));
+
+            var result = await kernel.SendAsync(new SubmitCode("""
+                #!set --name newVar1 --value @fsharp:var1 --mime-type text/plain
+                #!set --name newVar2 --value @fsharp:var2 --mime-type text/plain
+                #!set --name newVar3 --value @input:input-please
+                """, targetKernelName: "csharp"));
+
+            result.Events.Should().NotContainErrors();
+
+            result = await kernel.SendAsync(new RequestValueInfos("csharp"));
+
+            var valueInfosProduced = result.Events.Should()
+                .ContainSingle<ValueInfosProduced>()
+                .Which;
+
+            valueInfosProduced.ValueInfos.Select(v => v.Name).Should().BeEquivalentTo("newVar1", "newVar2", "newVar3");
+        }
+
         [Theory]
         [InlineData(
             """
-                #!fsharp
+                #!fsharp 
                 let x = 123
                 """,
             """

src/Microsoft.DotNet.Interactive/KernelExtensions.cs

@@ -7,6 +7,7 @@
 using System.CommandLine.Invocation;
 using System.CommandLine.NamingConventionBinder;
 using System.CommandLine.Parsing;
+using System.Diagnostics;
 using System.IO;
 using System.Linq;
 using System.Reactive.Linq;
@@ -215,7 +216,7 @@ private static async Task HandleSetMagicCommand<T>(
         T kernel,
         InvocationContext cmdLineContext,
         Option<string> nameOption,
-        Option<object> valueOption,
+        Option<ValueOptionResult> valueOption,
         Option<string> mimeTypeOption,
         Option<bool> byrefOption)
         where T : Kernel
@@ -230,8 +231,14 @@ private static async Task HandleSetMagicCommand<T>(
             var events = new List<ValueProduced>();
 
             using var subscription = context.KernelEvents.OfType<ValueProduced>().Subscribe(events.Add);
+
+            var valueSource = cmdLineContext.ParseResult.GetValueForOption(valueOption);
+
 
-            var valueProduced = events.SingleOrDefault();
+            var valueProduced = valueSource switch
+            { { Name: var sourceValueName, Kernel: var sourceKernelName } when !string.IsNullOrWhiteSpace(sourceKernelName) && !string.IsNullOrEmpty(sourceKernelName) && sourceKernelName != "input" => events.SingleOrDefault(e => e.Name == sourceValueName && e.Command.TargetKernelName == sourceKernelName),
+                _ => null
+            };
 
             if (valueProduced is { })
             {
@@ -242,15 +249,16 @@ private static async Task HandleSetMagicCommand<T>(
             }
             else
             {
-                var interpolatedValue = cmdLineContext.ParseResult.GetValueForOption(valueOption);
 
-                await SendValue(kernel, interpolatedValue, null, valueName);
+                await SendValue(kernel,valueSource?.Value, null, valueName);
             }
         }
         else
         {
             context.Fail(context.Command, new CommandNotSupportedException(typeof(SendValue), kernel));
         }
+
+
     }
 
     public static T UseValueSharing<T>(this T kernel) where T : Kernel
@@ -293,7 +301,7 @@ private static void ConfigureAndAddSetMagicCommand<T>(T destinationKernel) where
                 HtmlFormatter.MimeType,
                 PlainTextFormatter.MimeType);
 
-        var valueOption = new Option<object>(
+        var valueOption = new Option<ValueOptionResult>(
             "--value",
             description:
             LocalizationResources.Magics_set_value_Description(),
@@ -355,13 +363,13 @@ destinationKernel.RootKernel is CompositeKernel root &&
 
         destinationKernel.AddDirective(set);
 
-        object ParseValueOption(ArgumentResult argResult)
+        ValueOptionResult ParseValueOption(ArgumentResult argResult)
         {
             var valueOptionValue = argResult.Tokens.Single().Value;
 
             if (!valueOptionValue.StartsWith("@"))
             {
-                return valueOptionValue;
+                return new ValueOptionResult( valueOptionValue, null,null);
             }
 
             bool isByref;
@@ -412,15 +420,17 @@ object ParseValueOption(ArgumentResult argResult)
 
             if (isByref)
             {
-                return valueProduced.Value;
+                return new ValueOptionResult(valueProduced.Value, sourceKernelName, sourceValueName);
             }
             else
             {
-                return valueProduced.FormattedValue;
+                return new ValueOptionResult(valueProduced.FormattedValue, sourceKernelName, sourceValueName);
             }
         }
     }
 
+    private record ValueOptionResult(object Value, string Kernel, string Name);
+
     private static void ConfigureAndAddShareMagicCommand<T>(T kernel) where T : Kernel
     {
         var sourceValueNameArg = new Argument<string>(