chore: import upstream snapshot with attribution

dotnet/tests/Microsoft.Agents.AI.Hyperlight.UnitTests/ApprovalComputationTests.cs

@@ -0,0 +1,62 @@
+// Copyright (c) Microsoft. All rights reserved.
+
+using Microsoft.Extensions.AI;
+
+namespace Microsoft.Agents.AI.Hyperlight.UnitTests;
+
+public sealed class ApprovalComputationTests
+{
+    [Fact]
+    public void AlwaysRequire_ReturnsTrueWithNoTools()
+    {
+        // Act / Assert
+        Assert.True(HyperlightCodeActProvider.ComputeApprovalRequired(
+            CodeActApprovalMode.AlwaysRequire,
+            tools: []));
+    }
+
+    [Fact]
+    public void AlwaysRequire_ReturnsTrueEvenWithoutApprovalTool()
+    {
+        // Arrange
+        var tool = AIFunctionFactory.Create(() => "ok", name: "t");
+
+        // Act / Assert
+        Assert.True(HyperlightCodeActProvider.ComputeApprovalRequired(
+            CodeActApprovalMode.AlwaysRequire,
+            tools: [tool]));
+    }
+
+    [Fact]
+    public void NeverRequire_NoTools_ReturnsFalse()
+    {
+        Assert.False(HyperlightCodeActProvider.ComputeApprovalRequired(
+            CodeActApprovalMode.NeverRequire,
+            tools: []));
+    }
+
+    [Fact]
+    public void NeverRequire_NoApprovalRequiredTool_ReturnsFalse()
+    {
+        // Arrange
+        var tool = AIFunctionFactory.Create(() => "ok", name: "t");
+
+        // Act / Assert
+        Assert.False(HyperlightCodeActProvider.ComputeApprovalRequired(
+            CodeActApprovalMode.NeverRequire,
+            tools: [tool]));
+    }
+
+    [Fact]
+    public void NeverRequire_WithApprovalRequiredTool_ReturnsTrue()
+    {
+        // Arrange
+        var tool = AIFunctionFactory.Create(() => "ok", name: "t");
+        var wrapped = new ApprovalRequiredAIFunction(tool);
+
+        // Act / Assert
+        Assert.True(HyperlightCodeActProvider.ComputeApprovalRequired(
+            CodeActApprovalMode.NeverRequire,
+            tools: [wrapped]));
+    }
+}

dotnet/tests/Microsoft.Agents.AI.Hyperlight.UnitTests/HyperlightCodeActProviderTests.cs

@@ -0,0 +1,173 @@
+// Copyright (c) Microsoft. All rights reserved.
+
+using System.Linq;
+using Microsoft.Extensions.AI;
+
+namespace Microsoft.Agents.AI.Hyperlight.UnitTests;
+
+public sealed class HyperlightCodeActProviderTests
+{
+    [Fact]
+    public void Ctor_NullOptions_UsesDefaults()
+    {
+        // Act
+        using var provider = new HyperlightCodeActProvider();
+
+        // Assert
+        Assert.Empty(provider.GetTools());
+        Assert.Empty(provider.GetFileMounts());
+        Assert.Empty(provider.GetAllowedDomains());
+        Assert.Equal([HyperlightCodeActProvider.FixedStateKey], provider.StateKeys);
+    }
+
+    [Fact]
+    public void StateKeys_IsFixedSingleKey()
+    {
+        // Arrange
+        using var provider = new HyperlightCodeActProvider(new HyperlightCodeActProviderOptions());
+
+        // Act / Assert
+        Assert.Equal([HyperlightCodeActProvider.FixedStateKey], provider.StateKeys);
+    }
+
+    [Fact]
+    public void Tools_Crud_AddReplacesByName()
+    {
+        // Arrange
+        using var provider = new HyperlightCodeActProvider(new HyperlightCodeActProviderOptions());
+        var first = AIFunctionFactory.Create(() => "a", name: "t");
+        var replacement = AIFunctionFactory.Create(() => "b", name: "t");
+
+        // Act
+        provider.AddTools(first);
+        provider.AddTools(replacement);
+
+        // Assert
+        var tools = provider.GetTools();
+        Assert.Single(tools);
+        Assert.Same(replacement, tools[0]);
+    }
+
+    [Fact]
+    public void Tools_RemoveAndClear_Work()
+    {
+        // Arrange
+        using var provider = new HyperlightCodeActProvider(new HyperlightCodeActProviderOptions());
+        provider.AddTools(
+            AIFunctionFactory.Create(() => "a", name: "a"),
+            AIFunctionFactory.Create(() => "b", name: "b"));
+
+        // Act
+        provider.RemoveTools("a");
+
+        // Assert
+        Assert.Single(provider.GetTools());
+        Assert.Equal("b", provider.GetTools()[0].Name);
+
+        // Act
+        provider.ClearTools();
+
+        // Assert
+        Assert.Empty(provider.GetTools());
+    }
+
+    [Fact]
+    public void FileMounts_Crud_ReplaceByMountPath()
+    {
+        // Arrange
+        using var provider = new HyperlightCodeActProvider(new HyperlightCodeActProviderOptions());
+        var m1 = new FileMount("/host/a", "/input/a");
+        var m2 = new FileMount("/host/a-new", "/input/a");
+        var m3 = new FileMount("/host/b", "/input/b");
+
+        // Act
+        provider.AddFileMounts(m1, m3);
+        provider.AddFileMounts(m2);
+
+        // Assert
+        var mounts = provider.GetFileMounts().OrderBy(m => m.MountPath).ToArray();
+        Assert.Equal(2, mounts.Length);
+        Assert.Same(m2, mounts[0]);
+        Assert.Same(m3, mounts[1]);
+
+        // Act
+        provider.RemoveFileMounts("/input/a");
+
+        // Assert
+        Assert.Single(provider.GetFileMounts());
+
+        // Act
+        provider.ClearFileMounts();
+
+        // Assert
+        Assert.Empty(provider.GetFileMounts());
+    }
+
+    [Fact]
+    public void AllowedDomains_Crud_ReplaceByTarget()
+    {
+        // Arrange
+        using var provider = new HyperlightCodeActProvider(new HyperlightCodeActProviderOptions());
+        var d1 = new AllowedDomain("https://a", ["GET"]);
+        var d2 = new AllowedDomain("https://a", ["POST"]);
+        var d3 = new AllowedDomain("https://b");
+
+        // Act
+        provider.AddAllowedDomains(d1, d3);
+        provider.AddAllowedDomains(d2);
+
+        // Assert
+        var domains = provider.GetAllowedDomains().OrderBy(d => d.Target).ToArray();
+        Assert.Equal(2, domains.Length);
+        Assert.Same(d2, domains[0]);
+        Assert.Same(d3, domains[1]);
+
+        // Act
+        provider.RemoveAllowedDomains("https://a");
+
+        // Assert
+        Assert.Single(provider.GetAllowedDomains());
+
+        // Act
+        provider.ClearAllowedDomains();
+
+        // Assert
+        Assert.Empty(provider.GetAllowedDomains());
+    }
+
+    [Fact]
+    public void Ctor_SeedsFromOptions()
+    {
+        // Arrange
+        var tool = AIFunctionFactory.Create(() => "x", name: "x");
+        var options = new HyperlightCodeActProviderOptions
+        {
+            Tools = new[] { tool },
+            FileMounts = new[] { new FileMount("/h", "/m") },
+            AllowedDomains = new[] { new AllowedDomain("https://a") },
+        };
+
+        // Act
+        using var provider = new HyperlightCodeActProvider(options);
+
+        // Assert
+        Assert.Single(provider.GetTools());
+        Assert.Single(provider.GetFileMounts());
+        Assert.Single(provider.GetAllowedDomains());
+    }
+
+    [Fact]
+    public void Dispose_IsIdempotentAndBlocksFurtherAddTools()
+    {
+        // Arrange
+        var provider = new HyperlightCodeActProvider(new HyperlightCodeActProviderOptions());
+        var tool = AIFunctionFactory.Create(() => "x", name: "x");
+
+        // Act
+        provider.Dispose();
+        provider.Dispose();
+
+        // Assert
+        Assert.Throws<System.ObjectDisposedException>(() => provider.AddTools(tool));
+    }
+}

dotnet/tests/Microsoft.Agents.AI.Hyperlight.UnitTests/InstructionBuilderTests.cs

@@ -0,0 +1,108 @@
+// Copyright (c) Microsoft. All rights reserved.
+
+using System.Collections.Generic;
+using Microsoft.Agents.AI.Hyperlight.Internal;
+using Microsoft.Extensions.AI;
+
+namespace Microsoft.Agents.AI.Hyperlight.UnitTests;
+
+public sealed class InstructionBuilderTests
+{
+    [Fact]
+    public void BuildContextInstructions_HiddenTools_MentionsCallTool()
+    {
+        // Act
+        var text = InstructionBuilder.BuildContextInstructions(toolsVisibleToModel: false);
+
+        // Assert
+        Assert.Contains("execute_code", text);
+        Assert.Contains("call_tool", text);
+        // Backend-agnostic: don't mention a specific language.
+        Assert.DoesNotContain("Python", text);
+    }
+
+    [Fact]
+    public void BuildContextInstructions_VisibleTools_OmitsCallTool()
+    {
+        // Act
+        var text = InstructionBuilder.BuildContextInstructions(toolsVisibleToModel: true);
+
+        // Assert
+        Assert.Contains("execute_code", text);
+        Assert.DoesNotContain("call_tool", text);
+        Assert.DoesNotContain("Python", text);
+    }
+
+    [Fact]
+    public void BuildExecuteCodeDescription_WithNoExtras_ReturnsBaseBlurbOnly()
+    {
+        // Act
+        var text = InstructionBuilder.BuildExecuteCodeDescription(
+            tools: [],
+            fileMounts: [],
+            allowedDomains: [],
+            hasHostInputDirectory: false);
+
+        // Assert
+        Assert.Contains("Executes code", text);
+        Assert.DoesNotContain("call_tool", text);
+        Assert.DoesNotContain("Filesystem access", text);
+        Assert.DoesNotContain("Outbound network access", text);
+    }
+
+    [Fact]
+    public void BuildExecuteCodeDescription_WithTools_IncludesToolNames()
+    {
+        // Arrange
+        var tool = AIFunctionFactory.Create(() => "ok", name: "fetch_docs", description: "fetch docs");
+
+        // Act
+        var text = InstructionBuilder.BuildExecuteCodeDescription(
+            tools: [tool],
+            fileMounts: [],
+            allowedDomains: [],
+            hasHostInputDirectory: false);
+
+        // Assert
+        Assert.Contains("call_tool", text);
+        Assert.Contains("fetch_docs", text);
+        Assert.Contains("fetch docs", text);
+    }
+
+    [Fact]
+    public void BuildExecuteCodeDescription_WithFilesystem_IncludesSandboxPathsOnly()
+    {
+        // Act
+        var text = InstructionBuilder.BuildExecuteCodeDescription(
+            tools: [],
+            fileMounts: [new FileMount("/host/data.csv", "/input/data.csv")],
+            allowedDomains: [],
+            hasHostInputDirectory: true);
+
+        // Assert
+        Assert.Contains("Filesystem access", text);
+        Assert.Contains("/input", text);
+        Assert.Contains("/input/data.csv", text);
+
+        // Host paths must not leak to the model.
+        Assert.DoesNotContain("/host/workspace", text);
+        Assert.DoesNotContain("/host/data.csv", text);
+    }
+
+    [Fact]
+    public void BuildExecuteCodeDescription_WithAllowedDomains_IncludesNetworkSection()
+    {
+        // Act
+        var text = InstructionBuilder.BuildExecuteCodeDescription(
+            tools: [],
+            fileMounts: [],
+            allowedDomains: [new AllowedDomain("https://api.github.com", new List<string> { "GET", "POST" })],
+            hasHostInputDirectory: false);
+
+        // Assert
+        Assert.Contains("Outbound network access", text);
+        Assert.Contains("api.github.com", text);
+        Assert.Contains("GET", text);
+        Assert.Contains("POST", text);
+    }
+}

dotnet/tests/Microsoft.Agents.AI.Hyperlight.UnitTests/Microsoft.Agents.AI.Hyperlight.UnitTests.csproj

@@ -0,0 +1,16 @@
+<Project Sdk="Microsoft.NET.Sdk">
+
+  <PropertyGroup>
+    <TargetFrameworks>$(TargetFrameworksCore)</TargetFrameworks>
+  </PropertyGroup>
+
+  <PropertyGroup Condition="$([MSBuild]::IsTargetFrameworkCompatible('$(TargetFramework)', 'net8.0'))">
+    <JsonSerializerIsReflectionEnabledByDefault>false</JsonSerializerIsReflectionEnabledByDefault>
+  </PropertyGroup>
+
+  <ItemGroup>
+    <ProjectReference Include="..\..\src\Microsoft.Agents.AI.Hyperlight\Microsoft.Agents.AI.Hyperlight.csproj" />
+    <ProjectReference Include="..\..\src\Microsoft.Agents.AI\Microsoft.Agents.AI.csproj" />
+  </ItemGroup>
+
+</Project>

dotnet/tests/Microsoft.Agents.AI.Hyperlight.UnitTests/ProvideAIContextTests.cs

@@ -0,0 +1,104 @@
+// Copyright (c) Microsoft. All rights reserved.
+
+using System.Linq;
+using System.Threading.Tasks;
+using Microsoft.Agents.AI.Hyperlight.Internal;
+using Microsoft.Extensions.AI;
+using Moq;
+
+namespace Microsoft.Agents.AI.Hyperlight.UnitTests;
+
+public sealed class ProvideAIContextTests
+{
+    private static readonly AIAgent s_mockAgent = new Mock<AIAgent>().Object;
+
+    private static AIContextProvider.InvokingContext NewInvokingContext() => new(s_mockAgent, session: null, new AIContext());
+
+    [Fact]
+    public async Task ProvideAIContextAsync_ReturnsExecuteCodeToolAndInstructionsAsync()
+    {
+        // Arrange
+        using var provider = new HyperlightCodeActProvider(new HyperlightCodeActProviderOptions());
+
+        // Act
+        var context = await provider.InvokingAsync(NewInvokingContext());
+
+        // Assert
+        Assert.NotNull(context);
+        Assert.NotNull(context!.Tools);
+        var tools = context.Tools!.ToList();
+        Assert.Single(tools);
+        var function = Assert.IsAssignableFrom<AIFunction>(tools[0]);
+        Assert.Equal("execute_code", function.Name);
+        Assert.False(string.IsNullOrWhiteSpace(context.Instructions));
+    }
+
+    [Fact]
+    public async Task ProvideAIContextAsync_AlwaysRequire_WrapsInApprovalRequiredAsync()
+    {
+        // Arrange
+        using var provider = new HyperlightCodeActProvider(new HyperlightCodeActProviderOptions
+        {
+            ApprovalMode = CodeActApprovalMode.AlwaysRequire,
+        });
+
+        // Act
+        var context = await provider.InvokingAsync(NewInvokingContext());
+
+        // Assert
+        _ = Assert.IsType<ApprovalRequiredAIFunction>(context!.Tools!.First());
+    }
+
+    [Fact]
+    public async Task ProvideAIContextAsync_NeverRequireWithApprovalTool_WrapsInApprovalRequiredAsync()
+    {
+        // Arrange
+        var inner = AIFunctionFactory.Create(() => "ok", name: "t");
+        using var provider = new HyperlightCodeActProvider(new HyperlightCodeActProviderOptions
+        {
+            ApprovalMode = CodeActApprovalMode.NeverRequire,
+            Tools = [new ApprovalRequiredAIFunction(inner)],
+        });
+
+        // Act
+        var context = await provider.InvokingAsync(NewInvokingContext());
+
+        // Assert
+        _ = Assert.IsType<ApprovalRequiredAIFunction>(context!.Tools!.First());
+    }
+
+    [Fact]
+    public async Task ProvideAIContextAsync_CapturesSnapshot_MutationsAfterDoNotAffectDescriptionAsync()
+    {
+        // Arrange
+        using var provider = new HyperlightCodeActProvider(new HyperlightCodeActProviderOptions());
+        provider.AddTools(AIFunctionFactory.Create(() => "one", name: "first_tool"));
+
+        // Act
+        var context = await provider.InvokingAsync(NewInvokingContext());
+        provider.AddTools(AIFunctionFactory.Create(() => "two", name: "second_tool"));
+
+        // Assert — the returned execute_code description must reflect the first snapshot only.
+        var function = Assert.IsAssignableFrom<AIFunction>(context!.Tools!.First());
+        Assert.Contains("first_tool", function.Description);
+        Assert.DoesNotContain("second_tool", function.Description);
+    }
+
+    [Fact]
+    public async Task ProvideAIContextAsync_AddToolsSameNameReplacement_ChangesSnapshotFingerprintAsync()
+    {
+        // Arrange
+        using var provider = new HyperlightCodeActProvider(new HyperlightCodeActProviderOptions());
+        provider.AddTools(AIFunctionFactory.Create(() => "one", name: "same_tool"));
+
+        // Act
+        var firstContext = await provider.InvokingAsync(NewInvokingContext());
+        provider.AddTools(AIFunctionFactory.Create(() => "two", name: "same_tool"));
+        var secondContext = await provider.InvokingAsync(NewInvokingContext());
+
+        // Assert
+        var firstFunction = Assert.IsType<ExecuteCodeFunction>(firstContext!.Tools!.First());
+        var secondFunction = Assert.IsType<ExecuteCodeFunction>(secondContext!.Tools!.First());
+        Assert.NotEqual(firstFunction.ConfigFingerprint, secondFunction.ConfigFingerprint);
+    }
+}

dotnet/tests/Microsoft.Agents.AI.Hyperlight.UnitTests/SandboxExecutorTests.cs

@@ -0,0 +1,112 @@
+// Copyright (c) Microsoft. All rights reserved.
+
+using System;
+using Microsoft.Agents.AI.Hyperlight.Internal;
+using Microsoft.Extensions.AI;
+
+namespace Microsoft.Agents.AI.Hyperlight.UnitTests;
+
+public sealed class SandboxExecutorTests
+{
+    [Fact]
+    public void Fingerprint_DifferentToolSets_DifferentFingerprints()
+    {
+        // Arrange
+        var t1 = AIFunctionFactory.Create(() => "a", name: "a");
+        var t2 = AIFunctionFactory.Create(() => "b", name: "b");
+
+        // Act
+        var fpA = SandboxExecutor.RunSnapshot.ComputeFingerprint([t1], [], [], hostInputDirectory: null);
+        var fpAB = SandboxExecutor.RunSnapshot.ComputeFingerprint([t1, t2], [], [], hostInputDirectory: null);
+
+        // Assert
+        Assert.NotEqual(fpA, fpAB);
+    }
+
+    [Fact]
+    public void Fingerprint_OrderInsensitive_OnTools()
+    {
+        // Arrange
+        var t1 = AIFunctionFactory.Create(() => "a", name: "a");
+        var t2 = AIFunctionFactory.Create(() => "b", name: "b");
+
+        // Act
+        var fp1 = SandboxExecutor.RunSnapshot.ComputeFingerprint([t1, t2], [], [], hostInputDirectory: null);
+        var fp2 = SandboxExecutor.RunSnapshot.ComputeFingerprint([t2, t1], [], [], hostInputDirectory: null);
+
+        // Assert
+        Assert.Equal(fp1, fp2);
+    }
+
+    [Fact]
+    public void Fingerprint_SameNameDifferentToolRegistryVersionIds_DifferentFingerprints()
+    {
+        // Arrange
+        var t1 = AIFunctionFactory.Create(() => "a", name: "t");
+        var t2 = AIFunctionFactory.Create(() => "b", name: "t");
+        var firstVersion = Guid.Parse("11111111-1111-1111-1111-111111111111");
+        var secondVersion = Guid.Parse("22222222-2222-2222-2222-222222222222");
+
+        // Act
+        var fp1 = SandboxExecutor.RunSnapshot.ComputeFingerprint(
+            [t1],
+            [],
+            [],
+            hostInputDirectory: null,
+            toolRegistryVersion: firstVersion);
+        var fp2 = SandboxExecutor.RunSnapshot.ComputeFingerprint(
+            [t2],
+            [],
+            [],
+            hostInputDirectory: null,
+            toolRegistryVersion: secondVersion);
+
+        // Assert
+        Assert.NotEqual(fp1, fp2);
+    }
+
+    [Fact]
+    public void Fingerprint_DifferentMounts_DifferentFingerprints()
+    {
+        // Act
+        var fpEmpty = SandboxExecutor.RunSnapshot.ComputeFingerprint([], [], [], hostInputDirectory: null);
+        var fpMount = SandboxExecutor.RunSnapshot.ComputeFingerprint(
+            [],
+            [new FileMount("/host/a", "/input/a")],
+            [],
+            hostInputDirectory: null);
+
+        // Assert
+        Assert.NotEqual(fpEmpty, fpMount);
+    }
+
+    [Fact]
+    public void Fingerprint_DifferentAllowedDomains_DifferentFingerprints()
+    {
+        // Act
+        var fp1 = SandboxExecutor.RunSnapshot.ComputeFingerprint(
+            [],
+            [],
+            [new AllowedDomain("https://a")],
+            hostInputDirectory: null);
+        var fp2 = SandboxExecutor.RunSnapshot.ComputeFingerprint(
+            [],
+            [],
+            [new AllowedDomain("https://b")],
+            hostInputDirectory: null);
+
+        // Assert
+        Assert.NotEqual(fp1, fp2);
+    }
+
+    [Fact]
+    public void Fingerprint_DifferentHostInputDirectory_DifferentFingerprints()
+    {
+        // Act
+        var fpNone = SandboxExecutor.RunSnapshot.ComputeFingerprint([], [], [], hostInputDirectory: null);
+        var fpDir = SandboxExecutor.RunSnapshot.ComputeFingerprint([], [], [], hostInputDirectory: "/tmp/work");
+
+        // Assert
+        Assert.NotEqual(fpNone, fpDir);
+    }
+}

dotnet/tests/Microsoft.Agents.AI.Hyperlight.UnitTests/ToolBridgeTests.cs

@@ -0,0 +1,71 @@
+// Copyright (c) Microsoft. All rights reserved.
+
+using System;
+using System.Text.Json;
+using System.Threading.Tasks;
+using Microsoft.Agents.AI.Hyperlight.Internal;
+using Microsoft.Extensions.AI;
+
+namespace Microsoft.Agents.AI.Hyperlight.UnitTests;
+
+public sealed class ToolBridgeTests
+{
+    [Fact]
+    public async Task InvokeAsync_PassesArgumentsAndReturnsSerializedResultAsync()
+    {
+        // Arrange
+        static string Echo(string value) => $"echo:{value}";
+        var tool = AIFunctionFactory.Create(Echo, name: "echo");
+
+        // Act
+        var result = await ToolBridge.InvokeAsync(tool, """{"value":"hello"}""");
+
+        // Assert — AIFunction.InvokeAsync returns the string; ToolBridge JSON-encodes it.
+        Assert.Equal("\"echo:hello\"", result);
+    }
+
+    [Fact]
+    public async Task InvokeAsync_ReturnsErrorJsonOnExceptionAsync()
+    {
+        // Arrange
+        static int Boom() => throw new InvalidOperationException("nope");
+        var tool = AIFunctionFactory.Create(Boom, name: "boom");
+
+        // Act
+        var result = await ToolBridge.InvokeAsync(tool, "{}");
+
+        // Assert
+        using var doc = JsonDocument.Parse(result);
+        Assert.True(doc.RootElement.TryGetProperty("error", out var err));
+        Assert.Contains("nope", err.GetString()!);
+    }
+
+    [Fact]
+    public async Task InvokeAsync_EmptyArguments_InvokesToolWithNoArgsAsync()
+    {
+        // Arrange
+        static string Hi() => "hi";
+        var tool = AIFunctionFactory.Create(Hi, name: "hi");
+
+        // Act
+        var result = await ToolBridge.InvokeAsync(tool, string.Empty);
+
+        // Assert
+        Assert.Equal("\"hi\"", result);
+    }
+
+    [Fact]
+    public async Task InvokeAsync_NonObjectJson_ReturnsErrorAsync()
+    {
+        // Arrange
+        static string Hi() => "hi";
+        var tool = AIFunctionFactory.Create(Hi, name: "hi");
+
+        // Act
+        var result = await ToolBridge.InvokeAsync(tool, "[1, 2, 3]");
+
+        // Assert
+        using var doc = JsonDocument.Parse(result);
+        Assert.True(doc.RootElement.TryGetProperty("error", out _));
+    }
+}