chore: import upstream snapshot with attribution

dotnet/tests/Microsoft.Agents.AI.Hosting.AzureFunctions.UnitTests/BuiltInFunctionsWorkflowRoutingTests.cs

@@ -0,0 +1,52 @@
+// Copyright (c) Microsoft. All rights reserved.
+
+namespace Microsoft.Agents.AI.Hosting.AzureFunctions.UnitTests;
+
+public sealed class BuiltInFunctionsWorkflowRoutingTests
+{
+    [Theory]
+    [InlineData("http-MyWorkflow-status", "-status", "MyWorkflow")]
+    [InlineData("http-OrderProcessor-status", "-status", "OrderProcessor")]
+    [InlineData("http-MyWorkflow-respond", "-respond", "MyWorkflow")]
+    [InlineData("http-Multi-Dash-Name-status", "-status", "Multi-Dash-Name")]
+    public void GetWorkflowName_ReturnsCorrectName(string functionName, string suffix, string expectedWorkflowName)
+    {
+        // Act
+        string result = BuiltInFunctions.GetWorkflowName(functionName, suffix);
+
+        // Assert
+        Assert.Equal(expectedWorkflowName, result);
+    }
+
+    [Theory]
+    [InlineData("invalid-name", "-status")]
+    [InlineData("http-MyWorkflow-respond", "-status")] // wrong suffix
+    [InlineData("mcptool-MyWorkflow-status", "-status")] // wrong prefix
+    public void GetWorkflowName_ThrowsForInvalidPattern(string functionName, string suffix)
+    {
+        // Act & Assert
+        Assert.Throws<InvalidOperationException>(() =>
+            BuiltInFunctions.GetWorkflowName(functionName, suffix));
+    }
+
+    [Theory]
+    [InlineData("dafx-MyWorkflow", "http-MyWorkflow-status", "-status", true)]
+    [InlineData("dafx-MyWorkflow", "http-MyWorkflow-respond", "-respond", true)]
+    [InlineData("dafx-myworkflow", "http-MyWorkflow-status", "-status", true)] // case-insensitive
+    [InlineData("dafx-MYWORKFLOW", "http-MyWorkflow-respond", "-respond", true)] // case-insensitive
+    [InlineData("dafx-OtherWorkflow", "http-MyWorkflow-status", "-status", false)] // cross-workflow
+    [InlineData("dafx-PrivilegedWorkflow", "http-PublicWorkflow-status", "-status", false)] // attack scenario
+    [InlineData("dafx-PrivilegedWorkflow", "http-PublicWorkflow-respond", "-respond", false)] // attack scenario
+    public void IsOrchestrationOwnedByWorkflow_ValidatesCorrectly(
+        string orchestrationName,
+        string functionName,
+        string suffix,
+        bool expectedResult)
+    {
+        // Act
+        bool result = BuiltInFunctions.IsOrchestrationOwnedByWorkflow(orchestrationName, functionName, suffix);
+
+        // Assert
+        Assert.Equal(expectedResult, result);
+    }
+}

dotnet/tests/Microsoft.Agents.AI.Hosting.AzureFunctions.UnitTests/DurableAgentFunctionMetadataTransformerTests.cs

@@ -0,0 +1,225 @@
+// Copyright (c) Microsoft. All rights reserved.
+
+using System.Diagnostics.CodeAnalysis;
+using Microsoft.Azure.Functions.Worker.Core.FunctionMetadata;
+using Microsoft.Extensions.Logging.Abstractions;
+
+namespace Microsoft.Agents.AI.Hosting.AzureFunctions.UnitTests;
+
+public sealed class DurableAgentFunctionMetadataTransformerTests
+{
+    [Theory]
+    [InlineData(0, false, false, 1)] // entity only
+    [InlineData(0, true, false, 2)] // entity + http
+    [InlineData(0, false, true, 2)] // entity + mcp tool
+    [InlineData(0, true, true, 3)] // entity + http + mcp tool
+    [InlineData(3, true, true, 3)] // entity + http + mcp tool added to existing
+    public void Transform_AddsAgentAndHttpTriggers_ForEachAgent(
+        int initialMetadataEntryCount,
+        bool enableHttp,
+        bool enableMcp,
+        int expectedMetadataCount)
+    {
+        // Arrange
+        Dictionary<string, Func<IServiceProvider, AIAgent>> agents = new()
+        {
+            { "testAgent", _ => new TestAgent("testAgent", "Test agent description") }
+        };
+
+        FunctionsAgentOptions options = new();
+
+        options.HttpTrigger.IsEnabled = enableHttp;
+        options.McpToolTrigger.IsEnabled = enableMcp;
+
+        IFunctionsAgentOptionsProvider agentOptionsProvider = new FakeOptionsProvider(new Dictionary<string, FunctionsAgentOptions>
+        {
+            { "testAgent", options }
+        });
+
+        List<IFunctionMetadata> metadataList = BuildFunctionMetadataList(initialMetadataEntryCount);
+
+        DurableAgentFunctionMetadataTransformer transformer = new(
+            agents,
+            NullLogger<DurableAgentFunctionMetadataTransformer>.Instance,
+            new FakeServiceProvider(),
+            agentOptionsProvider);
+
+        // Act
+        transformer.Transform(metadataList);
+
+        // Assert
+        Assert.Equal(initialMetadataEntryCount + expectedMetadataCount, metadataList.Count);
+
+        DefaultFunctionMetadata agentTrigger = Assert.IsType<DefaultFunctionMetadata>(metadataList[initialMetadataEntryCount]);
+        Assert.Equal("dafx-testAgent", agentTrigger.Name);
+        Assert.Contains("entityTrigger", agentTrigger.RawBindings![0]);
+
+        if (enableHttp)
+        {
+            DefaultFunctionMetadata httpTrigger = Assert.IsType<DefaultFunctionMetadata>(metadataList[initialMetadataEntryCount + 1]);
+            Assert.Equal("http-testAgent", httpTrigger.Name);
+            Assert.Contains("httpTrigger", httpTrigger.RawBindings![0]);
+        }
+
+        if (enableMcp)
+        {
+            int mcpIndex = initialMetadataEntryCount + (enableHttp ? 2 : 1);
+            DefaultFunctionMetadata mcpToolTrigger = Assert.IsType<DefaultFunctionMetadata>(metadataList[mcpIndex]);
+            Assert.Equal("mcptool-testAgent", mcpToolTrigger.Name);
+            Assert.Contains("mcpToolTrigger", mcpToolTrigger.RawBindings![0]);
+        }
+    }
+
+    [Fact]
+    public void Transform_AddsTriggers_ForMultipleAgents()
+    {
+        // Arrange
+        Dictionary<string, Func<IServiceProvider, AIAgent>> agents = new()
+        {
+            { "agentA", _ => new TestAgent("testAgentA", "Test agent description") },
+            { "agentB", _ => new TestAgent("testAgentB", "Test agent description") },
+            { "agentC", _ => new TestAgent("testAgentC", "Test agent description") }
+        };
+
+        // Helper to create options with configurable triggers
+        static FunctionsAgentOptions CreateFunctionsAgentOptions(bool httpEnabled, bool mcpEnabled)
+        {
+            FunctionsAgentOptions options = new();
+            options.HttpTrigger.IsEnabled = httpEnabled;
+            options.McpToolTrigger.IsEnabled = mcpEnabled;
+            return options;
+        }
+
+        FunctionsAgentOptions agentOptionsA = CreateFunctionsAgentOptions(true, false);
+        FunctionsAgentOptions agentOptionsB = CreateFunctionsAgentOptions(true, true);
+        FunctionsAgentOptions agentOptionsC = CreateFunctionsAgentOptions(true, true);
+
+        Dictionary<string, FunctionsAgentOptions> functionsAgentOptions = new()
+        {
+            { "agentA", agentOptionsA },
+            { "agentB", agentOptionsB },
+            { "agentC", agentOptionsC }
+        };
+
+        IFunctionsAgentOptionsProvider agentOptionsProvider = new FakeOptionsProvider(functionsAgentOptions);
+        DurableAgentFunctionMetadataTransformer transformer = new(
+            agents,
+            NullLogger<DurableAgentFunctionMetadataTransformer>.Instance,
+            new FakeServiceProvider(),
+            agentOptionsProvider);
+
+        const int InitialMetadataEntryCount = 2;
+        List<IFunctionMetadata> metadataList = BuildFunctionMetadataList(InitialMetadataEntryCount);
+
+        // Act
+        transformer.Transform(metadataList);
+
+        // Assert
+        Assert.Equal(InitialMetadataEntryCount + (agents.Count * 2) + 2, metadataList.Count);
+
+        foreach (string agentName in agents.Keys)
+        {
+            // The agent's entity trigger name is prefixed with "dafx-"
+            DefaultFunctionMetadata entityMeta =
+                Assert.IsType<DefaultFunctionMetadata>(
+                    Assert.Single(metadataList, m => m.Name == $"dafx-{agentName}"));
+            Assert.NotNull(entityMeta.RawBindings);
+            Assert.Contains("entityTrigger", entityMeta.RawBindings[0]);
+
+            DefaultFunctionMetadata httpMeta =
+                Assert.IsType<DefaultFunctionMetadata>(
+                    Assert.Single(metadataList, m => m.Name == $"http-{agentName}"));
+            Assert.NotNull(httpMeta.RawBindings);
+            Assert.Contains("httpTrigger", httpMeta.RawBindings[0]);
+            Assert.Contains($"agents/{agentName}/run", httpMeta.RawBindings[0]);
+
+            // We expect 2 mcp tool triggers only for agentB and agentC
+            if (agentName is "agentB" or "agentC")
+            {
+                DefaultFunctionMetadata? mcpToolMeta =
+                    Assert.Single(metadataList, m => m.Name == $"mcptool-{agentName}") as DefaultFunctionMetadata;
+                Assert.NotNull(mcpToolMeta);
+                Assert.NotNull(mcpToolMeta.RawBindings);
+                Assert.Equal(4, mcpToolMeta.RawBindings.Count);
+                Assert.Contains("mcpToolTrigger", mcpToolMeta.RawBindings[0]);
+                Assert.Contains("mcpToolProperty", mcpToolMeta.RawBindings[1]); // We expect 2 tool property bindings
+                Assert.Contains("mcpToolProperty", mcpToolMeta.RawBindings[2]);
+            }
+        }
+    }
+
+    [Fact]
+    public void Transform_SkipsAgents_WithoutExplicitOptions()
+    {
+        // Arrange: two agents in the dictionary, but only one has explicit FunctionsAgentOptions.
+        // This simulates a workflow-auto-registered agent (workflowAgent) alongside a standalone agent.
+        Dictionary<string, Func<IServiceProvider, AIAgent>> agents = new()
+        {
+            { "standaloneAgent", _ => new TestAgent("standaloneAgent", "Standalone agent") },
+            { "workflowAgent", _ => new TestAgent("workflowAgent", "Auto-registered by workflow") }
+        };
+
+        FunctionsAgentOptions standaloneOptions = new();
+        standaloneOptions.HttpTrigger.IsEnabled = true;
+
+        // Only standaloneAgent has explicit options; workflowAgent does not.
+        IFunctionsAgentOptionsProvider agentOptionsProvider = new FakeOptionsProvider(new Dictionary<string, FunctionsAgentOptions>
+        {
+            { "standaloneAgent", standaloneOptions }
+        });
+
+        List<IFunctionMetadata> metadataList = [];
+
+        DurableAgentFunctionMetadataTransformer transformer = new(
+            agents,
+            NullLogger<DurableAgentFunctionMetadataTransformer>.Instance,
+            new FakeServiceProvider(),
+            agentOptionsProvider);
+
+        // Act
+        transformer.Transform(metadataList);
+
+        // Assert: only standaloneAgent should have triggers (entity + http = 2).
+        // workflowAgent should be skipped entirely.
+        Assert.Equal(2, metadataList.Count);
+        Assert.Contains(metadataList, m => m.Name == "dafx-standaloneAgent");
+        Assert.Contains(metadataList, m => m.Name == "http-standaloneAgent");
+        Assert.DoesNotContain(metadataList, m => m.Name!.Contains("workflowAgent"));
+    }
+
+    private static List<IFunctionMetadata> BuildFunctionMetadataList(int numberOfFunctions)
+    {
+        List<IFunctionMetadata> list = [];
+        for (int i = 0; i < numberOfFunctions; i++)
+        {
+            list.Add(new DefaultFunctionMetadata
+            {
+                Language = "dotnet-isolated",
+                Name = $"SingleAgentOrchestration{i + 1}",
+                EntryPoint = "MyApp.Functions.SingleAgentOrchestration",
+                RawBindings = ["{\r\n \"name\": \"context\",\r\n \"direction\": \"In\",\r\n \"type\": \"orchestrationTrigger\",\r\n \"properties\": {}\r\n }"],
+                ScriptFile = "MyApp.dll"
+            });
+        }
+
+        return list;
+    }
+
+    private sealed class FakeServiceProvider : IServiceProvider
+    {
+        public object? GetService(Type serviceType) => null;
+    }
+
+    private sealed class FakeOptionsProvider : IFunctionsAgentOptionsProvider
+    {
+        private readonly Dictionary<string, FunctionsAgentOptions> _map;
+
+        public FakeOptionsProvider(Dictionary<string, FunctionsAgentOptions> map)
+        {
+            this._map = map ?? throw new ArgumentNullException(nameof(map));
+        }
+
+        public bool TryGet(string agentName, [NotNullWhen(true)] out FunctionsAgentOptions? options)
+            => this._map.TryGetValue(agentName, out options);
+    }
+}

dotnet/tests/Microsoft.Agents.AI.Hosting.AzureFunctions.UnitTests/FunctionMetadataFactoryTests.cs

@@ -0,0 +1,121 @@
+// Copyright (c) Microsoft. All rights reserved.
+
+using System.Text.Json;
+using Microsoft.Azure.Functions.Worker.Core.FunctionMetadata;
+
+namespace Microsoft.Agents.AI.Hosting.AzureFunctions.UnitTests;
+
+public sealed class FunctionMetadataFactoryTests
+{
+    [Fact]
+    public void CreateEntityTrigger_SetsCorrectNameAndBindings()
+    {
+        DefaultFunctionMetadata metadata = FunctionMetadataFactory.CreateEntityTrigger("myAgent");
+
+        Assert.Equal("dafx-myAgent", metadata.Name);
+        Assert.Equal("dotnet-isolated", metadata.Language);
+        Assert.Equal(BuiltInFunctions.RunAgentEntityFunctionEntryPoint, metadata.EntryPoint);
+        Assert.NotNull(metadata.RawBindings);
+        Assert.Equal(2, metadata.RawBindings.Count);
+        Assert.Contains("entityTrigger", metadata.RawBindings[0]);
+        Assert.Contains("durableClient", metadata.RawBindings[1]);
+    }
+
+    [Fact]
+    public void CreateHttpTrigger_SetsCorrectNameRouteAndDefaults()
+    {
+        DefaultFunctionMetadata metadata = FunctionMetadataFactory.CreateHttpTrigger(
+            "myWorkflow", "workflows/myWorkflow/run", BuiltInFunctions.RunWorkflowOrchestrationHttpFunctionEntryPoint);
+
+        Assert.Equal("http-myWorkflow", metadata.Name);
+        Assert.Equal("dotnet-isolated", metadata.Language);
+        Assert.Equal(BuiltInFunctions.RunWorkflowOrchestrationHttpFunctionEntryPoint, metadata.EntryPoint);
+        Assert.NotNull(metadata.RawBindings);
+        Assert.Equal(3, metadata.RawBindings.Count);
+        Assert.Contains("httpTrigger", metadata.RawBindings[0]);
+        Assert.Contains("workflows/myWorkflow/run", metadata.RawBindings[0]);
+        Assert.Contains("\"post\"", metadata.RawBindings[0]);
+        Assert.Contains("http", metadata.RawBindings[1]);
+        Assert.Contains("durableClient", metadata.RawBindings[2]);
+    }
+
+    [Fact]
+    public void CreateHttpTrigger_RespectsCustomMethods()
+    {
+        DefaultFunctionMetadata metadata = FunctionMetadataFactory.CreateHttpTrigger(
+            "status", "workflows/status/{runId}", BuiltInFunctions.GetWorkflowStatusHttpFunctionEntryPoint, methods: "\"get\"");
+
+        Assert.NotNull(metadata.RawBindings);
+        Assert.Contains("\"get\"", metadata.RawBindings[0]);
+        Assert.DoesNotContain("\"post\"", metadata.RawBindings[0]);
+    }
+
+    [Fact]
+    public void CreateActivityTrigger_SetsCorrectNameAndBindings()
+    {
+        DefaultFunctionMetadata metadata = FunctionMetadataFactory.CreateActivityTrigger("dafx-MyExecutor");
+
+        Assert.Equal("dafx-MyExecutor", metadata.Name);
+        Assert.Equal("dotnet-isolated", metadata.Language);
+        Assert.Equal(BuiltInFunctions.InvokeWorkflowActivityFunctionEntryPoint, metadata.EntryPoint);
+        Assert.NotNull(metadata.RawBindings);
+        Assert.Equal(2, metadata.RawBindings.Count);
+        Assert.Contains("activityTrigger", metadata.RawBindings[0]);
+        Assert.Contains("durableClient", metadata.RawBindings[1]);
+    }
+
+    [Fact]
+    public void CreateOrchestrationTrigger_SetsCorrectNameAndBindings()
+    {
+        DefaultFunctionMetadata metadata = FunctionMetadataFactory.CreateOrchestrationTrigger(
+            "dafx-MyWorkflow", BuiltInFunctions.RunWorkflowOrchestrationFunctionEntryPoint);
+
+        Assert.Equal("dafx-MyWorkflow", metadata.Name);
+        Assert.Equal("dotnet-isolated", metadata.Language);
+        Assert.Equal(BuiltInFunctions.RunWorkflowOrchestrationFunctionEntryPoint, metadata.EntryPoint);
+        Assert.NotNull(metadata.RawBindings);
+        Assert.Single(metadata.RawBindings);
+        Assert.Contains("orchestrationTrigger", metadata.RawBindings[0]);
+    }
+
+    [Fact]
+    public void CreateWorkflowMcpToolTrigger_SetsCorrectNameAndBindings()
+    {
+        DefaultFunctionMetadata metadata = FunctionMetadataFactory.CreateWorkflowMcpToolTrigger("Translate", "Translate text");
+
+        Assert.Equal("mcptool-Translate", metadata.Name);
+        Assert.Equal("dotnet-isolated", metadata.Language);
+        Assert.Equal(BuiltInFunctions.RunWorkflowMcpToolFunctionEntryPoint, metadata.EntryPoint);
+        Assert.NotNull(metadata.RawBindings);
+        Assert.Equal(3, metadata.RawBindings.Count);
+
+        // Verify all bindings are valid JSON
+        foreach (string binding in metadata.RawBindings)
+        {
+            JsonDocument.Parse(binding);
+        }
+
+        // mcpToolTrigger binding
+        Assert.Contains("mcpToolTrigger", metadata.RawBindings[0]);
+        Assert.Contains("\"toolName\":\"Translate\"", metadata.RawBindings[0]);
+        Assert.Contains("\"description\":\"Translate text\"", metadata.RawBindings[0]);
+        Assert.Contains("toolProperties", metadata.RawBindings[0]);
+
+        // mcpToolProperty binding for input
+        Assert.Contains("mcpToolProperty", metadata.RawBindings[1]);
+        Assert.Contains("\"propertyName\":\"input\"", metadata.RawBindings[1]);
+        Assert.Contains("\"isRequired\":true", metadata.RawBindings[1]);
+
+        // durableClient binding
+        Assert.Contains("durableClient", metadata.RawBindings[2]);
+    }
+
+    [Fact]
+    public void CreateWorkflowMcpToolTrigger_UsesDefaultDescription_WhenNull()
+    {
+        DefaultFunctionMetadata metadata = FunctionMetadataFactory.CreateWorkflowMcpToolTrigger("MyWorkflow", description: null);
+
+        Assert.NotNull(metadata.RawBindings);
+        Assert.Contains("Run the MyWorkflow workflow", metadata.RawBindings[0]);
+    }
+}

dotnet/tests/Microsoft.Agents.AI.Hosting.AzureFunctions.UnitTests/Microsoft.Agents.AI.Hosting.AzureFunctions.UnitTests.csproj

@@ -0,0 +1,12 @@
+<Project Sdk="Microsoft.NET.Sdk">
+
+  <PropertyGroup>
+    <TargetFrameworks>$(TargetFrameworksCore)</TargetFrameworks>
+    <ImplicitUsings>enable</ImplicitUsings>
+  </PropertyGroup>
+
+  <ItemGroup>
+    <ProjectReference Include="..\..\src\Microsoft.Agents.AI.Hosting.AzureFunctions\Microsoft.Agents.AI.Hosting.AzureFunctions.csproj" />
+  </ItemGroup>
+
+</Project>

dotnet/tests/Microsoft.Agents.AI.Hosting.AzureFunctions.UnitTests/TestAgent.cs

@@ -0,0 +1,36 @@
+// Copyright (c) Microsoft. All rights reserved.
+
+using System.Text.Json;
+using Microsoft.Extensions.AI;
+
+namespace Microsoft.Agents.AI.Hosting.AzureFunctions.UnitTests;
+
+internal sealed class TestAgent(string name, string description) : AIAgent
+{
+    public override string? Name => name;
+
+    public override string? Description => description;
+
+    protected override ValueTask<AgentSession> CreateSessionCoreAsync(CancellationToken cancellationToken = default) => new(new DummyAgentSession());
+
+    protected override ValueTask<JsonElement> SerializeSessionCoreAsync(AgentSession session, JsonSerializerOptions? jsonSerializerOptions = null, CancellationToken cancellationToken = default)
+        => throw new NotImplementedException();
+
+    protected override ValueTask<AgentSession> DeserializeSessionCoreAsync(
+        JsonElement serializedState,
+        JsonSerializerOptions? jsonSerializerOptions = null, CancellationToken cancellationToken = default) => new(new DummyAgentSession());
+
+    protected override Task<AgentResponse> RunCoreAsync(
+        IEnumerable<ChatMessage> messages,
+        AgentSession? session = null,
+        AgentRunOptions? options = null,
+        CancellationToken cancellationToken = default) => Task.FromResult(new AgentResponse([.. messages]));
+
+    protected override IAsyncEnumerable<AgentResponseUpdate> RunCoreStreamingAsync(
+        IEnumerable<ChatMessage> messages,
+        AgentSession? session = null,
+        AgentRunOptions? options = null,
+        CancellationToken cancellationToken = default) => throw new NotSupportedException();
+
+    private sealed class DummyAgentSession : AgentSession;
+}