From 400d7504186040dd9307d6d751fe16096a767b63 Mon Sep 17 00:00:00 2001
From: "lemiller@microsoft.com" <lemiller@microsoft.com>
Date: Wed, 5 Apr 2023 23:38:00 -0700
Subject: [PATCH 1/4] [sq][build] function flow - ready for testing

dd planning functionality and tests to SemanticKernel project

      Summary: This commit adds several classes and methods to support planning functionality in the SemanticKernel project. It also adds unit and integration tests for the planning module and the skills involved in creating and executing plans. The main changes are:

      - Added a new class FunctionFlowParser that can parse XML plans created by the Function Flow semantic function. The parser converts the XML string into a SequentialPlan object that can be executed by the planner.
      - Added a new class PlannerConfig that encapsulates the common configuration options for planner instances, such as relevancy threshold, max tokens, and excluded or included functions.
      - Added a new class FunctionFlowPlanner that implements a planner that uses a semantic function to generate a step-by-step plan from a goal, using relevant functions from the kernel.
      - Added a new class SequentialPlan that represents a plan composed of sequential steps. The SequentialPlan class inherits from the Plan class and overrides the InvokeNextStepAsync method to execute the next function in the plan. The SequentialPlan class also has properties for storing the output and result keys of each step.
      - Added a new skill PlannerSkill that can execute a plan using the kernel's skills and context.
      - Added a new email skill that can send emails using the OpenAI completion backend. The email skill demonstrates how to use the context variables and named parameters in the plan steps.
      - Added two new extension methods to the SKContext class: GetFunctionsManualAsync and GetAvailableFunctionsAsync. These methods allow the user to query for functions that match a semantic query and a planner configuration, and to get a manual string for each function.
      - Added several unit tests for the planning functionality of the semantic kernel, covering different scenarios of creating and executing plans using different skills and functions.
      - Added several integration tests for the planning and email skills, covering different scenarios of creating and executing sequential plans that involve summarizing, translating, and sending emails.
      - Updated the Example12_Planning.cs file to demonstrate how to use the planning functionality with a simple web search example and a poetry writing and translating example. The file also demonstrates two different ways of using the planner skill: directly as a skill function, or as a planner class.
      - Imported some skills from the sample skills directory, such as WebSearchEngineSkill and SummarizeSkill.
      - Added some TODO comments and bug reports for the planning module.
---
 .../Planning/FunctionFlowParserTests.cs       | 100 +++++
 .../Planning/PlanTests.cs                     | 268 +++++++++++-
 .../Planning/FunctionFlowRunnerTests.cs       |  93 ++++-
 .../Planning/PlanningTests.cs                 | 391 ++++++++++++++++++
 .../Planning/SKContextExtensionsTests.cs      |   1 +
 .../src/SemanticKernel/Orchestration/Plan.cs  |   2 +-
 .../Planning/FunctionFlowParser.cs            | 184 +++++++++
 .../Planning/Planners/FunctionFlowPlanner.cs  |  69 ++++
 .../Planning/Planners/PlannerConfig.cs        |  53 +++
 .../Planning/SKContextPlanningExtensions.cs   |  63 +++
 .../SemanticKernel/Planning/SequentialPlan.cs | 219 ++++++++++
 .../Example12_Planning.cs                     | 106 ++++-
 .../dotnet/kernel-syntax-examples/Program.cs  |  88 ++--
 13 files changed, 1582 insertions(+), 55 deletions(-)
 create mode 100644 dotnet/src/SemanticKernel.IntegrationTests/Planning/FunctionFlowParserTests.cs
 create mode 100644 dotnet/src/SemanticKernel.UnitTests/Planning/PlanningTests.cs
 create mode 100644 dotnet/src/SemanticKernel/Planning/FunctionFlowParser.cs
 create mode 100644 dotnet/src/SemanticKernel/Planning/Planners/FunctionFlowPlanner.cs
 create mode 100644 dotnet/src/SemanticKernel/Planning/Planners/PlannerConfig.cs
 create mode 100644 dotnet/src/SemanticKernel/Planning/SequentialPlan.cs

diff --git a/dotnet/src/SemanticKernel.IntegrationTests/Planning/FunctionFlowParserTests.cs b/dotnet/src/SemanticKernel.IntegrationTests/Planning/FunctionFlowParserTests.cs
new file mode 100644
index 000000000000..5fdfd62fd901
--- /dev/null
+++ b/dotnet/src/SemanticKernel.IntegrationTests/Planning/FunctionFlowParserTests.cs
@@ -0,0 +1,100 @@
+// Copyright (c) Microsoft. All rights reserved.
+
+using Microsoft.Extensions.Configuration;
+using Microsoft.SemanticKernel;
+using Microsoft.SemanticKernel.Planning;
+using SemanticKernel.IntegrationTests.TestSettings;
+using Xunit;
+using Xunit.Abstractions;
+
+namespace SemanticKernel.IntegrationTests.Planning;
+
+public class FunctionFlowRunnerTests
+{
+    public FunctionFlowRunnerTests(ITestOutputHelper output)
+    {
+        // Load configuration
+        this._configuration = new ConfigurationBuilder()
+            .AddJsonFile(path: "testsettings.json", optional: false, reloadOnChange: true)
+            .AddJsonFile(path: "testsettings.development.json", optional: true, reloadOnChange: true)
+            .AddEnvironmentVariables()
+            .AddUserSecrets<FunctionFlowRunnerTests>()
+            .Build();
+    }
+
+    [Fact]
+    public void CanCallToPlanFromXml()
+    {
+        // Arrange
+        AzureOpenAIConfiguration? azureOpenAIConfiguration = this._configuration.GetSection("AzureOpenAI").Get<AzureOpenAIConfiguration>();
+        Assert.NotNull(azureOpenAIConfiguration);
+
+        IKernel kernel = Kernel.Builder
+            .Configure(config =>
+            {
+                config.AddAzureOpenAITextCompletionService(
+                    serviceId: azureOpenAIConfiguration.ServiceId,
+                    deploymentName: azureOpenAIConfiguration.DeploymentName,
+                    endpoint: azureOpenAIConfiguration.Endpoint,
+                    apiKey: azureOpenAIConfiguration.ApiKey);
+                config.SetDefaultTextCompletionService(azureOpenAIConfiguration.ServiceId);
+            })
+            .Build();
+        kernel.ImportSkill(new EmailSkill(), "email");
+        var summarizeSkill = TestHelpers.GetSkill("SummarizeSkill", kernel);
+        var writerSkill = TestHelpers.GetSkill("WriterSkill", kernel);
+
+        _ = kernel.Config.AddAzureOpenAITextCompletionService("test", "test", "test", "test");
+
+        var planString =
+            @"<goal>
+Summarize an input, translate to french, and e-mail to John Doe
+</goal>
+<plan>
+    <function.SummarizeSkill.Summarize/>
+    <function.WriterSkill.Translate language=""French"" setContextVariable=""TRANSLATED_SUMMARY""/>
+    <function.email.GetEmailAddressAsync input=""John Doe"" setContextVariable=""EMAIL_ADDRESS""/>
+    <function.email.SendEmailAsync input=""$TRANSLATED_SUMMARY"" email_address=""$EMAIL_ADDRESS""/>
+</plan>";
+
+        // Act
+        var plan = planString.ToPlanFromXml(kernel.CreateNewContext());
+
+        // Assert
+        Assert.NotNull(plan);
+        Assert.Equal("Summarize an input, translate to french, and e-mail to John Doe", plan.Description);
+
+        Assert.Equal(4, plan.Steps.Count);
+        Assert.Collection(plan.Steps,
+            step =>
+            {
+                Assert.Equal("SummarizeSkill", step.SkillName);
+                Assert.Equal("Summarize", step.Name);
+            },
+            step =>
+            {
+                Assert.Equal("WriterSkill", step.SkillName);
+                Assert.Equal("Translate", step.Name);
+                Assert.Equal("French", step.NamedParameters["language"]);
+                Assert.Equal("TRANSLATED_SUMMARY", (step as SequentialPlan)!.OutputKey);
+                // TODO Above, This illustrates the need well. Or is this just part of the step State with the actual output?
+            },
+            step =>
+            {
+                Assert.Equal("email", step.SkillName);
+                Assert.Equal("GetEmailAddressAsync", step.Name);
+                Assert.Equal("John Doe", step.NamedParameters["input"]);
+                Assert.Equal("EMAIL_ADDRESS", (step as SequentialPlan)!.OutputKey);
+            },
+            step =>
+            {
+                Assert.Equal("email", step.SkillName);
+                Assert.Equal("SendEmailAsync", step.Name);
+                Assert.Equal("$TRANSLATED_SUMMARY", step.NamedParameters["input"]);
+                Assert.Equal("$EMAIL_ADDRESS", step.NamedParameters["email_address"]);
+            }
+        );
+    }
+
+    private readonly IConfigurationRoot _configuration;
+}
diff --git a/dotnet/src/SemanticKernel.IntegrationTests/Planning/PlanTests.cs b/dotnet/src/SemanticKernel.IntegrationTests/Planning/PlanTests.cs
index 0dbae002bd3b..d72fc5ecd35a 100644
--- a/dotnet/src/SemanticKernel.IntegrationTests/Planning/PlanTests.cs
+++ b/dotnet/src/SemanticKernel.IntegrationTests/Planning/PlanTests.cs
@@ -47,6 +47,56 @@ public void CreatePlan(string prompt)
         Assert.Empty(plan.Steps);
     }
 
+    [Theory]
+    [InlineData("Write a poem and send it in an e-mail to Kai.", "SendEmailAsync", "_GLOBAL_FUNCTIONS_")]
+    public async Task CreatePlanFunctionFlowAsync(string prompt, string expectedFunction, string expectedSkill)
+    {
+        // Arrange
+        IKernel target = this.InitializeKernel();
+
+        var planner = new Planner(Planner.Mode.FunctionFlow, target);
+
+        // Act
+        if (await planner.CreatePlanAsync(prompt) is SequentialPlan plan)
+        {
+            // Assert
+            Assert.Contains(
+                plan.Steps,
+                step =>
+                    step.Name.Equals(expectedFunction, StringComparison.OrdinalIgnoreCase) &&
+                    step.SkillName.Equals(expectedSkill, StringComparison.OrdinalIgnoreCase));
+        }
+        else
+        {
+            Assert.Fail("Plan was not created successfully.");
+        }
+    }
+
+    [Theory]
+    [InlineData("Write a poem and send it in an e-mail to Kai.", "SendEmailAsync", "_GLOBAL_FUNCTIONS_")]
+    public async Task CreatePlanGoalRelevantAsync(string prompt, string expectedFunction, string expectedSkill)
+    {
+        // Arrange
+        IKernel target = this.InitializeKernel(true);
+
+        var planner = new Planner(Planner.Mode.GoalRelevant, target);
+
+        // Act
+        if (await planner.CreatePlanAsync(prompt) is SequentialPlan plan)
+        {
+            // Assert
+            Assert.Contains(
+                plan.Steps,
+                step =>
+                    step.Name.Equals(expectedFunction, StringComparison.OrdinalIgnoreCase) &&
+                    step.SkillName.Equals(expectedSkill, StringComparison.OrdinalIgnoreCase));
+        }
+        else
+        {
+            Assert.Fail("Plan was not created successfully.");
+        }
+    }
+
     [Theory]
     [InlineData("This is a story about a dog.", "kai@email.com")]
     public async Task CanExecuteRunSimpleAsync(string inputToEmail, string expectedEmail)
@@ -121,6 +171,222 @@ public async Task CanExecutePanWithTreeStepsAsync()
             result.Result);
     }
 
+    [Theory]
+    [InlineData(null, "Write a poem or joke and send it in an e-mail to Kai.", null)]
+    [InlineData("", "Write a poem or joke and send it in an e-mail to Kai.", "")]
+    [InlineData("Hello World!", "Write a poem or joke and send it in an e-mail to Kai.", "some_email@email.com")]
+    public async Task CanExecuteRunPlanSimpleManualStateAsync(string input, string goal, string email)
+    {
+        // Arrange
+        IKernel target = this.InitializeKernel();
+
+        // Create the input mapping from parent (plan) plan state to child plan (sendEmailPlan) state.
+        var cv = new ContextVariables();
+        cv.Set("email_address", "$TheEmailFromState");
+        var sendEmailPlan = new SequentialPlan("SendEmailAsync")
+        {
+            SkillName = "_GLOBAL_FUNCTIONS_",
+            NamedParameters = cv
+        }; // TODO A separate test where this is just a Plan() object using the function //todo I think I did this
+
+        var plan = new SequentialPlan(goal);
+        plan.Steps.Add(sendEmailPlan);
+        plan.State.Set("TheEmailFromState", email); // manually prepare the state
+
+        // Act
+        var result = await target.StepAsync(input, plan);
+
+        // Assert
+        var expectedBody = input;
+        Assert.Empty(plan.Steps);
+        Assert.Equal(goal, plan.Description);
+        Assert.Equal($"Sent email to: {email}. Body: {expectedBody}".Trim(), plan.State.ToString());
+    }
+
+    [Theory]
+    [InlineData(null, "Write a poem or joke and send it in an e-mail to Kai.", null)]
+    [InlineData("", "Write a poem or joke and send it in an e-mail to Kai.", "")]
+    [InlineData("Hello World!", "Write a poem or joke and send it in an e-mail to Kai.", "some_email@email.com")]
+    public async Task CanExecuteRunPlanManualStateAsync(string input, string goal, string email)
+    {
+        // Arrange
+        IKernel target = this.InitializeKernel();
+
+        var emailSkill = target.ImportSkill(new EmailSkill());
+
+        // Create the input mapping from parent (plan) plan state to child plan (sendEmailPlan) state.
+        var cv = new ContextVariables();
+        cv.Set("email_address", "$TheEmailFromState");
+        var sendEmailPlan = new Plan(emailSkill["SendEmailAsync"])
+        {
+            NamedParameters = cv
+        };
+
+        var plan = new SequentialPlan(goal);
+        plan.Steps.Add(sendEmailPlan);
+        plan.State.Set("TheEmailFromState", email); // manually prepare the state
+
+        // Act
+        var result = await target.StepAsync(input, plan);
+
+        // Assert
+        var expectedBody = input;
+        Assert.Empty(plan.Steps);
+        Assert.Equal(goal, plan.Description);
+        Assert.Equal($"Sent email to: {email}. Body: {expectedBody}".Trim(), plan.State.ToString());
+    }
+
+    [Theory]
+    [InlineData("Summarize an input, translate to french, and e-mail to Kai", "This is a story about a dog.", "French", "Kai", "Kai@example.com")]
+    public async Task CanExecuteRunPlanSimpleAsync(string goal, string inputToSummarize, string inputLanguage, string inputName, string expectedEmail)
+    {
+        // Arrange
+        IKernel target = this.InitializeKernel();
+
+        var expectedBody = $"Sent email to: {expectedEmail}. Body:".Trim();
+
+        var summarizePlan = new SequentialPlan("Summarize")
+        {
+            SkillName = "SummarizeSkill"
+        };
+
+        var cv = new ContextVariables();
+        cv.Set("language", inputLanguage);
+        var translatePlan = new SequentialPlan("Translate")
+        {
+            SkillName = "WriterSkill",
+            OutputKey = "TRANSLATED_SUMMARY",
+            NamedParameters = cv
+        };
+
+        cv = new ContextVariables();
+        cv.Update(inputName);
+        var getEmailPlan = new SequentialPlan("GetEmailAddressAsync")
+        {
+            SkillName = "_GLOBAL_FUNCTIONS_",
+            OutputKey = "TheEmailFromState",
+            NamedParameters = cv,
+        };
+
+        cv = new ContextVariables();
+        cv.Set("email_address", "$TheEmailFromState");
+        cv.Set("input", "$TRANSLATED_SUMMARY");
+        var sendEmailPlan = new SequentialPlan("SendEmailAsync")
+        {
+            SkillName = "_GLOBAL_FUNCTIONS_",
+            NamedParameters = cv
+        };
+
+        var plan = new SequentialPlan(goal);
+        plan.Steps.Add(summarizePlan);
+        plan.Steps.Add(translatePlan);
+        plan.Steps.Add(getEmailPlan);
+        plan.Steps.Add(sendEmailPlan);
+
+        // Act
+        var result = await target.StepAsync(inputToSummarize, plan);
+        Assert.Equal(3, result.Steps.Count);
+        result = await target.StepAsync(result);
+        Assert.Equal(2, result.Steps.Count);
+        result = await target.StepAsync(result);
+        Assert.Single(result.Steps);
+        result = await target.StepAsync(result);
+
+        // Assert
+        Assert.Empty(plan.Steps);
+        Assert.Equal(goal, plan.Description);
+        Assert.Contains(expectedBody, plan.State.ToString(), StringComparison.OrdinalIgnoreCase);
+        Assert.True(expectedBody.Length < plan.State.ToString().Length);
+    }
+
+    [Theory]
+    [InlineData("Summarize an input, translate to french, and e-mail to Kai", "This is a story about a dog.", "French", "Kai", "Kai@example.com")]
+    public async Task CanExecuteRunSequentialAsync(string goal, string inputToSummarize, string inputLanguage, string inputName, string expectedEmail)
+    {
+        // Arrange
+        IKernel target = this.InitializeKernel();
+
+        var expectedBody = $"Sent email to: {expectedEmail}. Body:".Trim();
+
+        var summarizePlan = new SequentialPlan("Summarize")
+        {
+            SkillName = "SummarizeSkill"
+        };
+
+        var cv = new ContextVariables();
+        cv.Set("language", inputLanguage);
+        var translatePlan = new SequentialPlan("Translate")
+        {
+            SkillName = "WriterSkill",
+            OutputKey = "TRANSLATED_SUMMARY",
+            NamedParameters = cv
+        };
+
+        cv = new ContextVariables();
+        cv.Update(inputName);
+        var getEmailPlan = new SequentialPlan("GetEmailAddressAsync")
+        {
+            SkillName = "_GLOBAL_FUNCTIONS_",
+            OutputKey = "TheEmailFromState",
+            NamedParameters = cv,
+        };
+
+        cv = new ContextVariables();
+        cv.Set("email_address", "$TheEmailFromState");
+        cv.Set("input", "$TRANSLATED_SUMMARY");
+        var sendEmailPlan = new SequentialPlan("SendEmailAsync")
+        {
+            SkillName = "_GLOBAL_FUNCTIONS_",
+            NamedParameters = cv
+        };
+
+        var plan = new SequentialPlan(goal);
+        plan.Steps.Add(summarizePlan);
+        plan.Steps.Add(translatePlan);
+        plan.Steps.Add(getEmailPlan);
+        plan.Steps.Add(sendEmailPlan);
+
+        // Act
+        var result = await target.RunAsync(inputToSummarize, plan);
+
+        // Assert
+        Assert.Contains(expectedBody, result.Result, StringComparison.OrdinalIgnoreCase);
+        Assert.True(expectedBody.Length < result.Result.Length);
+    }
+
+    [Theory]
+    [InlineData("Summarize an input, translate to french, and e-mail to Kai", "This is a story about a dog.", "French", "kai@email.com")]
+    public async Task CanExecuteRunSequentialFunctionsAsync(string goal, string inputToSummarize, string inputLanguage, string expectedEmail)
+    {
+        // Arrange
+        IKernel target = this.InitializeKernel();
+
+        var summarizeSkill = TestHelpers.GetSkill("SummarizeSkill", target);
+        var writerSkill = TestHelpers.GetSkill("WriterSkill", target);
+        var emailSkill = target.ImportSkill(new EmailSkill());
+
+        var expectedBody = $"Sent email to: {expectedEmail}. Body:".Trim();
+
+        var summarizePlan = new Plan(summarizeSkill["Summarize"]);
+        var translatePlan = new Plan(writerSkill["Translate"]);
+        var sendEmailPlan = new Plan(emailSkill["SendEmailAsync"]);
+
+        var plan = new SequentialPlan(goal);
+        plan.Steps.Add(summarizePlan);
+        plan.Steps.Add(translatePlan);
+        plan.Steps.Add(sendEmailPlan);
+
+        // Act
+        var cv = new ContextVariables();
+        cv.Update(inputToSummarize);
+        cv.Set("email_address", expectedEmail);
+        cv.Set("language", inputLanguage);
+        var result = await target.RunAsync(cv, plan);
+
+        // Assert
+        Assert.Contains(expectedBody, result.Result, StringComparison.OrdinalIgnoreCase);
+    }
+
     private IKernel InitializeKernel(bool useEmbeddings = false)
     {
         AzureOpenAIConfiguration? azureOpenAIConfiguration = this._configuration.GetSection("AzureOpenAI").Get<AzureOpenAIConfiguration>();
@@ -161,7 +427,7 @@ private IKernel InitializeKernel(bool useEmbeddings = false)
         // Import all sample skills available for demonstration purposes.
         TestHelpers.ImportSampleSkills(kernel);
 
-        var emailSkill = kernel.ImportSkill(new EmailSkill());
+        _ = kernel.ImportSkill(new EmailSkill());
         return kernel;
     }
 
diff --git a/dotnet/src/SemanticKernel.UnitTests/Planning/FunctionFlowRunnerTests.cs b/dotnet/src/SemanticKernel.UnitTests/Planning/FunctionFlowRunnerTests.cs
index 21d55d6acb41..f0b33924cbd5 100644
--- a/dotnet/src/SemanticKernel.UnitTests/Planning/FunctionFlowRunnerTests.cs
+++ b/dotnet/src/SemanticKernel.UnitTests/Planning/FunctionFlowRunnerTests.cs
@@ -272,7 +272,7 @@ public async Task ItExecuteXmlPlanAsyncAndReturnsAsExpectedAsync(string inputPla
         var mockFunction = new Mock<ISKFunction>();
 
         var ifStructureResultContext = this.CreateSKContext(kernel);
-        ifStructureResultContext.Variables.Update("{\"valid\": true}");
+        ifStructureResultContext.Variables.Update( /*lang=json,strict*/ "{\"valid\": true}");
 
         var evaluateConditionResultContext = this.CreateSKContext(kernel);
         evaluateConditionResultContext.Variables.Update($"{{\"valid\": true, \"condition\": {((conditionResult ?? false) ? "true" : "false")}}}");
@@ -310,7 +310,7 @@ public async Task ItExecuteXmlPlanAsyncAndReturnsAsExpectedAsync(string inputPla
             NormalizeSpacesBeforeFunctions(result.Variables[SkillPlan.PlanKey]));
 
         // Removes line breaks and spaces before <function, <if, </if, <else, </else, </plan
-        string NormalizeSpacesBeforeFunctions(string input)
+        static string NormalizeSpacesBeforeFunctions(string input)
         {
             return Regex.Replace(input, @"\s+(?=<function|<[/]*if|<[/]*else|</plan)", string.Empty, RegexOptions.IgnoreCase)
                 .Replace("\n", string.Empty, StringComparison.OrdinalIgnoreCase);
@@ -342,3 +342,92 @@ private Mock<IKernel> CreateKernelMock(
         return kernelMock;
     }
 }
+// namespace SemanticKernel.UnitTests.Planning;
+
+// public class FunctionFlowRunnerTests
+// // {
+// //     public FunctionFlowRunnerTests(ITestOutputHelper output)
+// //     {
+// //         // Load configuration
+// //         this._configuration = new ConfigurationBuilder()
+// //             .AddJsonFile(path: "testsettings.json", optional: false, reloadOnChange: true)
+// //             .AddJsonFile(path: "testsettings.development.json", optional: true, reloadOnChange: true)
+// //             .AddEnvironmentVariables()
+// //             .AddUserSecrets<FunctionFlowRunnerTests>()
+// //             .Build();
+// //     }
+
+// //     [Fact]
+// //     public void CanCallToPlanFromXml()
+// //     {
+// //         // Arrange
+// //         AzureOpenAIConfiguration? azureOpenAIConfiguration = this._configuration.GetSection("AzureOpenAI").Get<AzureOpenAIConfiguration>();
+// //         Assert.NotNull(azureOpenAIConfiguration);
+
+// //         IKernel kernel = Kernel.Builder
+// //             .Configure(config =>
+// //             {
+// //                 config.AddAzureOpenAICompletionBackend(
+// //                     label: azureOpenAIConfiguration.Label,
+// //                     deploymentName: azureOpenAIConfiguration.DeploymentName,
+// //                     endpoint: azureOpenAIConfiguration.Endpoint,
+// //                     apiKey: azureOpenAIConfiguration.ApiKey);
+// //                 config.SetDefaultCompletionBackend(azureOpenAIConfiguration.Label);
+// //             })
+// //             .Build();
+// //         kernel.ImportSkill(new EmailSkill(), "email");
+// //         var summarizeSkill = TestHelpers.GetSkill("SummarizeSkill", kernel);
+// //         var writerSkill = TestHelpers.GetSkill("WriterSkill", kernel);
+
+// //         _ = kernel.Config.AddOpenAICompletionBackend("test", "test", "test");
+// //         var functionFlowRunner = new FunctionFlowRunner(kernel);
+// //         var planString =
+// // @"<goal>
+// // Summarize an input, translate to french, and e-mail to John Doe
+// // </goal>
+// // <plan>
+// //     <function.SummarizeSkill.Summarize/>
+// //     <function.WriterSkill.Translate language=""French"" setContextVariable=""TRANSLATED_SUMMARY""/>
+// //     <function.email.GetEmailAddressAsync input=""John Doe"" setContextVariable=""EMAIL_ADDRESS""/>
+// //     <function.email.SendEmailAsync input=""$TRANSLATED_SUMMARY"" email_address=""$EMAIL_ADDRESS""/>
+// // </plan>";
+
+// //         // Act
+// //         var plan = functionFlowRunner.ToPlanFromXml(planString);
+
+// //         // Assert
+// //         Assert.NotNull(plan);
+// //         Assert.Equal("Summarize an input, translate to french, and e-mail to John Doe", plan.Goal);
+// //         Assert.Equal(4, plan.Steps.Count);
+// //         Assert.Collection(plan.Steps,
+// //             step =>
+// //             {
+// //                 Assert.Equal("SummarizeSkill", step.SelectedSkill);
+// //                 Assert.Equal("Summarize", step.SelectedFunction);
+// //             },
+// //             step =>
+// //             {
+// //                 Assert.Equal("WriterSkill", step.SelectedSkill);
+// //                 Assert.Equal("Translate", step.SelectedFunction);
+// //                 Assert.Equal("French", step.NamedParameters["language"]);
+// //                 // Assert.Equal("TRANSLATED_SUMMARY", step.NamedParameters["setContextVariable"]);
+// //             },
+// //             step =>
+// //             {
+// //                 Assert.Equal("email", step.SelectedSkill);
+// //                 Assert.Equal("GetEmailAddressAsync", step.SelectedFunction);
+// //                 Assert.Equal("John Doe", step.NamedParameters["input"]);
+// //                 // Assert.Equal("EMAIL_ADDRESS", step.NamedParameters["setContextVariable"]);
+// //             },
+// //             step =>
+// //             {
+// //                 Assert.Equal("email", step.SelectedSkill);
+// //                 Assert.Equal("SendEmailAsync", step.SelectedFunction);
+// //                 // Assert.Equal("TRANSLATED_SUMMARY", step.NamedParameters["input"]);
+// //                 // Assert.Equal("EMAIL_ADDRESS", step.NamedParameters["email_address"]);
+// //             }
+// //         );
+// //     }
+
+// //     private readonly IConfigurationRoot _configuration;
+// }
diff --git a/dotnet/src/SemanticKernel.UnitTests/Planning/PlanningTests.cs b/dotnet/src/SemanticKernel.UnitTests/Planning/PlanningTests.cs
new file mode 100644
index 000000000000..0091fb67681c
--- /dev/null
+++ b/dotnet/src/SemanticKernel.UnitTests/Planning/PlanningTests.cs
@@ -0,0 +1,391 @@
+// Copyright (c) Microsoft. All rights reserved.
+
+using System.Collections.Generic;
+using System.Linq;
+using System.Threading;
+using System.Threading.Tasks;
+using Microsoft.Extensions.Logging;
+using Microsoft.SemanticKernel;
+using Microsoft.SemanticKernel.AI.TextCompletion;
+using Microsoft.SemanticKernel.Memory;
+using Microsoft.SemanticKernel.Orchestration;
+using Microsoft.SemanticKernel.Planning;
+using Microsoft.SemanticKernel.Planning.Planners;
+using Microsoft.SemanticKernel.SemanticFunctions;
+using Microsoft.SemanticKernel.SkillDefinition;
+using Moq;
+using Xunit;
+
+namespace SemanticKernel.UnitTests.Planning;
+
+public sealed class PlanningTests
+{
+    // Method to create Mock<ISKFunction> objects
+    private static Mock<ISKFunction> CreateMockFunction(FunctionView functionView)
+    {
+        var mockFunction = new Mock<ISKFunction>();
+        mockFunction.Setup(x => x.Describe()).Returns(functionView);
+        mockFunction.Setup(x => x.Name).Returns(functionView.Name);
+        mockFunction.Setup(x => x.SkillName).Returns(functionView.SkillName);
+        return mockFunction;
+    }
+
+    [Theory]
+    [InlineData("Write a poem or joke and send it in an e-mail to Kai.")]
+    public async Task ItCanCreatePlanAsync(string goal)
+    {
+        // Arrange
+        var kernel = new Mock<IKernel>();
+        kernel.Setup(x => x.Log).Returns(new Mock<ILogger>().Object);
+
+        var memory = new Mock<ISemanticTextMemory>();
+
+        var input = new List<(string name, string skillName, string description, bool isSemantic)>()
+        {
+            ("SendEmail", "email", "Send an e-mail", false),
+            ("GetEmailAddress", "email", "Get an e-mail address", false),
+            ("Translate", "WriterSkill", "Translate something", true),
+            ("Summarize", "SummarizeSkill", "Summarize something", true)
+        };
+
+        var functionsView = new FunctionsView();
+        var skills = new Mock<ISkillCollection>();
+        foreach (var (name, skillName, description, isSemantic) in input)
+        {
+            var functionView = new FunctionView(name, skillName, description, new List<ParameterView>(), isSemantic, true);
+            var mockFunction = CreateMockFunction(functionView);
+            functionsView.AddFunction(functionView);
+
+            if (isSemantic)
+            {
+                skills.Setup(x => x.GetSemanticFunction(It.Is<string>(s => s == skillName), It.Is<string>(s => s == name)))
+                    .Returns(mockFunction.Object);
+                skills.Setup(x => x.HasSemanticFunction(It.Is<string>(s => s == skillName), It.Is<string>(s => s == name))).Returns(true);
+            }
+            else
+            {
+                skills.Setup(x => x.GetNativeFunction(It.Is<string>(s => s == skillName), It.Is<string>(s => s == name)))
+                    .Returns(mockFunction.Object);
+                skills.Setup(x => x.HasNativeFunction(It.Is<string>(s => s == skillName), It.Is<string>(s => s == name))).Returns(true);
+            }
+        }
+
+        skills.Setup(x => x.GetFunctionsView(It.IsAny<bool>(), It.IsAny<bool>())).Returns(functionsView);
+
+        var expectedFunctions = input.Select(x => x.name).ToList();
+        var expectedSkills = input.Select(x => x.skillName).ToList();
+
+        var context = new SKContext(
+            new ContextVariables(),
+            memory.Object,
+            skills.Object,
+            new Mock<ILogger>().Object
+        );
+
+        var returnContext = new SKContext(
+            new ContextVariables(),
+            memory.Object,
+            skills.Object,
+            new Mock<ILogger>().Object
+        );
+        var planString =
+            @"
+<plan>
+    <function.SummarizeSkill.Summarize/>
+    <function.WriterSkill.Translate language=""French"" setContextVariable=""TRANSLATED_SUMMARY""/>
+    <function.email.GetEmailAddress input=""John Doe"" setContextVariable=""EMAIL_ADDRESS""/>
+    <function.email.SendEmail input=""$TRANSLATED_SUMMARY"" email_address=""$EMAIL_ADDRESS""/>
+</plan>";
+
+        returnContext.Variables.Update(planString);
+
+        var mockFunctionFlowFunction = new Mock<ISKFunction>();
+        mockFunctionFlowFunction.Setup(x => x.InvokeAsync(
+            It.IsAny<SKContext>(),
+            null,
+            null,
+            null
+        )).Callback<SKContext, CompleteRequestSettings, ILogger, CancellationToken?>(
+            (c, s, l, ct) => c.Variables.Update("Hello world!")
+        ).Returns(() => Task.FromResult(returnContext));
+
+        // Mock Skills
+        kernel.Setup(x => x.Skills).Returns(skills.Object);
+        kernel.Setup(x => x.CreateNewContext()).Returns(context);
+
+        kernel.Setup(x => x.RegisterSemanticFunction(
+            It.IsAny<string>(),
+            It.IsAny<string>(),
+            It.IsAny<SemanticFunctionConfig>()
+        )).Returns(mockFunctionFlowFunction.Object);
+
+        var planner = new Planner(Planner.Mode.FunctionFlow, kernel.Object);
+
+        // Act
+        var plan = await planner.CreatePlanAsync(goal);
+        if (plan is SequentialPlan sequentialPlan)
+        {
+            Assert.Contains(
+                sequentialPlan.Steps,
+                step =>
+                    expectedFunctions.Contains(step.Name) &&
+                    expectedSkills.Contains(step.SkillName));
+
+            foreach (var expectedFunction in expectedFunctions)
+            {
+                Assert.Contains(
+                    sequentialPlan.Steps,
+                    step => step.Name == expectedFunction);
+            }
+
+            foreach (var expectedSkill in expectedSkills)
+            {
+                Assert.Contains(
+                    sequentialPlan.Steps,
+                    step => step.SkillName == expectedSkill);
+            }
+
+            Assert.Equal(goal, sequentialPlan.Description);
+        }
+        else
+        {
+            Assert.Fail("Plan was not created successfully.");
+        }
+
+        // Assert
+        Assert.Equal(goal, plan.Description);
+    }
+
+    // [Theory]
+    // [InlineData("Write a poem or joke and send it in an e-mail to Kai.", "SendEmailAsync", "_GLOBAL_FUNCTIONS_")]
+    // public async Task CreatePlanDefaultAsync(string prompt, string expectedFunction, string expectedSkill)
+    // {
+    //     // Arrange
+    //     AzureOpenAIConfiguration? azureOpenAIConfiguration = this._configuration.GetSection("AzureOpenAI").Get<AzureOpenAIConfiguration>();
+    //     Assert.NotNull(azureOpenAIConfiguration);
+
+    //     IKernel target = Kernel.Builder
+    //         .WithLogger(this._logger)
+    //         .Configure(config =>
+    //         {
+    //             config.AddAzureOpenAICompletionBackend(
+    //                 label: azureOpenAIConfiguration.Label,
+    //                 deploymentName: azureOpenAIConfiguration.DeploymentName,
+    //                 endpoint: azureOpenAIConfiguration.Endpoint,
+    //                 apiKey: azureOpenAIConfiguration.ApiKey);
+    //             config.SetDefaultCompletionBackend(azureOpenAIConfiguration.Label);
+    //         })
+    //         .Build();
+
+    //     // Import all sample skills available for demonstration purposes.
+    //     // TestHelpers.ImportSampleSkills(target);
+    //     // If I import everything with no relevance, the changes of an invalid xml being returned is very high.
+    //     var writerSkill = TestHelpers.GetSkill("WriterSkill", target);
+
+    //     var emailSkill = target.ImportSkill(new EmailSkill());
+
+    //     var planner = new Planner(target);
+
+    //     // Act
+    //     if (await planner.CreatePlanAsync(prompt) is SequentialPlan plan)
+    //     {
+    //         // Assert
+    //         // Assert.Empty(actual.LastErrorDescription);
+    //         // Assert.False(actual.ErrorOccurred);
+    //         Assert.Contains(
+    //             plan.Root.Steps,
+    //             step =>
+    //                 step.SelectedFunction.Equals(expectedFunction, StringComparison.OrdinalIgnoreCase) &&
+    //                 step.SelectedSkill.Equals(expectedSkill, StringComparison.OrdinalIgnoreCase));
+    //     }
+    //     else
+    //     {
+    //         Assert.Fail("Plan was not created successfully.");
+    //     }
+    // }
+
+    // [Theory]
+    // [InlineData("Write a poem or joke and send it in an e-mail to Kai.", "SendEmailAsync", "_GLOBAL_FUNCTIONS_")]
+    // public async Task CreatePlanFunctionFlowAsync(string prompt, string expectedFunction, string expectedSkill)
+    // {
+    //     // Arrange
+    //     AzureOpenAIConfiguration? azureOpenAIConfiguration = this._configuration.GetSection("AzureOpenAI").Get<AzureOpenAIConfiguration>();
+    //     Assert.NotNull(azureOpenAIConfiguration);
+
+    //     AzureOpenAIConfiguration? azureOpenAIEmbeddingsConfiguration = this._configuration.GetSection("AzureOpenAIEmbeddings").Get<AzureOpenAIConfiguration>();
+    //     Assert.NotNull(azureOpenAIEmbeddingsConfiguration);
+
+    //     IKernel target = Kernel.Builder
+    //         .WithLogger(this._logger)
+    //         .Configure(config =>
+    //         {
+    //             config.AddAzureOpenAICompletionBackend(
+    //                 label: azureOpenAIConfiguration.Label,
+    //                 deploymentName: azureOpenAIConfiguration.DeploymentName,
+    //                 endpoint: azureOpenAIConfiguration.Endpoint,
+    //                 apiKey: azureOpenAIConfiguration.ApiKey);
+
+    //             config.AddAzureOpenAIEmbeddingsBackend(
+    //                 label: azureOpenAIEmbeddingsConfiguration.Label,
+    //                 deploymentName: azureOpenAIEmbeddingsConfiguration.DeploymentName,
+    //                 endpoint: azureOpenAIEmbeddingsConfiguration.Endpoint,
+    //                 apiKey: azureOpenAIEmbeddingsConfiguration.ApiKey);
+
+    //             config.SetDefaultCompletionBackend(azureOpenAIConfiguration.Label);
+    //         })
+    //         .WithMemoryStorage(new VolatileMemoryStore())
+    //         .Build();
+
+    //     // Import all sample skills available for demonstration purposes.
+    //     // TestHelpers.ImportSampleSkills(target);
+    //     var chatSkill = TestHelpers.GetSkill("ChatSkill", target);
+    //     var summarizeSkill = TestHelpers.GetSkill("SummarizeSkill", target);
+    //     var writerSkill = TestHelpers.GetSkill("WriterSkill", target);
+    //     var calendarSkill = TestHelpers.GetSkill("CalendarSkill", target);
+    //     var childrensBookSkill = TestHelpers.GetSkill("ChildrensBookSkill", target);
+    //     var classificationSkill = TestHelpers.GetSkill("ClassificationSkill", target);
+
+    //     // TODO This is still unreliable in creating a valid plan xml -- what's going on?
+
+    //     var emailSkill = target.ImportSkill(new EmailSkill());
+
+    //     var planner = new Planner(target, Planner.Mode.Root.DescriptionRelevant);
+
+    //     // Act
+    //     if (await planner.CreatePlanAsync(prompt) is SequentialPlan plan)
+    //     {
+    //         // Assert
+    //         // Assert.Empty(actual.LastErrorDescription);
+    //         // Assert.False(actual.ErrorOccurred);
+    //         Assert.Contains(
+    //             plan.Root.Steps,
+    //             step =>
+    //                 step.SelectedFunction.Equals(expectedFunction, StringComparison.OrdinalIgnoreCase) &&
+    //                 step.SelectedSkill.Equals(expectedSkill, StringComparison.OrdinalIgnoreCase));
+    //     }
+    //     else
+    //     {
+    //         Assert.Fail("Plan was not created successfully.");
+    //     }
+    // }
+
+    // [Theory]
+    // [InlineData("Write a poem or joke and send it in an e-mail to Kai.")]
+    // public async Task CreatePlanSimpleAsync(string prompt)
+    // {
+    //     // Arrange
+    //     AzureOpenAIConfiguration? azureOpenAIConfiguration = this._configuration.GetSection("AzureOpenAI").Get<AzureOpenAIConfiguration>();
+    //     Assert.NotNull(azureOpenAIConfiguration);
+
+    //     IKernel target = Kernel.Builder
+    //         .WithLogger(this._logger)
+    //         .Configure(config =>
+    //         {
+    //             config.AddAzureOpenAICompletionBackend(
+    //                 label: azureOpenAIConfiguration.Label,
+    //                 deploymentName: azureOpenAIConfiguration.DeploymentName,
+    //                 endpoint: azureOpenAIConfiguration.Endpoint,
+    //                 apiKey: azureOpenAIConfiguration.ApiKey);
+    //             config.SetDefaultCompletionBackend(azureOpenAIConfiguration.Label);
+    //         })
+    //         .Build();
+
+    //     // Import all sample skills available for demonstration purposes.
+    //     // TestHelpers.ImportSampleSkills(target);
+    //     // If I import everything with no relevance, the changes of an invalid xml being returned is very high.
+    //     var writerSkill = TestHelpers.GetSkill("WriterSkill", target);
+
+    //     var emailSkill = target.ImportSkill(new EmailSkill());
+
+    //     var planner = new Planner(target, Planner.Mode.Simple);
+
+    //     // Act
+    //     if (await planner.CreatePlanAsync(prompt) is BasePlan plan)
+    //     {
+    //         // Assert
+    //         // Assert.Empty(actual.LastErrorDescription);
+    //         // Assert.False(actual.ErrorOccurred);
+    //         Assert.Equal(prompt, plan.Root.Description);
+    //     }
+    //     else
+    //     {
+    //         Assert.Fail("Plan was not created successfully.");
+    //     }
+    // }
+
+    // [Theory]
+    // [InlineData(null, "Write a poem or joke and send it in an e-mail to Kai.", null)]
+    // [InlineData("", "Write a poem or joke and send it in an e-mail to Kai.", "")]
+    // [InlineData("Hello World!", "Write a poem or joke and send it in an e-mail to Kai.", "some_email@email.com")]
+    // public async Task CanExecuteRunPlanSimpleAsync(string input, string goal, string email)
+    // {
+    //     // Arrange
+    //     AzureOpenAIConfiguration? azureOpenAIConfiguration = this._configuration.GetSection("AzureOpenAI").Get<AzureOpenAIConfiguration>();
+    //     Assert.NotNull(azureOpenAIConfiguration);
+
+    //     IKernel target = Kernel.Builder
+    //         .WithLogger(this._logger)
+    //         .Configure(config =>
+    //         {
+    //             config.AddAzureOpenAICompletionBackend(
+    //                 label: azureOpenAIConfiguration.Label,
+    //                 deploymentName: azureOpenAIConfiguration.DeploymentName,
+    //                 endpoint: azureOpenAIConfiguration.Endpoint,
+    //                 apiKey: azureOpenAIConfiguration.ApiKey);
+    //             config.SetDefaultCompletionBackend(azureOpenAIConfiguration.Label);
+    //         })
+    //         .Build();
+
+    //     // Import all sample skills available for demonstration purposes.
+    //     TestHelpers.ImportSampleSkills(target);
+    //     var emailSkill = target.ImportSkill(new EmailSkill());
+
+    //     var cv = new ContextVariables();
+    //     cv.Set("email_address", "$TheEmailFromState");
+    //     var plan = new SequentialPlan() { Goal = goal };
+    //     plan.Root.Steps.Add(new PlanStep()
+    //     {
+    //         SelectedFunction = "SendEmailAsync",
+    //         SelectedSkill = "_GLOBAL_FUNCTIONS_",
+    //         NamedParameters = cv
+    //     });
+    //     plan.State.Set("TheEmailFromState", email);
+
+    //     // Act
+    //     await target.RunAsync(input, plan);
+
+    //     // BUG FOUND -- The parameters of the Step are not populated properly
+
+    //     // Assert
+    //     // Assert.Empty(plan.LastErrorDescription);
+    //     // Assert.False(plan.ErrorOccurred);
+    //     var expectedBody = string.IsNullOrEmpty(input) ? goal : input;
+    //     Assert.Equal(0, plan.Root.Steps.Count);
+    //     Assert.Equal(goal, plan.Root.Description);
+    //     Assert.Equal($"Sent email to: {email}. Body: {expectedBody}", plan.State.ToString()); // TODO Make a Result and other properties
+    // }
+
+    // private readonly XunitLogger<object> _logger;
+    // private readonly RedirectOutput _testOutputHelper;
+    // private readonly IConfigurationRoot _configuration;
+
+    // public void Dispose()
+    // {
+    //     this.Dispose(true);
+    //     GC.SuppressFinalize(this);
+    // }
+
+    // ~PlanningTests()
+    // {
+    //     this.Dispose(false);
+    // }
+
+    // private void Dispose(bool disposing)
+    // {
+    //     if (disposing)
+    //     {
+    //         this._logger.Dispose();
+    //         this._testOutputHelper.Dispose();
+    //     }
+    // }
+}
diff --git a/dotnet/src/SemanticKernel.UnitTests/Planning/SKContextExtensionsTests.cs b/dotnet/src/SemanticKernel.UnitTests/Planning/SKContextExtensionsTests.cs
index aa6082a523e0..82eff6c84355 100644
--- a/dotnet/src/SemanticKernel.UnitTests/Planning/SKContextExtensionsTests.cs
+++ b/dotnet/src/SemanticKernel.UnitTests/Planning/SKContextExtensionsTests.cs
@@ -6,6 +6,7 @@
 using System.Threading.Tasks;
 using Microsoft.SemanticKernel.Memory;
 using Microsoft.SemanticKernel.Orchestration;
+using Microsoft.SemanticKernel.Planning;
 using Microsoft.SemanticKernel.SkillDefinition;
 using Moq;
 using SemanticKernel.UnitTests.XunitHelpers;
diff --git a/dotnet/src/SemanticKernel/Orchestration/Plan.cs b/dotnet/src/SemanticKernel/Orchestration/Plan.cs
index 59c619b150cf..c6079e253b41 100644
--- a/dotnet/src/SemanticKernel/Orchestration/Plan.cs
+++ b/dotnet/src/SemanticKernel/Orchestration/Plan.cs
@@ -267,7 +267,7 @@ public async Task<Plan> InvokeNextStepAsync(SKContext context)
         return this;
     }
 
-    public void SetFunction(ISKFunction function)
+    internal void SetFunction(ISKFunction function)
     {
         this.Function = function;
         this.Name = function.Name;
diff --git a/dotnet/src/SemanticKernel/Planning/FunctionFlowParser.cs b/dotnet/src/SemanticKernel/Planning/FunctionFlowParser.cs
new file mode 100644
index 000000000000..18c3b331cc01
--- /dev/null
+++ b/dotnet/src/SemanticKernel/Planning/FunctionFlowParser.cs
@@ -0,0 +1,184 @@
+// Copyright (c) Microsoft. All rights reserved.
+
+using System;
+using System.Text;
+using System.Xml;
+using Microsoft.Extensions.Logging;
+using Microsoft.SemanticKernel.Diagnostics;
+using Microsoft.SemanticKernel.Orchestration;
+
+namespace Microsoft.SemanticKernel.Planning;
+
+/// <summary>
+/// Parse XML plans created by the Function Flow semantic function.
+/// </summary>
+internal static class FunctionFlowParser
+{
+    /// <summary>
+    /// The tag name used in the plan xml for the user's goal/ask.
+    /// </summary>
+    internal const string GoalTag = "goal";
+
+    /// <summary>
+    /// The tag name used in the plan xml for the solution.
+    /// </summary>
+    internal const string SolutionTag = "plan";
+
+    /// <summary>
+    /// The tag name used in the plan xml for a step that calls a skill function.
+    /// </summary>
+    internal const string FunctionTag = "function.";
+
+    /// <summary>
+    /// The attribute tag used in the plan xml for setting the context variable name to set the output of a function to.
+    /// </summary>
+    internal const string SetContextVariableTag = "setContextVariable";
+
+    /// <summary>
+    /// The attribute tag used in the plan xml for appending the output of a function to the final result for a plan.
+    /// </summary>
+    internal const string AppendToResultTag = "appendToResult";
+
+    internal static SequentialPlan ToPlanFromXml(this string xmlString, SKContext context)
+    {
+        try
+        {
+            XmlDocument xmlDoc = new();
+            try
+            {
+                xmlDoc.LoadXml("<xml>" + xmlString + "</xml>");
+            }
+            catch (XmlException e)
+            {
+                throw new PlanningException(PlanningException.ErrorCodes.InvalidPlan, "Failed to parse plan xml.", e);
+            }
+
+            // Get the Goal
+            var (goalTxt, goalXmlString) = GatherGoal(xmlDoc);
+
+            // Get the Solution
+            XmlNodeList solution = xmlDoc.GetElementsByTagName(SolutionTag);
+
+            var plan = new SequentialPlan(goalTxt);
+
+            // loop through solution node and add to Steps
+            foreach (XmlNode o in solution)
+            {
+                var parentNodeName = o.Name;
+
+                foreach (XmlNode o2 in o.ChildNodes)
+                {
+                    if (o2.Name == "#text")
+                    {
+                        if (o2.Value != null)
+                        {
+                            plan.Steps.Add(new Plan(o2.Value.Trim())); // todo debug this
+                        }
+
+                        continue;
+                    }
+
+                    if (o2.Name.StartsWith(FunctionTag, StringComparison.InvariantCultureIgnoreCase))
+                    {
+                        var skillFunctionName = o2.Name.Split(FunctionTag)?[1] ?? string.Empty;
+                        GetSkillFunctionNames(skillFunctionName, out var skillName, out var functionName);
+
+                        // TODO I think we can remove this.
+                        if (!string.IsNullOrEmpty(functionName) && context.IsFunctionRegistered(skillName, functionName, out var skillFunction))
+                        {
+                            Verify.NotNull(functionName, nameof(functionName));
+                            Verify.NotNull(skillFunction, nameof(skillFunction));
+
+                            var planStep = new SequentialPlan(skillFunction);
+
+                            var functionVariables = new ContextVariables();
+
+                            var view = skillFunction.Describe();
+                            foreach (var p in view.Parameters)
+                            {
+                                functionVariables.Set(p.Name, p.DefaultValue);
+                            }
+
+                            var variableTargetName = string.Empty;
+                            var appendToResultName = string.Empty;
+                            if (o2.Attributes is not null)
+                            {
+                                foreach (XmlAttribute attr in o2.Attributes)
+                                {
+                                    context.Log.LogTrace("{0}: processing attribute {1}", parentNodeName, attr.ToString());
+                                    if (attr.InnerText.StartsWith("$", StringComparison.InvariantCultureIgnoreCase))
+                                    {
+                                        functionVariables.Set(attr.Name, attr.InnerText);
+                                    }
+                                    else if (attr.Name.Equals(SetContextVariableTag, StringComparison.OrdinalIgnoreCase))
+                                    {
+                                        variableTargetName = attr.InnerText;
+                                    }
+                                    else if (attr.Name.Equals(AppendToResultTag, StringComparison.OrdinalIgnoreCase))
+                                    {
+                                        appendToResultName = attr.InnerText;
+                                    }
+                                    else
+                                    {
+                                        functionVariables.Set(attr.Name, attr.InnerText);
+                                    }
+                                }
+                            }
+
+                            // Plan properties
+                            planStep.OutputKey = variableTargetName;
+                            planStep.ResultKey = appendToResultName;
+                            planStep.NamedParameters = functionVariables;
+                            plan.Steps.Add(planStep);
+
+                            if (!string.IsNullOrEmpty(variableTargetName))
+                            {
+                                context.Variables.Set(variableTargetName,
+                                    "<NOT_YET_SET>"); // TODO - this is a hack to make sure the variable is set (even if it is empty)
+                            }
+                        }
+                        else
+                        {
+                            context.Log.LogTrace("{0}: appending function node {1}", parentNodeName, skillFunctionName);
+                            plan.Steps.Add(new Plan(o2.InnerText)); // TODO DEBUG THIS
+                        }
+
+                        continue;
+                    }
+
+                    plan.Steps.Add(new Plan(o2.InnerText)); // TODO DEBUG THIS
+                }
+            }
+
+            return plan;
+        }
+        catch (Exception e) when (!e.IsCriticalException())
+        {
+            context.Log.LogError(e, "Plan parsing failed: {0}", e.Message);
+            throw;
+        }
+    }
+
+    private static (string goalTxt, string goalXmlString) GatherGoal(XmlDocument xmlDoc)
+    {
+        XmlNodeList goal = xmlDoc.GetElementsByTagName(GoalTag);
+        if (goal.Count == 0)
+        {
+            throw new PlanningException(PlanningException.ErrorCodes.InvalidPlan, "No goal found.");
+        }
+
+        string goalTxt = goal[0]!.FirstChild!.Value ?? string.Empty;
+        var goalContent = new StringBuilder();
+        _ = goalContent.Append($"<{GoalTag}>")
+            .Append(goalTxt)
+            .AppendLine($"</{GoalTag}>");
+        return (goalTxt.Trim(), goalContent.Replace("\r\n", "\n").ToString().Trim());
+    }
+
+    private static void GetSkillFunctionNames(string skillFunctionName, out string skillName, out string functionName)
+    {
+        var skillFunctionNameParts = skillFunctionName.Split(".");
+        skillName = skillFunctionNameParts?.Length > 0 ? skillFunctionNameParts[0] : string.Empty;
+        functionName = skillFunctionNameParts?.Length > 1 ? skillFunctionNameParts[1] : skillFunctionName;
+    }
+}
diff --git a/dotnet/src/SemanticKernel/Planning/Planners/FunctionFlowPlanner.cs b/dotnet/src/SemanticKernel/Planning/Planners/FunctionFlowPlanner.cs
new file mode 100644
index 000000000000..d084c3f62877
--- /dev/null
+++ b/dotnet/src/SemanticKernel/Planning/Planners/FunctionFlowPlanner.cs
@@ -0,0 +1,69 @@
+// Copyright (c) Microsoft. All rights reserved.
+
+using System.Threading.Tasks;
+using Microsoft.SemanticKernel.CoreSkills;
+using Microsoft.SemanticKernel.Diagnostics;
+using Microsoft.SemanticKernel.Orchestration;
+
+namespace Microsoft.SemanticKernel.Planning.Planners;
+
+public class FunctionFlowPlanner : IPlanner
+{
+    public FunctionFlowPlanner(IKernel? kernel, PlannerConfig? config)
+    {
+        Verify.NotNull(kernel, $"{this.GetType().FullName} requires a kernel instance.");
+        this.Config = config ?? new();
+
+        this._functionFlowFunction = kernel.CreateSemanticFunction(
+            promptTemplate: SemanticFunctionConstants.FunctionFlowFunctionDefinition,
+            skillName: RestrictedSkillName,
+            description: "Given a request or command or goal generate a step by step plan to " +
+                         "fulfill the request using functions. This ability is also known as decision making and function flow",
+            maxTokens: this.Config.MaxTokens,
+            temperature: 0.0,
+            stopSequences: new[] { "<!--" });
+
+        this._context = kernel.CreateNewContext();
+    }
+
+    public async Task<Plan> CreatePlanAsync(string goal)
+    {
+        string relevantFunctionsManual = await this._context.GetFunctionsManualAsync(goal, this.Config);
+        this._context.Variables.Set("available_functions", relevantFunctionsManual);
+
+        this._context.Variables.Update(goal);
+
+        var planResult = await this._functionFlowFunction.InvokeAsync(this._context);
+
+        string fullPlan = $"<{FunctionFlowParser.GoalTag}>\n{goal}\n</{FunctionFlowParser.GoalTag}>\n{planResult.Result.Trim()}";
+
+        var plan = fullPlan.ToPlanFromXml(this._context);
+
+        return plan;
+    }
+
+    protected PlannerConfig Config { get; }
+
+    private readonly SKContext _context;
+
+    /// <summary>
+    /// the function flow semantic function, which takes a goal and creates an xml plan that can be executed
+    /// </summary>
+    private readonly ISKFunction _functionFlowFunction;
+
+    /// <summary>
+    /// The name to use when creating semantic functions that are restricted from the PlannerSkill plans
+    /// </summary>
+    private const string RestrictedSkillName = "PlannerSkill_Excluded"; // todo we've got copies of this now
+}
+
+public class GoalRelevantPlanner : FunctionFlowPlanner
+{
+    public GoalRelevantPlanner(IKernel? kernel) : base(kernel, new() { RelevancyThreshold = 0.78 })
+    {
+    }
+
+    public GoalRelevantPlanner(IKernel? kernel, PlannerConfig? config) : base(kernel, config)
+    {
+    }
+}
diff --git a/dotnet/src/SemanticKernel/Planning/Planners/PlannerConfig.cs b/dotnet/src/SemanticKernel/Planning/Planners/PlannerConfig.cs
new file mode 100644
index 000000000000..6eb00c60c00c
--- /dev/null
+++ b/dotnet/src/SemanticKernel/Planning/Planners/PlannerConfig.cs
@@ -0,0 +1,53 @@
+// Copyright (c) Microsoft Corporation. All not reserved.
+
+using System.Collections.Generic;
+
+namespace Microsoft.SemanticKernel.Planning.Planners;
+
+/// <summary>
+/// Common configuration for planner instances.
+/// </summary>
+public sealed class PlannerConfig
+{
+    /// <summary>
+    /// The minimum relevancy score for a function to be considered
+    /// </summary>
+    /// <remarks>
+    /// 0.78 is a good value for our samples and demonstrations.
+    /// Depending on the embeddings engine used, the user ask, the step goal
+    /// and the functions available, this value may need to be adjusted.
+    /// For default, this is set to null to exhibit previous behavior.
+    /// </remarks>
+    public double? RelevancyThreshold { get; set; }
+
+    /// <summary>
+    /// The maximum number of relevant functions to include in the plan.
+    /// </summary>
+    /// <remarks>
+    /// Limits the number of relevant functions as result of semantic
+    /// search included in the plan creation request.
+    /// <see cref="IncludedFunctions"/> will be included
+    /// in the plan regardless of this limit.
+    /// </remarks>
+    public int MaxRelevantFunctions { get; set; } = 100;
+
+    /// <summary>
+    /// A list of skills to exclude from the plan creation request.
+    /// </summary>
+    public HashSet<string> ExcludedSkills { get; } = new() { };
+
+    /// <summary>
+    /// A list of functions to exclude from the plan creation request.
+    /// </summary>
+    public HashSet<string> ExcludedFunctions { get; } = new() { };
+
+    /// <summary>
+    /// A list of functions to include in the plan creation request.
+    /// </summary>
+    public HashSet<string> IncludedFunctions { get; } = new() { "BucketOutputs" };
+
+    /// <summary>
+    ///
+    /// </summary>
+    public int MaxTokens { get; set; } = 1024;
+}
diff --git a/dotnet/src/SemanticKernel/Planning/SKContextPlanningExtensions.cs b/dotnet/src/SemanticKernel/Planning/SKContextPlanningExtensions.cs
index 8a69d19d638f..c2c46cf9d5bd 100644
--- a/dotnet/src/SemanticKernel/Planning/SKContextPlanningExtensions.cs
+++ b/dotnet/src/SemanticKernel/Planning/SKContextPlanningExtensions.cs
@@ -6,6 +6,7 @@
 using System.Threading.Tasks;
 using Microsoft.Extensions.Logging;
 using Microsoft.SemanticKernel.Memory;
+using Microsoft.SemanticKernel.Planning.Planners;
 using Microsoft.SemanticKernel.SkillDefinition;
 using static Microsoft.SemanticKernel.CoreSkills.PlannerSkill;
 
@@ -38,6 +39,68 @@ internal static async Task<string> GetFunctionsManualAsync(
         return string.Join("\n\n", functions.Select(x => x.ToManualString()));
     }
 
+    internal static async Task<string> GetFunctionsManualAsync(
+        this SKContext context,
+        string? semanticQuery = null,
+        PlannerConfig? config = null)
+    {
+        config ??= new PlannerConfig();
+        var functions = await context.GetAvailableFunctionsAsync(config, semanticQuery);
+
+        return string.Join("\n\n", functions.Select(x => x.ToManualString()));
+    }
+
+    internal static async Task<List<FunctionView>> GetAvailableFunctionsAsync(
+        this SKContext context,
+        PlannerConfig config,
+        string? semanticQuery = null)
+    {
+        var excludedSkills = config.ExcludedSkills ?? new();
+        var excludedFunctions = config.ExcludedFunctions ?? new();
+        var includedFunctions = config.IncludedFunctions ?? new();
+
+        context.ThrowIfSkillCollectionNotSet();
+
+        var functionsView = context.Skills!.GetFunctionsView();
+
+        var availableFunctions = functionsView.SemanticFunctions
+            .Concat(functionsView.NativeFunctions)
+            .SelectMany(x => x.Value)
+            .Where(s => !excludedSkills.Contains(s.SkillName) && !excludedFunctions.Contains(s.Name))
+            .ToList();
+
+        List<FunctionView>? result = null;
+        if (string.IsNullOrEmpty(semanticQuery) || context.Memory is NullMemory || config.RelevancyThreshold is null)
+        {
+            // If no semantic query is provided, return all available functions.
+            // If a Memory provider has not been registered, return all available functions.
+            result = availableFunctions;
+        }
+        else
+        {
+            result = new List<FunctionView>();
+
+            // Remember functions in memory so that they can be searched.
+            await RememberFunctionsAsync(context, availableFunctions);
+
+            // Search for functions that match the semantic query.
+            var memories = context.Memory.SearchAsync(PlannerMemoryCollectionName, semanticQuery, config.MaxRelevantFunctions, config.RelevancyThreshold.Value,
+                context.CancellationToken);
+
+            // Add functions that were found in the search results.
+            result.AddRange(await GetRelevantFunctionsAsync(context, availableFunctions, memories));
+
+            // Add any missing functions that were included but not found in the search results.
+            var missingFunctions = includedFunctions
+                .Except(result.Select(x => x.Name))
+                .Join(availableFunctions, f => f, af => af.Name, (_, af) => af);
+
+            result.AddRange(missingFunctions);
+        }
+
+        return result;
+    }
+
     /// <summary>
     /// Returns a list of functions that are available to the user based on the semantic query and the excluded skills and functions.
     /// </summary>
diff --git a/dotnet/src/SemanticKernel/Planning/SequentialPlan.cs b/dotnet/src/SemanticKernel/Planning/SequentialPlan.cs
new file mode 100644
index 000000000000..9edafaa7fcc5
--- /dev/null
+++ b/dotnet/src/SemanticKernel/Planning/SequentialPlan.cs
@@ -0,0 +1,219 @@
+// Copyright (c) Microsoft. All rights reserved.
+
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text.Json.Serialization;
+using System.Threading.Tasks;
+using Microsoft.SemanticKernel.Orchestration;
+
+namespace Microsoft.SemanticKernel.Planning;
+
+public class SequentialPlan : Plan
+{
+    /// <summary>
+    /// Key used to store the function output of the step in the state
+    /// </summary>
+    [JsonPropertyName("output_key")]
+    public string OutputKey { get; set; } = string.Empty;
+
+    /// <summary>
+    /// Key used to store the function output as a plan result in the state
+    /// </summary>
+    [JsonPropertyName("result_key")]
+    public string ResultKey { get; set; } = string.Empty;
+
+    public SequentialPlan(string goal) : base(goal)
+    {
+    }
+
+    public SequentialPlan(ISKFunction function) : base(function)
+    {
+    }
+
+    protected override async Task<Plan> InvokeNextStepAsync(SKContext context)
+    {
+        var nextStep = this.PopNextStep();
+
+        // todo -- if nextStep.Steps has children, execute them [first]
+        // Otherwise, execute the function
+
+        if (nextStep == null)
+        {
+            return this;
+        }
+
+        var skillName = nextStep.SkillName;
+        var functionName = nextStep.Name;
+
+        if (context.IsFunctionRegistered(skillName, functionName, out var skillFunction))
+        {
+            if (skillFunction is null)
+            {
+                throw new InvalidOperationException($"Function {skillName}.{functionName} is not registered");
+            }
+
+            nextStep.SetFunction(skillFunction);
+
+            var functionVariables = this.GetNextStepVariables(context.Variables, nextStep);
+
+            // If a function is registered, we will execute it and remove it from the list
+            // The functionVariables will be passed to the functions.
+            var keysToIgnore = functionVariables.Select(x => x.Key).ToList();
+            // var result = await kernel.RunAsync(functionVariables, context.CancellationToken, skillFunction!);
+            var functionContext = new SKContext(functionVariables, context.Memory, context.Skills, context.Log, context.CancellationToken);
+            var result = await skillFunction.InvokeAsync(functionContext);
+
+            if (result.ErrorOccurred)
+            {
+                throw new InvalidOperationException($"Function {skillName}.{functionName} failed: {result.LastErrorDescription}", result.LastException);
+            }
+
+            foreach (var (key, _) in functionVariables)
+            {
+                if (!keysToIgnore.Contains(key, StringComparer.InvariantCultureIgnoreCase) && functionVariables.Get(key, out var value))
+                {
+                    this.State.Set(key, value);
+                }
+            }
+
+            if (nextStep is SequentialPlan sequentialPlan)
+            {
+                if (string.IsNullOrEmpty(sequentialPlan.OutputKey))
+                {
+                    _ = this.State.Update(result.Result.Trim());
+                }
+                else
+                {
+                    this.State.Set(sequentialPlan.OutputKey, result.Result.Trim());
+                }
+
+                _ = this.State.Update(result.Result.Trim());
+                if (!string.IsNullOrEmpty(sequentialPlan.OutputKey))
+                {
+                    this.State.Set(sequentialPlan.OutputKey, result.Result.Trim());
+                }
+
+                if (!string.IsNullOrEmpty(sequentialPlan.ResultKey))
+                {
+                    _ = this.State.Get(SkillPlan.ResultKey, out var resultsSoFar);
+                    this.State.Set(SkillPlan.ResultKey,
+                        string.Join(Environment.NewLine + Environment.NewLine, resultsSoFar, result.Result.Trim()));
+                }
+            }
+            else
+            {
+                this.State.Update(result.Result.Trim());
+            }
+
+            return this;
+        }
+        else
+        {
+            throw new InvalidOperationException($"Function {skillName}.{functionName} is not registered");
+        }
+    }
+
+    private ContextVariables GetNextStepVariables(ContextVariables variables, Plan step)
+    {
+        // Initialize function-scoped ContextVariables
+        // Default input should be the Input from the SKContext, or the Input from the Plan.State, or the Plan.Goal
+        var planInput = string.IsNullOrEmpty(variables.Input) ? this.State.Input : variables.Input;
+        var functionInput = string.IsNullOrEmpty(planInput) ? (this.Steps.FirstOrDefault()?.Description ?? string.Empty) : planInput;
+        var functionVariables = new ContextVariables(functionInput);
+
+        var functionParameters = step.Describe();
+        foreach (var param in functionParameters.Parameters)
+        {
+            // otherwise get it from the state if present
+            // todo how was language going through correctly?
+            if (variables.Get(param.Name, out var value) && !string.IsNullOrEmpty(value))
+            {
+                functionVariables.Set(param.Name, value);
+            }
+        }
+
+        // NameParameters are the parameters that are passed to the function
+        // These should be pre-populated by the plan, either with a value or a template expression (e.g. $variableName)
+        // The template expression will be replaced with the value of the variable in the variables or the Plan.State
+        // If the variable is not found, the template expression will be replaced with an empty string
+        // Special parameters are:
+        //  - SetContextVariable: The name of a variable in the variables to set with the result of the function
+        //  - AppendToResult: The name of a variable in the variables to append the result of the function to
+        //  - Input: The input to the function. If not specified, the input will be the variables.Input, or the Plan.State.Input, or the Plan.Goal
+        //  - Output: The output of the function. If not specified, the output will be the variables.Output, or the Plan.State.Output, or the Plan.Result
+        // Keys that are not associated with function parameters or special parameters will be ignored
+        foreach (var param in step.NamedParameters)
+        {
+            if (param.Value.StartsWith("$", StringComparison.InvariantCultureIgnoreCase))
+            {
+                // Split the attribute value on the comma or ; character
+                var attrValues = param.Value.Split(new char[] { ',', ';' }, StringSplitOptions.RemoveEmptyEntries);
+                if (attrValues.Length > 0)
+                {
+                    // If there are multiple values, create a list of the values
+                    var attrValueList = new List<string>();
+                    foreach (var attrValue in attrValues)
+                    {
+                        var variableName = attrValue[1..];
+                        if (variables.Get(variableName, out var variableReplacement))
+                        {
+                            attrValueList.Add(variableReplacement);
+                        }
+                        else if (this.State.Get(attrValue[1..], out variableReplacement))
+                        {
+                            attrValueList.Add(variableReplacement);
+                        }
+                    }
+
+                    if (attrValueList.Count > 0)
+                    {
+                        functionVariables.Set(param.Key, string.Concat(attrValueList));
+                    }
+                }
+            }
+            else
+            {
+                // TODO
+                // What to do when step.NameParameters conflicts with the current context?
+                // Does that only happen with INPUT?
+                if (param.Key != "INPUT" || !string.IsNullOrEmpty(param.Value))
+                {
+                    functionVariables.Set(param.Key, param.Value);
+                }
+                else
+                {
+                    // otherwise get it from the state if present
+                    // todo how was language going through correctly?
+                    if (this.State.Get(param.Key, out var value) && !string.IsNullOrEmpty(value))
+                    {
+                        functionVariables.Set(param.Key, value);
+                    }
+                }
+            }
+        }
+
+        return functionVariables;
+    }
+
+    private Plan? PopNextStep()
+    {
+        // var step = this.Steps.First();
+        // var parent = step;
+        // while (step.Steps.Count > 0)
+        // {
+        //     step = step.Steps[0];
+        //     parent.Steps.RemoveAt(0); // TODO Does this do what I want? has this.Steps changed?
+        // }
+
+        // If we have a children steps, pop from there. Do not worry about nested for now.
+        if (this.Steps.Count > 0)
+        {
+            var step = this.Steps[0];
+            this.Steps.RemoveAt(0);
+            return step;
+        }
+
+        return this;
+    }
+}
diff --git a/samples/dotnet/kernel-syntax-examples/Example12_Planning.cs b/samples/dotnet/kernel-syntax-examples/Example12_Planning.cs
index 13524430e509..b255ce7b018b 100644
--- a/samples/dotnet/kernel-syntax-examples/Example12_Planning.cs
+++ b/samples/dotnet/kernel-syntax-examples/Example12_Planning.cs
@@ -3,12 +3,17 @@
 using System;
 using System.Collections.Generic;
 using System.Diagnostics;
+using System.Threading;
 using System.Threading.Tasks;
 using Microsoft.SemanticKernel;
 using Microsoft.SemanticKernel.CoreSkills;
 using Microsoft.SemanticKernel.KernelExtensions;
 using Microsoft.SemanticKernel.Memory;
 using Microsoft.SemanticKernel.Orchestration;
+using Microsoft.SemanticKernel.Planning;
+using Microsoft.SemanticKernel.Planning.Planners;
+using Microsoft.SemanticKernel.Skills.Web;
+using Microsoft.SemanticKernel.Skills.Web.Bing;
 using RepoUtils;
 using Skills;
 using TextSkill = Skills.TextSkill;
@@ -18,11 +23,12 @@ internal static class Example12_Planning
 {
     public static async Task RunAsync()
     {
-        await PoetrySamplesAsync();
-        await EmailSamplesAsync();
-        await BookSamplesAsync();
-        await MemorySampleAsync();
-        await ConditionalSampleAsync();
+        // await PoetrySamplesAsync();
+        // await EmailSamplesAsync();
+        // await BookSamplesAsync();
+        // await MemorySampleAsync();
+        // await ConditionalSampleAsync();
+        await CompareContrastPlanningAsync();
     }
 
     private static async Task ConditionalSampleAsync()
@@ -62,6 +68,92 @@ private static async Task ConditionalSampleAsync()
         Console.WriteLine(originalPlan.Variables.ToPlan().PlanString);
 
         await ExecutePlanAsync(kernel, planner, originalPlan, 20);
+        await GitHubIssueAsync();
+    }
+
+    private static async Task GitHubIssueAsync()
+    {
+        var kernel = InitializeKernel();
+
+        using BingConnector connector = new(Env.Var("BING_API_KEY"));
+        var webSearchSkill = new WebSearchEngineSkill(connector);
+
+        IDictionary<string, ISKFunction> plannerSkill = kernel.ImportSkill(new PlannerSkill(kernel), "planning");
+
+        kernel.ImportSkill(webSearchSkill, nameof(WebSearchEngineSkill));
+
+        string folder = RepoFiles.SampleSkillsPath();
+        kernel.ImportSemanticSkillFromDirectory(folder, "SummarizeSkill");
+        kernel.ImportSemanticSkillFromDirectory(folder, "FunSkill");
+
+        var planXml = @"
+<goal>
+What's the tallest building in Europe?
+</goal>
+<plan>
+  <function.WebSearchEngineSkill.SearchAsync/>
+</plan>";
+
+        var plan = new SkillPlan()
+        {
+            PlanString = planXml,
+            Goal = "What's the tallest building in Europe?",
+        };
+
+        var cv = new ContextVariables();
+        cv.UpdateWithPlanEntry(plan);
+        var planContext = new SKContext(
+            cv,
+            kernel.Memory,
+            kernel.Skills,
+            kernel.Log,
+            CancellationToken.None);
+
+        await ExecutePlanAsync(kernel, plannerSkill, planContext);
+    }
+
+    private static async Task CompareContrastPlanningAsync()
+    {
+        const string goal = "Write a poem about John Doe, then translate it into Italian.";
+        IKernel kernel;
+        // ********************
+        // Option 1: Using the planner skill directly
+        // ********************
+        kernel = InitializeKernel();
+
+        IDictionary<string, ISKFunction> plannerSkill = kernel.ImportSkill(new PlannerSkill(kernel), "planning");
+
+        SKContext planContext = await kernel.RunAsync(goal, plannerSkill["CreatePlan"]);
+
+        SKContext planResults = await kernel.RunAsync(planContext.Variables, plannerSkill["ExecutePlan"]);
+        SkillPlan plan = planResults.Variables.ToPlan();
+
+        // ********************
+        // Option 2: Using the planner class directly
+        // ********************
+        kernel = InitializeKernel();
+
+        var plannerObject = new Planner(); // Mode = Simple by default
+
+        var planObject = await plannerObject.CreatePlanAsync(goal);
+
+        var updatedPlan = await kernel.RunAsync(goal, planObject);
+    }
+
+    private static IKernel InitializeKernel()
+    {
+        var kernel = new KernelBuilder().WithLogger(ConsoleLogger.Log).Build();
+        kernel.Config.AddAzureOpenAITextCompletionService(
+            Env.Var("AZURE_OPENAI_DEPLOYMENT_LABEL"),
+            Env.Var("AZURE_OPENAI_DEPLOYMENT_NAME"),
+            Env.Var("AZURE_OPENAI_ENDPOINT"),
+            Env.Var("AZURE_OPENAI_KEY"));
+
+        string folder = RepoFiles.SampleSkillsPath();
+        kernel.ImportSemanticSkillFromDirectory(folder, "SummarizeSkill");
+        kernel.ImportSemanticSkillFromDirectory(folder, "WriterSkill");
+
+        return kernel;
     }
 
     private static async Task PoetrySamplesAsync()
@@ -257,8 +349,8 @@ private static async Task<SKContext> ExecutePlanAsync(
                     break;
                 }
 
-                // Console.WriteLine($"Step {step} - Results so far:");
-                // Console.WriteLine(results.ToPlan().Result);
+                Console.WriteLine($"Step {step} - Results so far:");
+                Console.WriteLine(results.Result);
             }
             else
             {
diff --git a/samples/dotnet/kernel-syntax-examples/Program.cs b/samples/dotnet/kernel-syntax-examples/Program.cs
index ef0ccc638d12..486c3e4be091 100644
--- a/samples/dotnet/kernel-syntax-examples/Program.cs
+++ b/samples/dotnet/kernel-syntax-examples/Program.cs
@@ -8,73 +8,73 @@ public static class Program
     // ReSharper disable once InconsistentNaming
     public static async Task Main()
     {
-        Example01_NativeFunctions.Run();
-        Console.WriteLine("== DONE ==");
+        //     Example01_NativeFunctions.Run();
+        //     Console.WriteLine("== DONE ==");
 
-        await Example02_Pipeline.RunAsync();
-        Console.WriteLine("== DONE ==");
+        //     await Example02_Pipeline.RunAsync();
+        //     Console.WriteLine("== DONE ==");
 
-        await Example03_Variables.RunAsync();
-        Console.WriteLine("== DONE ==");
+        //     await Example03_Variables.RunAsync();
+        //     Console.WriteLine("== DONE ==");
 
-        await Example04_BingSkillAndConnector.RunAsync();
-        Console.WriteLine("== DONE ==");
+        //     await Example04_BingSkillAndConnector.RunAsync();
+        //     Console.WriteLine("== DONE ==");
 
-        await Example05_CombineLLMPromptsAndNativeCode.RunAsync();
-        Console.WriteLine("== DONE ==");
+        //     await Example05_CombineLLMPromptsAndNativeCode.RunAsync();
+        //     Console.WriteLine("== DONE ==");
 
-        await Example06_InlineFunctionDefinition.RunAsync();
-        Console.WriteLine("== DONE ==");
+        //     await Example06_InlineFunctionDefinition.RunAsync();
+        //     Console.WriteLine("== DONE ==");
 
-        await Example07_TemplateLanguage.RunAsync();
-        Console.WriteLine("== DONE ==");
+        //     await Example07_TemplateLanguage.RunAsync();
+        //     Console.WriteLine("== DONE ==");
 
-        await Example08_RetryHandler.RunAsync();
-        Console.WriteLine("== DONE ==");
+        //     await Example08_RetryHandler.RunAsync();
+        //     Console.WriteLine("== DONE ==");
 
-        await Example09_FunctionTypes.RunAsync();
-        Console.WriteLine("== DONE ==");
+        //     await Example09_FunctionTypes.RunAsync();
+        //     Console.WriteLine("== DONE ==");
 
-        Example10_DescribeAllSkillsAndFunctions.Run();
-        Console.WriteLine("== DONE ==");
+        //     Example10_DescribeAllSkillsAndFunctions.Run();
+        //     Console.WriteLine("== DONE ==");
 
-        await Example11_WebSearchQueries.RunAsync();
-        Console.WriteLine("== DONE ==");
+        //     await Example11_WebSearchQueries.RunAsync();
+        //     Console.WriteLine("== DONE ==");
 
         await Example12_Planning.RunAsync();
         Console.WriteLine("== DONE ==");
 
-        await Example13_ConversationSummarySkill.RunAsync();
-        Console.WriteLine("== DONE ==");
+        //     await Example13_ConversationSummarySkill.RunAsync();
+        //     Console.WriteLine("== DONE ==");
 
-        await Example14_Memory.RunAsync();
-        Console.WriteLine("== DONE ==");
+        //     await Example14_Memory.RunAsync();
+        //     Console.WriteLine("== DONE ==");
 
-        await Example15_MemorySkill.RunAsync();
-        Console.WriteLine("== DONE ==");
+        //     await Example15_MemorySkill.RunAsync();
+        //     Console.WriteLine("== DONE ==");
 
-        await Example16_CustomLLM.RunAsync();
-        Console.WriteLine("== DONE ==");
+        //     await Example16_CustomLLM.RunAsync();
+        //     Console.WriteLine("== DONE ==");
 
-        await Example17_ChatGPT.RunAsync();
-        Console.WriteLine("== DONE ==");
+        //     await Example17_ChatGPT.RunAsync();
+        //     Console.WriteLine("== DONE ==");
 
-        await Example18_DallE.RunAsync();
-        Console.WriteLine("== DONE ==");
+        //     await Example18_DallE.RunAsync();
+        //     Console.WriteLine("== DONE ==");
 
-        await Example19_Qdrant.RunAsync();
-        Console.WriteLine("== DONE ==");
+        //     await Example19_Qdrant.RunAsync();
+        //     Console.WriteLine("== DONE ==");
 
-        await Example20_HuggingFace.RunAsync();
-        Console.WriteLine("== DONE ==");
+        // await Example20_HuggingFace.RunAsync();
+        // Console.WriteLine("== DONE ==");
 
-        await Example21_ChatGptPlugins.RunAsync();
-        Console.WriteLine("== DONE ==");
+        // await Example21_ChatGptPlugins.RunAsync();
+        // Console.WriteLine("== DONE ==");
 
-        await Example22_OpenApiSkill.RunAsync();
-        Console.WriteLine("== DONE ==");
+        // await Example22_OpenApiSkill.RunAsync();
+        // Console.WriteLine("== DONE ==");
 
-        await Example23_ReadOnlyMemoryStore.RunAsync();
-        Console.WriteLine("== DONE ==");
+        // await Example23_ReadOnlyMemoryStore.RunAsync();
+        // Console.WriteLine("== DONE ==");
     }
 }

From 22a670de18b1e2ede030dffcb6f7cb3aadfb53b5 Mon Sep 17 00:00:00 2001
From: "lemiller@microsoft.com" <lemiller@microsoft.com>
Date: Fri, 7 Apr 2023 09:59:14 -0700
Subject: [PATCH 2/4] Building - tests failing

---
 .../Planning/FunctionFlowParserTests.cs       |   5 +-
 .../Planning/PlanTests.cs                     |  98 ++--
 .../Planning/PlanningTests.cs                 |  59 +--
 .../Planning/FunctionFlowParser.cs            |  10 +-
 .../Planning/Planners/FunctionFlowPlanner.cs  |   4 +-
 .../SemanticKernel/Planning/SequentialPlan.cs | 423 +++++++++---------
 6 files changed, 297 insertions(+), 302 deletions(-)

diff --git a/dotnet/src/SemanticKernel.IntegrationTests/Planning/FunctionFlowParserTests.cs b/dotnet/src/SemanticKernel.IntegrationTests/Planning/FunctionFlowParserTests.cs
index 5fdfd62fd901..08ac8ec4b3a9 100644
--- a/dotnet/src/SemanticKernel.IntegrationTests/Planning/FunctionFlowParserTests.cs
+++ b/dotnet/src/SemanticKernel.IntegrationTests/Planning/FunctionFlowParserTests.cs
@@ -3,6 +3,7 @@
 using Microsoft.Extensions.Configuration;
 using Microsoft.SemanticKernel;
 using Microsoft.SemanticKernel.Planning;
+using SemanticKernel.IntegrationTests.Fakes;
 using SemanticKernel.IntegrationTests.TestSettings;
 using Xunit;
 using Xunit.Abstractions;
@@ -76,7 +77,7 @@ public void CanCallToPlanFromXml()
                 Assert.Equal("WriterSkill", step.SkillName);
                 Assert.Equal("Translate", step.Name);
                 Assert.Equal("French", step.NamedParameters["language"]);
-                Assert.Equal("TRANSLATED_SUMMARY", (step as SequentialPlan)!.OutputKey);
+                // Assert.Equal("TRANSLATED_SUMMARY", (step as Plan)!.OutputKey);
                 // TODO Above, This illustrates the need well. Or is this just part of the step State with the actual output?
             },
             step =>
@@ -84,7 +85,7 @@ public void CanCallToPlanFromXml()
                 Assert.Equal("email", step.SkillName);
                 Assert.Equal("GetEmailAddressAsync", step.Name);
                 Assert.Equal("John Doe", step.NamedParameters["input"]);
-                Assert.Equal("EMAIL_ADDRESS", (step as SequentialPlan)!.OutputKey);
+                // Assert.Equal("EMAIL_ADDRESS", (step as Plan)!.OutputKey);
             },
             step =>
             {
diff --git a/dotnet/src/SemanticKernel.IntegrationTests/Planning/PlanTests.cs b/dotnet/src/SemanticKernel.IntegrationTests/Planning/PlanTests.cs
index d72fc5ecd35a..4b5532c97790 100644
--- a/dotnet/src/SemanticKernel.IntegrationTests/Planning/PlanTests.cs
+++ b/dotnet/src/SemanticKernel.IntegrationTests/Planning/PlanTests.cs
@@ -8,6 +8,7 @@
 using Microsoft.SemanticKernel;
 using Microsoft.SemanticKernel.Memory;
 using Microsoft.SemanticKernel.Orchestration;
+using Microsoft.SemanticKernel.Planning.Planners;
 using SemanticKernel.IntegrationTests.Fakes;
 using SemanticKernel.IntegrationTests.TestSettings;
 using Xunit;
@@ -54,22 +55,16 @@ public async Task CreatePlanFunctionFlowAsync(string prompt, string expectedFunc
         // Arrange
         IKernel target = this.InitializeKernel();
 
-        var planner = new Planner(Planner.Mode.FunctionFlow, target);
+        var planner = new FunctionFlowPlanner(target);
 
         // Act
-        if (await planner.CreatePlanAsync(prompt) is SequentialPlan plan)
-        {
-            // Assert
-            Assert.Contains(
-                plan.Steps,
-                step =>
-                    step.Name.Equals(expectedFunction, StringComparison.OrdinalIgnoreCase) &&
-                    step.SkillName.Equals(expectedSkill, StringComparison.OrdinalIgnoreCase));
-        }
-        else
-        {
-            Assert.Fail("Plan was not created successfully.");
-        }
+        var plan = await planner.CreatePlanAsync(prompt);
+        // Assert
+        Assert.Contains(
+            plan.Steps,
+            step =>
+                step.Name.Equals(expectedFunction, StringComparison.OrdinalIgnoreCase) &&
+                step.SkillName.Equals(expectedSkill, StringComparison.OrdinalIgnoreCase));
     }
 
     [Theory]
@@ -79,22 +74,17 @@ public async Task CreatePlanGoalRelevantAsync(string prompt, string expectedFunc
         // Arrange
         IKernel target = this.InitializeKernel(true);
 
-        var planner = new Planner(Planner.Mode.GoalRelevant, target);
+        var planner = new FunctionFlowPlanner(target, new PlannerConfig() { RelevancyThreshold = 0.78 });
 
         // Act
-        if (await planner.CreatePlanAsync(prompt) is SequentialPlan plan)
-        {
-            // Assert
-            Assert.Contains(
-                plan.Steps,
-                step =>
-                    step.Name.Equals(expectedFunction, StringComparison.OrdinalIgnoreCase) &&
-                    step.SkillName.Equals(expectedSkill, StringComparison.OrdinalIgnoreCase));
-        }
-        else
-        {
-            Assert.Fail("Plan was not created successfully.");
-        }
+        var plan = await planner.CreatePlanAsync(prompt);
+        // Assert
+        Assert.Contains(
+            plan.Steps,
+            step =>
+                step.Name.Equals(expectedFunction, StringComparison.OrdinalIgnoreCase) &&
+                step.SkillName.Equals(expectedSkill, StringComparison.OrdinalIgnoreCase));
+
     }
 
     [Theory]
@@ -183,13 +173,13 @@ public async Task CanExecuteRunPlanSimpleManualStateAsync(string input, string g
         // Create the input mapping from parent (plan) plan state to child plan (sendEmailPlan) state.
         var cv = new ContextVariables();
         cv.Set("email_address", "$TheEmailFromState");
-        var sendEmailPlan = new SequentialPlan("SendEmailAsync")
+        var sendEmailPlan = new Plan("SendEmailAsync")
         {
             SkillName = "_GLOBAL_FUNCTIONS_",
             NamedParameters = cv
         }; // TODO A separate test where this is just a Plan() object using the function //todo I think I did this
 
-        var plan = new SequentialPlan(goal);
+        var plan = new Plan(goal);
         plan.Steps.Add(sendEmailPlan);
         plan.State.Set("TheEmailFromState", email); // manually prepare the state
 
@@ -222,7 +212,7 @@ public async Task CanExecuteRunPlanManualStateAsync(string input, string goal, s
             NamedParameters = cv
         };
 
-        var plan = new SequentialPlan(goal);
+        var plan = new Plan(goal);
         plan.Steps.Add(sendEmailPlan);
         plan.State.Set("TheEmailFromState", email); // manually prepare the state
 
@@ -245,39 +235,39 @@ public async Task CanExecuteRunPlanSimpleAsync(string goal, string inputToSummar
 
         var expectedBody = $"Sent email to: {expectedEmail}. Body:".Trim();
 
-        var summarizePlan = new SequentialPlan("Summarize")
+        var summarizePlan = new Plan("Summarize")
         {
             SkillName = "SummarizeSkill"
         };
 
         var cv = new ContextVariables();
         cv.Set("language", inputLanguage);
-        var translatePlan = new SequentialPlan("Translate")
+        var translatePlan = new Plan("Translate")
         {
             SkillName = "WriterSkill",
-            OutputKey = "TRANSLATED_SUMMARY",
+            // OutputKey = "TRANSLATED_SUMMARY",
             NamedParameters = cv
         };
 
         cv = new ContextVariables();
         cv.Update(inputName);
-        var getEmailPlan = new SequentialPlan("GetEmailAddressAsync")
+        var getEmailPlan = new Plan("GetEmailAddressAsync")
         {
             SkillName = "_GLOBAL_FUNCTIONS_",
-            OutputKey = "TheEmailFromState",
+            // OutputKey = "TheEmailFromState",
             NamedParameters = cv,
         };
 
         cv = new ContextVariables();
         cv.Set("email_address", "$TheEmailFromState");
         cv.Set("input", "$TRANSLATED_SUMMARY");
-        var sendEmailPlan = new SequentialPlan("SendEmailAsync")
+        var sendEmailPlan = new Plan("SendEmailAsync")
         {
             SkillName = "_GLOBAL_FUNCTIONS_",
             NamedParameters = cv
         };
 
-        var plan = new SequentialPlan(goal);
+        var plan = new Plan(goal);
         plan.Steps.Add(summarizePlan);
         plan.Steps.Add(translatePlan);
         plan.Steps.Add(getEmailPlan);
@@ -285,15 +275,23 @@ public async Task CanExecuteRunPlanSimpleAsync(string goal, string inputToSummar
 
         // Act
         var result = await target.StepAsync(inputToSummarize, plan);
-        Assert.Equal(3, result.Steps.Count);
+        Assert.Equal(4, result.Steps.Count);
+        Assert.Equal(1, result.NextStep);
+        Assert.True(result.HasNextStep);
         result = await target.StepAsync(result);
-        Assert.Equal(2, result.Steps.Count);
+        Assert.Equal(4, result.Steps.Count);
+        Assert.Equal(2, result.NextStep);
+        Assert.True(result.HasNextStep);
         result = await target.StepAsync(result);
-        Assert.Single(result.Steps);
+        Assert.Equal(4, result.Steps.Count);
+        Assert.Equal(3, result.NextStep);
+        Assert.True(result.HasNextStep);
         result = await target.StepAsync(result);
 
         // Assert
-        Assert.Empty(plan.Steps);
+        Assert.Equal(4, result.Steps.Count);
+        Assert.Equal(4, result.NextStep);
+        Assert.False(result.HasNextStep);
         Assert.Equal(goal, plan.Description);
         Assert.Contains(expectedBody, plan.State.ToString(), StringComparison.OrdinalIgnoreCase);
         Assert.True(expectedBody.Length < plan.State.ToString().Length);
@@ -308,39 +306,39 @@ public async Task CanExecuteRunSequentialAsync(string goal, string inputToSummar
 
         var expectedBody = $"Sent email to: {expectedEmail}. Body:".Trim();
 
-        var summarizePlan = new SequentialPlan("Summarize")
+        var summarizePlan = new Plan("Summarize")
         {
             SkillName = "SummarizeSkill"
         };
 
         var cv = new ContextVariables();
         cv.Set("language", inputLanguage);
-        var translatePlan = new SequentialPlan("Translate")
+        var translatePlan = new Plan("Translate")
         {
             SkillName = "WriterSkill",
-            OutputKey = "TRANSLATED_SUMMARY",
+            // OutputKey = "TRANSLATED_SUMMARY",
             NamedParameters = cv
         };
 
         cv = new ContextVariables();
         cv.Update(inputName);
-        var getEmailPlan = new SequentialPlan("GetEmailAddressAsync")
+        var getEmailPlan = new Plan("GetEmailAddressAsync")
         {
             SkillName = "_GLOBAL_FUNCTIONS_",
-            OutputKey = "TheEmailFromState",
+            // OutputKey = "TheEmailFromState",
             NamedParameters = cv,
         };
 
         cv = new ContextVariables();
         cv.Set("email_address", "$TheEmailFromState");
         cv.Set("input", "$TRANSLATED_SUMMARY");
-        var sendEmailPlan = new SequentialPlan("SendEmailAsync")
+        var sendEmailPlan = new Plan("SendEmailAsync")
         {
             SkillName = "_GLOBAL_FUNCTIONS_",
             NamedParameters = cv
         };
 
-        var plan = new SequentialPlan(goal);
+        var plan = new Plan(goal);
         plan.Steps.Add(summarizePlan);
         plan.Steps.Add(translatePlan);
         plan.Steps.Add(getEmailPlan);
@@ -371,7 +369,7 @@ public async Task CanExecuteRunSequentialFunctionsAsync(string goal, string inpu
         var translatePlan = new Plan(writerSkill["Translate"]);
         var sendEmailPlan = new Plan(emailSkill["SendEmailAsync"]);
 
-        var plan = new SequentialPlan(goal);
+        var plan = new Plan(goal);
         plan.Steps.Add(summarizePlan);
         plan.Steps.Add(translatePlan);
         plan.Steps.Add(sendEmailPlan);
diff --git a/dotnet/src/SemanticKernel.UnitTests/Planning/PlanningTests.cs b/dotnet/src/SemanticKernel.UnitTests/Planning/PlanningTests.cs
index 0091fb67681c..a89100e7cec2 100644
--- a/dotnet/src/SemanticKernel.UnitTests/Planning/PlanningTests.cs
+++ b/dotnet/src/SemanticKernel.UnitTests/Planning/PlanningTests.cs
@@ -9,7 +9,6 @@
 using Microsoft.SemanticKernel.AI.TextCompletion;
 using Microsoft.SemanticKernel.Memory;
 using Microsoft.SemanticKernel.Orchestration;
-using Microsoft.SemanticKernel.Planning;
 using Microsoft.SemanticKernel.Planning.Planners;
 using Microsoft.SemanticKernel.SemanticFunctions;
 using Microsoft.SemanticKernel.SkillDefinition;
@@ -56,6 +55,18 @@ public async Task ItCanCreatePlanAsync(string goal)
             var mockFunction = CreateMockFunction(functionView);
             functionsView.AddFunction(functionView);
 
+            // Task<SKContext> InvokeAsync(
+            //     SKContext? context = null,
+            //     CompleteRequestSettings? settings = null,
+            //     ILogger? log = null,
+            //     CancellationToken? cancel = null);
+            mockFunction.Setup(x => x.InvokeAsync(It.IsAny<SKContext>(), It.IsAny<CompleteRequestSettings>(), It.IsAny<ILogger>(), It.IsAny<CancellationToken>()))
+                .Returns<SKContext, CompleteRequestSettings, ILogger, CancellationToken>((context, settings, log, cancel) =>
+                {
+                    context.Variables.Update("MOCK FUNCTION CALLED");
+                    return Task.FromResult(context);
+                });
+
             if (isSemantic)
             {
                 skills.Setup(x => x.GetSemanticFunction(It.Is<string>(s => s == skillName), It.Is<string>(s => s == name)))
@@ -119,41 +130,33 @@ public async Task ItCanCreatePlanAsync(string goal)
             It.IsAny<SemanticFunctionConfig>()
         )).Returns(mockFunctionFlowFunction.Object);
 
-        var planner = new Planner(Planner.Mode.FunctionFlow, kernel.Object);
+        // var planner = new Planner(Planner.Mode.FunctionFlow, kernel.Object);
+        var planner = new FunctionFlowPlanner(kernel.Object);
 
         // Act
         var plan = await planner.CreatePlanAsync(goal);
-        if (plan is SequentialPlan sequentialPlan)
-        {
-            Assert.Contains(
-                sequentialPlan.Steps,
-                step =>
-                    expectedFunctions.Contains(step.Name) &&
-                    expectedSkills.Contains(step.SkillName));
+        // Assert
+        Assert.Equal(goal, plan.Description);
 
-            foreach (var expectedFunction in expectedFunctions)
-            {
-                Assert.Contains(
-                    sequentialPlan.Steps,
-                    step => step.Name == expectedFunction);
-            }
+        Assert.Contains(
+            plan.Steps,
+            step =>
+                expectedFunctions.Contains(step.Name) &&
+                expectedSkills.Contains(step.SkillName));
 
-            foreach (var expectedSkill in expectedSkills)
-            {
-                Assert.Contains(
-                    sequentialPlan.Steps,
-                    step => step.SkillName == expectedSkill);
-            }
-
-            Assert.Equal(goal, sequentialPlan.Description);
-        }
-        else
+        foreach (var expectedFunction in expectedFunctions)
         {
-            Assert.Fail("Plan was not created successfully.");
+            Assert.Contains(
+                plan.Steps,
+                step => step.Name == expectedFunction);
         }
 
-        // Assert
-        Assert.Equal(goal, plan.Description);
+        foreach (var expectedSkill in expectedSkills)
+        {
+            Assert.Contains(
+                plan.Steps,
+                step => step.SkillName == expectedSkill);
+        }
     }
 
     // [Theory]
diff --git a/dotnet/src/SemanticKernel/Planning/FunctionFlowParser.cs b/dotnet/src/SemanticKernel/Planning/FunctionFlowParser.cs
index 18c3b331cc01..c3d8ac0346e7 100644
--- a/dotnet/src/SemanticKernel/Planning/FunctionFlowParser.cs
+++ b/dotnet/src/SemanticKernel/Planning/FunctionFlowParser.cs
@@ -39,7 +39,7 @@ internal static class FunctionFlowParser
     /// </summary>
     internal const string AppendToResultTag = "appendToResult";
 
-    internal static SequentialPlan ToPlanFromXml(this string xmlString, SKContext context)
+    internal static Plan ToPlanFromXml(this string xmlString, SKContext context)
     {
         try
         {
@@ -59,7 +59,7 @@ internal static SequentialPlan ToPlanFromXml(this string xmlString, SKContext co
             // Get the Solution
             XmlNodeList solution = xmlDoc.GetElementsByTagName(SolutionTag);
 
-            var plan = new SequentialPlan(goalTxt);
+            var plan = new Plan(goalTxt);
 
             // loop through solution node and add to Steps
             foreach (XmlNode o in solution)
@@ -89,7 +89,7 @@ internal static SequentialPlan ToPlanFromXml(this string xmlString, SKContext co
                             Verify.NotNull(functionName, nameof(functionName));
                             Verify.NotNull(skillFunction, nameof(skillFunction));
 
-                            var planStep = new SequentialPlan(skillFunction);
+                            var planStep = new Plan(skillFunction);
 
                             var functionVariables = new ContextVariables();
 
@@ -126,8 +126,8 @@ internal static SequentialPlan ToPlanFromXml(this string xmlString, SKContext co
                             }
 
                             // Plan properties
-                            planStep.OutputKey = variableTargetName;
-                            planStep.ResultKey = appendToResultName;
+                            // planStep.OutputKey = variableTargetName;
+                            // planStep.ResultKey = appendToResultName;
                             planStep.NamedParameters = functionVariables;
                             plan.Steps.Add(planStep);
 
diff --git a/dotnet/src/SemanticKernel/Planning/Planners/FunctionFlowPlanner.cs b/dotnet/src/SemanticKernel/Planning/Planners/FunctionFlowPlanner.cs
index d084c3f62877..6e7b37e2a0e2 100644
--- a/dotnet/src/SemanticKernel/Planning/Planners/FunctionFlowPlanner.cs
+++ b/dotnet/src/SemanticKernel/Planning/Planners/FunctionFlowPlanner.cs
@@ -7,9 +7,9 @@
 
 namespace Microsoft.SemanticKernel.Planning.Planners;
 
-public class FunctionFlowPlanner : IPlanner
+public class FunctionFlowPlanner
 {
-    public FunctionFlowPlanner(IKernel? kernel, PlannerConfig? config)
+    public FunctionFlowPlanner(IKernel? kernel, PlannerConfig? config = null)
     {
         Verify.NotNull(kernel, $"{this.GetType().FullName} requires a kernel instance.");
         this.Config = config ?? new();
diff --git a/dotnet/src/SemanticKernel/Planning/SequentialPlan.cs b/dotnet/src/SemanticKernel/Planning/SequentialPlan.cs
index 9edafaa7fcc5..a48284ee444e 100644
--- a/dotnet/src/SemanticKernel/Planning/SequentialPlan.cs
+++ b/dotnet/src/SemanticKernel/Planning/SequentialPlan.cs
@@ -1,219 +1,212 @@
 // Copyright (c) Microsoft. All rights reserved.
 
-using System;
-using System.Collections.Generic;
-using System.Linq;
-using System.Text.Json.Serialization;
-using System.Threading.Tasks;
-using Microsoft.SemanticKernel.Orchestration;
-
 namespace Microsoft.SemanticKernel.Planning;
 
-public class SequentialPlan : Plan
-{
-    /// <summary>
-    /// Key used to store the function output of the step in the state
-    /// </summary>
-    [JsonPropertyName("output_key")]
-    public string OutputKey { get; set; } = string.Empty;
-
-    /// <summary>
-    /// Key used to store the function output as a plan result in the state
-    /// </summary>
-    [JsonPropertyName("result_key")]
-    public string ResultKey { get; set; } = string.Empty;
-
-    public SequentialPlan(string goal) : base(goal)
-    {
-    }
-
-    public SequentialPlan(ISKFunction function) : base(function)
-    {
-    }
-
-    protected override async Task<Plan> InvokeNextStepAsync(SKContext context)
-    {
-        var nextStep = this.PopNextStep();
-
-        // todo -- if nextStep.Steps has children, execute them [first]
-        // Otherwise, execute the function
-
-        if (nextStep == null)
-        {
-            return this;
-        }
-
-        var skillName = nextStep.SkillName;
-        var functionName = nextStep.Name;
-
-        if (context.IsFunctionRegistered(skillName, functionName, out var skillFunction))
-        {
-            if (skillFunction is null)
-            {
-                throw new InvalidOperationException($"Function {skillName}.{functionName} is not registered");
-            }
-
-            nextStep.SetFunction(skillFunction);
-
-            var functionVariables = this.GetNextStepVariables(context.Variables, nextStep);
-
-            // If a function is registered, we will execute it and remove it from the list
-            // The functionVariables will be passed to the functions.
-            var keysToIgnore = functionVariables.Select(x => x.Key).ToList();
-            // var result = await kernel.RunAsync(functionVariables, context.CancellationToken, skillFunction!);
-            var functionContext = new SKContext(functionVariables, context.Memory, context.Skills, context.Log, context.CancellationToken);
-            var result = await skillFunction.InvokeAsync(functionContext);
-
-            if (result.ErrorOccurred)
-            {
-                throw new InvalidOperationException($"Function {skillName}.{functionName} failed: {result.LastErrorDescription}", result.LastException);
-            }
-
-            foreach (var (key, _) in functionVariables)
-            {
-                if (!keysToIgnore.Contains(key, StringComparer.InvariantCultureIgnoreCase) && functionVariables.Get(key, out var value))
-                {
-                    this.State.Set(key, value);
-                }
-            }
-
-            if (nextStep is SequentialPlan sequentialPlan)
-            {
-                if (string.IsNullOrEmpty(sequentialPlan.OutputKey))
-                {
-                    _ = this.State.Update(result.Result.Trim());
-                }
-                else
-                {
-                    this.State.Set(sequentialPlan.OutputKey, result.Result.Trim());
-                }
-
-                _ = this.State.Update(result.Result.Trim());
-                if (!string.IsNullOrEmpty(sequentialPlan.OutputKey))
-                {
-                    this.State.Set(sequentialPlan.OutputKey, result.Result.Trim());
-                }
-
-                if (!string.IsNullOrEmpty(sequentialPlan.ResultKey))
-                {
-                    _ = this.State.Get(SkillPlan.ResultKey, out var resultsSoFar);
-                    this.State.Set(SkillPlan.ResultKey,
-                        string.Join(Environment.NewLine + Environment.NewLine, resultsSoFar, result.Result.Trim()));
-                }
-            }
-            else
-            {
-                this.State.Update(result.Result.Trim());
-            }
-
-            return this;
-        }
-        else
-        {
-            throw new InvalidOperationException($"Function {skillName}.{functionName} is not registered");
-        }
-    }
-
-    private ContextVariables GetNextStepVariables(ContextVariables variables, Plan step)
-    {
-        // Initialize function-scoped ContextVariables
-        // Default input should be the Input from the SKContext, or the Input from the Plan.State, or the Plan.Goal
-        var planInput = string.IsNullOrEmpty(variables.Input) ? this.State.Input : variables.Input;
-        var functionInput = string.IsNullOrEmpty(planInput) ? (this.Steps.FirstOrDefault()?.Description ?? string.Empty) : planInput;
-        var functionVariables = new ContextVariables(functionInput);
-
-        var functionParameters = step.Describe();
-        foreach (var param in functionParameters.Parameters)
-        {
-            // otherwise get it from the state if present
-            // todo how was language going through correctly?
-            if (variables.Get(param.Name, out var value) && !string.IsNullOrEmpty(value))
-            {
-                functionVariables.Set(param.Name, value);
-            }
-        }
-
-        // NameParameters are the parameters that are passed to the function
-        // These should be pre-populated by the plan, either with a value or a template expression (e.g. $variableName)
-        // The template expression will be replaced with the value of the variable in the variables or the Plan.State
-        // If the variable is not found, the template expression will be replaced with an empty string
-        // Special parameters are:
-        //  - SetContextVariable: The name of a variable in the variables to set with the result of the function
-        //  - AppendToResult: The name of a variable in the variables to append the result of the function to
-        //  - Input: The input to the function. If not specified, the input will be the variables.Input, or the Plan.State.Input, or the Plan.Goal
-        //  - Output: The output of the function. If not specified, the output will be the variables.Output, or the Plan.State.Output, or the Plan.Result
-        // Keys that are not associated with function parameters or special parameters will be ignored
-        foreach (var param in step.NamedParameters)
-        {
-            if (param.Value.StartsWith("$", StringComparison.InvariantCultureIgnoreCase))
-            {
-                // Split the attribute value on the comma or ; character
-                var attrValues = param.Value.Split(new char[] { ',', ';' }, StringSplitOptions.RemoveEmptyEntries);
-                if (attrValues.Length > 0)
-                {
-                    // If there are multiple values, create a list of the values
-                    var attrValueList = new List<string>();
-                    foreach (var attrValue in attrValues)
-                    {
-                        var variableName = attrValue[1..];
-                        if (variables.Get(variableName, out var variableReplacement))
-                        {
-                            attrValueList.Add(variableReplacement);
-                        }
-                        else if (this.State.Get(attrValue[1..], out variableReplacement))
-                        {
-                            attrValueList.Add(variableReplacement);
-                        }
-                    }
-
-                    if (attrValueList.Count > 0)
-                    {
-                        functionVariables.Set(param.Key, string.Concat(attrValueList));
-                    }
-                }
-            }
-            else
-            {
-                // TODO
-                // What to do when step.NameParameters conflicts with the current context?
-                // Does that only happen with INPUT?
-                if (param.Key != "INPUT" || !string.IsNullOrEmpty(param.Value))
-                {
-                    functionVariables.Set(param.Key, param.Value);
-                }
-                else
-                {
-                    // otherwise get it from the state if present
-                    // todo how was language going through correctly?
-                    if (this.State.Get(param.Key, out var value) && !string.IsNullOrEmpty(value))
-                    {
-                        functionVariables.Set(param.Key, value);
-                    }
-                }
-            }
-        }
-
-        return functionVariables;
-    }
-
-    private Plan? PopNextStep()
-    {
-        // var step = this.Steps.First();
-        // var parent = step;
-        // while (step.Steps.Count > 0)
-        // {
-        //     step = step.Steps[0];
-        //     parent.Steps.RemoveAt(0); // TODO Does this do what I want? has this.Steps changed?
-        // }
-
-        // If we have a children steps, pop from there. Do not worry about nested for now.
-        if (this.Steps.Count > 0)
-        {
-            var step = this.Steps[0];
-            this.Steps.RemoveAt(0);
-            return step;
-        }
-
-        return this;
-    }
-}
+// public class SequentialPlan : Plan
+// {
+//     /// <summary>
+//     /// Key used to store the function output of the step in the state
+//     /// </summary>
+//     [JsonPropertyName("output_key")]
+//     public string OutputKey { get; set; } = string.Empty;
+
+//     /// <summary>
+//     /// Key used to store the function output as a plan result in the state
+//     /// </summary>
+//     [JsonPropertyName("result_key")]
+//     public string ResultKey { get; set; } = string.Empty;
+
+//     public SequentialPlan(string goal) : base(goal)
+//     {
+//     }
+
+//     public SequentialPlan(ISKFunction function) : base(function)
+//     {
+//     }
+
+//     protected override async Task<Plan> InvokeNextStepAsync(SKContext context)
+//     {
+//         var nextStep = this.PopNextStep();
+
+//         // todo -- if nextStep.Steps has children, execute them [first]
+//         // Otherwise, execute the function
+
+//         if (nextStep == null)
+//         {
+//             return this;
+//         }
+
+//         var skillName = nextStep.SkillName;
+//         var functionName = nextStep.Name;
+
+//         if (context.IsFunctionRegistered(skillName, functionName, out var skillFunction))
+//         {
+//             if (skillFunction is null)
+//             {
+//                 throw new InvalidOperationException($"Function {skillName}.{functionName} is not registered");
+//             }
+
+//             nextStep.SetFunction(skillFunction);
+
+//             var functionVariables = this.GetNextStepVariables(context.Variables, nextStep);
+
+//             // If a function is registered, we will execute it and remove it from the list
+//             // The functionVariables will be passed to the functions.
+//             var keysToIgnore = functionVariables.Select(x => x.Key).ToList();
+//             // var result = await kernel.RunAsync(functionVariables, context.CancellationToken, skillFunction!);
+//             var functionContext = new SKContext(functionVariables, context.Memory, context.Skills, context.Log, context.CancellationToken);
+//             var result = await skillFunction.InvokeAsync(functionContext);
+
+//             if (result.ErrorOccurred)
+//             {
+//                 throw new InvalidOperationException($"Function {skillName}.{functionName} failed: {result.LastErrorDescription}", result.LastException);
+//             }
+
+//             foreach (var (key, _) in functionVariables)
+//             {
+//                 if (!keysToIgnore.Contains(key, StringComparer.InvariantCultureIgnoreCase) && functionVariables.Get(key, out var value))
+//                 {
+//                     this.State.Set(key, value);
+//                 }
+//             }
+
+//             if (nextStep is SequentialPlan sequentialPlan)
+//             {
+//                 if (string.IsNullOrEmpty(sequentialPlan.OutputKey))
+//                 {
+//                     _ = this.State.Update(result.Result.Trim());
+//                 }
+//                 else
+//                 {
+//                     this.State.Set(sequentialPlan.OutputKey, result.Result.Trim());
+//                 }
+
+//                 _ = this.State.Update(result.Result.Trim());
+//                 if (!string.IsNullOrEmpty(sequentialPlan.OutputKey))
+//                 {
+//                     this.State.Set(sequentialPlan.OutputKey, result.Result.Trim());
+//                 }
+
+//                 if (!string.IsNullOrEmpty(sequentialPlan.ResultKey))
+//                 {
+//                     _ = this.State.Get(SkillPlan.ResultKey, out var resultsSoFar);
+//                     this.State.Set(SkillPlan.ResultKey,
+//                         string.Join(Environment.NewLine + Environment.NewLine, resultsSoFar, result.Result.Trim()));
+//                 }
+//             }
+//             else
+//             {
+//                 this.State.Update(result.Result.Trim());
+//             }
+
+//             return this;
+//         }
+//         else
+//         {
+//             throw new InvalidOperationException($"Function {skillName}.{functionName} is not registered");
+//         }
+//     }
+
+//     private ContextVariables GetNextStepVariables(ContextVariables variables, Plan step)
+//     {
+//         // Initialize function-scoped ContextVariables
+//         // Default input should be the Input from the SKContext, or the Input from the Plan.State, or the Plan.Goal
+//         var planInput = string.IsNullOrEmpty(variables.Input) ? this.State.Input : variables.Input;
+//         var functionInput = string.IsNullOrEmpty(planInput) ? (this.Steps.FirstOrDefault()?.Description ?? string.Empty) : planInput;
+//         var functionVariables = new ContextVariables(functionInput);
+
+//         var functionParameters = step.Describe();
+//         foreach (var param in functionParameters.Parameters)
+//         {
+//             // otherwise get it from the state if present
+//             // todo how was language going through correctly?
+//             if (variables.Get(param.Name, out var value) && !string.IsNullOrEmpty(value))
+//             {
+//                 functionVariables.Set(param.Name, value);
+//             }
+//         }
+
+//         // NameParameters are the parameters that are passed to the function
+//         // These should be pre-populated by the plan, either with a value or a template expression (e.g. $variableName)
+//         // The template expression will be replaced with the value of the variable in the variables or the Plan.State
+//         // If the variable is not found, the template expression will be replaced with an empty string
+//         // Special parameters are:
+//         //  - SetContextVariable: The name of a variable in the variables to set with the result of the function
+//         //  - AppendToResult: The name of a variable in the variables to append the result of the function to
+//         //  - Input: The input to the function. If not specified, the input will be the variables.Input, or the Plan.State.Input, or the Plan.Goal
+//         //  - Output: The output of the function. If not specified, the output will be the variables.Output, or the Plan.State.Output, or the Plan.Result
+//         // Keys that are not associated with function parameters or special parameters will be ignored
+//         foreach (var param in step.NamedParameters)
+//         {
+//             if (param.Value.StartsWith("$", StringComparison.InvariantCultureIgnoreCase))
+//             {
+//                 // Split the attribute value on the comma or ; character
+//                 var attrValues = param.Value.Split(new char[] { ',', ';' }, StringSplitOptions.RemoveEmptyEntries);
+//                 if (attrValues.Length > 0)
+//                 {
+//                     // If there are multiple values, create a list of the values
+//                     var attrValueList = new List<string>();
+//                     foreach (var attrValue in attrValues)
+//                     {
+//                         var variableName = attrValue[1..];
+//                         if (variables.Get(variableName, out var variableReplacement))
+//                         {
+//                             attrValueList.Add(variableReplacement);
+//                         }
+//                         else if (this.State.Get(attrValue[1..], out variableReplacement))
+//                         {
+//                             attrValueList.Add(variableReplacement);
+//                         }
+//                     }
+
+//                     if (attrValueList.Count > 0)
+//                     {
+//                         functionVariables.Set(param.Key, string.Concat(attrValueList));
+//                     }
+//                 }
+//             }
+//             else
+//             {
+//                 // TODO
+//                 // What to do when step.NameParameters conflicts with the current context?
+//                 // Does that only happen with INPUT?
+//                 if (param.Key != "INPUT" || !string.IsNullOrEmpty(param.Value))
+//                 {
+//                     functionVariables.Set(param.Key, param.Value);
+//                 }
+//                 else
+//                 {
+//                     // otherwise get it from the state if present
+//                     // todo how was language going through correctly?
+//                     if (this.State.Get(param.Key, out var value) && !string.IsNullOrEmpty(value))
+//                     {
+//                         functionVariables.Set(param.Key, value);
+//                     }
+//                 }
+//             }
+//         }
+
+//         return functionVariables;
+//     }
+
+//     private Plan? PopNextStep()
+//     {
+//         // var step = this.Steps.First();
+//         // var parent = step;
+//         // while (step.Steps.Count > 0)
+//         // {
+//         //     step = step.Steps[0];
+//         //     parent.Steps.RemoveAt(0); // TODO Does this do what I want? has this.Steps changed?
+//         // }
+
+//         // If we have a children steps, pop from there. Do not worry about nested for now.
+//         if (this.Steps.Count > 0)
+//         {
+//             var step = this.Steps[0];
+//             this.Steps.RemoveAt(0);
+//             return step;
+//         }
+
+//         return this;
+//     }
+// }

From a6e4e9315ef47c5a38abca6e18a4fe27582319d6 Mon Sep 17 00:00:00 2001
From: "lemiller@microsoft.com" <lemiller@microsoft.com>
Date: Fri, 7 Apr 2023 15:22:04 -0700
Subject: [PATCH 3/4] Enabled FunctionFlow behavior

 This commit makes several changes to the Plan class and its related classes and tests. It refactors the Plan class to use the new ISKFunction interface and the FunctionView class, and to improve the handling of function parameters and variables. It also adds a new method to set the function and name properties of the Plan class, and a new property to specify the output keys for each step. It removes the SequentialPlan class, which was no longer needed, and some unused or redundant code from the SequentialPlan.cs file. It updates the PlanTests class to use imported skills instead of hard-coded skill names and functions, and to use the new Plan constructor. It also fixes some minor formatting and naming issues, and adds some comments and assertions for clarity.

 TODO - tests about book scenario, appending results (or not).
---
 .../Planning/PlanTests.cs                     | 175 +++++++++++---
 .../src/SemanticKernel/Orchestration/Plan.cs  | 226 +++++++++++++++++-
 .../SemanticKernel/Planning/SequentialPlan.cs | 212 ----------------
 3 files changed, 360 insertions(+), 253 deletions(-)
 delete mode 100644 dotnet/src/SemanticKernel/Planning/SequentialPlan.cs

diff --git a/dotnet/src/SemanticKernel.IntegrationTests/Planning/PlanTests.cs b/dotnet/src/SemanticKernel.IntegrationTests/Planning/PlanTests.cs
index 4b5532c97790..2f46e4c6bd0a 100644
--- a/dotnet/src/SemanticKernel.IntegrationTests/Planning/PlanTests.cs
+++ b/dotnet/src/SemanticKernel.IntegrationTests/Planning/PlanTests.cs
@@ -169,15 +169,20 @@ public async Task CanExecuteRunPlanSimpleManualStateAsync(string input, string g
     {
         // Arrange
         IKernel target = this.InitializeKernel();
+        var emailSkill = target.ImportSkill(new EmailSkill());
 
         // Create the input mapping from parent (plan) plan state to child plan (sendEmailPlan) state.
         var cv = new ContextVariables();
         cv.Set("email_address", "$TheEmailFromState");
-        var sendEmailPlan = new Plan("SendEmailAsync")
+        // var sendEmailPlan = new Plan("SendEmailAsync")
+        // {
+        //     SkillName = "_GLOBAL_FUNCTIONS_",
+        //     NamedParameters = cv
+        // }; // TODO A separate test where this is just a Plan() object using the function //todo I think I did this
+        var sendEmailPlan = new Plan(emailSkill["SendEmailAsync"])
         {
-            SkillName = "_GLOBAL_FUNCTIONS_",
-            NamedParameters = cv
-        }; // TODO A separate test where this is just a Plan() object using the function //todo I think I did this
+            NamedParameters = cv,
+        };
 
         var plan = new Plan(goal);
         plan.Steps.Add(sendEmailPlan);
@@ -187,8 +192,10 @@ public async Task CanExecuteRunPlanSimpleManualStateAsync(string input, string g
         var result = await target.StepAsync(input, plan);
 
         // Assert
-        var expectedBody = input;
-        Assert.Empty(plan.Steps);
+        var expectedBody = string.IsNullOrEmpty(input) ? goal : input;
+        Assert.Single(result.Steps);
+        Assert.Equal(1, result.NextStep);
+        Assert.False(result.HasNextStep);
         Assert.Equal(goal, plan.Description);
         Assert.Equal($"Sent email to: {email}. Body: {expectedBody}".Trim(), plan.State.ToString());
     }
@@ -220,50 +227,52 @@ public async Task CanExecuteRunPlanManualStateAsync(string input, string goal, s
         var result = await target.StepAsync(input, plan);
 
         // Assert
-        var expectedBody = input;
-        Assert.Empty(plan.Steps);
+        var expectedBody = string.IsNullOrEmpty(input) ? goal : input;
+        Assert.False(plan.HasNextStep);
         Assert.Equal(goal, plan.Description);
         Assert.Equal($"Sent email to: {email}. Body: {expectedBody}".Trim(), plan.State.ToString());
     }
 
     [Theory]
     [InlineData("Summarize an input, translate to french, and e-mail to Kai", "This is a story about a dog.", "French", "Kai", "Kai@example.com")]
-    public async Task CanExecuteRunPlanSimpleAsync(string goal, string inputToSummarize, string inputLanguage, string inputName, string expectedEmail)
+    public async Task CanExecuteRunPlanAsync(string goal, string inputToSummarize, string inputLanguage, string inputName, string expectedEmail)
     {
         // Arrange
         IKernel target = this.InitializeKernel();
 
+        var summarizeSkill = TestHelpers.GetSkill("SummarizeSkill", target);
+        var writerSkill = TestHelpers.GetSkill("WriterSkill", target);
+        var emailSkill = target.ImportSkill(new EmailSkill());
+
         var expectedBody = $"Sent email to: {expectedEmail}. Body:".Trim();
 
-        var summarizePlan = new Plan("Summarize")
-        {
-            SkillName = "SummarizeSkill"
-        };
+        var summarizePlan = new Plan(summarizeSkill["Summarize"]);
 
         var cv = new ContextVariables();
         cv.Set("language", inputLanguage);
-        var translatePlan = new Plan("Translate")
+        var outputs = new ContextVariables();
+        outputs.Set("RESULT", "TRANSLATED_SUMMARY");
+        var translatePlan = new Plan(writerSkill["Translate"])
         {
-            SkillName = "WriterSkill",
-            // OutputKey = "TRANSLATED_SUMMARY",
-            NamedParameters = cv
+            NamedParameters = cv,
+            NamedOutputs = outputs,
         };
 
         cv = new ContextVariables();
         cv.Update(inputName);
-        var getEmailPlan = new Plan("GetEmailAddressAsync")
+        outputs = new ContextVariables();
+        outputs.Set("RESULT", "TheEmailFromState");
+        var getEmailPlan = new Plan(emailSkill["GetEmailAddressAsync"])
         {
-            SkillName = "_GLOBAL_FUNCTIONS_",
-            // OutputKey = "TheEmailFromState",
             NamedParameters = cv,
+            NamedOutputs = outputs,
         };
 
         cv = new ContextVariables();
         cv.Set("email_address", "$TheEmailFromState");
         cv.Set("input", "$TRANSLATED_SUMMARY");
-        var sendEmailPlan = new Plan("SendEmailAsync")
+        var sendEmailPlan = new Plan(emailSkill["SendEmailAsync"])
         {
-            SkillName = "_GLOBAL_FUNCTIONS_",
             NamedParameters = cv
         };
 
@@ -297,44 +306,140 @@ public async Task CanExecuteRunPlanSimpleAsync(string goal, string inputToSummar
         Assert.True(expectedBody.Length < plan.State.ToString().Length);
     }
 
+    // [Theory]
+    // [InlineData("Summarize an input, translate to french, and e-mail to Kai", "This is a story about a dog.", "French", "Kai", "Kai@example.com")]
+    // public async Task CanExecuteRunPlanSimpleAsync(string goal, string inputToSummarize, string inputLanguage, string inputName, string expectedEmail)
+    // {
+
+    //     // TODO -- Do I even want to support this? Basically getting the functions on the fly rather than initialize at plan creation?
+
+    //     // Arrange
+    //     IKernel target = this.InitializeKernel();
+
+    //     var expectedBody = $"Sent email to: {expectedEmail}. Body:".Trim();
+
+    //     var summarizePlan = new Plan("Summarize")
+    //     {
+    //         SkillName = "SummarizeSkill"
+    //     };
+
+    //     var cv = new ContextVariables();
+    //     cv.Set("language", inputLanguage);
+    //     var translatePlan = new Plan("Translate")
+    //     {
+    //         SkillName = "WriterSkill",
+    //         // OutputKey = "TRANSLATED_SUMMARY",
+    //         NamedParameters = cv
+    //     };
+
+    //     cv = new ContextVariables();
+    //     cv.Update(inputName);
+    //     var getEmailPlan = new Plan("GetEmailAddressAsync")
+    //     {
+    //         SkillName = "_GLOBAL_FUNCTIONS_",
+    //         // OutputKey = "TheEmailFromState",
+    //         NamedParameters = cv,
+    //     };
+
+    //     cv = new ContextVariables();
+    //     cv.Set("email_address", "$TheEmailFromState");
+    //     cv.Set("input", "$TRANSLATED_SUMMARY");
+    //     var sendEmailPlan = new Plan("SendEmailAsync")
+    //     {
+    //         SkillName = "_GLOBAL_FUNCTIONS_",
+    //         NamedParameters = cv
+    //     };
+
+    //     var plan = new Plan(goal);
+    //     plan.Steps.Add(summarizePlan);
+    //     plan.Steps.Add(translatePlan);
+    //     plan.Steps.Add(getEmailPlan);
+    //     plan.Steps.Add(sendEmailPlan);
+
+    //     // Act
+    //     var result = await target.StepAsync(inputToSummarize, plan);
+    //     Assert.Equal(4, result.Steps.Count);
+    //     Assert.Equal(1, result.NextStep);
+    //     Assert.True(result.HasNextStep);
+    //     result = await target.StepAsync(result);
+    //     Assert.Equal(4, result.Steps.Count);
+    //     Assert.Equal(2, result.NextStep);
+    //     Assert.True(result.HasNextStep);
+    //     result = await target.StepAsync(result);
+    //     Assert.Equal(4, result.Steps.Count);
+    //     Assert.Equal(3, result.NextStep);
+    //     Assert.True(result.HasNextStep);
+    //     result = await target.StepAsync(result);
+
+    //     // Assert
+    //     Assert.Equal(4, result.Steps.Count);
+    //     Assert.Equal(4, result.NextStep);
+    //     Assert.False(result.HasNextStep);
+    //     Assert.Equal(goal, plan.Description);
+    //     Assert.Contains(expectedBody, plan.State.ToString(), StringComparison.OrdinalIgnoreCase);
+    //     Assert.True(expectedBody.Length < plan.State.ToString().Length);
+    // }
+
     [Theory]
     [InlineData("Summarize an input, translate to french, and e-mail to Kai", "This is a story about a dog.", "French", "Kai", "Kai@example.com")]
     public async Task CanExecuteRunSequentialAsync(string goal, string inputToSummarize, string inputLanguage, string inputName, string expectedEmail)
     {
         // Arrange
         IKernel target = this.InitializeKernel();
+        var summarizeSkill = TestHelpers.GetSkill("SummarizeSkill", target);
+        var writerSkill = TestHelpers.GetSkill("WriterSkill", target);
+        var emailSkill = target.ImportSkill(new EmailSkill());
 
         var expectedBody = $"Sent email to: {expectedEmail}. Body:".Trim();
 
-        var summarizePlan = new Plan("Summarize")
-        {
-            SkillName = "SummarizeSkill"
-        };
+        // var summarizePlan = new Plan("Summarize")
+        // {
+        //     SkillName = "SummarizeSkill"
+        // };
+        var summarizePlan = new Plan(summarizeSkill["Summarize"]);
 
         var cv = new ContextVariables();
         cv.Set("language", inputLanguage);
-        var translatePlan = new Plan("Translate")
+        var outputs = new ContextVariables();
+        outputs.Set("RESULT", "TRANSLATED_SUMMARY");
+        // var translatePlan = new Plan("Translate")
+        // {
+        //     SkillName = "WriterSkill",
+        //     // OutputKey = "TRANSLATED_SUMMARY",
+        //     NamedParameters = cv
+
+        var translatePlan = new Plan(writerSkill["Translate"])
         {
-            SkillName = "WriterSkill",
-            // OutputKey = "TRANSLATED_SUMMARY",
-            NamedParameters = cv
+            NamedParameters = cv,
+            NamedOutputs = outputs,
         };
 
         cv = new ContextVariables();
         cv.Update(inputName);
-        var getEmailPlan = new Plan("GetEmailAddressAsync")
+        outputs = new ContextVariables();
+        outputs.Set("RESULT", "TheEmailFromState");
+        // var getEmailPlan = new Plan("GetEmailAddressAsync")
+        // {
+        //     SkillName = "_GLOBAL_FUNCTIONS_",
+        //     // OutputKey = "TheEmailFromState",
+        //     NamedParameters = cv,
+        // };
+        var getEmailPlan = new Plan(emailSkill["GetEmailAddressAsync"])
         {
-            SkillName = "_GLOBAL_FUNCTIONS_",
-            // OutputKey = "TheEmailFromState",
             NamedParameters = cv,
+            NamedOutputs = outputs,
         };
 
         cv = new ContextVariables();
         cv.Set("email_address", "$TheEmailFromState");
         cv.Set("input", "$TRANSLATED_SUMMARY");
-        var sendEmailPlan = new Plan("SendEmailAsync")
+        // var sendEmailPlan = new Plan("SendEmailAsync")
+        // {
+        //     SkillName = "_GLOBAL_FUNCTIONS_",
+        //     NamedParameters = cv
+        // };
+        var sendEmailPlan = new Plan(emailSkill["SendEmailAsync"])
         {
-            SkillName = "_GLOBAL_FUNCTIONS_",
             NamedParameters = cv
         };
 
diff --git a/dotnet/src/SemanticKernel/Orchestration/Plan.cs b/dotnet/src/SemanticKernel/Orchestration/Plan.cs
index c6079e253b41..25e703bee8a9 100644
--- a/dotnet/src/SemanticKernel/Orchestration/Plan.cs
+++ b/dotnet/src/SemanticKernel/Orchestration/Plan.cs
@@ -2,6 +2,7 @@
 
 using System;
 using System.Collections.Generic;
+using System.Linq;
 using System.Text.Json.Serialization;
 using System.Threading;
 using System.Threading.Tasks;
@@ -36,6 +37,12 @@ public sealed class Plan : ISKFunction
     [JsonPropertyName("named_parameters")]
     public ContextVariables NamedParameters { get; set; } = new();
 
+    /// <summary>
+    /// Named outputs for the function
+    /// </summary>
+    [JsonPropertyName("named_outputs")]
+    public ContextVariables NamedOutputs { get; set; } = new();
+
     public bool HasNextStep => this.NextStep < this.Steps.Count;
 
     public int NextStep { get; private set; } = 0;
@@ -158,7 +165,7 @@ public Task<Plan> RunNextStepAsync(IKernel kernel, ContextVariables variables, C
     public FunctionView Describe()
     {
         // TODO - Eventually, we should be able to describe a plan and it's expected inputs/outputs
-        return this.Function?.Describe() ?? throw new NotImplementedException();
+        return this.Function?.Describe() ?? new();
     }
 
     /// <inheritdoc/>
@@ -195,8 +202,8 @@ public async Task<SKContext> InvokeAsync(SKContext? context = null, CompleteRequ
             while (this.HasNextStep)
             {
                 var functionContext = context;
-                // Loop through State and add anything missing to functionContext
 
+                // Loop through State and add anything missing to functionContext
                 foreach (var item in this.State)
                 {
                     if (!functionContext.Variables.ContainsKey(item.Key))
@@ -252,22 +259,229 @@ public async Task<Plan> InvokeNextStepAsync(SKContext context)
         {
             var step = this.Steps[this.NextStep];
 
-            context = await step.InvokeAsync(context);
+            var functionVariables = this.GetNextStepVariables(context.Variables, step);
+            var functionContext = new SKContext(functionVariables, context.Memory, context.Skills, context.Log, context.CancellationToken);
+
+            var keysToIgnore = functionVariables.Select(x => x.Key).ToList(); // when will there be new keys added? that's output kind of?
 
-            if (context.ErrorOccurred)
+            var result = await step.InvokeAsync(functionContext);
+
+            if (result.ErrorOccurred)
             {
                 throw new KernelException(KernelException.ErrorCodes.FunctionInvokeError,
                     $"Error occurred while running plan step: {context.LastErrorDescription}", context.LastException);
             }
 
+            #region Update State
+            // TODO What does this do?
+            foreach (var (key, _) in functionVariables)
+            {
+                if (!keysToIgnore.Contains(key, StringComparer.InvariantCultureIgnoreCase) && functionVariables.Get(key, out var value))
+                {
+                    this.State.Set(key, value);
+                }
+            }
+
+            // TODO Handle outputs
+            this.State.Update(result.Result.Trim()); // default
+
+            foreach (var item in step.NamedOutputs)
+            {
+                if (string.IsNullOrEmpty(item.Key) || item.Key.ToUpperInvariant() == "INPUT" || string.IsNullOrEmpty(item.Value))
+                {
+                    continue;
+                }
+
+                if (item.Key.ToUpperInvariant() == "RESULT")
+                {
+                    this.State.Set(item.Value, result.Result.Trim());
+                }
+                else if (result.Variables.Get(item.Key, out var value))
+                {
+                    this.State.Set(item.Value, value); // iffy on this one...
+                }
+            }
+            // if (string.IsNullOrEmpty(sequentialPlan.OutputKey))
+            // {
+            //     _ = this.State.Update(result.Result.Trim());
+            // }
+            // else
+            // {
+            //     this.State.Set(sequentialPlan.OutputKey, result.Result.Trim());
+            // }
+
+            // _ = this.State.Update(result.Result.Trim());
+            // if (!string.IsNullOrEmpty(sequentialPlan.OutputKey))
+            // {
+            //     this.State.Set(sequentialPlan.OutputKey, result.Result.Trim());
+            // }
+
+            // if (!string.IsNullOrEmpty(sequentialPlan.ResultKey))
+            // {
+            //     _ = this.State.Get(SkillPlan.ResultKey, out var resultsSoFar);
+            //     this.State.Set(SkillPlan.ResultKey,
+            //         string.Join(Environment.NewLine + Environment.NewLine, resultsSoFar, result.Result.Trim()));
+            // }
+
+            #endregion Update State
+
             this.NextStep++;
-            this.State.Update(context.Result.Trim());
         }
 
         return this;
     }
 
-    internal void SetFunction(ISKFunction function)
+    private ContextVariables GetNextStepVariables(ContextVariables variables, Plan step)
+    {
+        // Initialize function-scoped ContextVariables
+        // Default input should be the Input from the SKContext, or the Input from the Plan.State, or the Plan.Goal
+        var planInput = string.IsNullOrEmpty(variables.Input) ? this.State.Input : variables.Input;
+        var functionInput = string.IsNullOrEmpty(planInput) ? (this.Description ?? string.Empty) : planInput;
+        var functionVariables = new ContextVariables(functionInput);
+
+        // When I execute a plan, it has a State, ContextVariables, and a Goal
+
+        // Priority for functionVariables is:
+        // - NamedParameters (pull from State by a key value)
+        // - Parameters (pull from ContextVariables by name match, backup from State by name match)
+
+
+        var functionParameters = step.Describe();
+        foreach (var param in functionParameters.Parameters)
+        {
+            if (variables.Get(param.Name, out var value) && !string.IsNullOrEmpty(value))
+            {
+                functionVariables.Set(param.Name, value);
+            }
+            else if (this.State.Get(param.Name, out value) && !string.IsNullOrEmpty(value))
+            {
+                functionVariables.Set(param.Name, value);
+            }
+        }
+
+        foreach (var item in step.NamedParameters)
+        {
+            if (item.Value.StartsWith("$", StringComparison.InvariantCultureIgnoreCase))
+            {
+                var attrValues = item.Value.Split(new char[] { ',', ';' }, StringSplitOptions.RemoveEmptyEntries);
+                var attrValueList = new List<string>();
+                foreach (var attrValue in attrValues)
+                {
+                    var attr = attrValue.TrimStart('$');
+                    if (variables.Get(attr, out var value) && !string.IsNullOrEmpty(value))
+                    {
+                        attrValueList.Add(value);
+                    }
+                    else if (this.State.Get(attr, out value) && !string.IsNullOrEmpty(value))
+                    {
+                        attrValueList.Add(value);
+                    }
+                }
+                functionVariables.Set(item.Key, string.Concat(attrValueList));
+            }
+            else
+            {
+                // if (item.Key != "input" && ) // TODO DO we need this?
+                if (!string.IsNullOrEmpty(item.Value))
+                {
+                    functionVariables.Set(item.Key, item.Value);
+                }
+                else if (variables.Get(item.Value, out var value) && !string.IsNullOrEmpty(value))
+                {
+                    functionVariables.Set(item.Key, value);
+                }
+                else if (this.State.Get(item.Value, out value) && !string.IsNullOrEmpty(value))
+                {
+                    functionVariables.Set(item.Key, value);
+                }
+            }
+        }
+
+
+
+
+        // OLD Code -- let's do it better now.
+        // // step.NamedParameters <string, string> e.g. "input": "EMAIL_TO" -- these always come from state (why not variables override as well?)
+
+        // // step.Describe().Parameters <ParameterInfo> e.g. "input"
+        // // Populate as many of the required parameters from the variables, and then the plan State
+
+
+        // var functionParameters = step.Describe();
+        // foreach (var param in functionParameters.Parameters)
+        // {
+        //     // otherwise get it from the state if present
+        //     // todo how was language going through correctly?
+        //     if (variables.Get(param.Name, out var value) && !string.IsNullOrEmpty(value))
+        //     {
+        //         functionVariables.Set(param.Name, value);
+        //     }
+        // }
+
+        // // NameParameters are the parameters that are passed to the function
+        // // These should be pre-populated by the plan, either with a value or a template expression (e.g. $variableName)
+        // // The template expression will be replaced with the value of the variable in the variables or the Plan.State
+        // // If the variable is not found, the template expression will be replaced with an empty string
+        // // Special parameters are:
+        // //  - SetContextVariable: The name of a variable in the variables to set with the result of the function
+        // //  - AppendToResult: The name of a variable in the variables to append the result of the function to
+        // //  - Input: The input to the function. If not specified, the input will be the variables.Input, or the Plan.State.Input, or the Plan.Goal
+        // //  - Output: The output of the function. If not specified, the output will be the variables.Output, or the Plan.State.Output, or the Plan.Result
+        // // Keys that are not associated with function parameters or special parameters will be ignored
+        // foreach (var param in step.NamedParameters)
+        // {
+        //     if (param.Value.StartsWith("$", StringComparison.InvariantCultureIgnoreCase))
+        //     {
+        //         // Split the attribute value on the comma or ; character
+        //         var attrValues = param.Value.Split(new char[] { ',', ';' }, StringSplitOptions.RemoveEmptyEntries);
+        //         if (attrValues.Length > 0)
+        //         {
+        //             // If there are multiple values, create a list of the values
+        //             var attrValueList = new List<string>();
+        //             foreach (var attrValue in attrValues)
+        //             {
+        //                 var variableName = attrValue[1..];
+        //                 if (variables.Get(variableName, out var variableReplacement))
+        //                 {
+        //                     attrValueList.Add(variableReplacement);
+        //                 }
+        //                 else if (this.State.Get(attrValue[1..], out variableReplacement))
+        //                 {
+        //                     attrValueList.Add(variableReplacement);
+        //                 }
+        //             }
+
+        //             if (attrValueList.Count > 0)
+        //             {
+        //                 functionVariables.Set(param.Key, string.Concat(attrValueList));
+        //             }
+        //         }
+        //     }
+        //     else
+        //     {
+        //         // TODO
+        //         // What to do when step.NameParameters conflicts with the current context?
+        //         // Does that only happen with INPUT?
+        //         if (param.Key != "INPUT" || !string.IsNullOrEmpty(param.Value))
+        //         {
+        //             functionVariables.Set(param.Key, param.Value);
+        //         }
+        //         else
+        //         {
+        //             // otherwise get it from the state if present
+        //             // todo how was language going through correctly?
+        //             if (this.State.Get(param.Key, out var value) && !string.IsNullOrEmpty(value))
+        //             {
+        //                 functionVariables.Set(param.Key, value);
+        //             }
+        //         }
+        //     }
+        // }
+
+        return functionVariables;
+    }
+
+    private void SetFunction(ISKFunction function)
     {
         this.Function = function;
         this.Name = function.Name;
diff --git a/dotnet/src/SemanticKernel/Planning/SequentialPlan.cs b/dotnet/src/SemanticKernel/Planning/SequentialPlan.cs
deleted file mode 100644
index a48284ee444e..000000000000
--- a/dotnet/src/SemanticKernel/Planning/SequentialPlan.cs
+++ /dev/null
@@ -1,212 +0,0 @@
-// Copyright (c) Microsoft. All rights reserved.
-
-namespace Microsoft.SemanticKernel.Planning;
-
-// public class SequentialPlan : Plan
-// {
-//     /// <summary>
-//     /// Key used to store the function output of the step in the state
-//     /// </summary>
-//     [JsonPropertyName("output_key")]
-//     public string OutputKey { get; set; } = string.Empty;
-
-//     /// <summary>
-//     /// Key used to store the function output as a plan result in the state
-//     /// </summary>
-//     [JsonPropertyName("result_key")]
-//     public string ResultKey { get; set; } = string.Empty;
-
-//     public SequentialPlan(string goal) : base(goal)
-//     {
-//     }
-
-//     public SequentialPlan(ISKFunction function) : base(function)
-//     {
-//     }
-
-//     protected override async Task<Plan> InvokeNextStepAsync(SKContext context)
-//     {
-//         var nextStep = this.PopNextStep();
-
-//         // todo -- if nextStep.Steps has children, execute them [first]
-//         // Otherwise, execute the function
-
-//         if (nextStep == null)
-//         {
-//             return this;
-//         }
-
-//         var skillName = nextStep.SkillName;
-//         var functionName = nextStep.Name;
-
-//         if (context.IsFunctionRegistered(skillName, functionName, out var skillFunction))
-//         {
-//             if (skillFunction is null)
-//             {
-//                 throw new InvalidOperationException($"Function {skillName}.{functionName} is not registered");
-//             }
-
-//             nextStep.SetFunction(skillFunction);
-
-//             var functionVariables = this.GetNextStepVariables(context.Variables, nextStep);
-
-//             // If a function is registered, we will execute it and remove it from the list
-//             // The functionVariables will be passed to the functions.
-//             var keysToIgnore = functionVariables.Select(x => x.Key).ToList();
-//             // var result = await kernel.RunAsync(functionVariables, context.CancellationToken, skillFunction!);
-//             var functionContext = new SKContext(functionVariables, context.Memory, context.Skills, context.Log, context.CancellationToken);
-//             var result = await skillFunction.InvokeAsync(functionContext);
-
-//             if (result.ErrorOccurred)
-//             {
-//                 throw new InvalidOperationException($"Function {skillName}.{functionName} failed: {result.LastErrorDescription}", result.LastException);
-//             }
-
-//             foreach (var (key, _) in functionVariables)
-//             {
-//                 if (!keysToIgnore.Contains(key, StringComparer.InvariantCultureIgnoreCase) && functionVariables.Get(key, out var value))
-//                 {
-//                     this.State.Set(key, value);
-//                 }
-//             }
-
-//             if (nextStep is SequentialPlan sequentialPlan)
-//             {
-//                 if (string.IsNullOrEmpty(sequentialPlan.OutputKey))
-//                 {
-//                     _ = this.State.Update(result.Result.Trim());
-//                 }
-//                 else
-//                 {
-//                     this.State.Set(sequentialPlan.OutputKey, result.Result.Trim());
-//                 }
-
-//                 _ = this.State.Update(result.Result.Trim());
-//                 if (!string.IsNullOrEmpty(sequentialPlan.OutputKey))
-//                 {
-//                     this.State.Set(sequentialPlan.OutputKey, result.Result.Trim());
-//                 }
-
-//                 if (!string.IsNullOrEmpty(sequentialPlan.ResultKey))
-//                 {
-//                     _ = this.State.Get(SkillPlan.ResultKey, out var resultsSoFar);
-//                     this.State.Set(SkillPlan.ResultKey,
-//                         string.Join(Environment.NewLine + Environment.NewLine, resultsSoFar, result.Result.Trim()));
-//                 }
-//             }
-//             else
-//             {
-//                 this.State.Update(result.Result.Trim());
-//             }
-
-//             return this;
-//         }
-//         else
-//         {
-//             throw new InvalidOperationException($"Function {skillName}.{functionName} is not registered");
-//         }
-//     }
-
-//     private ContextVariables GetNextStepVariables(ContextVariables variables, Plan step)
-//     {
-//         // Initialize function-scoped ContextVariables
-//         // Default input should be the Input from the SKContext, or the Input from the Plan.State, or the Plan.Goal
-//         var planInput = string.IsNullOrEmpty(variables.Input) ? this.State.Input : variables.Input;
-//         var functionInput = string.IsNullOrEmpty(planInput) ? (this.Steps.FirstOrDefault()?.Description ?? string.Empty) : planInput;
-//         var functionVariables = new ContextVariables(functionInput);
-
-//         var functionParameters = step.Describe();
-//         foreach (var param in functionParameters.Parameters)
-//         {
-//             // otherwise get it from the state if present
-//             // todo how was language going through correctly?
-//             if (variables.Get(param.Name, out var value) && !string.IsNullOrEmpty(value))
-//             {
-//                 functionVariables.Set(param.Name, value);
-//             }
-//         }
-
-//         // NameParameters are the parameters that are passed to the function
-//         // These should be pre-populated by the plan, either with a value or a template expression (e.g. $variableName)
-//         // The template expression will be replaced with the value of the variable in the variables or the Plan.State
-//         // If the variable is not found, the template expression will be replaced with an empty string
-//         // Special parameters are:
-//         //  - SetContextVariable: The name of a variable in the variables to set with the result of the function
-//         //  - AppendToResult: The name of a variable in the variables to append the result of the function to
-//         //  - Input: The input to the function. If not specified, the input will be the variables.Input, or the Plan.State.Input, or the Plan.Goal
-//         //  - Output: The output of the function. If not specified, the output will be the variables.Output, or the Plan.State.Output, or the Plan.Result
-//         // Keys that are not associated with function parameters or special parameters will be ignored
-//         foreach (var param in step.NamedParameters)
-//         {
-//             if (param.Value.StartsWith("$", StringComparison.InvariantCultureIgnoreCase))
-//             {
-//                 // Split the attribute value on the comma or ; character
-//                 var attrValues = param.Value.Split(new char[] { ',', ';' }, StringSplitOptions.RemoveEmptyEntries);
-//                 if (attrValues.Length > 0)
-//                 {
-//                     // If there are multiple values, create a list of the values
-//                     var attrValueList = new List<string>();
-//                     foreach (var attrValue in attrValues)
-//                     {
-//                         var variableName = attrValue[1..];
-//                         if (variables.Get(variableName, out var variableReplacement))
-//                         {
-//                             attrValueList.Add(variableReplacement);
-//                         }
-//                         else if (this.State.Get(attrValue[1..], out variableReplacement))
-//                         {
-//                             attrValueList.Add(variableReplacement);
-//                         }
-//                     }
-
-//                     if (attrValueList.Count > 0)
-//                     {
-//                         functionVariables.Set(param.Key, string.Concat(attrValueList));
-//                     }
-//                 }
-//             }
-//             else
-//             {
-//                 // TODO
-//                 // What to do when step.NameParameters conflicts with the current context?
-//                 // Does that only happen with INPUT?
-//                 if (param.Key != "INPUT" || !string.IsNullOrEmpty(param.Value))
-//                 {
-//                     functionVariables.Set(param.Key, param.Value);
-//                 }
-//                 else
-//                 {
-//                     // otherwise get it from the state if present
-//                     // todo how was language going through correctly?
-//                     if (this.State.Get(param.Key, out var value) && !string.IsNullOrEmpty(value))
-//                     {
-//                         functionVariables.Set(param.Key, value);
-//                     }
-//                 }
-//             }
-//         }
-
-//         return functionVariables;
-//     }
-
-//     private Plan? PopNextStep()
-//     {
-//         // var step = this.Steps.First();
-//         // var parent = step;
-//         // while (step.Steps.Count > 0)
-//         // {
-//         //     step = step.Steps[0];
-//         //     parent.Steps.RemoveAt(0); // TODO Does this do what I want? has this.Steps changed?
-//         // }
-
-//         // If we have a children steps, pop from there. Do not worry about nested for now.
-//         if (this.Steps.Count > 0)
-//         {
-//             var step = this.Steps[0];
-//             this.Steps.RemoveAt(0);
-//             return step;
-//         }
-
-//         return this;
-//     }
-// }

From 5b7c978c8a788cac2c37feb9804ec51aaedd5490 Mon Sep 17 00:00:00 2001
From: "lemiller@microsoft.com" <lemiller@microsoft.com>
Date: Fri, 7 Apr 2023 16:06:30 -0700
Subject: [PATCH 4/4] UT test failures -- likely some bugs!

---
 dotnet/src/SemanticKernel.UnitTests/Orchestration/PlanTests.cs | 2 ++
 1 file changed, 2 insertions(+)

diff --git a/dotnet/src/SemanticKernel.UnitTests/Orchestration/PlanTests.cs b/dotnet/src/SemanticKernel.UnitTests/Orchestration/PlanTests.cs
index 5b23ef57b84b..5a560b6a5ca1 100644
--- a/dotnet/src/SemanticKernel.UnitTests/Orchestration/PlanTests.cs
+++ b/dotnet/src/SemanticKernel.UnitTests/Orchestration/PlanTests.cs
@@ -326,6 +326,7 @@ public async Task CanStepPlanWithStepsAndContextAsync()
 
         // Assert
         Assert.NotNull(plan);
+        // TODO another UT failure catching a bug
         Assert.Equal($"{stepOutput}{planInput}foo", plan.State.ToString());
 
         // Act
@@ -464,6 +465,7 @@ public async Task CanExecutePanWithTreeStepsAsync()
 
         // Assert
         Assert.NotNull(plan);
+        // TODO GOod this UT caught a bug, we're being a little too loose with input getting overwritten.
         Assert.Equal($"Child 3 heard Child 2 is happy about Child 1 output! - this just happened.", plan.State.ToString());
         nodeFunction1.Verify(x => x.InvokeAsync(It.IsAny<SKContext>(), null, null, null), Times.Once);
         childFunction1.Verify(x => x.InvokeAsync(It.IsAny<SKContext>(), null, null, null), Times.Once);