Fail the code submission when user input is canceled

src/Microsoft.DotNet.Interactive.Tests/KeyValueStoreKernelTests.cs

@@ -445,6 +445,33 @@ public async Task Completions_show_value_options()
               .Contain("--name", "--from-url", "--from-file", "--mime-type");
     }
 
+    [Fact]
+    public async Task Canceled_input_request_does_not_record_input_token_as_value()
+    {
+        using var kernel = CreateKernel();
+
+        kernel.RegisterCommandHandler<RequestInput>((requestInput, context) =>
+        {
+            context.Fail(requestInput);
+            return Task.CompletedTask;
+        });
+
+        kernel.SetDefaultTargetKernelNameForCommand(typeof(RequestInput), kernel.Name);
+
+        var result = await kernel.SubmitCodeAsync(
+                         """
+                         #!value --from-value @input:{"type": "file"} --name file
+                         """);
+
+        result.Events.Should().ContainSingle<CommandFailed>();
+
+        var keyValueStoreKernel = kernel.FindKernelByName("value");
+
+        var (_, valueInfosProduced) = await keyValueStoreKernel.TryRequestValueInfosAsync();
+
+        valueInfosProduced.ValueInfos.Should().BeEmpty();
+    }
+
     private static CompositeKernel CreateKernel() =>
         new()
         {

src/Microsoft.DotNet.Interactive/KeyValueStoreKernel.cs

@@ -95,6 +95,12 @@ Task<KernelCommand> TryGetKernelCommandAsync(
                 ExpressionBindingResult expressionBindingResult,
                 Kernel keyValueStoreKernel)
             {
+                if (expressionBindingResult.Diagnostics.FirstOrDefault(d => d.Severity == DiagnosticSeverity.Error) is { } diagnostic)
+                {
+                    directiveNode.AddDiagnostic(diagnostic);
+                    return Task.FromResult<KernelCommand>(null);
+                }
+
                 var parameterValues = directiveNode
                                       .GetParameterValues(directive, expressionBindingResult.BoundValues)
                                       .ToDictionary(t => t.Name, t => (t.Value, t.ParameterNode));

src/Microsoft.DotNet.Interactive/Parsing/DirectiveExpressionNode.cs

@@ -16,6 +16,9 @@ internal DirectiveExpressionNode(SourceText sourceText, SyntaxTree syntaxTree) :
 
     public DirectiveExpressionParametersNode? ParametersNode { get; private set; }
 
+    public bool IsInputExpression => 
+        TypeNode?.Type is "input" or "password";
+
     public void Add(DirectiveExpressionTypeNode node)
     {
         AddInternal(node);

src/Microsoft.DotNet.Interactive/Parsing/PolyglotSyntaxParser.cs

@@ -193,6 +193,9 @@ void AppendNode(SyntaxNode node)
                     case DirectiveParameterValueNode valueNode when subcommandNode is null:
                         directiveNode.Add(valueNode);
                         break;
+                    case DirectiveParameterValueNode valueNode when subcommandNode is not null:
+                        subcommandNode.Add(valueNode);
+                        break;
 
                     case DirectiveParameterValueNode valueNode when subcommandNode is not null:
                         subcommandNode.Add(valueNode);

src/Microsoft.DotNet.Interactive/Parsing/SubmissionParser.cs

@@ -784,7 +784,8 @@ await RequestSingleValueOrInputAsync(
                             sourceCommand,
                             directiveNode.TargetKernelName);
 
-                    if (expressionNode.Parent is { Parent: DirectiveParameterNode { NameNode.Text: { } parameterName } })
+                    if (bindingResult?.IsSuccessful == true &&
+                        expressionNode.Parent is { Parent: DirectiveParameterNode { NameNode.Text: { } parameterName } })
                     {
                         if (inputProduced is not null)
                         {
@@ -798,6 +799,14 @@ await RequestSingleValueOrInputAsync(
                             valuesProduced.Add(parameterName, valueProduced);
                         }
                     }
+                    else
+                    {
+                        if (directiveNode.DescendantNodesAndTokens().OfType<DirectiveExpressionNode>().Any(node => node.IsInputExpression) &&
+                            KernelInvocationContext.Current is { Command: SubmitCode } context)
+                        {
+                            context.Fail(sourceCommand, message: "Input not provided.");
+                        }
+                    }
 
                     return bindingResult;
                 });