chore: import upstream snapshot with attribution

dotnet/samples/04-hosting/DurableAgents/AzureFunctions/02_AgentOrchestration_Chaining/02_AgentOrchestration_Chaining.csproj

@@ -0,0 +1,42 @@
+<Project Sdk="Microsoft.NET.Sdk">
+  <PropertyGroup>
+    <TargetFrameworks>net10.0</TargetFrameworks>
+    <AzureFunctionsVersion>v4</AzureFunctionsVersion>
+    <OutputType>Exe</OutputType>
+    <ImplicitUsings>enable</ImplicitUsings>
+    <Nullable>enable</Nullable>
+    <!-- The Functions build tools don't like namespaces that start with a number -->
+    <AssemblyName>AgentOrchestration_Chaining</AssemblyName>
+    <RootNamespace>AgentOrchestration_Chaining</RootNamespace>
+  </PropertyGroup>
+
+  <ItemGroup>
+    <FrameworkReference Include="Microsoft.AspNetCore.App" />
+  </ItemGroup>
+
+  <!-- Azure Functions packages -->
+  <ItemGroup>
+    <PackageReference Include="Microsoft.Azure.Functions.Worker" />
+    <PackageReference Include="Microsoft.Azure.Functions.Worker.Extensions.DurableTask" />
+    <PackageReference Include="Microsoft.Azure.Functions.Worker.Extensions.DurableTask.AzureManaged" />
+    <PackageReference Include="Microsoft.Azure.Functions.Worker.Extensions.Http.AspNetCore" />
+    <PackageReference Include="Microsoft.Azure.Functions.Worker.Sdk" />
+  </ItemGroup>
+
+  <ItemGroup>
+    <PackageReference Include="Azure.AI.OpenAI" />
+    <PackageReference Include="Azure.Identity" />
+  </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.Hosting.AzureFunctions" />
+    <PackageReference Include="Microsoft.Agents.AI.OpenAI" />
+  </ItemGroup>
+  -->
+  <ItemGroup>
+    <ProjectReference Include="..\..\..\..\..\src\Microsoft.Agents.AI.Hosting.AzureFunctions\Microsoft.Agents.AI.Hosting.AzureFunctions.csproj" />
+    <ProjectReference Include="..\..\..\..\..\src\Microsoft.Agents.AI.OpenAI\Microsoft.Agents.AI.OpenAI.csproj" />
+  </ItemGroup>
+</Project>

dotnet/samples/04-hosting/DurableAgents/AzureFunctions/02_AgentOrchestration_Chaining/FunctionTriggers.cs

@@ -0,0 +1,92 @@
+// Copyright (c) Microsoft. All rights reserved.
+
+using System.Net;
+using System.Text.Json;
+using Microsoft.Agents.AI;
+using Microsoft.Agents.AI.DurableTask;
+using Microsoft.Azure.Functions.Worker;
+using Microsoft.Azure.Functions.Worker.Http;
+using Microsoft.DurableTask;
+using Microsoft.DurableTask.Client;
+
+namespace AgentOrchestration_Chaining;
+
+public static class FunctionTriggers
+{
+    public sealed record TextResponse(string Text);
+
+    [Function(nameof(RunOrchestrationAsync))]
+    public static async Task<string> RunOrchestrationAsync([OrchestrationTrigger] 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;
+    }
+
+    // POST /singleagent/run
+    [Function(nameof(StartOrchestrationAsync))]
+    public static async Task<HttpResponseData> StartOrchestrationAsync(
+        [HttpTrigger(AuthorizationLevel.Anonymous, "post", Route = "singleagent/run")] HttpRequestData req,
+        [DurableClient] DurableTaskClient client)
+    {
+        string instanceId = await client.ScheduleNewOrchestrationInstanceAsync(
+            orchestratorName: nameof(RunOrchestrationAsync));
+
+        HttpResponseData response = req.CreateResponse(HttpStatusCode.Accepted);
+        await response.WriteAsJsonAsync(new
+        {
+            message = "Single-agent orchestration started.",
+            instanceId,
+            statusQueryGetUri = GetStatusQueryGetUri(req, instanceId),
+        });
+        return response;
+    }
+
+    // GET /singleagent/status/{instanceId}
+    [Function(nameof(GetOrchestrationStatusAsync))]
+    public static async Task<HttpResponseData> GetOrchestrationStatusAsync(
+        [HttpTrigger(AuthorizationLevel.Anonymous, "get", Route = "singleagent/status/{instanceId}")] HttpRequestData req,
+        string instanceId,
+        [DurableClient] DurableTaskClient client)
+    {
+        OrchestrationMetadata? status = await client.GetInstanceAsync(
+            instanceId,
+            getInputsAndOutputs: true,
+            req.FunctionContext.CancellationToken);
+
+        if (status is null)
+        {
+            HttpResponseData notFound = req.CreateResponse(HttpStatusCode.NotFound);
+            await notFound.WriteAsJsonAsync(new { error = "Instance not found" });
+            return notFound;
+        }
+
+        HttpResponseData response = req.CreateResponse(HttpStatusCode.OK);
+        await response.WriteAsJsonAsync(new
+        {
+            instanceId = status.InstanceId,
+            runtimeStatus = status.RuntimeStatus.ToString(),
+            input = status.SerializedInput is not null ? (object)status.ReadInputAs<JsonElement>() : null,
+            output = status.SerializedOutput is not null ? (object)status.ReadOutputAs<JsonElement>() : null,
+            failureDetails = status.FailureDetails
+        });
+        return response;
+    }
+
+    private static string GetStatusQueryGetUri(HttpRequestData req, string instanceId)
+    {
+        // NOTE: This can be made more robust by considering the value of
+        //       request headers like "X-Forwarded-Host" and "X-Forwarded-Proto".
+        string authority = $"{req.Url.Scheme}://{req.Url.Authority}";
+        return $"{authority}/api/singleagent/status/{instanceId}";
+    }
+}

dotnet/samples/04-hosting/DurableAgents/AzureFunctions/02_AgentOrchestration_Chaining/Program.cs

@@ -0,0 +1,45 @@
+// Copyright (c) Microsoft. All rights reserved.
+
+#pragma warning disable IDE0002 // Simplify Member Access
+
+using Azure;
+using Azure.AI.OpenAI;
+using Azure.Identity;
+using Microsoft.Agents.AI;
+using Microsoft.Agents.AI.Hosting.AzureFunctions;
+using Microsoft.Azure.Functions.Worker.Builder;
+using Microsoft.Extensions.Hosting;
+using OpenAI.Chat;
+
+// 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.");
+
+// Use Azure Key Credential if provided, otherwise use Azure CLI Credential.
+string? azureOpenAiKey = System.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);
+
+using IHost app = FunctionsApplication
+    .CreateBuilder(args)
+    .ConfigureFunctionsWebApplication()
+    .ConfigureDurableAgents(options => options.AddAIAgent(writerAgent))
+    .Build();
+
+app.Run();

dotnet/samples/04-hosting/DurableAgents/AzureFunctions/02_AgentOrchestration_Chaining/README.md

@@ -0,0 +1,59 @@
+# Single Agent Orchestration Sample
+
+This sample demonstrates how to use the Durable Agent Framework (DAFx) to create a simple Azure Functions 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
+- HTTP API integration for starting and monitoring orchestrations
+
+## 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 and function app running, you can test the sample by sending an HTTP request to start the orchestration.
+
+You can use the `demo.http` file to start the orchestration, or a command line tool like `curl` as shown below:
+
+Bash (Linux/macOS/WSL):
+
+```bash
+curl -X POST http://localhost:7071/api/singleagent/run
+```
+
+PowerShell:
+
+```powershell
+Invoke-RestMethod -Method Post -Uri http://localhost:7071/api/singleagent/run
+```
+
+The response will be a JSON object that looks something like the following, which indicates that the orchestration has started.
+
+```json
+{
+  "message": "Single-agent orchestration started.",
+  "instanceId": "86313f1d45fb42eeb50b1852626bf3ff",
+  "statusQueryGetUri": "http://localhost:7071/api/singleagent/status/86313f1d45fb42eeb50b1852626bf3ff"
+}
+```
+
+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
+
+Once the orchestration has completed, you can get the status of the orchestration by sending a GET request to the `statusQueryGetUri` URL. The response will be a JSON object that looks something like the following:
+
+```json
+{
+    "failureDetails": null,
+    "input": null,
+    "instanceId": "86313f1d45fb42eeb50b1852626bf3ff",
+    "output": "Learning serves as the key, opening doors to boundless opportunities and a brighter future.",
+    "runtimeStatus": "Completed"
+}
+```

dotnet/samples/04-hosting/DurableAgents/AzureFunctions/02_AgentOrchestration_Chaining/demo.http

@@ -0,0 +1,3 @@
+### Start the single-agent orchestration
+POST http://localhost:7071/api/singleagent/run
+

dotnet/samples/04-hosting/DurableAgents/AzureFunctions/02_AgentOrchestration_Chaining/host.json

@@ -0,0 +1,20 @@
+{
+  "version": "2.0",
+  "logging": {
+    "logLevel": {
+      "Microsoft.Agents.AI.DurableTask": "Information",
+      "Microsoft.Agents.AI.Hosting.AzureFunctions": "Information",
+      "DurableTask": "Information",
+      "Microsoft.DurableTask": "Information"
+    }
+  },
+  "extensions": {
+    "durableTask": {
+      "hubName": "default",
+      "storageProvider": {
+        "type": "AzureManaged",
+        "connectionStringName": "DURABLE_TASK_SCHEDULER_CONNECTION_STRING"
+      }
+    }
+  }
+}