chore: import upstream snapshot with attribution

2026-07-13 13:39:25 +08:00
commit db620d33df
5151 changed files with 925932 additions and 0 deletions
@@ -0,0 +1,30 @@
+<Project Sdk="Microsoft.NET.Sdk">
+  <PropertyGroup>
+    <TargetFrameworks>net10.0</TargetFrameworks>
+    <OutputType>Exe</OutputType>
+    <ImplicitUsings>enable</ImplicitUsings>
+    <Nullable>enable</Nullable>
+    <AssemblyName>AgentOrchestration_Chaining</AssemblyName>
+    <RootNamespace>AgentOrchestration_Chaining</RootNamespace>
+  </PropertyGroup>
+
+  <ItemGroup>
+    <PackageReference Include="Azure.AI.OpenAI" />
+    <PackageReference Include="Azure.Identity" />
+    <PackageReference Include="Microsoft.DurableTask.Client.AzureManaged" />
+    <PackageReference Include="Microsoft.DurableTask.Worker.AzureManaged" />
+    <PackageReference Include="Microsoft.Extensions.Hosting" />
+  </ItemGroup>
+
+  <!-- Local projects that should be switched to package references when using the sample outside of this MAF repo -->
+  <!--
+  <ItemGroup>
+    <PackageReference Include="Microsoft.Agents.AI.DurableTask" />
+    <PackageReference Include="Microsoft.Agents.AI.OpenAI" />
+  </ItemGroup>
+  -->
+  <ItemGroup>
+    <ProjectReference Include="..\..\..\..\..\src\Microsoft.Agents.AI.DurableTask\Microsoft.Agents.AI.DurableTask.csproj" />
+    <ProjectReference Include="..\..\..\..\..\src\Microsoft.Agents.AI.OpenAI\Microsoft.Agents.AI.OpenAI.csproj" />
+  </ItemGroup>
+</Project>
@@ -0,0 +1,6 @@
+// Copyright (c) Microsoft. All rights reserved.
+
+namespace AgentOrchestration_Chaining;
+
+// Response model
+public sealed record TextResponse(string Text);
@@ -0,0 +1,151 @@
+// Copyright (c) Microsoft. All rights reserved.
+
+using AgentOrchestration_Chaining;
+using Azure;
+using Azure.AI.OpenAI;
+using Azure.Identity;
+using Microsoft.Agents.AI;
+using Microsoft.Agents.AI.DurableTask;
+using Microsoft.DurableTask;
+using Microsoft.DurableTask.Client;
+using Microsoft.DurableTask.Client.AzureManaged;
+using Microsoft.DurableTask.Worker;
+using Microsoft.DurableTask.Worker.AzureManaged;
+using Microsoft.Extensions.DependencyInjection;
+using Microsoft.Extensions.Hosting;
+using Microsoft.Extensions.Logging;
+using OpenAI.Chat;
+using Environment = System.Environment;
+
+// Get the Azure OpenAI endpoint and deployment name from environment variables.
+string endpoint = Environment.GetEnvironmentVariable("AZURE_OPENAI_ENDPOINT")
+    ?? throw new InvalidOperationException("AZURE_OPENAI_ENDPOINT is not set.");
+string deploymentName = Environment.GetEnvironmentVariable("AZURE_OPENAI_DEPLOYMENT_NAME")
+    ?? throw new InvalidOperationException("AZURE_OPENAI_DEPLOYMENT_NAME is not set.");
+
+// Get DTS connection string from environment variable
+string dtsConnectionString = Environment.GetEnvironmentVariable("DURABLE_TASK_SCHEDULER_CONNECTION_STRING")
+    ?? "Endpoint=http://localhost:8080;TaskHub=default;Authentication=None";
+
+// Use Azure Key Credential if provided, otherwise use Azure CLI Credential.
+string? azureOpenAiKey = Environment.GetEnvironmentVariable("AZURE_OPENAI_API_KEY");
+// WARNING: DefaultAzureCredential is convenient for development but requires careful consideration in production.
+// In production, consider using a specific credential (e.g., ManagedIdentityCredential) to avoid
+// latency issues, unintended credential probing, and potential security risks from fallback mechanisms.
+AzureOpenAIClient client = !string.IsNullOrEmpty(azureOpenAiKey)
+    ? new AzureOpenAIClient(new Uri(endpoint), new AzureKeyCredential(azureOpenAiKey))
+    : new AzureOpenAIClient(new Uri(endpoint), new DefaultAzureCredential());
+
+// Single agent used by the orchestration to demonstrate sequential calls on the same session.
+const string WriterName = "WriterAgent";
+const string WriterInstructions =
+    """
+    You refine short pieces of text. When given an initial sentence you enhance it;
+    when given an improved sentence you polish it further.
+    """;
+
+AIAgent writerAgent = client.GetChatClient(deploymentName).AsAIAgent(WriterInstructions, WriterName);
+
+// Orchestrator function
+static async Task<string> RunOrchestratorAsync(TaskOrchestrationContext context)
+{
+    DurableAIAgent writer = context.GetAgent("WriterAgent");
+    AgentSession writerSession = await writer.CreateSessionAsync();
+
+    AgentResponse<TextResponse> initial = await writer.RunAsync<TextResponse>(
+        message: "Write a concise inspirational sentence about learning.",
+        session: writerSession);
+
+    AgentResponse<TextResponse> refined = await writer.RunAsync<TextResponse>(
+        message: $"Improve this further while keeping it under 25 words: {initial.Result.Text}",
+        session: writerSession);
+
+    return refined.Result.Text;
+}
+
+// Configure the console app to host the AI agent.
+IHost host = Host.CreateDefaultBuilder(args)
+    .ConfigureLogging(loggingBuilder => loggingBuilder.SetMinimumLevel(LogLevel.Warning))
+    .ConfigureServices(services =>
+    {
+        services.ConfigureDurableAgents(
+            options => options.AddAIAgent(writerAgent),
+            workerBuilder: builder =>
+            {
+                builder.UseDurableTaskScheduler(dtsConnectionString);
+                builder.AddTasks(registry => registry.AddOrchestratorFunc(nameof(RunOrchestratorAsync), RunOrchestratorAsync));
+            },
+            clientBuilder: builder => builder.UseDurableTaskScheduler(dtsConnectionString));
+    })
+    .Build();
+
+await host.StartAsync();
+
+DurableTaskClient durableClient = host.Services.GetRequiredService<DurableTaskClient>();
+
+// Console colors for better UX
+Console.ForegroundColor = ConsoleColor.Cyan;
+Console.WriteLine("=== Single Agent Orchestration Chaining Sample ===");
+Console.ResetColor();
+Console.WriteLine("Starting orchestration...");
+Console.WriteLine();
+
+try
+{
+    // Start the orchestration
+    string instanceId = await durableClient.ScheduleNewOrchestrationInstanceAsync(
+        orchestratorName: nameof(RunOrchestratorAsync));
+
+    Console.ForegroundColor = ConsoleColor.Gray;
+    Console.WriteLine($"Orchestration started with instance ID: {instanceId}");
+    Console.WriteLine("Waiting for completion...");
+    Console.ResetColor();
+
+    // Wait for orchestration to complete
+    OrchestrationMetadata status = await durableClient.WaitForInstanceCompletionAsync(
+        instanceId,
+        getInputsAndOutputs: true,
+        CancellationToken.None);
+
+    Console.WriteLine();
+
+    if (status.RuntimeStatus == OrchestrationRuntimeStatus.Completed)
+    {
+        Console.ForegroundColor = ConsoleColor.Green;
+        Console.WriteLine("✓ Orchestration completed successfully!");
+        Console.ResetColor();
+        Console.WriteLine();
+        Console.ForegroundColor = ConsoleColor.Yellow;
+        Console.Write("Result: ");
+        Console.ResetColor();
+        Console.WriteLine(status.ReadOutputAs<string>());
+    }
+    else if (status.RuntimeStatus == OrchestrationRuntimeStatus.Failed)
+    {
+        Console.ForegroundColor = ConsoleColor.Red;
+        Console.WriteLine("✗ Orchestration failed!");
+        Console.ResetColor();
+        if (status.FailureDetails != null)
+        {
+            Console.WriteLine($"Error: {status.FailureDetails.ErrorMessage}");
+        }
+        Environment.Exit(1);
+    }
+    else
+    {
+        Console.ForegroundColor = ConsoleColor.Yellow;
+        Console.WriteLine($"Orchestration status: {status.RuntimeStatus}");
+        Console.ResetColor();
+    }
+}
+catch (Exception ex)
+{
+    Console.ForegroundColor = ConsoleColor.Red;
+    Console.Error.WriteLine($"Error: {ex.Message}");
+    Console.ResetColor();
+    Environment.Exit(1);
+}
+finally
+{
+    await host.StopAsync();
+}
@@ -0,0 +1,53 @@
+# Single Agent Orchestration Sample
+
+This sample demonstrates how to use the durable agents extension to create a simple console app that orchestrates sequential calls to a single AI agent using the same session for context continuity.
+
+## Key Concepts Demonstrated
+
+- Orchestrating multiple interactions with the same agent in a deterministic order
+- Using the same `AgentSession` across multiple calls to maintain conversational context
+- Durable orchestration with automatic checkpointing and resumption from failures
+- Waiting for orchestration completion using `WaitForInstanceCompletionAsync`
+
+## Environment Setup
+
+See the [README.md](../README.md) file in the parent directory for more information on how to configure the environment, including how to install and run common sample dependencies.
+
+## Running the Sample
+
+With the environment setup, you can run the sample:
+
+```bash
+cd dotnet/samples/04-hosting/DurableAgents/ConsoleApps/02_AgentOrchestration_Chaining
+dotnet run --framework net10.0
+```
+
+The app will start the orchestration, wait for it to complete, and display the result:
+
+```text
+=== Single Agent Orchestration Chaining Sample ===
+Starting orchestration...
+
+Orchestration started with instance ID: 86313f1d45fb42eeb50b1852626bf3ff
+Waiting for completion...
+
+✓ Orchestration completed successfully!
+
+Result: Learning serves as the key, opening doors to boundless opportunities and a brighter future.
+```
+
+The orchestration will proceed to run the WriterAgent twice in sequence:
+
+1. First, it writes an inspirational sentence about learning
+2. Then, it refines the initial output using the same conversation thread
+
+## Viewing Orchestration State
+
+You can view the state of the orchestration in the Durable Task Scheduler dashboard:
+
+1. Open your browser and navigate to `http://localhost:8082`
+2. In the dashboard, you can see:
+   - **Orchestrations**: View the orchestration instance, including its runtime status, input, output, and execution history
+   - **Agents**: View the state of the WriterAgent, including conversation history maintained across the orchestration steps
+
+The orchestration instance ID is displayed in the console output. You can use this ID to find the specific orchestration in the dashboard and inspect its execution details, including the sequence of agent calls and their results.