Sample format

* support code skills

* address pr review comments

* address package and syntax checks

* address pr review comments

* address pr review comment

* address failed check

* rename agentskill and agetnskillprovider

* move agent skills related assets to _skills.py

* address pr review comments

* address review comments

* support kwargs

* address pr review feedback

.github/.linkspector.yml

@@ -20,6 +20,7 @@ ignorePatterns:
   - pattern: "https://your-resource.openai.azure.com/"
   - pattern: "http://host.docker.internal"
   - pattern: "https://openai.github.io/openai-agents-js/openai/agents/classes/"
+  - pattern: "https:\/\/dotnet.microsoft.com\/download"
 # excludedDirs:
   # Folders which include links to localhost, since it's not ignored with regular expressions
 baseUrl: https://github.com/microsoft/agent-framework/

.github/workflows/dotnet-build-and-test.yml

@@ -59,20 +59,20 @@ jobs:
         if: steps.filter.outputs.dotnet != 'true'
         run: echo "NOT dotnet file"
 
-  dotnet-build-and-test:
+  # Build the full solution (including samples) on all TFMs. No tests.
+  dotnet-build:
     needs: paths-filter
     if: needs.paths-filter.outputs.dotnetChanges == 'true'
     strategy:
       fail-fast: false
       matrix:
         include:
-          - { targetFramework: "net10.0", os: "ubuntu-latest", configuration: Release, integration-tests: true, environment: "integration" }
+          - { targetFramework: "net10.0", os: "ubuntu-latest", configuration: Release }
           - { targetFramework: "net9.0", os: "windows-latest", configuration: Debug }
           - { targetFramework: "net8.0", os: "ubuntu-latest", configuration: Release }
-          - { targetFramework: "net472", os: "windows-latest", configuration: Release, integration-tests: true, environment: "integration" }
+          - { targetFramework: "net472", os: "windows-latest", configuration: Release }
 
     runs-on: ${{ matrix.os }}
-    environment: ${{ matrix.environment }}
     steps:
       - uses: actions/checkout@v6
         with:
@@ -84,16 +84,6 @@ jobs:
               python
               workflow-samples
 
-      # Start Cosmos DB Emulator for all integration tests and only for unit tests when CosmosDB changes happened)
-      - name: Start Azure Cosmos DB Emulator
-        if: ${{ runner.os == 'Windows' && (needs.paths-filter.outputs.cosmosDbChanges == 'true' || (github.event_name != 'pull_request' && matrix.integration-tests)) }}
-        shell: pwsh
-        run: |
-          Write-Host "Launching Azure Cosmos DB Emulator"
-          Import-Module "$env:ProgramFiles\Azure Cosmos DB Emulator\PSModules\Microsoft.Azure.CosmosDB.Emulator"
-          Start-CosmosDbEmulator -NoUI -Key "C2y6yDjf5/R+ob0N8A7Cgv30VRDJIWEHLM+4QDU5DE2nQ9nDuVTqobD4b8mGGyPMbIZnqyMsEcaGQy67XIw/Jw=="
-          echo "COSMOSDB_EMULATOR_AVAILABLE=true" >> $env:GITHUB_ENV
-
       - name: Setup dotnet
         uses: actions/setup-dotnet@v5.1.0
         with:
@@ -140,25 +130,98 @@ jobs:
           popd
           rm -rf "$TEMP_DIR"
 
-      - name: Run Unit Tests
-        shell: bash
-        run: |
-          export UT_PROJECTS=$(find ./dotnet -type f -name "*.UnitTests.csproj" | tr '\n' ' ')
-          for project in $UT_PROJECTS; do
-            # Query the project's target frameworks using MSBuild with the current configuration
-            target_frameworks=$(dotnet msbuild $project -getProperty:TargetFrameworks -p:Configuration=${{ matrix.configuration }} -nologo 2>/dev/null | tr -d '\r')
+  # Build src+tests only (no samples) for a single TFM and run tests.
+  dotnet-test:
+    needs: paths-filter
+    if: needs.paths-filter.outputs.dotnetChanges == 'true'
+    strategy:
+      fail-fast: false
+      matrix:
+        include:
+          - { targetFramework: "net10.0", os: "ubuntu-latest", configuration: Release, integration-tests: true, environment: "integration" }
+          - { targetFramework: "net472", os: "windows-latest", configuration: Release, integration-tests: true, environment: "integration" }
 
-            # Check if the project supports the target framework
-            if [[ "$target_frameworks" == *"${{ matrix.targetFramework }}"* ]]; then
-              if [[ "${{ matrix.targetFramework }}" == "${{ env.COVERAGE_FRAMEWORK }}" ]]; then
-                dotnet test -f ${{ matrix.targetFramework }} -c ${{ matrix.configuration }} $project --no-build -v Normal --logger trx --collect:"XPlat Code Coverage" --results-directory:"TestResults/Coverage/" -- DataCollectionRunSettings.DataCollectors.DataCollector.Configuration.ExcludeByAttribute=GeneratedCodeAttribute,CompilerGeneratedAttribute,ExcludeFromCodeCoverageAttribute
-              else
-                dotnet test -f ${{ matrix.targetFramework }} -c ${{ matrix.configuration }} $project --no-build -v Normal --logger trx
-              fi
-            else
-              echo "Skipping $project - does not support target framework ${{ matrix.targetFramework }} (supports: $target_frameworks)"
-            fi
-          done
+    runs-on: ${{ matrix.os }}
+    environment: ${{ matrix.environment }}
+    steps:
+      - uses: actions/checkout@v6
+        with:
+            persist-credentials: false
+            sparse-checkout: |
+              .
+              .github
+              dotnet
+              python
+              workflow-samples
+
+      # Start Cosmos DB Emulator for all integration tests and only for unit tests when CosmosDB changes happened)
+      - name: Start Azure Cosmos DB Emulator
+        if: ${{ runner.os == 'Windows' && (needs.paths-filter.outputs.cosmosDbChanges == 'true' || (github.event_name != 'pull_request' && matrix.integration-tests)) }}
+        shell: pwsh
+        run: |
+          Write-Host "Launching Azure Cosmos DB Emulator"
+          Import-Module "$env:ProgramFiles\Azure Cosmos DB Emulator\PSModules\Microsoft.Azure.CosmosDB.Emulator"
+          Start-CosmosDbEmulator -NoUI -Key "C2y6yDjf5/R+ob0N8A7Cgv30VRDJIWEHLM+4QDU5DE2nQ9nDuVTqobD4b8mGGyPMbIZnqyMsEcaGQy67XIw/Jw=="
+          echo "COSMOSDB_EMULATOR_AVAILABLE=true" >> $env:GITHUB_ENV
+
+      - name: Setup dotnet
+        uses: actions/setup-dotnet@v5.1.0
+        with:
+          global-json-file: ${{ github.workspace }}/dotnet/global.json
+
+      - name: Generate test solution (no samples)
+        shell: pwsh
+        run: |
+          ./dotnet/eng/scripts/New-FilteredSolution.ps1 `
+            -Solution dotnet/agent-framework-dotnet.slnx `
+            -TargetFramework ${{ matrix.targetFramework }} `
+            -Configuration ${{ matrix.configuration }} `
+            -ExcludeSamples `
+            -OutputPath dotnet/filtered.slnx `
+            -Verbose
+
+      - name: Build src and tests
+        shell: bash
+        run: dotnet build dotnet/filtered.slnx -c ${{ matrix.configuration }} -f ${{ matrix.targetFramework }} --warnaserror
+
+      - name: Generate test-type filtered solutions
+        shell: pwsh
+        run: |
+          $commonArgs = @{
+            Solution       = "dotnet/filtered.slnx"
+            TargetFramework = "${{ matrix.targetFramework }}"
+            Configuration   = "${{ matrix.configuration }}"
+            Verbose         = $true
+          }
+          ./dotnet/eng/scripts/New-FilteredSolution.ps1 @commonArgs `
+            -TestProjectNameFilter "*UnitTests*" `
+            -OutputPath dotnet/filtered-unit.slnx
+          ./dotnet/eng/scripts/New-FilteredSolution.ps1 @commonArgs `
+            -TestProjectNameFilter "*IntegrationTests*" `
+            -OutputPath dotnet/filtered-integration.slnx
+
+      - name: Run Unit Tests
+        shell: pwsh
+        working-directory: dotnet
+        run: |
+          $coverageSettings = Join-Path $PWD "tests/coverage.runsettings"
+          $coverageArgs = @()
+          if ("${{ matrix.targetFramework }}" -eq "${{ env.COVERAGE_FRAMEWORK }}") {
+            $coverageArgs = @(
+              "--coverage",
+              "--coverage-output-format", "cobertura",
+              "--coverage-settings", $coverageSettings,
+              "--results-directory", "../TestResults/Coverage/"
+            )
+          }
+
+          dotnet test --solution ./filtered-unit.slnx `
+            -f ${{ matrix.targetFramework }} `
+            -c ${{ matrix.configuration }} `
+            --no-build -v Normal `
+            --report-xunit-trx `
+            --ignore-exit-code 8 `
+            @coverageArgs
         env:
           # Cosmos DB Emulator connection settings
           COSMOSDB_ENDPOINT: https://localhost:8081
@@ -185,21 +248,19 @@ jobs:
         id: azure-functions-setup
 
       - name: Run Integration Tests
-        shell: bash
+        shell: pwsh
+        working-directory: dotnet
         if: github.event_name != 'pull_request' && matrix.integration-tests
         run: |
-          export INTEGRATION_TEST_PROJECTS=$(find ./dotnet -type f -name "*IntegrationTests.csproj" | tr '\n' ' ')
-          for project in $INTEGRATION_TEST_PROJECTS; do
-            # Query the project's target frameworks using MSBuild with the current configuration
-            target_frameworks=$(dotnet msbuild $project -getProperty:TargetFrameworks -p:Configuration=${{ matrix.configuration }} -nologo 2>/dev/null | tr -d '\r')
-
-            # Check if the project supports the target framework
-            if [[ "$target_frameworks" == *"${{ matrix.targetFramework }}"* ]]; then
-              dotnet test -f ${{ matrix.targetFramework }} -c ${{ matrix.configuration }} $project --no-build -v Normal --logger trx --filter "Category!=IntegrationDisabled"
-            else
-              echo "Skipping $project - does not support target framework ${{ matrix.targetFramework }} (supports: $target_frameworks)"
-            fi
-          done
+          dotnet test --solution ./filtered-integration.slnx `
+            -f ${{ matrix.targetFramework }} `
+            -c ${{ matrix.configuration }} `
+            --no-build -v Normal `
+            --report-xunit-trx `
+            --ignore-exit-code 8 `
+            --filter-not-trait "Category=IntegrationDisabled" `
+            --parallel-algorithm aggressive `
+            --max-threads 2.0x
         env:
           # Cosmos DB Emulator connection settings
           COSMOSDB_ENDPOINT: https://localhost:8081
@@ -222,7 +283,7 @@ jobs:
         if: matrix.targetFramework == env.COVERAGE_FRAMEWORK
         uses: danielpalme/ReportGenerator-GitHub-Action@5.5.1
         with:
-          reports: "./TestResults/Coverage/**/coverage.cobertura.xml"
+          reports: "./TestResults/Coverage/**/*.cobertura.xml"
           targetdir: "./TestResults/Reports"
           reporttypes: "HtmlInline;JsonSummary"
 
@@ -236,13 +297,13 @@ jobs:
       - name: Check coverage
         if: matrix.targetFramework == env.COVERAGE_FRAMEWORK
         shell: pwsh
-        run: .github/workflows/dotnet-check-coverage.ps1 -JsonReportPath "TestResults/Reports/Summary.json" -CoverageThreshold $env:COVERAGE_THRESHOLD
+        run: ./dotnet/eng/scripts/dotnet-check-coverage.ps1 -JsonReportPath "TestResults/Reports/Summary.json" -CoverageThreshold $env:COVERAGE_THRESHOLD
 
   # This final job is required to satisfy the merge queue. It must only run (or succeed) if no tests failed
   dotnet-build-and-test-check:
     if: always()
     runs-on: ubuntu-latest
-    needs: [dotnet-build-and-test]
+    needs: [dotnet-build, dotnet-test]
     steps:
       - name: Get Date
         shell: bash

dotnet/.github/skills/build-and-test/SKILL.md

@@ -17,14 +17,17 @@ dotnet format             # Auto-fix formatting for all projects
 
 # Build/test/format a specific project (preferred for isolated/internal changes)
 dotnet build src/Microsoft.Agents.AI.<Package> --tl:off
-dotnet test tests/Microsoft.Agents.AI.<Package>.UnitTests
+dotnet test --project tests/Microsoft.Agents.AI.<Package>.UnitTests
 dotnet format src/Microsoft.Agents.AI.<Package>
 
 # Run a single test
-dotnet test --filter "FullyQualifiedName~Namespace.TestClassName.TestMethodName"
+# Replace the filter values with the appropriate assembly, namespace, class, and method names for the test you want to run and use * as a wildcard elsewhere, e.g. "/*/*/HttpClientTests/GetAsync_ReturnsSuccessStatusCode"
+# Use `--ignore-exit-code 8` to avoid failing the build when no tests are found for some projects
+dotnet test --filter-query "/<assemblyFilter>/<namespaceFilter>/<classFilter>/<methodFilter>" --ignore-exit-code 8
 
 # Run unit tests only
-dotnet test --filter FullyQualifiedName\~UnitTests
+# Use `--ignore-exit-code 8` to avoid failing the build when no tests are found for integration test projects
+dotnet test --filter-query "/*UnitTests*/*/*/*" --ignore-exit-code 8
 ```
 
 Use `--tl:off` when building to avoid flickering when running commands in the agent.
@@ -56,7 +59,7 @@ Example: Running tests for a single project using .NET 10.
 
 ```bash
 # From dotnet/ directory
-dotnet test ./tests/Microsoft.Agents.AI.Abstractions.UnitTests -f net10.0
+dotnet test --project ./tests/Microsoft.Agents.AI.Abstractions.UnitTests -f net10.0
 ```
 
 Example: Running a single test in a specific project using .NET 10.
@@ -64,7 +67,7 @@ Provide the full namespace, class name, and method name for the test you want to
 
 ```bash
 # From dotnet/ directory
-dotnet test ./tests/Microsoft.Agents.AI.Abstractions.UnitTests -f net10.0 --filter "FullyQualifiedName~Microsoft.Agents.AI.Abstractions.UnitTests.AgentRunOptionsTests.CloningConstructorCopiesProperties"
+dotnet test --project ./tests/Microsoft.Agents.AI.Abstractions.UnitTests -f net10.0 --filter-query "/*/Microsoft.Agents.AI.Abstractions.UnitTests/AgentRunOptionsTests/CloningConstructorCopiesProperties"
 ```
 
 ### Multi-target framework tip
@@ -83,3 +86,45 @@ Just remember to run `dotnet restore` after pulling changes, making changes to p
 Unit tests target both .NET Framework as well as .NET Core. When running on Linux, only the .NET Core tests can be run, as .NET Framework is not supported on Linux.
 
 To run only the .NET Core tests, use the `-f net10.0` option with `dotnet test`.
+
+### Microsoft Testing Platform (MTP)
+
+Tests use the [Microsoft Testing Platform](https://learn.microsoft.com/dotnet/core/testing/unit-testing-platform-intro) via xUnit v3. Key differences from the legacy VSTest runner:
+
+- **`dotnet test` requires `--project`** to specify a test project directly (positional arguments are no longer supported).
+- **Test output** uses the MTP format (e.g., `[✓112/x0/↓0]` progress and `Test run summary: Passed!`).
+- **TRX reports** use `--report-xunit-trx` instead of `--logger trx`.
+- **Code coverage** uses `Microsoft.Testing.Extensions.CodeCoverage` with `--coverage --coverage-output-format cobertura`.
+- **Running a test project directly** is supported via `dotnet run --project <test-project>`. This bypasses the `dotnet test` infrastructure and runs the test executable directly with the MTP command line.
+
+- **Running tests across the solution** with a filter may cause some projects to match zero tests, which MTP treats as a failure (exit code 8). Use `--ignore-exit-code 8` to suppress this:
+
+```bash
+# Run all unit tests across the solution, ignoring projects with no matching tests
+dotnet test --solution ./agent-framework-dotnet.slnx --no-build -f net10.0 --ignore-exit-code 8
+```
+
+- **Running tests with `--solution` for a specific TFM** requires all projects in the solution to support that TFM. Not all projects target every framework (e.g., some are `net10.0`-only). Use `./dotnet/eng/scripts/New-FilteredSolution.ps1` to generate a filtered solution:
+
+```powershell
+# Generate a filtered solution for net472 and run tests
+$filtered = ./dotnet/eng/scripts/New-FilteredSolution.ps1 -Solution dotnet/agent-framework-dotnet.slnx -TargetFramework net472
+dotnet test --solution $filtered --no-build -f net472 --ignore-exit-code 8
+
+# Exclude samples and keep only unit test projects
+./dotnet/eng/scripts/New-FilteredSolution.ps1 -Solution dotnet/agent-framework-dotnet.slnx -TargetFramework net10.0 -ExcludeSamples -TestProjectNameFilter "*UnitTests*" -OutputPath dotnet/filtered-unit.slnx
+```
+
+```bash
+# Run tests via dotnet test (uses MTP under the hood)
+dotnet test --project ./tests/Microsoft.Agents.AI.UnitTests -f net10.0
+
+# Run tests with code coverage (Cobertura format)
+dotnet test --project ./tests/Microsoft.Agents.AI.UnitTests -f net10.0 --coverage --coverage-output-format cobertura --coverage-settings ./tests/coverage.runsettings
+
+# Run tests directly via dotnet run (MTP native command line)
+dotnet run --project ./tests/Microsoft.Agents.AI.UnitTests -f net10.0
+
+# Show MTP command line help
+dotnet run --project ./tests/Microsoft.Agents.AI.UnitTests -f net10.0 -- -?
+```

dotnet/Directory.Packages.props

@@ -140,12 +140,10 @@
     <PackageVersion Include="Microsoft.AspNetCore.TestHost" Condition="'$(TargetFramework)' == 'net10.0'" Version="10.0.0" />
     <PackageVersion Include="Microsoft.NET.Test.Sdk" Version="18.0.0" />
     <PackageVersion Include="Moq" Version="[4.18.4]" />
-    <PackageVersion Include="xunit" Version="2.9.3" />
-    <PackageVersion Include="xunit.abstractions" Version="2.0.3" />
-    <PackageVersion Include="xunit.runner.visualstudio" Version="3.1.3" />
-    <PackageVersion Include="Xunit.SkippableFact" Version="1.5.23" />
-    <PackageVersion Include="xretry" Version="1.9.0" />
-    <PackageVersion Include="coverlet.collector" Version="6.0.4" />
+    <PackageVersion Include="xunit.v3.mtp-v2" Version="3.2.2" />
+    <PackageVersion Include="xunit.runner.visualstudio" Version="3.1.5" />
+    <PackageVersion Include="xRetry.v3" Version="1.0.0-rc3" />
+    <PackageVersion Include="Microsoft.Testing.Extensions.CodeCoverage" Version="18.4.1" />
     <!-- Symbols -->
     <PackageVersion Include="Microsoft.SourceLink.GitHub" Version="8.0.0" />
     <!-- Toolset -->

dotnet/agent-framework-dotnet.slnx

@@ -56,6 +56,7 @@
     <Project Path="samples/02-agents/Agents/Agent_Step15_DeepResearch/Agent_Step15_DeepResearch.csproj" />
     <Project Path="samples/02-agents/Agents/Agent_Step16_Declarative/Agent_Step16_Declarative.csproj" />
     <Project Path="samples/02-agents/Agents/Agent_Step17_AdditionalAIContext/Agent_Step17_AdditionalAIContext.csproj" />
+    <Project Path="samples/02-agents/Agents/Agent_Step18_CompactionPipeline/Agent_Step18_CompactionPipeline.csproj" />
   </Folder>
   <Folder Name="/Samples/02-agents/DeclarativeAgents/">
     <Project Path="samples/02-agents/DeclarativeAgents/ChatClient/DeclarativeChatClientAgents.csproj" />
@@ -286,6 +287,8 @@
     <Project Path="samples/05-end-to-end/HostedAgents/AgentsInWorkflows/AgentsInWorkflows.csproj" />
     <Project Path="samples/05-end-to-end/HostedAgents/AgentWithHostedMCP/AgentWithHostedMCP.csproj" />
     <Project Path="samples/05-end-to-end/HostedAgents/AgentWithTextSearchRag/AgentWithTextSearchRag.csproj" />
+    <Project Path="samples/05-end-to-end/HostedAgents/FoundryMultiAgent/FoundryMultiAgent.csproj" />
+    <Project Path="samples/05-end-to-end/HostedAgents/FoundrySingleAgent/FoundrySingleAgent.csproj" />
   </Folder>
   <Folder Name="/Samples/05-end-to-end/AspNetAgentAuthorization/">
     <File Path="samples/05-end-to-end/AspNetAgentAuthorization/docker-compose.yml" />
@@ -311,7 +314,6 @@
   </Folder>
   <Folder Name="/Solution Items/.github/workflows/">
     <File Path="../.github/workflows/dotnet-build-and-test.yml" />
-    <File Path="../.github/workflows/dotnet-check-coverage.ps1" />
     <File Path="../.github/workflows/dotnet-format.yml" />
   </Folder>
   <Folder Name="/Solution Items/demos/">
@@ -348,6 +350,10 @@
     <File Path="eng/MSBuild/Shared.props" />
     <File Path="eng/MSBuild/Shared.targets" />
   </Folder>
+  <Folder Name="/Solution Items/eng/scripts/">
+    <File Path="eng/scripts/dotnet-check-coverage.ps1" />
+    <File Path="eng/scripts/New-FilteredSolution.ps1" />
+  </Folder>
   <Folder Name="/Solution Items/nuget/">
     <File Path="nuget/icon.png" />
     <File Path="nuget/nuget-package.props" />
@@ -413,6 +419,10 @@
     <File Path="src/Shared/IntegrationTests/OpenAIConfiguration.cs" />
     <File Path="src/Shared/IntegrationTests/README.md" />
   </Folder>
+  <Folder Name="/Solution Items/src/Shared/IntegrationTestsAzureCredentials/">
+    <File Path="src/Shared/IntegrationTestsAzureCredentials/README.md" />
+    <File Path="src/Shared/IntegrationTestsAzureCredentials/TestAzureCliCredentials.cs" />
+  </Folder>
   <Folder Name="/Solution Items/src/Shared/Samples/">
     <File Path="src/Shared/Samples/BaseSample.cs" />
     <File Path="src/Shared/Samples/README.md" />

dotnet/eng/MSBuild/Shared.props

@@ -8,6 +8,9 @@
   <ItemGroup Condition="'$(InjectSharedIntegrationTestCode)' == 'true'">
     <Compile Include="$(MSBuildThisFileDirectory)\..\..\src\Shared\IntegrationTests\*.cs" LinkBase="Shared\IntegrationTests" />
   </ItemGroup>
+  <ItemGroup Condition="'$(InjectSharedIntegrationTestAzureCredentialsCode)' == 'true'">
+    <Compile Include="$(MSBuildThisFileDirectory)\..\..\src\Shared\IntegrationTestsAzureCredentials\*.cs" LinkBase="Shared\IntegrationTestsAzureCredentials" />
+  </ItemGroup>
   <ItemGroup Condition="'$(InjectSharedBuildTestCode)' == 'true'">
     <Compile Include="$(MSBuildThisFileDirectory)\..\..\src\Shared\CodeTests\*.cs" LinkBase="Shared\CodeTests" />
   </ItemGroup>

dotnet/eng/scripts/New-FilteredSolution.ps1

@@ -0,0 +1,145 @@
+#!/usr/bin/env pwsh
+# Copyright (c) Microsoft. All rights reserved.
+
+<#
+.SYNOPSIS
+    Generates a filtered .slnx solution file by removing projects that don't match the specified criteria.
+
+.DESCRIPTION
+    Parses a .slnx solution file and applies one or more filters:
+    - Removes projects that don't support the specified target framework (via MSBuild query).
+    - Optionally removes all sample projects (under samples/).
+    - Optionally filters test projects by name pattern (e.g., only *UnitTests*).
+    Writes the filtered solution to the specified output path and prints the path.
+
+.PARAMETER Solution
+    Path to the source .slnx solution file.
+
+.PARAMETER TargetFramework
+    The target framework to filter by (e.g., net10.0, net472).
+
+.PARAMETER Configuration
+    Optional MSBuild configuration used when querying TargetFrameworks. Defaults to Debug.
+
+.PARAMETER TestProjectNameFilter
+    Optional wildcard pattern to filter test project names (e.g., *UnitTests*, *IntegrationTests*).
+    When specified, only test projects whose filename matches this pattern are kept.
+
+.PARAMETER ExcludeSamples
+    When specified, removes all projects under the samples/ directory from the solution.
+
+.PARAMETER OutputPath
+    Optional output path for the filtered .slnx file. If not specified, a temp file is created.
+
+.EXAMPLE
+    # Generate a filtered solution and run tests
+    $filtered = ./dotnet/eng/scripts/New-FilteredSolution.ps1 -Solution dotnet/agent-framework-dotnet.slnx -TargetFramework net472
+    dotnet test --solution $filtered --no-build -f net472
+
+.EXAMPLE
+    # Generate a solution with only unit test projects
+    ./dotnet/eng/scripts/New-FilteredSolution.ps1 -Solution dotnet/agent-framework-dotnet.slnx -TargetFramework net10.0 -TestProjectNameFilter "*UnitTests*" -OutputPath filtered-unit.slnx
+
+.EXAMPLE
+    # Inline usage with dotnet test (PowerShell)
+    dotnet test --solution (./dotnet/eng/scripts/New-FilteredSolution.ps1 -Solution dotnet/agent-framework-dotnet.slnx -TargetFramework net472) --no-build -f net472
+#>
+
+[CmdletBinding()]
+param(
+    [Parameter(Mandatory)]
+    [string]$Solution,
+
+    [Parameter(Mandatory)]
+    [string]$TargetFramework,
+
+    [string]$Configuration = "Debug",
+
+    [string]$TestProjectNameFilter,
+
+    [switch]$ExcludeSamples,
+
+    [string]$OutputPath
+)
+
+$ErrorActionPreference = "Stop"
+
+# Resolve the solution path
+$solutionPath = Resolve-Path $Solution
+$solutionDir = Split-Path $solutionPath -Parent
+
+if (-not $OutputPath) {
+    $OutputPath = [System.IO.Path]::Combine([System.IO.Path]::GetTempPath(), "filtered-$(Split-Path $solutionPath -Leaf)")
+}
+
+# Parse the .slnx XML
+[xml]$slnx = Get-Content $solutionPath -Raw
+
+$removed = @()
+$kept = @()
+
+# Remove sample projects if requested
+if ($ExcludeSamples) {
+    $sampleProjects = $slnx.SelectNodes("//Project[contains(@Path, 'samples/')]")
+    foreach ($proj in $sampleProjects) {
+        $projRelPath = $proj.GetAttribute("Path")
+        Write-Verbose "Removing (sample): $projRelPath"
+        $removed += $projRelPath
+        $proj.ParentNode.RemoveChild($proj) | Out-Null
+    }
+    Write-Host "Removed $($sampleProjects.Count) sample project(s)." -ForegroundColor Yellow
+}
+
+# Filter all remaining projects by target framework
+$allProjects = $slnx.SelectNodes("//Project")
+
+foreach ($proj in $allProjects) {
+    $projRelPath = $proj.GetAttribute("Path")
+    $projFullPath = Join-Path $solutionDir $projRelPath
+    $projFileName = Split-Path $projRelPath -Leaf
+    $isTestProject = $projRelPath -like "*tests/*"
+
+    # Filter test projects by name pattern if specified
+    if ($isTestProject -and $TestProjectNameFilter -and ($projFileName -notlike $TestProjectNameFilter)) {
+        Write-Verbose "Removing (name filter): $projRelPath"
+        $removed += $projRelPath
+        $proj.ParentNode.RemoveChild($proj) | Out-Null
+        continue
+    }
+
+    if (-not (Test-Path $projFullPath)) {
+        Write-Verbose "Project not found, keeping in solution: $projRelPath"
+        $kept += $projRelPath
+        continue
+    }
+
+    # Query the project's target frameworks using MSBuild
+    $targetFrameworks = & dotnet msbuild $projFullPath -getProperty:TargetFrameworks -p:Configuration=$Configuration -nologo 2>$null
+    $targetFrameworks = $targetFrameworks.Trim()
+
+    if ($targetFrameworks -like "*$TargetFramework*") {
+        Write-Verbose "Keeping: $projRelPath (targets: $targetFrameworks)"
+        $kept += $projRelPath
+    }
+    else {
+        Write-Verbose "Removing: $projRelPath (targets: $targetFrameworks, missing: $TargetFramework)"
+        $removed += $projRelPath
+        $proj.ParentNode.RemoveChild($proj) | Out-Null
+    }
+}
+
+# Write the filtered solution
+$slnx.Save($OutputPath)
+
+# Report results to stderr so stdout is clean for piping
+Write-Host "Filtered solution written to: $OutputPath" -ForegroundColor Green
+if ($removed.Count -gt 0) {
+    Write-Host "Removed $($removed.Count) project(s):" -ForegroundColor Yellow
+    foreach ($r in $removed) {
+        Write-Host "  - $r" -ForegroundColor Yellow
+    }
+}
+Write-Host "Kept $($kept.Count) project(s)." -ForegroundColor Green
+
+# Output the path for piping
+Write-Output $OutputPath

dotnet/global.json

@@ -3,5 +3,8 @@
         "version": "10.0.100",
         "rollForward": "minor",
         "allowPrerelease": false
+    },
+    "test": {
+        "runner": "Microsoft.Testing.Platform"
     }
 }

dotnet/samples/02-agents/Agents/Agent_Step18_CompactionPipeline/Agent_Step18_CompactionPipeline.csproj

@@ -0,0 +1,21 @@
+<Project Sdk="Microsoft.NET.Sdk">
+
+  <PropertyGroup>
+    <OutputType>Exe</OutputType>
+    <TargetFrameworks>net10.0</TargetFrameworks>
+
+    <Nullable>enable</Nullable>
+    <ImplicitUsings>enable</ImplicitUsings>
+  </PropertyGroup>
+
+  <ItemGroup>
+    <PackageReference Include="Azure.AI.OpenAI" />
+    <PackageReference Include="Azure.Identity" />
+    <PackageReference Include="Microsoft.Extensions.AI.OpenAI" />
+  </ItemGroup>
+
+  <ItemGroup>
+    <ProjectReference Include="..\..\..\..\src\Microsoft.Agents.AI.OpenAI\Microsoft.Agents.AI.OpenAI.csproj" />
+  </ItemGroup>
+
+</Project>

dotnet/samples/02-agents/Agents/Agent_Step18_CompactionPipeline/Program.cs

@@ -0,0 +1,120 @@
+// Copyright (c) Microsoft. All rights reserved.
+
+// This sample demonstrates how to use a ChatHistoryCompactionPipeline as the ChatReducer for an agent's
+// in-memory chat history. The pipeline chains multiple compaction strategies from gentle to aggressive:
+//   1. ToolResultCompactionStrategy - Collapses old tool-call groups into concise summaries
+//   2. SummarizationCompactionStrategy - LLM-compresses older conversation spans
+//   3. SlidingWindowCompactionStrategy - Keeps only the most recent N user turns
+//   4. TruncationCompactionStrategy - Emergency token-budget backstop
+
+using System.ComponentModel;
+using Azure.AI.OpenAI;
+using Azure.Identity;
+using Microsoft.Agents.AI;
+using Microsoft.Agents.AI.Compaction;
+using Microsoft.Extensions.AI;
+
+var endpoint = Environment.GetEnvironmentVariable("AZURE_OPENAI_ENDPOINT") ?? throw new InvalidOperationException("AZURE_OPENAI_ENDPOINT is not set.");
+var deploymentName = Environment.GetEnvironmentVariable("AZURE_OPENAI_DEPLOYMENT_NAME") ?? "gpt-4o-mini";
+
+// 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 openAIClient = new(new Uri(endpoint), new DefaultAzureCredential());
+
+// Create a chat client for the agent and a separate one for the summarization strategy.
+// Using the same model for simplicity; in production, use a smaller/cheaper model for summarization.
+IChatClient agentChatClient = openAIClient.GetChatClient(deploymentName).AsIChatClient();
+IChatClient summarizerChatClient = openAIClient.GetChatClient(deploymentName).AsIChatClient();
+
+// Define a tool the agent can use, so we can see tool-result compaction in action.
+[Description("Look up the current price of a product by name.")]
+static string LookupPrice([Description("The product name to look up.")] string productName) =>
+    productName.ToUpperInvariant() switch
+    {
+        "LAPTOP" => "The laptop costs $999.99.",
+        "KEYBOARD" => "The keyboard costs $79.99.",
+        "MOUSE" => "The mouse costs $29.99.",
+        _ => $"Sorry, I don't have pricing for '{productName}'."
+    };
+
+// Configure the compaction pipeline with one of each strategy, ordered least to most aggressive.
+const int MaxTokens = 512;
+const int MaxTurns = 4;
+
+ChatHistoryCompactionPipeline compactionPipeline =
+    new(// 1. Gentle: collapse old tool-call groups into short summaries like "[Tool calls: LookupPrice]"
+        new ToolResultCompactionStrategy(MaxTokens, preserveRecentGroups: 2),
+
+        // 2. Moderate: use an LLM to summarize older conversation spans into a concise message
+        new SummarizationCompactionStrategy(summarizerChatClient, MaxTokens, preserveRecentGroups: 2),
+
+        // 3. Aggressive: keep only the last N user turns and their responses
+        new SlidingWindowCompactionStrategy(MaxTurns),
+
+        // 4. Emergency: drop oldest groups until under the token budget
+        new TruncationCompactionStrategy(MaxTokens, preserveRecentGroups: 1));
+
+// TODO: PRECONFIGURED PIPELINE
+////Create(
+////    Approach.Balanced,
+////    Size.Compact,
+////    summarizerChatClient);
+
+// Create the agent with an in-memory chat history provider whose reducer is the compaction pipeline.
+AIAgent agent =
+    agentChatClient.AsAIAgent(
+        new ChatClientAgentOptions
+        {
+            Name = "ShoppingAssistant",
+            ChatOptions = new()
+            {
+                Instructions =
+                    """
+                    You are a helpful, but long winded, shopping assistant.
+                    Help the user look up prices and compare products.
+                    When responding, Be sure to be extra descriptive and use as
+                    many words as possible without sounding ridiculous.
+                    """,
+                Tools = [AIFunctionFactory.Create(LookupPrice)],
+            },
+            ChatHistoryProvider = new InMemoryChatHistoryProvider(new() { ChatReducer = compactionPipeline }),
+        });
+
+AgentSession session = await agent.CreateSessionAsync();
+
+// Helper to print chat history size
+void PrintChatHistory()
+{
+    if (session.TryGetInMemoryChatHistory(out var history))
+    {
+        Console.ForegroundColor = ConsoleColor.Cyan;
+        Console.WriteLine($"\n[Messages: x{history.Count}]\n");
+        Console.ResetColor();
+    }
+}
+
+// Run a multi-turn conversation with tool calls to exercise the pipeline.
+string[] prompts =
+[
+    "What's the price of a laptop?",
+    "How about a keyboard?",
+    "And a mouse?",
+    "Which product is the cheapest?",
+    "Can you compare the laptop and the keyboard for me?",
+    "What was the first product I asked about?",
+    "Thank you!",
+];
+
+foreach (string prompt in prompts)
+{
+    Console.ForegroundColor = ConsoleColor.Cyan;
+    Console.Write("\n[User] ");
+    Console.ResetColor();
+    Console.WriteLine(prompt);
+    Console.ForegroundColor = ConsoleColor.Cyan;
+    Console.Write("\n[Agent] ");
+    Console.ResetColor();
+    Console.WriteLine(await agent.RunAsync(prompt, session));
+    PrintChatHistory();
+}

dotnet/samples/02-agents/Agents/README.md

@@ -44,6 +44,7 @@ Before you begin, ensure you have the following prerequisites:
 |[Deep research with an agent](./Agent_Step15_DeepResearch/)|This sample demonstrates how to use the Deep Research Tool to perform comprehensive research on complex topics|
 |[Declarative agent](./Agent_Step16_Declarative/)|This sample demonstrates how to declaratively define an agent.|
 |[Providing additional AI Context to an agent using multiple AIContextProviders](./Agent_Step17_AdditionalAIContext/)|This sample demonstrates how to inject additional AI context into a ChatClientAgent using multiple custom AIContextProvider components that are attached to the agent.|
+|[Using compaction pipeline with an agent](./Agent_Step18_CompactionPipeline/)|This sample demonstrates how to use a compaction pipeline to efficiently limit the size of the conversation history for an agent.|
 
 ## Running the samples from the console
 

dotnet/samples/05-end-to-end/AspNetAgentAuthorization/Service/Program.cs

@@ -75,10 +75,15 @@ string apiKey = builder.Configuration["OPENAI_API_KEY"]
     ?? throw new InvalidOperationException("Set the OPENAI_API_KEY environment variable.");
 string model = builder.Configuration["OPENAI_MODEL"] ?? "gpt-4.1-mini";
 
+// Here we are using Singleton lifetime, since none of the services, function tools and user context classes in the sample have state that are per request.
+// You should evaluate the appropriate lifetime for your own services and tools based on their behavior and dependencies.
+// E.g. if any of the service instances or tools maintain state that is specific to a user, and each request may be from a different user,
+// you should use Scoped lifetime instead, so that a new instance is created for each request.
+// Note that if you use Scoped lifetime for any dependencies, you must also use Scoped lifetime for any class that uses it, including the agent itself.
 builder.Services.AddHttpContextAccessor();
-builder.Services.AddScoped<IUserContext, KeycloakUserContext>();
-builder.Services.AddScoped<ExpenseService>();
-builder.Services.AddScoped<AIAgent>(sp =>
+builder.Services.AddSingleton<IUserContext, KeycloakUserContext>();
+builder.Services.AddSingleton<ExpenseService>();
+builder.Services.AddSingleton<AIAgent>(sp =>
 {
     var expenseService = sp.GetRequiredService<ExpenseService>();
 

dotnet/samples/05-end-to-end/AspNetAgentAuthorization/Service/UserContext.cs

@@ -27,43 +27,73 @@ public interface IUserContext
 /// Keycloak uses <c>sub</c> for the user ID, <c>preferred_username</c>
 /// for the login name, <c>given_name</c>/<c>family_name</c> for the
 /// display name, and <c>scope</c> (space-delimited) for granted scopes.
-/// Registered as a scoped service so it is resolved once per request.
+/// Registered as a singleton — claims are parsed once per request and
+/// cached in <see cref="HttpContext.Items"/>.
 /// </summary>
 public sealed class KeycloakUserContext : IUserContext
 {
-    public string UserId { get; }
+    private static readonly object s_cacheKey = new();
 
-    public string UserName { get; }
-
-    public string DisplayName { get; }
-
-    public IReadOnlySet<string> Scopes { get; }
+    private readonly IHttpContextAccessor _httpContextAccessor;
 
     public KeycloakUserContext(IHttpContextAccessor httpContextAccessor)
     {
-        ClaimsPrincipal? user = httpContextAccessor.HttpContext?.User;
+        this._httpContextAccessor = httpContextAccessor;
+    }
 
-        this.UserId = user?.FindFirstValue(ClaimTypes.NameIdentifier)
-                   ?? user?.FindFirstValue("sub")
-                   ?? "anonymous";
+    public string UserId => this.GetOrCreateCachedInfo().UserId;
 
-        this.UserName = user?.FindFirstValue("preferred_username")
-                     ?? user?.FindFirstValue(ClaimTypes.Name)
-                     ?? "unknown";
+    public string UserName => this.GetOrCreateCachedInfo().UserName;
+
+    public string DisplayName => this.GetOrCreateCachedInfo().DisplayName;
+
+    public IReadOnlySet<string> Scopes => this.GetOrCreateCachedInfo().Scopes;
+
+    private CachedUserInfo GetOrCreateCachedInfo()
+    {
+        HttpContext? httpContext = this._httpContextAccessor.HttpContext;
+        if (httpContext is not null && httpContext.Items.TryGetValue(s_cacheKey, out object? cached) && cached is CachedUserInfo info)
+        {
+            return info;
+        }
+
+        info = ParseClaims(httpContext?.User);
+
+        if (httpContext is not null)
+        {
+            httpContext.Items[s_cacheKey] = info;
+        }
+
+        return info;
+    }
+
+    private static CachedUserInfo ParseClaims(ClaimsPrincipal? user)
+    {
+        string userId = user?.FindFirstValue(ClaimTypes.NameIdentifier)
+                     ?? user?.FindFirstValue("sub")
+                     ?? "anonymous";
+
+        string userName = user?.FindFirstValue("preferred_username")
+                       ?? user?.FindFirstValue(ClaimTypes.Name)
+                       ?? "unknown";
 
         string? givenName = user?.FindFirstValue("given_name") ?? user?.FindFirstValue(ClaimTypes.GivenName);
         string? familyName = user?.FindFirstValue("family_name") ?? user?.FindFirstValue(ClaimTypes.Surname);
-        this.DisplayName = (givenName, familyName) switch
+        string displayName = (givenName, familyName) switch
         {
             (not null, not null) => $"{givenName} {familyName}",
             (not null, null) => givenName,
             (null, not null) => familyName,
-            _ => this.UserName,
+            _ => userName,
         };
 
         string? scopeClaim = user?.FindFirstValue("scope");
-        this.Scopes = scopeClaim is not null
+        IReadOnlySet<string> scopes = scopeClaim is not null
             ? new HashSet<string>(scopeClaim.Split(' ', StringSplitOptions.RemoveEmptyEntries), StringComparer.OrdinalIgnoreCase)
             : new HashSet<string>(StringComparer.OrdinalIgnoreCase);
+
+        return new CachedUserInfo(userId, userName, displayName, scopes);
     }
+
+    private sealed record CachedUserInfo(string UserId, string UserName, string DisplayName, IReadOnlySet<string> Scopes);
 }

dotnet/samples/05-end-to-end/HostedAgents/FoundryMultiAgent/Dockerfile

@@ -0,0 +1,20 @@
+# Build the application
+FROM mcr.microsoft.com/dotnet/sdk:10.0-alpine AS build
+WORKDIR /src
+
+# Copy files from the current directory on the host to the working directory in the container
+COPY . .
+
+RUN dotnet restore
+RUN dotnet build -c Release --no-restore
+RUN dotnet publish -c Release --no-build -o /app -f net10.0
+
+# Run the application
+FROM mcr.microsoft.com/dotnet/aspnet:10.0-alpine AS final
+WORKDIR /app
+
+# Copy everything needed to run the app from the "build" stage.
+COPY --from=build /app .
+
+EXPOSE 8088
+ENTRYPOINT ["dotnet", "FoundryMultiAgent.dll"]

dotnet/samples/05-end-to-end/HostedAgents/FoundryMultiAgent/FoundryMultiAgent.csproj

@@ -0,0 +1,76 @@
+<Project Sdk="Microsoft.NET.Sdk">
+  <PropertyGroup>
+    <OutputType>Exe</OutputType>
+    <TargetFrameworks>net10.0</TargetFrameworks>
+    <ImplicitUsings>enable</ImplicitUsings>
+    <Nullable>enable</Nullable>
+
+    <!-- 
+      Disable central package management for this project.
+      This project requires explicit package references with versions specified inline rather than 
+      inheriting them from Directory.Packages.props. This is necessary because a Docker image will 
+      be created from this project, and the Docker build process only has access to this folder 
+      and cannot access parent folders where Directory.Packages.props resides.
+    -->
+    <ManagePackageVersionsCentrally>false</ManagePackageVersionsCentrally>
+  </PropertyGroup>
+
+  <!-- 
+    Remove analyzer PackageReference items inherited from Directory.Packages.props.
+    Note: ManagePackageVersionsCentrally only controls PackageVersion items, not PackageReference items.
+    Directory.Packages.props contains both PackageVersion and PackageReference entries for analyzers,
+    and the PackageReference items are always inherited through MSBuild imports regardless of the 
+    ManagePackageVersionsCentrally setting. We must explicitly remove them before adding our own versions.
+  -->
+  <ItemGroup>
+    <PackageReference Remove="Microsoft.CodeAnalysis.NetAnalyzers" />
+    <PackageReference Remove="Microsoft.VisualStudio.Threading.Analyzers" />
+    <PackageReference Remove="xunit.analyzers" />
+    <PackageReference Remove="Moq.Analyzers" />
+    <PackageReference Remove="Roslynator.Analyzers" />
+    <PackageReference Remove="Roslynator.CodeAnalysis.Analyzers" />
+    <PackageReference Remove="Roslynator.Formatting.Analyzers" />
+  </ItemGroup>
+
+  <ItemGroup>
+    <PackageReference Include="Azure.AI.AgentServer.AgentFramework" Version="1.0.0-beta.8" />
+    <PackageReference Include="Azure.AI.Projects" Version="1.2.0-beta.5" />
+    <PackageReference Include="Azure.Identity" Version="1.17.1" />
+    <PackageReference Include="Microsoft.Agents.AI" Version="1.0.0-preview.251219.1" />
+    <PackageReference Include="Microsoft.Agents.AI.AzureAI" Version="1.0.0-preview.251219.1" />
+    <PackageReference Include="Microsoft.Agents.AI.Workflows" Version="1.0.0-preview.251219.1" />
+    <PackageReference Include="OpenTelemetry" Version="1.12.0" />
+    <PackageReference Include="OpenTelemetry.Exporter.OpenTelemetryProtocol" Version="1.12.0" />
+  </ItemGroup>
+
+  <!-- Add analyzers with compatible versions -->
+  <ItemGroup>
+    <PackageReference Include="Microsoft.CodeAnalysis.NetAnalyzers" Version="10.0.100">
+      <PrivateAssets>all</PrivateAssets>
+      <IncludeAssets>runtime; build; native; contentfiles; analyzers; buildtransitive</IncludeAssets>
+    </PackageReference>
+    <PackageReference Include="Microsoft.VisualStudio.Threading.Analyzers" Version="17.14.15">
+      <PrivateAssets>all</PrivateAssets>
+      <IncludeAssets>runtime; build; native; contentfiles; analyzers; buildtransitive</IncludeAssets>
+    </PackageReference>
+    <PackageReference Include="Roslynator.Analyzers" Version="4.14.1">
+      <PrivateAssets>all</PrivateAssets>
+      <IncludeAssets>runtime; build; native; contentfiles; analyzers; buildtransitive</IncludeAssets>
+    </PackageReference>
+    <PackageReference Include="Roslynator.CodeAnalysis.Analyzers" Version="4.14.1">
+      <PrivateAssets>all</PrivateAssets>
+      <IncludeAssets>runtime; build; native; contentfiles; analyzers; buildtransitive</IncludeAssets>
+    </PackageReference>
+    <PackageReference Include="Roslynator.Formatting.Analyzers" Version="4.14.1">
+      <PrivateAssets>all</PrivateAssets>
+      <IncludeAssets>runtime; build; native; contentfiles; analyzers; buildtransitive</IncludeAssets>
+    </PackageReference>
+  </ItemGroup>
+
+  <ItemGroup>
+    <None Update="appsettings.Development.json">
+      <CopyToOutputDirectory>PreserveNewest</CopyToOutputDirectory>
+    </None>
+  </ItemGroup>
+
+</Project>

dotnet/samples/05-end-to-end/HostedAgents/FoundryMultiAgent/Program.cs

@@ -0,0 +1,49 @@
+// Copyright (c) Microsoft. All rights reserved.
+
+// This sample demonstrates a multi-agent workflow with Writer and Reviewer agents
+// using Azure AI Foundry AIProjectClient and the Agent Framework WorkflowBuilder.
+
+using Azure.AI.AgentServer.AgentFramework.Extensions;
+using Azure.AI.Projects;
+using Azure.Identity;
+using Microsoft.Agents.AI;
+using Microsoft.Agents.AI.Workflows;
+
+var endpoint = Environment.GetEnvironmentVariable("AZURE_AI_PROJECT_ENDPOINT")
+    ?? throw new InvalidOperationException("AZURE_AI_PROJECT_ENDPOINT is not set.");
+var deploymentName = Environment.GetEnvironmentVariable("MODEL_DEPLOYMENT_NAME") ?? "gpt-4o-mini";
+
+Console.WriteLine($"Using Azure AI endpoint: {endpoint}");
+Console.WriteLine($"Using model deployment: {deploymentName}");
+
+// 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.
+AIProjectClient aiProjectClient = new(new Uri(endpoint), new DefaultAzureCredential());
+
+// Create Foundry agents
+AIAgent writerAgent = await aiProjectClient.CreateAIAgentAsync(
+    name: "Writer",
+    model: deploymentName,
+    instructions: "You are an excellent content writer. You create new content and edit contents based on the feedback.");
+
+AIAgent reviewerAgent = await aiProjectClient.CreateAIAgentAsync(
+    name: "Reviewer",
+    model: deploymentName,
+    instructions: "You are an excellent content reviewer. Provide actionable feedback to the writer about the provided content. Provide the feedback in the most concise manner possible.");
+
+try
+{
+    var workflow = new WorkflowBuilder(writerAgent)
+        .AddEdge(writerAgent, reviewerAgent)
+        .Build();
+
+    Console.WriteLine("Starting Writer-Reviewer Workflow Agent Server on http://localhost:8088");
+    await workflow.AsAgent().RunAIAgentAsync();
+}
+finally
+{
+    // Cleanup server-side agents
+    await aiProjectClient.Agents.DeleteAgentAsync(writerAgent.Name);
+    await aiProjectClient.Agents.DeleteAgentAsync(reviewerAgent.Name);
+}

dotnet/samples/05-end-to-end/HostedAgents/FoundryMultiAgent/README.md

@@ -0,0 +1,168 @@
+**IMPORTANT!** All samples and other resources made available in this GitHub repository ("samples") are designed to assist in accelerating development of agents, solutions, and agent workflows for various scenarios. Review all provided resources and carefully test output behavior in the context of your use case. AI responses may be inaccurate and AI actions should be monitored with human oversight. Learn more in the transparency documents for [Agent Service](https://learn.microsoft.com/en-us/azure/ai-foundry/responsible-ai/agents/transparency-note) and [Agent Framework](https://github.com/microsoft/agent-framework/blob/main/TRANSPARENCY_FAQ.md).
+
+Agents, solutions, or other output you create may be subject to legal and regulatory requirements, may require licenses, or may not be suitable for all industries, scenarios, or use cases. By using any sample, you are acknowledging that any output created using those samples are solely your responsibility, and that you will comply with all applicable laws, regulations, and relevant safety standards, terms of service, and codes of conduct.
+
+Third-party samples contained in this folder are subject to their own designated terms, and they have not been tested or verified by Microsoft or its affiliates.
+
+Microsoft has no responsibility to you or others with respect to any of these samples or any resulting output.
+
+# What this sample demonstrates
+
+This sample demonstrates a **key advantage of code-based hosted agents**:
+
+- **Multi-agent workflows** - Orchestrate multiple agents working together
+
+Code-based agents can execute **any C# code** you write. This sample includes a Writer-Reviewer workflow where two agents collaborate: a Writer creates content and a Reviewer provides feedback.
+
+The agent is hosted using the [Azure AI AgentServer SDK](https://www.nuget.org/packages/Azure.AI.AgentServer.AgentFramework/) and can be deployed to Microsoft Foundry.
+
+## How It Works
+
+### Multi-Agent Workflow
+
+In [Program.cs](Program.cs), the sample creates two agents using `AIProjectClient.CreateAIAgentAsync()` from the [Microsoft.Agents.AI.AzureAI](https://www.nuget.org/packages/Microsoft.Agents.AI.AzureAI/) package:
+
+- **Writer** - An agent that creates and edits content based on feedback
+- **Reviewer** - An agent that provides actionable feedback on the content
+
+The `WorkflowBuilder` from the [Microsoft.Agents.AI.Workflows](https://www.nuget.org/packages/Microsoft.Agents.AI.Workflows/) package connects these agents in a sequential flow:
+
+1. The Writer receives the initial request and generates content
+2. The Reviewer evaluates the content and provides feedback
+3. Both agent responses are output to the user
+
+### Agent Hosting
+
+The agent is hosted using the [Azure AI AgentServer SDK](https://www.nuget.org/packages/Azure.AI.AgentServer.AgentFramework/),
+which provisions a REST API endpoint compatible with the OpenAI Responses protocol.
+
+## Running the Agent Locally
+
+### Prerequisites
+
+Before running this sample, ensure you have:
+
+1. **Azure AI Foundry Project**
+   - Project created.
+   - Chat model deployed (e.g., `gpt-4o` or `gpt-4.1`)
+   - Note your project endpoint URL and model deployment name
+     > **Note**: You can right-click the project in the Microsoft Foundry VS Code extension and select `Copy Project Endpoint URL` to get the endpoint.
+
+2. **Azure CLI**
+   - Installed and authenticated
+   - Run `az login` and verify with `az account show`
+   - Your identity needs the **Azure AI Developer** role on the Foundry resource (for `agents/write` data action required by `CreateAIAgentAsync`)
+
+3. **.NET 10.0 SDK or later**
+   - Verify your version: `dotnet --version`
+   - Download from [https://dotnet.microsoft.com/download](https://dotnet.microsoft.com/download)
+
+### Environment Variables
+
+Set the following environment variables:
+
+**PowerShell:**
+
+```powershell
+# Replace with your actual values
+$env:AZURE_AI_PROJECT_ENDPOINT="https://<your-resource>.services.ai.azure.com/api/projects/<your-project>"
+$env:MODEL_DEPLOYMENT_NAME="gpt-4o-mini"
+```
+
+**Bash:**
+
+```bash
+export AZURE_AI_PROJECT_ENDPOINT="https://<your-resource>.services.ai.azure.com/api/projects/<your-project>"
+export MODEL_DEPLOYMENT_NAME="gpt-4o-mini"
+```
+
+### Running the Sample
+
+To run the agent, execute the following command in your terminal:
+
+```bash
+dotnet restore
+dotnet build
+dotnet run
+```
+
+This will start the hosted agent locally on `http://localhost:8088/`.
+
+### Interacting with the Agent
+
+**VS Code:**
+
+1. Open the Visual Studio Code Command Palette and execute the `Microsoft Foundry: Open Container Agent Playground Locally` command.
+2. Execute the following commands to start the containerized hosted agent.
+   ```bash
+   dotnet restore
+   dotnet build
+   dotnet run
+   ```
+3. Submit a request to the agent through the playground interface. For example, you may enter a prompt such as: "Create a slogan for a new electric SUV that is affordable and fun to drive."
+4. Review the agent's response in the playground interface.
+
+> **Note**: Open the local playground before starting the container agent to ensure the visualization functions correctly.
+
+**PowerShell (Windows):**
+
+```powershell
+$body = @{
+    input = "Create a slogan for a new electric SUV that is affordable and fun to drive"
+    stream = $false
+} | ConvertTo-Json
+
+Invoke-RestMethod -Uri http://localhost:8088/responses -Method Post -Body $body -ContentType "application/json"
+```
+
+**Bash/curl (Linux/macOS):**
+
+```bash
+curl -sS -H "Content-Type: application/json" -X POST http://localhost:8088/responses \
+   -d '{"input": "Create a slogan for a new electric SUV that is affordable and fun to drive","stream":false}'
+```
+
+You can also use the `run-requests.http` file in this directory with the VS Code REST Client extension.
+
+The Writer agent will generate content based on your prompt, and the Reviewer agent will provide feedback on the output.
+
+## Deploying the Agent to Microsoft Foundry
+
+**Preparation (required)**
+
+Please check the environment_variables section in [agent.yaml](agent.yaml) and ensure the variables there are set in your target Microsoft Foundry Project.
+
+To deploy the hosted agent:
+
+1. Open the VS Code Command Palette and run the `Microsoft Foundry: Deploy Hosted Agent` command.
+
+2. Follow the interactive deployment prompts. The extension will help you select or create the container files it needs.
+
+3. After deployment completes, the hosted agent appears under the `Hosted Agents (Preview)` section of the extension tree. You can select the agent there to view details and test it using the integrated playground.
+
+**What the deploy flow does for you:**
+
+- Creates or obtains an Azure Container Registry for the target project.
+- Builds and pushes a container image from your workspace (the build packages the workspace respecting `.dockerignore`).
+- Creates an agent version in Microsoft Foundry using the built image. If a `.env` file exists at the workspace root, the extension will parse it and include its key/value pairs as the hosted agent's environment variables in the create request (these variables will be available to the agent runtime).
+- Starts the agent container on the project's capability host. If the capability host is not provisioned, the extension will prompt you to enable it and will guide you through creating it.
+
+## MSI Configuration in the Azure Portal
+
+This sample requires the Microsoft Foundry Project to authenticate using a Managed Identity when running remotely in Azure. Grant the project's managed identity the required permissions by assigning the built-in [Azure AI User](https://aka.ms/foundry-ext-project-role) role.
+
+To configure the Managed Identity:
+
+1. In the Azure Portal, open the Foundry Project.
+2. Select "Access control (IAM)" from the left-hand menu.
+3. Click "Add" and choose "Add role assignment".
+4. In the role selection, search for and select "Azure AI User", then click "Next".
+5. For "Assign access to", choose "Managed identity".
+6. Click "Select members", locate the managed identity associated with your Foundry Project (you can search by the project name), then click "Select".
+7. Click "Review + assign" to complete the assignment.
+8. Allow a few minutes for the role assignment to propagate before running the application.
+
+## Additional Resources
+
+- [Microsoft Agents Framework](https://learn.microsoft.com/en-us/agent-framework/overview/agent-framework-overview)
+- [Managed Identities for Azure Resources](https://learn.microsoft.com/en-us/entra/identity/managed-identities-azure-resources/)

dotnet/samples/05-end-to-end/HostedAgents/FoundryMultiAgent/agent.yaml

@@ -0,0 +1,31 @@
+# yaml-language-server: $schema=https://raw.githubusercontent.com/microsoft/AgentSchema/refs/heads/main/schemas/v1.0/ContainerAgent.yaml
+
+name: FoundryMultiAgent
+displayName: "Foundry Multi-Agent Workflow"
+description: >
+  A multi-agent workflow featuring a Writer and Reviewer that collaborate
+  to create and refine content using Azure AI Foundry PersistentAgentsClient.
+metadata:
+  authors:
+    - Microsoft Agent Framework Team
+  tags:
+    - Azure AI AgentServer
+    - Microsoft Agent Framework
+    - Multi-Agent Workflow
+    - Writer-Reviewer
+    - Content Creation
+template:
+  kind: hosted
+  name: FoundryMultiAgent
+  protocols:
+    - protocol: responses
+      version: v1
+  environment_variables:
+    - name: AZURE_AI_PROJECT_ENDPOINT
+      value: ${AZURE_AI_PROJECT_ENDPOINT}
+    - name: MODEL_DEPLOYMENT_NAME
+      value: gpt-4o-mini
+resources:
+  - name: "gpt-4o-mini"
+    kind: model
+    id: gpt-4o-mini

dotnet/samples/05-end-to-end/HostedAgents/FoundryMultiAgent/appsettings.Development.json

@@ -0,0 +1,4 @@
+{
+    "AZURE_AI_PROJECT_ENDPOINT": "https://<your-resource>.services.ai.azure.com/api/projects/<your-project>",
+    "MODEL_DEPLOYMENT_NAME": "gpt-4o-mini"
+}

dotnet/samples/05-end-to-end/HostedAgents/FoundryMultiAgent/run-requests.http

@@ -0,0 +1,34 @@
+@host = http://localhost:8088
+@endpoint = {{host}}/responses
+
+### Health Check
+GET {{host}}/readiness
+
+### Simple string input - Content creation request
+POST {{endpoint}}
+Content-Type: application/json
+
+{
+    "input": "Create a slogan for a new electric SUV that is affordable and fun to drive",
+    "stream": false
+}
+
+### Explicit input format
+POST {{endpoint}}
+Content-Type: application/json
+
+{
+    "input": [
+        {
+            "type": "message",
+            "role": "user",
+            "content": [
+                {
+                    "type": "input_text",
+                    "text": "Write a short product description for a smart water bottle that tracks hydration"
+                }
+            ]
+        }
+    ],
+    "stream": false
+}

dotnet/samples/05-end-to-end/HostedAgents/FoundrySingleAgent/Dockerfile

@@ -0,0 +1,20 @@
+# Build the application
+FROM mcr.microsoft.com/dotnet/sdk:10.0-alpine AS build
+WORKDIR /src
+
+# Copy files from the current directory on the host to the working directory in the container
+COPY . .
+
+RUN dotnet restore
+RUN dotnet build -c Release --no-restore
+RUN dotnet publish -c Release --no-build -o /app -f net10.0
+
+# Run the application
+FROM mcr.microsoft.com/dotnet/aspnet:10.0-alpine AS final
+WORKDIR /app
+
+# Copy everything needed to run the app from the "build" stage.
+COPY --from=build /app .
+
+EXPOSE 8088
+ENTRYPOINT ["dotnet", "FoundrySingleAgent.dll"]

dotnet/samples/05-end-to-end/HostedAgents/FoundrySingleAgent/FoundrySingleAgent.csproj

@@ -0,0 +1,67 @@
+<Project Sdk="Microsoft.NET.Sdk">
+  <PropertyGroup>
+    <OutputType>Exe</OutputType>
+    <TargetFrameworks>net10.0</TargetFrameworks>
+    <Nullable>enable</Nullable>
+    <ImplicitUsings>enable</ImplicitUsings>
+
+    <!-- 
+      Disable central package management for this project.
+      This project requires explicit package references with versions specified inline rather than 
+      inheriting them from Directory.Packages.props. This is necessary because a Docker image will 
+      be created from this project, and the Docker build process only has access to this folder 
+      and cannot access parent folders where Directory.Packages.props resides.
+    -->
+    <ManagePackageVersionsCentrally>false</ManagePackageVersionsCentrally>
+  </PropertyGroup>
+
+  <!-- 
+    Remove analyzer PackageReference items inherited from Directory.Packages.props.
+    Note: ManagePackageVersionsCentrally only controls PackageVersion items, not PackageReference items.
+    Directory.Packages.props contains both PackageVersion and PackageReference entries for analyzers,
+    and the PackageReference items are always inherited through MSBuild imports regardless of the 
+    ManagePackageVersionsCentrally setting. We must explicitly remove them before adding our own versions.
+  -->
+  <ItemGroup>
+    <PackageReference Remove="Microsoft.CodeAnalysis.NetAnalyzers" />
+    <PackageReference Remove="Microsoft.VisualStudio.Threading.Analyzers" />
+    <PackageReference Remove="xunit.analyzers" />
+    <PackageReference Remove="Moq.Analyzers" />
+    <PackageReference Remove="Roslynator.Analyzers" />
+    <PackageReference Remove="Roslynator.CodeAnalysis.Analyzers" />
+    <PackageReference Remove="Roslynator.Formatting.Analyzers" />
+  </ItemGroup>
+
+  <ItemGroup>
+    <PackageReference Include="Azure.AI.AgentServer.AgentFramework" Version="1.0.0-beta.8" />
+    <PackageReference Include="Azure.AI.Projects" Version="1.2.0-beta.5" />
+    <PackageReference Include="Azure.Identity" Version="1.17.1" />
+    <PackageReference Include="Microsoft.Agents.AI" Version="1.0.0-preview.251219.1" />
+    <PackageReference Include="Microsoft.Agents.AI.AzureAI" Version="1.0.0-preview.251219.1" />
+  </ItemGroup>
+
+  <!-- Add analyzers with compatible versions -->
+  <ItemGroup>
+    <PackageReference Include="Microsoft.CodeAnalysis.NetAnalyzers" Version="10.0.100">
+      <PrivateAssets>all</PrivateAssets>
+      <IncludeAssets>runtime; build; native; contentfiles; analyzers; buildtransitive</IncludeAssets>
+    </PackageReference>
+    <PackageReference Include="Microsoft.VisualStudio.Threading.Analyzers" Version="17.14.15">
+      <PrivateAssets>all</PrivateAssets>
+      <IncludeAssets>runtime; build; native; contentfiles; analyzers; buildtransitive</IncludeAssets>
+    </PackageReference>
+    <PackageReference Include="Roslynator.Analyzers" Version="4.14.1">
+      <PrivateAssets>all</PrivateAssets>
+      <IncludeAssets>runtime; build; native; contentfiles; analyzers; buildtransitive</IncludeAssets>
+    </PackageReference>
+    <PackageReference Include="Roslynator.CodeAnalysis.Analyzers" Version="4.14.1">
+      <PrivateAssets>all</PrivateAssets>
+      <IncludeAssets>runtime; build; native; contentfiles; analyzers; buildtransitive</IncludeAssets>
+    </PackageReference>
+    <PackageReference Include="Roslynator.Formatting.Analyzers" Version="4.14.1">
+      <PrivateAssets>all</PrivateAssets>
+      <IncludeAssets>runtime; build; native; contentfiles; analyzers; buildtransitive</IncludeAssets>
+    </PackageReference>
+  </ItemGroup>
+
+</Project>

dotnet/samples/05-end-to-end/HostedAgents/FoundrySingleAgent/Program.cs

@@ -0,0 +1,128 @@
+// Copyright (c) Microsoft. All rights reserved.
+
+// Seattle Hotel Agent - A simple agent with a tool to find hotels in Seattle.
+// Uses Microsoft Agent Framework with Azure AI Foundry.
+// Ready for deployment to Foundry Hosted Agent service.
+
+using System.ComponentModel;
+using System.Globalization;
+using System.Text;
+
+using Azure.AI.AgentServer.AgentFramework.Extensions;
+using Azure.AI.Projects;
+using Azure.Identity;
+using Microsoft.Agents.AI;
+using Microsoft.Extensions.AI;
+
+// Get configuration from environment variables
+var endpoint = Environment.GetEnvironmentVariable("AZURE_AI_PROJECT_ENDPOINT")
+    ?? throw new InvalidOperationException("AZURE_AI_PROJECT_ENDPOINT is not set.");
+var deploymentName = Environment.GetEnvironmentVariable("MODEL_DEPLOYMENT_NAME") ?? "gpt-4o-mini";
+Console.WriteLine($"Project Endpoint: {endpoint}");
+Console.WriteLine($"Model Deployment: {deploymentName}");
+// Simulated hotel data for Seattle
+var seattleHotels = new[]
+{
+    new Hotel("Contoso Suites", 189, 4.5, "Downtown"),
+    new Hotel("Fabrikam Residences", 159, 4.2, "Pike Place Market"),
+    new Hotel("Alpine Ski House", 249, 4.7, "Seattle Center"),
+    new Hotel("Margie's Travel Lodge", 219, 4.4, "Waterfront"),
+    new Hotel("Northwind Inn", 139, 4.0, "Capitol Hill"),
+    new Hotel("Relecloud Hotel", 99, 3.8, "University District"),
+};
+
+[Description("Get available hotels in Seattle for the specified dates. This simulates a call to a hotel availability API.")]
+string GetAvailableHotels(
+    [Description("Check-in date in YYYY-MM-DD format")] string checkInDate,
+    [Description("Check-out date in YYYY-MM-DD format")] string checkOutDate,
+    [Description("Maximum price per night in USD (optional, defaults to 500)")] int maxPrice = 500)
+{
+    try
+    {
+        // Parse dates
+        if (!DateTime.TryParseExact(checkInDate, "yyyy-MM-dd", CultureInfo.InvariantCulture, DateTimeStyles.None, out var checkIn))
+        {
+            return "Error parsing check-in date. Please use YYYY-MM-DD format.";
+        }
+
+        if (!DateTime.TryParseExact(checkOutDate, "yyyy-MM-dd", CultureInfo.InvariantCulture, DateTimeStyles.None, out var checkOut))
+        {
+            return "Error parsing check-out date. Please use YYYY-MM-DD format.";
+        }
+
+        // Validate dates
+        if (checkOut <= checkIn)
+        {
+            return "Error: Check-out date must be after check-in date.";
+        }
+
+        var nights = (checkOut - checkIn).Days;
+
+        // Filter hotels by price
+        var availableHotels = seattleHotels.Where(h => h.PricePerNight <= maxPrice).ToList();
+
+        if (availableHotels.Count == 0)
+        {
+            return $"No hotels found in Seattle within your budget of ${maxPrice}/night.";
+        }
+
+        // Build response
+        var result = new StringBuilder();
+        result.AppendLine($"Available hotels in Seattle from {checkInDate} to {checkOutDate} ({nights} nights):");
+        result.AppendLine();
+
+        foreach (var hotel in availableHotels)
+        {
+            var totalCost = hotel.PricePerNight * nights;
+            result.AppendLine($"**{hotel.Name}**");
+            result.AppendLine($"   Location: {hotel.Location}");
+            result.AppendLine($"   Rating: {hotel.Rating}/5");
+            result.AppendLine($"   ${hotel.PricePerNight}/night (Total: ${totalCost})");
+            result.AppendLine();
+        }
+
+        return result.ToString();
+    }
+    catch (Exception ex)
+    {
+        return $"Error processing request. Details: {ex.Message}";
+    }
+}
+
+// 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.
+AIProjectClient aiProjectClient = new(new Uri(endpoint), new DefaultAzureCredential());
+
+// Create Foundry agent with hotel search tool
+AIAgent agent = await aiProjectClient.CreateAIAgentAsync(
+    name: "SeattleHotelAgent",
+    model: deploymentName,
+    instructions: """
+        You are a helpful travel assistant specializing in finding hotels in Seattle, Washington.
+
+        When a user asks about hotels in Seattle:
+        1. Ask for their check-in and check-out dates if not provided
+        2. Ask about their budget preferences if not mentioned
+        3. Use the GetAvailableHotels tool to find available options
+        4. Present the results in a friendly, informative way
+        5. Offer to help with additional questions about the hotels or Seattle
+
+        Be conversational and helpful. If users ask about things outside of Seattle hotels,
+        politely let them know you specialize in Seattle hotel recommendations.
+        """,
+    tools: [AIFunctionFactory.Create(GetAvailableHotels)]);
+
+try
+{
+    Console.WriteLine("Seattle Hotel Agent Server running on http://localhost:8088");
+    await agent.RunAIAgentAsync(telemetrySourceName: "Agents");
+}
+finally
+{
+    // Cleanup server-side agent
+    await aiProjectClient.Agents.DeleteAgentAsync(agent.Name);
+}
+
+// Hotel record for simulated data
+internal sealed record Hotel(string Name, int PricePerNight, double Rating, string Location);

dotnet/samples/05-end-to-end/HostedAgents/FoundrySingleAgent/README.md

@@ -0,0 +1,167 @@
+**IMPORTANT!** All samples and other resources made available in this GitHub repository ("samples") are designed to assist in accelerating development of agents, solutions, and agent workflows for various scenarios. Review all provided resources and carefully test output behavior in the context of your use case. AI responses may be inaccurate and AI actions should be monitored with human oversight. Learn more in the transparency documents for [Agent Service](https://learn.microsoft.com/en-us/azure/ai-foundry/responsible-ai/agents/transparency-note) and [Agent Framework](https://github.com/microsoft/agent-framework/blob/main/TRANSPARENCY_FAQ.md).
+
+Agents, solutions, or other output you create may be subject to legal and regulatory requirements, may require licenses, or may not be suitable for all industries, scenarios, or use cases. By using any sample, you are acknowledging that any output created using those samples are solely your responsibility, and that you will comply with all applicable laws, regulations, and relevant safety standards, terms of service, and codes of conduct.
+
+Third-party samples contained in this folder are subject to their own designated terms, and they have not been tested or verified by Microsoft or its affiliates.
+
+Microsoft has no responsibility to you or others with respect to any of these samples or any resulting output.
+
+# What this sample demonstrates
+
+This sample demonstrates a **key advantage of code-based hosted agents**:
+
+- **Local C# tool execution** - Run custom C# methods as agent tools
+
+Code-based agents can execute **any C# code** you write. This sample includes a Seattle Hotel Agent with a `GetAvailableHotels` tool that searches for available hotels based on check-in/check-out dates and budget preferences.
+
+The agent is hosted using the [Azure AI AgentServer SDK](https://learn.microsoft.com/en-us/dotnet/api/overview/azure/ai.agentserver.agentframework-readme) and can be deployed to Microsoft Foundry.
+
+## How It Works
+
+### Local Tools Integration
+
+In [Program.cs](Program.cs), the agent uses `AIProjectClient.CreateAIAgentAsync()` from the [Microsoft.Agents.AI.AzureAI](https://www.nuget.org/packages/Microsoft.Agents.AI.AzureAI/) package to create a Foundry agent with a local C# method (`GetAvailableHotels`) that simulates a hotel availability API. This demonstrates how code-based agents can execute custom server-side logic that prompt agents cannot access.
+
+The tool accepts:
+
+- **checkInDate** - Check-in date in YYYY-MM-DD format
+- **checkOutDate** - Check-out date in YYYY-MM-DD format
+- **maxPrice** - Maximum price per night in USD (optional, defaults to $500)
+
+### Agent Hosting
+
+The agent is hosted using the [Azure AI AgentServer SDK](https://learn.microsoft.com/en-us/dotnet/api/overview/azure/ai.agentserver.agentframework-readme),
+which provisions a REST API endpoint compatible with the OpenAI Responses protocol.
+
+## Running the Agent Locally
+
+### Prerequisites
+
+Before running this sample, ensure you have:
+
+1. **Azure AI Foundry Project**
+   - Project created.
+   - Chat model deployed (e.g., `gpt-4o` or `gpt-4.1`)
+   - Note your project endpoint URL and model deployment name
+
+2. **Azure CLI**
+   - Installed and authenticated
+   - Run `az login` and verify with `az account show`
+   - Your identity needs the **Azure AI Developer** role on the Foundry resource (for `agents/write` data action required by `CreateAIAgentAsync`)
+
+3. **.NET 10.0 SDK or later**
+   - Verify your version: `dotnet --version`
+   - Download from [https://dotnet.microsoft.com/download](https://dotnet.microsoft.com/download)
+
+### Environment Variables
+
+Set the following environment variables (matching `agent.yaml`):
+
+- `AZURE_AI_PROJECT_ENDPOINT` - Your Azure AI Foundry project endpoint URL (required)
+- `MODEL_DEPLOYMENT_NAME` - The deployment name for your chat model (defaults to `gpt-4o-mini`)
+
+**PowerShell:**
+
+```powershell
+# Replace with your actual values
+$env:AZURE_AI_PROJECT_ENDPOINT="https://<your-resource>.services.ai.azure.com/api/projects/<your-project>"
+$env:MODEL_DEPLOYMENT_NAME="gpt-4o-mini"
+```
+
+**Bash:**
+
+```bash
+export AZURE_AI_PROJECT_ENDPOINT="https://<your-resource>.services.ai.azure.com/api/projects/<your-project>"
+export MODEL_DEPLOYMENT_NAME="gpt-4o-mini"
+```
+
+### Running the Sample
+
+To run the agent, execute the following command in your terminal:
+
+```bash
+dotnet restore
+dotnet build
+dotnet run
+```
+
+This will start the hosted agent locally on `http://localhost:8088/`.
+
+### Interacting with the Agent
+
+**VS Code:**
+
+1. Open the Visual Studio Code Command Palette and execute the `Microsoft Foundry: Open Container Agent Playground Locally` command.
+2. Execute the following commands to start the containerized hosted agent.
+
+   ```bash
+   dotnet restore
+   dotnet build
+   dotnet run
+   ```
+
+3. Submit a request to the agent through the playground interface. For example, you may enter a prompt such as: "I need a hotel in Seattle from 2025-03-15 to 2025-03-18, budget under $200 per night."
+4. The agent will use the GetAvailableHotels tool to search for available hotels matching your criteria.
+
+> **Note**: Open the local playground before starting the container agent to ensure the visualization functions correctly.
+
+**PowerShell (Windows):**
+
+```powershell
+$body = @{
+    input = "I need a hotel in Seattle from 2025-03-15 to 2025-03-18, budget under `$200 per night"
+    stream = $false
+} | ConvertTo-Json
+
+Invoke-RestMethod -Uri http://localhost:8088/responses -Method Post -Body $body -ContentType "application/json"
+```
+
+**Bash/curl (Linux/macOS):**
+
+```bash
+curl -sS -H "Content-Type: application/json" -X POST http://localhost:8088/responses \
+   -d '{"input": "Find me hotels in Seattle for March 20-23, 2025 under $200 per night","stream":false}'
+```
+
+You can also use the `run-requests.http` file in this directory with the VS Code REST Client extension.
+
+The agent will use the `GetAvailableHotels` tool to search for available hotels matching your criteria.
+
+## Deploying the Agent to Microsoft Foundry
+
+**Preparation (required)**
+
+Please check the environment_variables section in [agent.yaml](agent.yaml) and ensure the variables there are set in your target Microsoft Foundry Project.
+
+To deploy the hosted agent:
+
+1. Open the VS Code Command Palette and run the `Microsoft Foundry: Deploy Hosted Agent` command.
+2. Follow the interactive deployment prompts. The extension will help you select or create the container files it needs.
+3. After deployment completes, the hosted agent appears under the `Hosted Agents (Preview)` section of the extension tree. You can select the agent there to view details and test it using the integrated playground.
+
+**What the deploy flow does for you:**
+
+- Creates or obtains an Azure Container Registry for the target project.
+- Builds and pushes a container image from your workspace (the build packages the workspace respecting `.dockerignore`).
+- Creates an agent version in Microsoft Foundry using the built image. If a `.env` file exists at the workspace root, the extension will parse it and include its key/value pairs as the hosted agent's environment variables in the create request (these variables will be available to the agent runtime).
+- Starts the agent container on the project's capability host. If the capability host is not provisioned, the extension will prompt you to enable it and will guide you through creating it.
+
+## MSI Configuration in the Azure Portal
+
+This sample requires the Microsoft Foundry Project to authenticate using a Managed Identity when running remotely in Azure. Grant the project's managed identity the required permissions by assigning the built-in [Azure AI User](https://aka.ms/foundry-ext-project-role) role.
+
+To configure the Managed Identity:
+
+1. In the Azure Portal, open the Foundry Project.
+2. Select "Access control (IAM)" from the left-hand menu.
+3. Click "Add" and choose "Add role assignment".
+4. In the role selection, search for and select "Azure AI User", then click "Next".
+5. For "Assign access to", choose "Managed identity".
+6. Click "Select members", locate the managed identity associated with your Foundry Project (you can search by the project name), then click "Select".
+7. Click "Review + assign" to complete the assignment.
+8. Allow a few minutes for the role assignment to propagate before running the application.
+
+## Additional Resources
+
+- [Microsoft Agents Framework](https://learn.microsoft.com/en-us/agent-framework/overview/agent-framework-overview)
+- [Managed Identities for Azure Resources](https://learn.microsoft.com/en-us/entra/identity/managed-identities-azure-resources/)

dotnet/samples/05-end-to-end/HostedAgents/FoundrySingleAgent/agent.yaml

@@ -0,0 +1,32 @@
+# yaml-language-server: $schema=https://raw.githubusercontent.com/microsoft/AgentSchema/refs/heads/main/schemas/v1.0/ContainerAgent.yaml
+
+name: FoundrySingleAgent
+displayName: "Foundry Single Agent with Local Tools"
+description: >
+  A travel assistant agent that helps users find hotels in Seattle.
+  Demonstrates local C# tool execution - a key advantage of code-based 
+  hosted agents over prompt agents.
+metadata:
+  authors:
+    - Microsoft Agent Framework Team
+  tags:
+    - Azure AI AgentServer
+    - Microsoft Agent Framework
+    - Local Tools
+    - Travel Assistant
+    - Hotel Search
+template:
+  kind: hosted
+  name: FoundrySingleAgent
+  protocols:
+    - protocol: responses
+      version: v1
+  environment_variables:
+    - name: AZURE_AI_PROJECT_ENDPOINT
+      value: ${AZURE_AI_PROJECT_ENDPOINT}
+    - name: MODEL_DEPLOYMENT_NAME
+      value: gpt-4o-mini
+resources:
+  - name: "gpt-4o-mini"
+    kind: model
+    id: gpt-4o-mini

dotnet/samples/05-end-to-end/HostedAgents/FoundrySingleAgent/run-requests.http

@@ -0,0 +1,52 @@
+@host = http://localhost:8088
+@endpoint = {{host}}/responses
+
+### Health Check
+GET {{host}}/readiness
+
+### Simple hotel search - budget under $200
+POST {{endpoint}}
+Content-Type: application/json
+
+{
+    "input": "I need a hotel in Seattle from 2025-03-15 to 2025-03-18, budget under $200 per night",
+    "stream": false
+}
+
+### Hotel search with higher budget
+POST {{endpoint}}
+Content-Type: application/json
+
+{
+    "input": "Find me hotels in Seattle for March 20-23, 2025 under $250 per night",
+    "stream": false
+}
+
+### Ask for recommendations without dates (agent should ask for clarification)
+POST {{endpoint}}
+Content-Type: application/json
+
+{
+    "input": "What hotels do you recommend in Seattle?",
+    "stream": false
+}
+
+### Explicit input format
+POST {{endpoint}}
+Content-Type: application/json
+
+{
+    "input": [
+        {
+            "type": "message",
+            "role": "user",
+            "content": [
+                {
+                    "type": "input_text",
+                    "text": "I'm looking for a hotel in Seattle from 2025-04-01 to 2025-04-05, my budget is $150 per night maximum"
+                }
+            ]
+        }
+    ],
+    "stream": false
+}

dotnet/samples/05-end-to-end/HostedAgents/README.md

@@ -12,6 +12,8 @@ These samples demonstrate how to build and host AI agents using the [Azure AI Ag
 | [`AgentWithHostedMCP`](./AgentWithHostedMCP/) | Hosted MCP server tool (Microsoft Learn search) |
 | [`AgentWithTextSearchRag`](./AgentWithTextSearchRag/) | RAG with `TextSearchProvider` (Contoso Outdoors) |
 | [`AgentsInWorkflows`](./AgentsInWorkflows/) | Sequential workflow pipeline (translation chain) |
+| [`FoundryMultiAgent`](./FoundryMultiAgent/) | Multi-agent Writer-Reviewer workflow using `AIProjectClient.CreateAIAgentAsync()` from [Microsoft.Agents.AI.AzureAI](https://www.nuget.org/packages/Microsoft.Agents.AI.AzureAI/) |
+| [`FoundrySingleAgent`](./FoundrySingleAgent/) | Single agent with local C# tool execution (hotel search) using `AIProjectClient.CreateAIAgentAsync()` from [Microsoft.Agents.AI.AzureAI](https://www.nuget.org/packages/Microsoft.Agents.AI.AzureAI/) |
 
 ## Common Prerequisites
 
@@ -38,9 +40,9 @@ Most samples require one or more of these environment variables:
 |----------|---------|-------------|
 | `AZURE_OPENAI_ENDPOINT` | Most samples | Your Azure OpenAI resource endpoint URL |
 | `AZURE_OPENAI_DEPLOYMENT_NAME` | Most samples | Chat model deployment name (defaults to `gpt-4o-mini`) |
-| `AZURE_AI_PROJECT_ENDPOINT` | AgentWithTools, AgentWithLocalTools | Azure AI Foundry project endpoint |
+| `AZURE_AI_PROJECT_ENDPOINT` | AgentWithTools, AgentWithLocalTools, FoundryMultiAgent, FoundrySingleAgent | Azure AI Foundry project endpoint |
 | `MCP_TOOL_CONNECTION_ID` | AgentWithTools | Foundry MCP tool connection name |
-| `MODEL_DEPLOYMENT_NAME` | AgentWithLocalTools | Chat model deployment name (defaults to `gpt-4o-mini`) |
+| `MODEL_DEPLOYMENT_NAME` | AgentWithLocalTools, FoundryMultiAgent, FoundrySingleAgent | Chat model deployment name (defaults to `gpt-4o-mini`) |
 
 See each sample's README for the specific variables required.
 

dotnet/src/Microsoft.Agents.AI.Abstractions/Compaction/ChatHistoryCompactionPipeline.Factory.cs

@@ -0,0 +1,102 @@
+// Copyright (c) Microsoft. All rights reserved.
+
+using System;
+using Microsoft.Extensions.AI;
+
+namespace Microsoft.Agents.AI.Compaction;
+
+public partial class ChatHistoryCompactionPipeline
+{
+    /// <summary>
+    /// %%% COMMENT
+    /// </summary>
+    public enum Size
+    {
+        /// <summary>
+        /// %%% COMMENT
+        /// </summary>
+        Compact,
+        /// <summary>
+        /// %%% COMMENT
+        /// </summary>
+        Adequate,
+        /// <summary>
+        /// %%% COMMENT
+        /// </summary>
+        Accomodating,
+    }
+
+    /// <summary>
+    /// %%% COMMENT
+    /// </summary>
+    public enum Approach
+    {
+        /// <summary>
+        /// %%% COMMENT
+        /// </summary>
+        Aggressive,
+        /// <summary>
+        /// %%% COMMENT
+        /// </summary>
+        Balanced,
+        /// <summary>
+        /// %%% COMMENT
+        /// </summary>
+        Gentle,
+    }
+
+    /// <summary>
+    /// %%% COMMENT
+    /// </summary>
+    /// <param name="approach"></param>
+    /// <param name="size"></param>
+    /// <param name="chatClient"></param>
+    /// <returns></returns>
+    /// <exception cref="NotImplementedException"></exception>
+    public static ChatHistoryCompactionPipeline Create(Approach approach, Size size, IChatClient chatClient) =>
+        approach switch
+        {
+            Approach.Aggressive => CreateAgressive(size, chatClient),
+            Approach.Balanced => CreateBalanced(size),
+            Approach.Gentle => CreateGentle(size),
+            _ => throw new NotImplementedException(), // %%% EXCEPTION
+        };
+
+    private static ChatHistoryCompactionPipeline CreateAgressive(Size size, IChatClient chatClient) =>
+        new(// 1. Gentle: collapse old tool-call groups into short summaries like "[Tool calls: LookupPrice]"
+            new ToolResultCompactionStrategy(MaxTokens(size), preserveRecentGroups: 2),
+            // 2. Moderate: use an LLM to summarize older conversation spans into a concise message
+            new SummarizationCompactionStrategy(chatClient, MaxTokens(size), preserveRecentGroups: 2),
+            // 3. Aggressive: keep only the last N user turns and their responses
+            new SlidingWindowCompactionStrategy(MaxTurns(size)),
+            // 4. Emergency: drop oldest groups until under the token budget
+            new TruncationCompactionStrategy(MaxTokens(size), preserveRecentGroups: 1));
+
+    private static ChatHistoryCompactionPipeline CreateBalanced(Size size) =>
+        new(// 1. Gentle: collapse old tool-call groups into short summaries like "[Tool calls: LookupPrice]"
+            new ToolResultCompactionStrategy(MaxTokens(size), preserveRecentGroups: 2),
+            // 2. Aggressive: keep only the last N user turns and their responses
+            new SlidingWindowCompactionStrategy(MaxTurns(size)));
+
+    private static ChatHistoryCompactionPipeline CreateGentle(Size size) =>
+        new(// 1. Gentle: collapse old tool-call groups into short summaries like "[Tool calls: LookupPrice]"
+            new ToolResultCompactionStrategy(MaxTokens(size), preserveRecentGroups: 2));
+
+    private static int MaxTokens(Size size) =>
+        size switch
+        {
+            Size.Compact => 500,
+            Size.Adequate => 1000,
+            Size.Accomodating => 2000,
+            _ => throw new NotImplementedException(), // %%% EXCEPTION
+        };
+
+    private static int MaxTurns(Size size) =>
+        size switch
+        {
+            Size.Compact => 10,
+            Size.Adequate => 50,
+            Size.Accomodating => 100,
+            _ => throw new NotImplementedException(), // %%% EXCEPTION
+        };
+}

dotnet/src/Microsoft.Agents.AI.Abstractions/Compaction/ChatHistoryCompactionPipeline.cs

@@ -0,0 +1,114 @@
+// Copyright (c) Microsoft. All rights reserved.
+
+using System;
+using System.Collections.Generic;
+using System.Diagnostics;
+using System.Threading;
+using System.Threading.Tasks;
+using Microsoft.Extensions.AI;
+using Microsoft.Shared.Diagnostics;
+
+namespace Microsoft.Agents.AI.Compaction;
+
+/// <summary>
+/// Executes a chain of <see cref="ChatHistoryCompactionStrategy"/> instances in order
+/// against a mutable message list.
+/// </summary>
+/// <remarks>
+/// <para>
+/// Each strategy's trigger is evaluated against the metrics <em>as they stand after prior strategies</em>,
+/// so earlier strategies can bring the conversation within thresholds that cause later strategies to skip.
+/// </para>
+/// <para>
+/// The pipeline is fully standalone — it can be used without any agent, session, or context provider.
+/// It also implements <see cref="IChatReducer"/> so it can be used directly anywhere a reducer is
+/// accepted (e.g., <see cref="InMemoryChatHistoryProviderOptions.ChatReducer"/>).
+/// </para>
+/// </remarks>
+public partial class ChatHistoryCompactionPipeline : IChatReducer
+{
+    private readonly ChatHistoryCompactionStrategy[] _strategies;
+    private readonly IChatHistoryMetricsCalculator _metricsCalculator;
+
+    /// <summary>
+    /// Initializes a new instance of the <see cref="ChatHistoryCompactionPipeline"/> class.
+    /// </summary>
+    /// <param name="strategies">The ordered list of compaction strategies to execute.</param>
+    /// <remarks>
+    /// By default, <see cref="DefaultChatHistoryMetricsCalculator"/> is used.
+    /// </remarks>
+    public ChatHistoryCompactionPipeline(
+        params IEnumerable<ChatHistoryCompactionStrategy> strategies)
+        : this(metricsCalculator: null, strategies) { }
+
+    /// <summary>
+    /// Initializes a new instance of the <see cref="ChatHistoryCompactionPipeline"/> class.
+    /// </summary>
+    /// <param name="metricsCalculator">
+    /// An optional metrics calculator. When <see langword="null"/>, a
+    /// <see cref="DefaultChatHistoryMetricsCalculator"/> is used.
+    /// </param>
+    /// <param name="strategies">The ordered list of compaction strategies to execute.</param>
+    public ChatHistoryCompactionPipeline(
+        IChatHistoryMetricsCalculator? metricsCalculator,
+        params IEnumerable<ChatHistoryCompactionStrategy> strategies)
+    {
+        this._strategies = [.. Throw.IfNull(strategies)];
+        this._metricsCalculator = metricsCalculator ?? DefaultChatHistoryMetricsCalculator.Instance;
+    }
+
+    /// <summary>
+    /// Reduces the given messages by running all strategies in sequence.
+    /// </summary>
+    /// <param name="messages">The messages to reduce.</param>
+    /// <param name="cancellationToken">The <see cref="CancellationToken"/> to monitor for cancellation requests.</param>
+    /// <returns>The reduced set of messages.</returns>
+    public virtual async Task<IEnumerable<ChatMessage>> ReduceAsync(
+        IEnumerable<ChatMessage> messages,
+        CancellationToken cancellationToken = default)
+    {
+        List<ChatMessage> messageBuffer = messages is List<ChatMessage> messageList ? messageList : [.. messages];
+        await this.CompactAsync(messageBuffer, cancellationToken).ConfigureAwait(false);
+        return messageBuffer;
+    }
+
+    /// <summary>
+    /// Run all strategies in sequence against the given messages.
+    /// </summary>
+    /// <param name="messages">The mutable message list to compact.</param>
+    /// <param name="cancellationToken">The <see cref="CancellationToken"/> to monitor for cancellation requests.</param>
+    /// <returns>A <see cref="CompactionPipelineResult"/> with aggregate and per-strategy metrics.</returns>
+    public async ValueTask<CompactionPipelineResult> CompactAsync(
+        List<ChatMessage> messages,
+        CancellationToken cancellationToken = default)
+    {
+        Throw.IfNull(messages);
+
+        ChatHistoryMetric overallBefore = this._metricsCalculator.Calculate(messages);
+
+        Debug.WriteLine($"COMPACTION: BEGIN x{overallBefore.MessageCount}/#{overallBefore.UserTurnCount} ({overallBefore.TokenCount} tokens)");
+
+        List<CompactionResult> compactionResults = new(this._strategies.Length);
+
+        Stopwatch timer = new();
+        TimeSpan startTime = TimeSpan.Zero;
+        ChatHistoryMetric overallAfter = overallBefore;
+        ChatHistoryMetric currentBefore = overallBefore;
+        foreach (ChatHistoryCompactionStrategy strategy in this._strategies)
+        {
+            // %%% VERBOSE - Debug.WriteLine($"COMPACTION: {strategy.Name} START");
+            timer.Start();
+            ChatHistoryCompactionStrategy.s_currentMetrics.Value = currentBefore;
+            CompactionResult strategyResult = await strategy.CompactAsync(messages, this._metricsCalculator, cancellationToken).ConfigureAwait(false);
+            timer.Stop();
+            TimeSpan elapsedTime = timer.Elapsed - startTime;
+            // %%% VERBOSE - Debug.WriteLine($"COMPACTION: {strategy.Name} FINISH [{elapsedTime}]");
+            compactionResults.Add(strategyResult);
+            overallAfter = currentBefore = strategyResult.After;
+        }
+
+        Debug.WriteLineIf(overallBefore.TokenCount != overallAfter.TokenCount, $"COMPACTION: TOTAL [{timer.Elapsed}] {overallBefore.TokenCount} => {overallAfter.TokenCount} tokens");
+
+        return new(overallBefore, overallAfter, compactionResults);
+    }
+}

dotnet/src/Microsoft.Agents.AI.Abstractions/Compaction/ChatHistoryCompactionStrategy.cs

@@ -0,0 +1,120 @@
+// Copyright (c) Microsoft. All rights reserved.
+
+using System;
+using System.Collections.Generic;
+using System.Diagnostics;
+using System.Threading;
+using System.Threading.Tasks;
+using Microsoft.Extensions.AI;
+using Microsoft.Shared.Diagnostics;
+
+namespace Microsoft.Agents.AI.Compaction;
+
+/// <summary>
+/// A named compaction strategy with an optional conditional trigger that delegates
+/// actual message reduction to an <see cref="IChatReducer"/>.
+/// </summary>
+/// <remarks>
+/// <para>
+/// Each strategy wraps an <see cref="IChatReducer"/> that performs the actual compaction,
+/// while the strategy adds:
+/// <list type="bullet">
+/// <item><description>A conditional trigger via <see cref="ShouldCompact"/> that decides whether compaction runs.</description></item>
+/// <item><description>Before/after <see cref="ChatHistoryMetric"/> reporting via <see cref="CompactionResult"/>.</description></item>
+/// </list>
+/// </para>
+/// <para>
+/// For simple cases, construct a <see cref="ChatHistoryCompactionStrategy"/> directly with any
+/// <see cref="IChatReducer"/>. For custom trigger logic, subclass and override <see cref="ShouldCompact"/>.
+/// </para>
+/// <para>
+/// Reducers <b>must</b> preserve atomic message groups: an assistant message containing
+/// tool calls and its corresponding tool result messages must be kept or removed together.
+/// Use <see cref="DefaultChatHistoryMetricsCalculator"/> to identify these groups when authoring custom reducers.
+/// </para>
+/// </remarks>
+public abstract class ChatHistoryCompactionStrategy
+{
+    internal static readonly AsyncLocal<ChatHistoryMetric> s_currentMetrics = new();
+
+    /// <summary>
+    /// Initializes a new instance of the <see cref="ChatHistoryCompactionStrategy"/> class.
+    /// </summary>
+    /// <param name="reducer">The <see cref="IChatReducer"/> that performs the actual message compaction.</param>
+    protected ChatHistoryCompactionStrategy(IChatReducer reducer)
+    {
+        this.Reducer = Throw.IfNull(reducer);
+    }
+
+    /// <summary>
+    /// Exposes the current <see cref="ChatHistoryMetric"/> for the executing strategy, allowing <see cref="Reducer"/> to make informed decisions.
+    /// </summary>
+    protected static ChatHistoryMetric CurrentMetrics => s_currentMetrics.Value ?? throw new InvalidOperationException($"No active {nameof(ChatHistoryCompactionStrategy)}.");
+
+    /// <summary>
+    /// Gets the <see cref="IChatReducer"/> that performs the actual message compaction.
+    /// </summary>
+    public IChatReducer Reducer { get; }
+
+    /// <summary>
+    /// Gets the display name of this strategy, used for logging and diagnostics.
+    /// </summary>
+    /// <remarks>
+    /// The default implementation returns the type name of the underlying <see cref="IChatReducer"/>.
+    /// </remarks>
+    public virtual string Name => this.Reducer.GetType().Name;
+
+    /// <summary>
+    /// Evaluates whether this strategy should execute given the current conversation metrics.
+    /// </summary>
+    /// <param name="metrics">The current conversation metrics.</param>
+    /// <returns>
+    /// <see langword="true"/> to proceed with compaction; <see langword="false"/> to skip.
+    /// </returns>
+    protected abstract bool ShouldCompact(ChatHistoryMetric metrics);
+
+    /// <summary>
+    /// Execute this strategy: check the trigger, delegate to the <see cref="IChatReducer"/>, and report metrics.
+    /// </summary>
+    /// <param name="history">The mutable message list to compact.</param>
+    /// <param name="metricsCalculator">The calculator to use for metric snapshots.</param>
+    /// <param name="cancellationToken">The <see cref="CancellationToken"/> to monitor for cancellation requests.</param>
+    /// <returns>A <see cref="CompactionResult"/> reporting the outcome.</returns>
+    internal async ValueTask<CompactionResult> CompactAsync(
+        List<ChatMessage> history,
+        IChatHistoryMetricsCalculator metricsCalculator,
+        CancellationToken cancellationToken = default)
+    {
+        Throw.IfNull(metricsCalculator);
+        Throw.IfNull(history);
+
+        ChatHistoryMetric beforeMetrics = CurrentMetrics;
+        if (!this.ShouldCompact(beforeMetrics))
+        {
+            // %%% VERBOSE - Debug.WriteLine($"COMPACTION: {this.Name} - Skipped");
+            return CompactionResult.Skipped(this.Name, beforeMetrics);
+        }
+
+        Debug.WriteLine($"COMPACTION: {this.Name} - Reducing");
+
+        IEnumerable<ChatMessage> reducerResult = await this.Reducer.ReduceAsync(history, cancellationToken).ConfigureAwait(false);
+
+        // Ensure we have a concrete collection to avoid multiple enumerations of the reducer result, which could be costly if it's an iterator.
+        ChatMessage[] reducedCopy = [.. reducerResult];
+
+        bool modified = reducedCopy.Length != history.Count;
+        if (modified)
+        {
+            history.Clear();
+            history.AddRange(reducedCopy);
+        }
+
+        ChatHistoryMetric afterMetrics = modified
+            ? metricsCalculator.Calculate(reducedCopy)
+            : beforeMetrics;
+
+        Debug.WriteLine($"COMPACTION: {this.Name} - Tokens {beforeMetrics.TokenCount} => {afterMetrics.TokenCount}");
+
+        return new(this.Name, applied: modified, beforeMetrics, afterMetrics);
+    }
+}

dotnet/src/Microsoft.Agents.AI.Abstractions/Compaction/ChatHistoryMetric.cs

@@ -0,0 +1,45 @@
+// Copyright (c) Microsoft. All rights reserved.
+
+using System.Collections.Generic;
+
+namespace Microsoft.Agents.AI.Compaction;
+
+/// <summary>
+/// Immutable snapshot of conversation metrics used for compaction trigger evaluation and reporting.
+/// </summary>
+public sealed class ChatHistoryMetric
+{
+    /// <summary>
+    /// Gets the estimated token count across all messages.
+    /// </summary>
+    public int TokenCount { get; init; }
+
+    /// <summary>
+    /// Gets the total serialized byte count of all messages.
+    /// </summary>
+    public long ByteCount { get; init; }
+
+#pragma warning disable IDE0001 // Simplify Names
+    /// <summary>
+    /// Gets the total number of <see cref="Microsoft.Extensions.AI.ChatMessage"/> objects.
+    /// </summary>
+#pragma warning restore IDE0001 // Simplify Names
+    public int MessageCount { get; init; }
+
+    /// <summary>
+    /// Gets the number of tool/function call content items across all messages.
+    /// </summary>
+    public int ToolCallCount { get; init; }
+
+    /// <summary>
+    /// Gets the number of user turns. A user turn is a user message together with the full
+    /// set of agent responses (including tool calls and results) before the next user input.
+    /// </summary>
+    public int UserTurnCount { get; init; }
+
+    /// <summary>
+    /// Gets the atomic message group index for the analyzed messages.
+    /// Each group represents a contiguous range of messages that must be kept or removed together.
+    /// </summary>
+    public IReadOnlyList<ChatMessageGroup> Groups { get; init; } = [];
+}

dotnet/src/Microsoft.Agents.AI.Abstractions/Compaction/ChatMessageGroup.cs

@@ -0,0 +1,64 @@
+// Copyright (c) Microsoft. All rights reserved.
+
+using System;
+
+namespace Microsoft.Agents.AI.Compaction;
+
+/// <summary>
+/// Represents a contiguous range of messages in a conversation that form an atomic group.
+/// Atomic groups must be kept or removed together to maintain API correctness.
+/// </summary>
+/// <remarks>
+/// For example, an assistant message containing tool calls and the subsequent tool result messages
+/// form an atomic group — removing one without the other causes API errors.
+/// </remarks>
+public readonly struct ChatMessageGroup : IEquatable<ChatMessageGroup>
+{
+    /// <summary>
+    /// Initializes a new instance of the <see cref="ChatMessageGroup"/> struct.
+    /// </summary>
+    /// <param name="startIndex">The zero-based index of the first message in this group.</param>
+    /// <param name="count">The number of messages in this group.</param>
+    /// <param name="kind">The kind of this message group.</param>
+    public ChatMessageGroup(int startIndex, int count, ChatMessageGroupKind kind)
+    {
+        this.StartIndex = startIndex;
+        this.Count = count;
+        this.Kind = kind;
+    }
+
+    /// <summary>
+    /// Gets the zero-based index of the first message in this group within the original message list.
+    /// </summary>
+    public int StartIndex { get; }
+
+    /// <summary>
+    /// Gets the number of messages in this group.
+    /// </summary>
+    public int Count { get; }
+
+    /// <summary>
+    /// Gets the kind of this message group.
+    /// </summary>
+    public ChatMessageGroupKind Kind { get; }
+
+    /// <inheritdoc/>
+    public bool Equals(ChatMessageGroup other) =>
+        this.StartIndex == other.StartIndex &&
+        this.Count == other.Count &&
+        this.Kind == other.Kind;
+
+    /// <inheritdoc/>
+    public override bool Equals(object? obj) =>
+        obj is ChatMessageGroup other &&
+        this.Equals(other);
+
+    /// <inheritdoc/>
+    public override int GetHashCode() => HashCode.Combine(this.StartIndex, this.Count, (int)this.Kind);
+
+    /// <summary>Determines whether two <see cref="ChatMessageGroup"/> instances are equal.</summary>
+    public static bool operator ==(ChatMessageGroup left, ChatMessageGroup right) => left.Equals(right);
+
+    /// <summary>Determines whether two <see cref="ChatMessageGroup"/> instances are not equal.</summary>
+    public static bool operator !=(ChatMessageGroup left, ChatMessageGroup right) => !left.Equals(right);
+}

dotnet/src/Microsoft.Agents.AI.Abstractions/Compaction/ChatMessageGroupKind.cs

@@ -0,0 +1,27 @@
+// Copyright (c) Microsoft. All rights reserved.
+
+namespace Microsoft.Agents.AI.Compaction;
+
+/// <summary>
+/// Identifies the kind of an atomic message group in a conversation.
+/// </summary>
+public enum ChatMessageGroupKind
+{
+    /// <summary>A system message.</summary>
+    System,
+
+    /// <summary>A user message (start of a user turn).</summary>
+    UserTurn,
+
+    /// <summary>An assistant message with tool calls and their corresponding tool result messages.</summary>
+    AssistantToolGroup,
+
+    /// <summary>An assistant message without tool calls.</summary>
+    AssistantPlain,
+
+    /// <summary>A tool result message that is not part of a recognized group.</summary>
+    ToolResult,
+
+    /// <summary>A message with an unrecognized role.</summary>
+    Other
+}

dotnet/src/Microsoft.Agents.AI.Abstractions/Compaction/ChatReducerCompactionStrategy.cs

@@ -0,0 +1,35 @@
+// Copyright (c) Microsoft. All rights reserved.
+
+using System;
+using Microsoft.Extensions.AI;
+using Microsoft.Shared.Diagnostics;
+
+namespace Microsoft.Agents.AI.Compaction;
+
+/// <summary>
+/// Represents a chat history compaction strategy that uses a condition function to determine when compaction should
+/// occur.
+/// </summary>
+/// <remarks>
+/// This strategy evaluates a user-provided condition against compaction metrics to decide whether to
+/// compact the chat history. It is useful for scenarios where compaction should be triggered based on custom thresholds
+/// or criteria. Inherits from ChatHistoryCompactionStrategy.
+/// </remarks>
+public class ChatReducerCompactionStrategy : ChatHistoryCompactionStrategy
+{
+    private readonly Func<ChatHistoryMetric, bool> _condition;
+
+    /// <summary>
+    /// Initializes a new instance of the <see cref="ChatReducerCompactionStrategy"/> class.
+    /// </summary>
+    public ChatReducerCompactionStrategy(
+        IChatReducer reducer,
+        Func<ChatHistoryMetric, bool> condition)
+        : base(reducer)
+    {
+        this._condition = Throw.IfNull(condition);
+    }
+
+    /// <inheritdoc/>
+    protected override bool ShouldCompact(ChatHistoryMetric metrics) => this._condition(metrics);
+}

dotnet/src/Microsoft.Agents.AI.Abstractions/Compaction/CompactionPipelineResult.cs

@@ -0,0 +1,49 @@
+// Copyright (c) Microsoft. All rights reserved.
+
+using System.Collections.Generic;
+using System.Linq;
+using Microsoft.Shared.Diagnostics;
+
+namespace Microsoft.Agents.AI.Compaction;
+
+/// <summary>
+/// Reports the aggregate outcome of a <see cref="ChatHistoryCompactionPipeline"/> execution.
+/// </summary>
+public sealed class CompactionPipelineResult
+{
+    /// <summary>
+    /// Initializes a new instance of the <see cref="CompactionPipelineResult"/> class.
+    /// </summary>
+    /// <param name="before">Metrics of the conversation before any strategy ran.</param>
+    /// <param name="after">Metrics of the conversation after all strategies ran.</param>
+    /// <param name="strategyResults">Per-strategy results in execution order.</param>
+    internal CompactionPipelineResult(
+        ChatHistoryMetric before,
+        ChatHistoryMetric after,
+        IReadOnlyList<CompactionResult> strategyResults)
+    {
+        this.Before = Throw.IfNull(before);
+        this.After = Throw.IfNull(after);
+        this.StrategyResults = Throw.IfNull(strategyResults);
+    }
+
+    /// <summary>
+    /// Gets the conversation metrics before any compaction strategy ran.
+    /// </summary>
+    public ChatHistoryMetric Before { get; }
+
+    /// <summary>
+    /// Gets the conversation metrics after all compaction strategies ran.
+    /// </summary>
+    public ChatHistoryMetric After { get; }
+
+    /// <summary>
+    /// Gets the per-strategy results in execution order.
+    /// </summary>
+    public IReadOnlyList<CompactionResult> StrategyResults { get; }
+
+    /// <summary>
+    /// Gets a value indicating whether any strategy modified the message list.
+    /// </summary>
+    public bool AnyApplied => this.StrategyResults.Any(r => r.Applied);
+}

dotnet/src/Microsoft.Agents.AI.Abstractions/Compaction/CompactionResult.cs

@@ -0,0 +1,55 @@
+// Copyright (c) Microsoft. All rights reserved.
+
+using Microsoft.Shared.Diagnostics;
+
+namespace Microsoft.Agents.AI.Compaction;
+
+/// <summary>
+/// Reports the outcome of a single <see cref="ChatHistoryCompactionStrategy"/> execution.
+/// </summary>
+public sealed class CompactionResult
+{
+    /// <summary>
+    /// Initializes a new instance of the <see cref="CompactionResult"/> class.
+    /// </summary>
+    /// <param name="strategyName">The name of the strategy that produced this result.</param>
+    /// <param name="applied">Whether the strategy modified the message list.</param>
+    /// <param name="before">Metrics before the strategy ran.</param>
+    /// <param name="after">Metrics after the strategy ran.</param>
+    public CompactionResult(string strategyName, bool applied, ChatHistoryMetric before, ChatHistoryMetric after)
+    {
+        this.StrategyName = Throw.IfNullOrWhitespace(strategyName);
+        this.Applied = applied;
+        this.Before = Throw.IfNull(before);
+        this.After = Throw.IfNull(after);
+    }
+
+    /// <summary>
+    /// Gets the name of the strategy that produced this result.
+    /// </summary>
+    public string StrategyName { get; }
+
+    /// <summary>
+    /// Gets a value indicating whether the strategy modified the message list.
+    /// </summary>
+    public bool Applied { get; }
+
+    /// <summary>
+    /// Gets the conversation metrics before the strategy executed.
+    /// </summary>
+    public ChatHistoryMetric Before { get; }
+
+    /// <summary>
+    /// Gets the conversation metrics after the strategy executed.
+    /// </summary>
+    public ChatHistoryMetric After { get; }
+
+    /// <summary>
+    /// Creates a <see cref="CompactionResult"/> representing a skipped strategy.
+    /// </summary>
+    /// <param name="strategyName">The name of the skipped strategy.</param>
+    /// <param name="metrics">The current conversation metrics.</param>
+    /// <returns>A result indicating no compaction was applied.</returns>
+    internal static CompactionResult Skipped(string strategyName, ChatHistoryMetric metrics)
+        => new(strategyName, applied: false, metrics, metrics);
+}

dotnet/src/Microsoft.Agents.AI.Abstractions/Compaction/DefaultChatHistoryMetricsCalculator.cs

@@ -0,0 +1,161 @@
+// Copyright (c) Microsoft. All rights reserved.
+
+using System.Collections.Generic;
+using System.Linq;
+using Microsoft.Extensions.AI;
+
+namespace Microsoft.Agents.AI.Compaction;
+
+/// <summary>
+/// Default implementation of <see cref="IChatHistoryMetricsCalculator"/> that uses
+/// JSON serialization length heuristics for token and byte estimation.
+/// </summary>
+/// <remarks>
+/// <para>
+/// Token estimation uses a configurable characters-per-token ratio (default ~4) since
+/// precise tokenization requires a model-specific tokenizer. For production workloads
+/// requiring accurate token counts, implement <see cref="IChatHistoryMetricsCalculator"/>
+/// with a model-appropriate tokenizer.
+/// </para>
+/// </remarks>
+public sealed class DefaultChatHistoryMetricsCalculator : IChatHistoryMetricsCalculator
+{
+    /// <summary>
+    /// Gets the singleton instance of the chat history metrics calculator.
+    /// </summary>
+    /// <remarks>
+    /// <see cref="DefaultChatHistoryMetricsCalculator"/> can be safety accessed by
+    /// concurrent threads.
+    /// </remarks>
+    public static readonly DefaultChatHistoryMetricsCalculator Instance = new();
+
+    private const int DefaultCharsPerToken = 4;
+    private const int PerMessageOverheadTokens = 4;
+
+    private readonly int _charsPerToken;
+
+    /// <summary>
+    /// Initializes a new instance of the <see cref="DefaultChatHistoryMetricsCalculator"/> class.
+    /// </summary>
+    /// <param name="charsPerToken">
+    /// The approximate number of characters per token used for estimation. Default is 4.
+    /// </param>
+    public DefaultChatHistoryMetricsCalculator(int charsPerToken = DefaultCharsPerToken)
+    {
+        this._charsPerToken = charsPerToken > 0 ? charsPerToken : DefaultCharsPerToken;
+    }
+
+    /// <inheritdoc/>
+    public ChatHistoryMetric Calculate(IReadOnlyList<ChatMessage> messages)
+    {
+        if (messages is null || messages.Count == 0)
+        {
+            return new();
+        }
+
+        int totalTokens = 0;
+        long totalBytes = 0;
+        int toolCallCount = 0;
+        int userTurnCount = 0;
+        bool inUserTurn = false;
+        List<ChatMessageGroup> groups = [];
+        int index = 0;
+
+        while (index < messages.Count)
+        {
+            ChatMessage message = messages[index];
+
+            // Accumulate per-message metrics
+            this.AccumulateMessageMetrics(message, ref totalTokens, ref totalBytes, ref toolCallCount);
+
+            if (message.Role == ChatRole.User)
+            {
+                if (!inUserTurn)
+                {
+                    userTurnCount++;
+                    inUserTurn = true;
+                }
+            }
+            else
+            {
+                inUserTurn = false;
+            }
+
+            // Identify the group starting at this message
+            if (message.Role == ChatRole.System)
+            {
+                groups.Add(new(index, 1, ChatMessageGroupKind.System));
+                index++;
+            }
+            else if (message.Role == ChatRole.User)
+            {
+                groups.Add(new(index, 1, ChatMessageGroupKind.UserTurn));
+                index++;
+            }
+            else if (message.Role == ChatRole.Assistant)
+            {
+                bool hasToolCalls = message.Contents!.Any(c => c is FunctionCallContent);
+
+                if (hasToolCalls)
+                {
+                    int groupStart = index;
+                    index++;
+
+                    while (index < messages.Count && messages[index].Role == ChatRole.Tool)
+                    {
+                        this.AccumulateMessageMetrics(messages[index], ref totalTokens, ref totalBytes, ref toolCallCount);
+                        inUserTurn = false;
+                        index++;
+                    }
+
+                    groups.Add(new(groupStart, index - groupStart, ChatMessageGroupKind.AssistantToolGroup));
+                }
+                else
+                {
+                    groups.Add(new(index, 1, ChatMessageGroupKind.AssistantPlain));
+                    index++;
+                }
+            }
+            else if (message.Role == ChatRole.Tool)
+            {
+                groups.Add(new(index, 1, ChatMessageGroupKind.ToolResult));
+                index++;
+            }
+            else
+            {
+                groups.Add(new(index, 1, ChatMessageGroupKind.Other));
+                index++;
+            }
+        }
+
+        return new()
+        {
+            TokenCount = totalTokens,
+            ByteCount = totalBytes,
+            MessageCount = messages.Count,
+            ToolCallCount = toolCallCount,
+            UserTurnCount = userTurnCount,
+            Groups = groups
+        };
+    }
+
+    private void AccumulateMessageMetrics(ChatMessage message, ref int totalTokens, ref long totalBytes, ref int toolCallCount)
+    {
+        string serialized = message.Text;
+
+        int charCount = serialized.Length;
+        totalBytes += System.Text.Encoding.UTF8.GetByteCount(serialized);
+        totalTokens += (charCount / this._charsPerToken) + PerMessageOverheadTokens;
+
+        if (message.Contents is not null)
+        {
+            foreach (AIContent content in message.Contents)
+            {
+                if (content is FunctionCallContent)
+                {
+                    toolCallCount++;
+                }
+            }
+        }
+    }
+}

dotnet/src/Microsoft.Agents.AI.Abstractions/Compaction/IChatHistoryMetricsCalculator.cs

@@ -0,0 +1,26 @@
+// Copyright (c) Microsoft. All rights reserved.
+
+using System.Collections.Generic;
+using Microsoft.Extensions.AI;
+
+namespace Microsoft.Agents.AI.Compaction;
+
+// %%% TODO: Is this interface needed? Consider whether the default implementation is sufficient
+// and whether custom metrics calculators are a realistic extension point.
+
+/// <summary>
+/// Computes <see cref="ChatHistoryMetric"/> for a list of messages.
+/// </summary>
+/// <remarks>
+/// Token counting is model-specific. Implementations can provide precise tokenization
+/// (e.g., using tiktoken or a model-specific tokenizer) or use estimation heuristics.
+/// </remarks>
+public interface IChatHistoryMetricsCalculator
+{
+    /// <summary>
+    /// Compute metrics for the given messages.
+    /// </summary>
+    /// <param name="messages">The messages to analyze.</param>
+    /// <returns>A <see cref="ChatHistoryMetric"/> snapshot.</returns>
+    ChatHistoryMetric Calculate(IReadOnlyList<ChatMessage> messages);
+}

dotnet/src/Microsoft.Agents.AI.Abstractions/Compaction/SlidingWindowCompactionStrategy.cs

@@ -0,0 +1,91 @@
+// Copyright (c) Microsoft. All rights reserved.
+
+using System.Collections.Generic;
+using System.Linq;
+using System.Threading;
+using System.Threading.Tasks;
+using Microsoft.Extensions.AI;
+
+namespace Microsoft.Agents.AI.Compaction;
+
+/// <summary>
+/// A compaction strategy that keeps only the most recent user turns and their
+/// associated response groups, removing older turns to bound conversation length.
+/// </summary>
+/// <remarks>
+/// <para>
+/// This strategy always preserves system messages. It identifies user turns in the
+/// conversation and keeps the last <c>maxTurns</c> turns along with all response groups
+/// (assistant replies, tool call groups) that follow each kept turn.
+/// </para>
+/// <para>
+/// The trigger condition fires only when the number of user turns exceeds <c>maxTurns</c>.
+/// </para>
+/// <para>
+/// This strategy is more predictable than token-based truncation for bounding conversation
+/// length, since it operates on logical turn boundaries rather than estimated token counts.
+/// </para>
+/// </remarks>
+public class SlidingWindowCompactionStrategy : ChatHistoryCompactionStrategy
+{
+    private readonly int _maxTurns;
+
+    /// <summary>
+    /// Initializes a new instance of the <see cref="SlidingWindowCompactionStrategy"/> class.
+    /// </summary>
+    /// <param name="maxTurns">
+    /// The maximum number of user turns to keep. Older turns and their associated responses are removed.
+    /// </param>
+    public SlidingWindowCompactionStrategy(int maxTurns)
+        : base(new SlidingWindowReducer(maxTurns))
+    {
+        this._maxTurns = maxTurns;
+    }
+
+    /// <inheritdoc/>
+    protected override bool ShouldCompact(ChatHistoryMetric metrics) =>
+        metrics.UserTurnCount > this._maxTurns;
+
+    /// <summary>
+    /// An <see cref="IChatReducer"/> that keeps system messages and the last N user turns
+    /// with all their associated response groups.
+    /// </summary>
+    private sealed class SlidingWindowReducer(int maxTurns) : IChatReducer
+    {
+        public Task<IEnumerable<ChatMessage>> ReduceAsync(
+            IEnumerable<ChatMessage> messages,
+            CancellationToken cancellationToken = default)
+        {
+            IReadOnlyList<ChatMessage> messageList = [.. messages]; // %%% PERFORMANCE
+            IReadOnlyList<ChatMessageGroup> groups = CurrentMetrics.Groups;
+
+            // Find the group-list indices where each user turn starts
+            int[] turnGroupIndices =
+                [.. CurrentMetrics.Groups
+                    .Select((group, index) => (group, index))
+                    .Where(t => t.group.Kind == ChatMessageGroupKind.UserTurn)
+                    .Select(t => t.index)];
+
+            // Keep the last maxTurns user turns and everything after the first kept turn
+            int firstKeptTurnIndex = turnGroupIndices.Length - maxTurns;
+            int firstKeptGroupIndex = turnGroupIndices[firstKeptTurnIndex];
+
+            List<ChatMessage> result = new(messageList.Count); // %%% PERFORMANCE
+            for (int gi = 0; gi < groups.Count; gi++)
+            {
+                ChatMessageGroup group = groups[gi];
+
+                // Always keep system messages; keep groups at or after the window start
+                if (group.Kind == ChatMessageGroupKind.System || gi >= firstKeptGroupIndex)
+                {
+                    for (int j = group.StartIndex; j < group.StartIndex + group.Count; j++)
+                    {
+                        result.Add(messageList[j]);
+                    }
+                }
+            }
+
+            return Task.FromResult<IEnumerable<ChatMessage>>(result);
+        }
+    }
+}

dotnet/src/Microsoft.Agents.AI.Abstractions/Compaction/SummarizationCompactionStrategy.cs

@@ -0,0 +1,166 @@
+// Copyright (c) Microsoft. All rights reserved.
+
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Threading;
+using System.Threading.Tasks;
+using Microsoft.Extensions.AI;
+using Microsoft.Shared.Diagnostics;
+
+namespace Microsoft.Agents.AI.Compaction;
+
+/// <summary>
+/// A compaction strategy that uses an LLM to summarize older portions of the conversation,
+/// replacing them with a concise summary message that preserves key facts and context.
+/// </summary>
+/// <remarks>
+/// <para>
+/// This strategy sits between tool-result clearing (gentle) and truncation (aggressive) in the
+/// compaction ladder. Unlike truncation which discards messages entirely, summarization preserves
+/// the essential information in compressed form, allowing the agent to maintain awareness of
+/// earlier context.
+/// </para>
+/// <para>
+/// The strategy protects system messages and the most recent <c>preserveRecentGroups</c>
+/// non-system groups. All older groups are collected and sent to the <see cref="IChatClient"/>
+/// for summarization. The resulting summary replaces those messages as a single assistant message.
+/// </para>
+/// </remarks>
+public class SummarizationCompactionStrategy : ChatHistoryCompactionStrategy
+{
+    private readonly int _maxTokens;
+
+    /// <summary>
+    /// The default summarization prompt used when none is provided.
+    /// </summary>
+    public const string DefaultSummarizationPrompt =
+        """
+        You are a conversation summarizer. Produce a concise summary of the conversation that preserves:
+        
+        - Key facts, decisions, and user preferences
+        - Important context needed for future turns
+        - Tool call outcomes and their significance
+
+        Omit pleasantries and redundant exchanges. Be factual and brief.
+        """;
+
+    /// <summary>
+    /// Initializes a new instance of the <see cref="SummarizationCompactionStrategy"/> class.
+    /// </summary>
+    /// <param name="chatClient">The <see cref="IChatClient"/> to use for generating summaries. A smaller, faster model is recommended.</param>
+    /// <param name="maxTokens">The maximum token budget. Summarization is triggered when the token count exceeds this value.</param>
+    /// <param name="preserveRecentGroups">
+    /// The number of most-recent non-system message groups to protect from summarization.
+    /// Defaults to 4, preserving the current and recent exchanges.
+    /// </param>
+    /// <param name="summarizationPrompt">
+    /// An optional custom system prompt for the summarization LLM call. When <see langword="null"/>,
+    /// a default prompt that emphasizes fact-preservation is used.
+    /// </param>
+    public SummarizationCompactionStrategy(
+        IChatClient chatClient,
+        int maxTokens,
+        int preserveRecentGroups = 4,
+        string? summarizationPrompt = null)
+        : base(new SummarizationReducer(chatClient, preserveRecentGroups, summarizationPrompt ?? DefaultSummarizationPrompt))
+    {
+        this._maxTokens = maxTokens;
+    }
+
+    /// <inheritdoc/>
+    protected override bool ShouldCompact(ChatHistoryMetric metrics) =>
+        metrics.TokenCount > this._maxTokens;
+
+    /// <summary>
+    /// An <see cref="IChatReducer"/> that sends older message groups to an LLM for summarization,
+    /// then replaces them with a single summary message.
+    /// </summary>
+    private sealed class SummarizationReducer : IChatReducer
+    {
+        private readonly IChatClient _chatClient;
+        private readonly int _preserveRecentGroups;
+        private readonly string _summarizationPrompt;
+
+        public SummarizationReducer(IChatClient chatClient, int preserveRecentGroups, string summarizationPrompt)
+        {
+            this._chatClient = Throw.IfNull(chatClient);
+            this._preserveRecentGroups = preserveRecentGroups;
+            this._summarizationPrompt = Throw.IfNullOrEmpty(summarizationPrompt);
+        }
+
+        public async Task<IEnumerable<ChatMessage>> ReduceAsync(
+            IEnumerable<ChatMessage> messages,
+            CancellationToken cancellationToken = default)
+        {
+            IReadOnlyList<ChatMessage> messageList = [.. messages];
+            IReadOnlyList<ChatMessageGroup> groups = CurrentMetrics.Groups;
+
+            List<ChatMessageGroup> nonSystemGroups = [.. groups.Where(g => g.Kind != ChatMessageGroupKind.System)];
+            int protectedFromIndex = Math.Max(0, nonSystemGroups.Count - this._preserveRecentGroups);
+
+            if (protectedFromIndex == 0)
+            {
+                // Nothing to summarize — all groups are protected
+                return messageList;
+            }
+
+            // Collect messages from groups that will be summarized
+            List<ChatMessage> toSummarize = [];
+            for (int i = 0; i < protectedFromIndex; i++)
+            {
+                ChatMessageGroup group = nonSystemGroups[i];
+                for (int j = group.StartIndex; j < group.StartIndex + group.Count; j++)
+                {
+                    toSummarize.Add(messageList[j]);
+                }
+            }
+
+            if (toSummarize.Count == 0)
+            {
+                return messageList;
+            }
+
+            // Build the summarization request
+            List<ChatMessage> summarizationRequest =
+            [
+                new(ChatRole.System, this._summarizationPrompt),
+                .. toSummarize,
+                new(ChatRole.User, "Summarize the conversation above concisely."),
+            ];
+
+            ChatResponse response = await this._chatClient.GetResponseAsync(summarizationRequest, cancellationToken: cancellationToken).ConfigureAwait(false);
+            string summaryText = string.IsNullOrWhiteSpace(response.Text) ? "[Summary unavailable]" : response.Text;
+
+            // Build result: system groups + summary + protected groups
+            List<ChatMessage> result = [];
+
+            // Keep system messages
+            foreach (ChatMessageGroup group in groups)
+            {
+                if (group.Kind == ChatMessageGroupKind.System)
+                {
+                    for (int j = group.StartIndex; j < group.StartIndex + group.Count; j++)
+                    {
+                        result.Add(messageList[j]);
+                    }
+                }
+            }
+
+            // Insert summary
+            result.Add(new ChatMessage(ChatRole.Assistant, $"[Summary]\n{summaryText}"));
+
+            // Keep protected groups
+            for (int i = protectedFromIndex; i < nonSystemGroups.Count; i++)
+            {
+                ChatMessageGroup group = nonSystemGroups[i];
+                for (int j = group.StartIndex; j < group.StartIndex + group.Count; j++)
+                {
+                    result.Add(messageList[j]);
+                }
+            }
+
+            return result;
+        }
+    }
+}

dotnet/src/Microsoft.Agents.AI.Abstractions/Compaction/ToolResultCompactionStrategy.cs

@@ -0,0 +1,118 @@
+// Copyright (c) Microsoft. All rights reserved.
+
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Threading;
+using System.Threading.Tasks;
+using Microsoft.Extensions.AI;
+
+namespace Microsoft.Agents.AI.Compaction;
+
+/// <summary>
+/// A compaction strategy that collapses old assistant-tool-call groups into single
+/// concise assistant messages, removing the detailed tool results while preserving
+/// a record of which tools were called.
+/// </summary>
+/// <remarks>
+/// <para>
+/// This is the gentlest compaction strategy — it does not remove any user messages or
+/// plain assistant responses. It only targets <see cref="ChatMessageGroupKind.AssistantToolGroup"/>
+/// entries outside the protected recent window, replacing each multi-message group
+/// (assistant call + tool results) with a single assistant message like
+/// <c>[Tool calls: get_weather, search_docs]</c>.
+/// </para>
+/// <para>
+/// The trigger condition fires only when token count exceeds <c>maxTokens</c> and
+/// there is at least one tool call in the conversation.
+/// </para>
+/// </remarks>
+public class ToolResultCompactionStrategy : ChatHistoryCompactionStrategy
+{
+    /// <summary>
+    /// The default value for `preserveRecentGroups` used when constructing <see cref="ToolResultCompactionStrategy"/>.
+    /// </summary>
+    public const int DefaultPreserveRecentGroups = 2;
+
+    private readonly int _maxTokens;
+
+    /// <summary>
+    /// Initializes a new instance of the <see cref="ToolResultCompactionStrategy"/> class.
+    /// </summary>
+    /// <param name="maxTokens">The maximum token budget. Tool groups are collapsed when the token count exceeds this value.</param>
+    /// <param name="preserveRecentGroups">
+    /// The number of most-recent non-system message groups to protect from collapsing.
+    /// Defaults to 2, ensuring the current turn's tool interactions remain visible.
+    /// </param>
+    public ToolResultCompactionStrategy(int maxTokens, int preserveRecentGroups = DefaultPreserveRecentGroups)
+        : base(new ToolResultClearingReducer(preserveRecentGroups))
+    {
+        this._maxTokens = maxTokens;
+    }
+
+    /// <inheritdoc/>
+    protected override bool ShouldCompact(ChatHistoryMetric metrics) =>
+        metrics.TokenCount > this._maxTokens && metrics.ToolCallCount > 0;
+
+    /// <summary>
+    /// An <see cref="IChatReducer"/> that collapses <see cref="ChatMessageGroupKind.AssistantToolGroup"/>
+    /// entries into single summary messages, preserving the most recent groups.
+    /// </summary>
+    private sealed class ToolResultClearingReducer(int preserveRecentGroups) : IChatReducer
+    {
+        public Task<IEnumerable<ChatMessage>> ReduceAsync(
+            IEnumerable<ChatMessage> messages,
+            CancellationToken cancellationToken = default)
+        {
+            IReadOnlyList<ChatMessage> messageList = [.. messages];
+            IReadOnlyList<ChatMessageGroup> groups = CurrentMetrics.Groups;
+
+            List<ChatMessageGroup> nonSystemGroups = [.. groups.Where(g => g.Kind != ChatMessageGroupKind.System)];
+            int protectedFromIndex = Math.Max(0, nonSystemGroups.Count - preserveRecentGroups);
+            HashSet<int> protectedGroupStarts = [];
+            for (int i = protectedFromIndex; i < nonSystemGroups.Count; i++)
+            {
+                protectedGroupStarts.Add(nonSystemGroups[i].StartIndex);
+            }
+
+            List<ChatMessage> result = new(messageList.Count);
+            bool anyCollapsed = false;
+
+            foreach (ChatMessageGroup group in groups)
+            {
+                if (group.Kind == ChatMessageGroupKind.AssistantToolGroup && !protectedGroupStarts.Contains(group.StartIndex))
+                {
+                    // Collapse this tool group into a single summary message
+                    List<string> toolNames = [];
+                    for (int j = group.StartIndex; j < group.StartIndex + group.Count; j++)
+                    {
+                        if (messageList[j].Contents is not null)
+                        {
+                            foreach (AIContent content in messageList[j].Contents)
+                            {
+                                if (content is FunctionCallContent fcc)
+                                {
+                                    toolNames.Add(fcc.Name);
+                                }
+                            }
+                        }
+                    }
+
+                    string summary = $"[Tool calls: {string.Join(", ", toolNames)}]";
+                    result.Add(new ChatMessage(ChatRole.Assistant, summary));
+                    anyCollapsed = true;
+                }
+                else
+                {
+                    // Keep this group as-is
+                    for (int j = group.StartIndex; j < group.StartIndex + group.Count; j++)
+                    {
+                        result.Add(messageList[j]);
+                    }
+                }
+            }
+
+            return Task.FromResult<IEnumerable<ChatMessage>>(anyCollapsed ? result : messageList);
+        }
+    }
+}

dotnet/src/Microsoft.Agents.AI.Abstractions/Compaction/TruncationCompactionStrategy.cs

@@ -0,0 +1,97 @@
+// Copyright (c) Microsoft. All rights reserved.
+
+using System.Collections.Generic;
+using System.Linq;
+using System.Threading;
+using System.Threading.Tasks;
+using Microsoft.Extensions.AI;
+
+namespace Microsoft.Agents.AI.Compaction;
+
+/// <summary>
+/// A compaction strategy that removes the oldest message groups until the estimated
+/// token count is within a specified budget.
+/// </summary>
+/// <remarks>
+/// <para>
+/// This strategy preserves system messages and removes the oldest non-system message groups first.
+/// It respects atomic group boundaries — an assistant message with tool calls and its
+/// corresponding tool result messages are always removed together.
+/// </para>
+/// <para>
+/// The trigger condition fires only when the current token count exceeds <c>maxTokens</c>.
+/// </para>
+/// </remarks>
+public class TruncationCompactionStrategy : ChatHistoryCompactionStrategy
+{
+    private readonly int _maxTokens;
+
+    /// <summary>
+    /// Initializes a new instance of the <see cref="TruncationCompactionStrategy"/> class.
+    /// </summary>
+    /// <param name="maxTokens">The maximum token budget. Groups are removed until the token count is at or below this value.</param>
+    /// <param name="preserveRecentGroups">
+    /// The minimum number of most-recent non-system message groups to keep.
+    /// Defaults to 1 so that at least the latest exchange is always preserved.
+    /// </param>
+    public TruncationCompactionStrategy(int maxTokens, int preserveRecentGroups = 1)
+        : base(new TruncationReducer(preserveRecentGroups))
+    {
+        this._maxTokens = maxTokens;
+    }
+
+    /// <inheritdoc/>
+    protected override bool ShouldCompact(ChatHistoryMetric metrics) =>
+        metrics.TokenCount > this._maxTokens;
+
+    /// <summary>
+    /// An <see cref="IChatReducer"/> that removes the oldest non-system message groups,
+    /// keeping at least the most recent group.
+    /// </summary>
+    private sealed class TruncationReducer(int preserveRecentGroups) : IChatReducer
+    {
+        public Task<IEnumerable<ChatMessage>> ReduceAsync(
+            IEnumerable<ChatMessage> messages,
+            CancellationToken cancellationToken = default)
+        {
+            IReadOnlyList<ChatMessage> messageList = [.. messages];
+
+            ChatMessageGroup[] removableGroups = [.. CurrentMetrics.Groups.Where(g => g.Kind != ChatMessageGroupKind.System)];
+
+            if (removableGroups.Length == 0)
+            {
+                return Task.FromResult<IEnumerable<ChatMessage>>(messageList);
+            }
+
+            // Remove oldest non-system groups, keeping at least preserveRecentGroups.
+            int maxRemovable = removableGroups.Length - preserveRecentGroups;
+
+            if (maxRemovable <= 0)
+            {
+                return Task.FromResult<IEnumerable<ChatMessage>>(messageList);
+            }
+
+            HashSet<int> removedGroupStarts = [];
+            for (int ri = 0; ri < maxRemovable; ri++)
+            {
+                removedGroupStarts.Add(removableGroups[ri].StartIndex);
+            }
+
+            List<ChatMessage> messagesToKeep = new(messageList.Count);
+            foreach (ChatMessageGroup group in CurrentMetrics.Groups)
+            {
+                if (removedGroupStarts.Contains(group.StartIndex))
+                {
+                    continue;
+                }
+
+                for (int j = group.StartIndex; j < group.StartIndex + group.Count; j++)
+                {
+                    messagesToKeep.Add(messageList[j]);
+                }
+            }
+
+            return Task.FromResult<IEnumerable<ChatMessage>>(messagesToKeep);
+        }
+    }
+}

dotnet/src/Microsoft.Agents.AI.Abstractions/Microsoft.Agents.AI.Abstractions.csproj

@@ -31,6 +31,10 @@
     <PackageReference Include="Microsoft.Extensions.Logging.Abstractions" />
   </ItemGroup>
 
+  <ItemGroup Condition="'$(TargetFrameworkIdentifier)' != '.NETCoreApp'">
+    <PackageReference Include="Microsoft.Bcl.HashCode" />
+  </ItemGroup>
+
   <ItemGroup>
     <InternalsVisibleTo Include="Microsoft.Agents.AI.Abstractions.UnitTests" />
   </ItemGroup>

dotnet/src/Microsoft.Agents.AI.GitHub.Copilot/GitHubCopilotAgent.cs

@@ -346,14 +346,14 @@ public sealed class GitHubCopilotAgent : AIAgent, IAsyncDisposable
         };
     }
 
-    private AgentResponseUpdate ConvertToAgentResponseUpdate(AssistantMessageEvent assistantMessage)
+    internal AgentResponseUpdate ConvertToAgentResponseUpdate(AssistantMessageEvent assistantMessage)
     {
-        TextContent textContent = new(assistantMessage.Data?.Content ?? string.Empty)
+        AIContent content = new()
         {
             RawRepresentation = assistantMessage
         };
 
-        return new AgentResponseUpdate(ChatRole.Assistant, [textContent])
+        return new AgentResponseUpdate(ChatRole.Assistant, [content])
         {
             AgentId = this.Id,
             ResponseId = assistantMessage.Data?.MessageId,

dotnet/src/Shared/IntegrationTestsAzureCredentials/README.md

@@ -0,0 +1,9 @@
+# Integration Tests Azure Credentials
+
+Adds a helper for loading Azure credentials in integration tests.
+
+```xml
+<PropertyGroup>
+  <InjectSharedIntegrationTestAzureCredentialsCode>true</InjectSharedIntegrationTestAzureCredentialsCode>
+</PropertyGroup>
+```

dotnet/src/Shared/IntegrationTestsAzureCredentials/TestAzureCliCredentials.cs

@@ -0,0 +1,28 @@
+// Copyright (c) Microsoft. All rights reserved.
+
+#pragma warning disable IDE0005 // This is required in some projects and not in others.
+using System;
+#pragma warning restore IDE0005
+using Azure.Identity;
+
+namespace Shared.IntegrationTests;
+
+/// <summary>
+/// Provides credential instances for integration tests with
+/// increased timeouts to avoid CI pipeline authentication failures.
+/// </summary>
+internal static class TestAzureCliCredentials
+{
+    /// <summary>
+    /// The default timeout for Azure CLI credential operations.
+    /// Increased from the default (~13s) to accommodate CI pipeline latency.
+    /// </summary>
+    private static readonly TimeSpan s_processTimeout = TimeSpan.FromSeconds(60);
+
+    /// <summary>
+    /// Creates a new <see cref="AzureCliCredential"/> with an increased process timeout
+    /// suitable for CI environments.
+    /// </summary>
+    public static AzureCliCredential CreateAzureCliCredential() =>
+        new(new AzureCliCredentialOptions { ProcessTimeout = s_processTimeout });
+}

dotnet/tests/AgentConformance.IntegrationTests/AgentTests.cs

@@ -15,11 +15,15 @@ public abstract class AgentTests<TAgentFixture>(Func<TAgentFixture> createAgentF
 {
     protected TAgentFixture Fixture { get; private set; } = default!;
 
-    public Task InitializeAsync()
+    public async ValueTask InitializeAsync()
     {
         this.Fixture = createAgentFixture();
-        return this.Fixture.InitializeAsync();
+        await this.Fixture.InitializeAsync();
     }
 
-    public Task DisposeAsync() => this.Fixture.DisposeAsync();
+    public async ValueTask DisposeAsync()
+    {
+        GC.SuppressFinalize(this);
+        await this.Fixture.DisposeAsync();
+    }
 }

dotnet/tests/AnthropicChatCompletion.IntegrationTests/AnthropicChatCompletion.IntegrationTests.csproj

@@ -1,6 +1,7 @@
 <Project Sdk="Microsoft.NET.Sdk">
 
   <PropertyGroup>
+    <NoWarn>$(NoWarn);CS8793</NoWarn>
     <InjectSharedIntegrationTestCode>True</InjectSharedIntegrationTestCode>
   </PropertyGroup>
 

dotnet/tests/AnthropicChatCompletion.IntegrationTests/AnthropicChatCompletionChatClientAgentRunStreamingTests.cs

@@ -1,26 +1,13 @@
 // Copyright (c) Microsoft. All rights reserved.
 
-using System;
-using System.Threading.Tasks;
 using AgentConformance.IntegrationTests;
 
 namespace AnthropicChatCompletion.IntegrationTests;
 
-public abstract class SkipAllChatClientRunStreaming(Func<AnthropicChatCompletionFixture> func) : ChatClientAgentRunStreamingTests<AnthropicChatCompletionFixture>(func)
-{
-    [Fact(Skip = AnthropicChatCompletionFixture.SkipReason)]
-    public override Task RunWithFunctionsInvokesFunctionsAndReturnsExpectedResultsAsync()
-        => base.RunWithFunctionsInvokesFunctionsAndReturnsExpectedResultsAsync();
+public class AnthropicBetaChatCompletionChatClientAgentReasoningRunStreamingTests() : ChatClientAgentRunStreamingTests<AnthropicChatCompletionFixture>(() => new(useReasoningChatModel: true, useBeta: true));
 
-    [Fact(Skip = AnthropicChatCompletionFixture.SkipReason)]
-    public override Task RunWithInstructionsAndNoMessageReturnsExpectedResultAsync()
-        => base.RunWithInstructionsAndNoMessageReturnsExpectedResultAsync();
-}
+public class AnthropicBetaChatCompletionChatClientAgentRunStreamingTests() : ChatClientAgentRunStreamingTests<AnthropicChatCompletionFixture>(() => new(useReasoningChatModel: false, useBeta: true));
 
-public class AnthropicBetaChatCompletionChatClientAgentReasoningRunStreamingTests() : SkipAllChatClientRunStreaming(() => new(useReasoningChatModel: true, useBeta: true));
+public class AnthropicChatCompletionChatClientAgentRunStreamingTests() : ChatClientAgentRunStreamingTests<AnthropicChatCompletionFixture>(() => new(useReasoningChatModel: false, useBeta: false));
 
-public class AnthropicBetaChatCompletionChatClientAgentRunStreamingTests() : SkipAllChatClientRunStreaming(() => new(useReasoningChatModel: false, useBeta: true));
-
-public class AnthropicChatCompletionChatClientAgentRunStreamingTests() : SkipAllChatClientRunStreaming(() => new(useReasoningChatModel: false, useBeta: false));
-
-public class AnthropicChatCompletionChatClientAgentReasoningRunStreamingTests() : SkipAllChatClientRunStreaming(() => new(useReasoningChatModel: true, useBeta: false));
+public class AnthropicChatCompletionChatClientAgentReasoningRunStreamingTests() : ChatClientAgentRunStreamingTests<AnthropicChatCompletionFixture>(() => new(useReasoningChatModel: true, useBeta: false));

dotnet/tests/AnthropicChatCompletion.IntegrationTests/AnthropicChatCompletionChatClientAgentRunTests.cs

@@ -1,30 +1,17 @@
 // Copyright (c) Microsoft. All rights reserved.
 
-using System;
-using System.Threading.Tasks;
 using AgentConformance.IntegrationTests;
 
 namespace AnthropicChatCompletion.IntegrationTests;
 
-public abstract class SkipAllChatClientAgentRun(Func<AnthropicChatCompletionFixture> func) : ChatClientAgentRunTests<AnthropicChatCompletionFixture>(func)
-{
-    [Fact(Skip = AnthropicChatCompletionFixture.SkipReason)]
-    public override Task RunWithFunctionsInvokesFunctionsAndReturnsExpectedResultsAsync()
-        => base.RunWithFunctionsInvokesFunctionsAndReturnsExpectedResultsAsync();
-
-    [Fact(Skip = AnthropicChatCompletionFixture.SkipReason)]
-    public override Task RunWithInstructionsAndNoMessageReturnsExpectedResultAsync()
-        => base.RunWithInstructionsAndNoMessageReturnsExpectedResultAsync();
-}
-
 public class AnthropicBetaChatCompletionChatClientAgentRunTests()
-    : SkipAllChatClientAgentRun(() => new(useReasoningChatModel: false, useBeta: true));
+    : ChatClientAgentRunTests<AnthropicChatCompletionFixture>(() => new(useReasoningChatModel: false, useBeta: true));
 
 public class AnthropicBetaChatCompletionChatClientAgentReasoningRunTests()
-    : SkipAllChatClientAgentRun(() => new(useReasoningChatModel: true, useBeta: true));
+    : ChatClientAgentRunTests<AnthropicChatCompletionFixture>(() => new(useReasoningChatModel: true, useBeta: true));
 
 public class AnthropicChatCompletionChatClientAgentRunTests()
-    : SkipAllChatClientAgentRun(() => new(useReasoningChatModel: false, useBeta: false));
+    : ChatClientAgentRunTests<AnthropicChatCompletionFixture>(() => new(useReasoningChatModel: false, useBeta: false));
 
 public class AnthropicChatCompletionChatClientAgentReasoningRunTests()
-    : SkipAllChatClientAgentRun(() => new(useReasoningChatModel: true, useBeta: false));
+    : ChatClientAgentRunTests<AnthropicChatCompletionFixture>(() => new(useReasoningChatModel: true, useBeta: false));

dotnet/tests/AnthropicChatCompletion.IntegrationTests/AnthropicChatCompletionFixture.cs

@@ -1,5 +1,6 @@
 // Copyright (c) Microsoft. All rights reserved.
 
+using System;
 using System.Collections.Generic;
 using System.Linq;
 using System.Threading.Tasks;
@@ -102,9 +103,15 @@ public class AnthropicChatCompletionFixture : IChatClientAgentFixture
         // Chat Completion does not require/support deleting sessions, so this is a no-op.
         Task.CompletedTask;
 
-    public async Task InitializeAsync() =>
+    public async ValueTask InitializeAsync()
+    {
+        Assert.SkipWhen(SkipReason is not null, SkipReason ?? string.Empty);
         this._agent = await this.CreateChatClientAgentAsync();
+    }
 
-    public Task DisposeAsync() =>
-        Task.CompletedTask;
+    public ValueTask DisposeAsync()
+    {
+        GC.SuppressFinalize(this);
+        return default;
+    }
 }

dotnet/tests/AnthropicChatCompletion.IntegrationTests/AnthropicChatCompletionRunStreamingTests.cs

@@ -1,37 +1,17 @@
 // Copyright (c) Microsoft. All rights reserved.
 
-using System;
-using System.Threading.Tasks;
 using AgentConformance.IntegrationTests;
 
 namespace AnthropicChatCompletion.IntegrationTests;
 
-public abstract class SkipAllRunStreaming(Func<AnthropicChatCompletionFixture> func) : RunStreamingTests<AnthropicChatCompletionFixture>(func)
-{
-    [Fact(Skip = AnthropicChatCompletionFixture.SkipReason)]
-    public override Task RunWithChatMessageReturnsExpectedResultAsync() => base.RunWithChatMessageReturnsExpectedResultAsync();
-
-    [Fact(Skip = AnthropicChatCompletionFixture.SkipReason)]
-    public override Task RunWithNoMessageDoesNotFailAsync() => base.RunWithNoMessageDoesNotFailAsync();
-
-    [Fact(Skip = AnthropicChatCompletionFixture.SkipReason)]
-    public override Task RunWithChatMessagesReturnsExpectedResultAsync() => base.RunWithChatMessagesReturnsExpectedResultAsync();
-
-    [Fact(Skip = AnthropicChatCompletionFixture.SkipReason)]
-    public override Task RunWithStringReturnsExpectedResultAsync() => base.RunWithStringReturnsExpectedResultAsync();
-
-    [Fact(Skip = AnthropicChatCompletionFixture.SkipReason)]
-    public override Task SessionMaintainsHistoryAsync() => base.SessionMaintainsHistoryAsync();
-}
-
 public class AnthropicBetaChatCompletionRunStreamingTests()
-    : SkipAllRunStreaming(() => new(useReasoningChatModel: false, useBeta: true));
+    : RunStreamingTests<AnthropicChatCompletionFixture>(() => new(useReasoningChatModel: false, useBeta: true));
 
 public class AnthropicBetaChatCompletionReasoningRunStreamingTests()
-    : SkipAllRunStreaming(() => new(useReasoningChatModel: true, useBeta: true));
+    : RunStreamingTests<AnthropicChatCompletionFixture>(() => new(useReasoningChatModel: true, useBeta: true));
 
 public class AnthropicChatCompletionRunStreamingTests()
-    : SkipAllRunStreaming(() => new(useReasoningChatModel: false, useBeta: false));
+    : RunStreamingTests<AnthropicChatCompletionFixture>(() => new(useReasoningChatModel: false, useBeta: false));
 
 public class AnthropicChatCompletionReasoningRunStreamingTests()
-    : SkipAllRunStreaming(() => new(useReasoningChatModel: true, useBeta: false));
+    : RunStreamingTests<AnthropicChatCompletionFixture>(() => new(useReasoningChatModel: true, useBeta: false));

dotnet/tests/AnthropicChatCompletion.IntegrationTests/AnthropicChatCompletionRunTests.cs

@@ -1,37 +1,17 @@
 // Copyright (c) Microsoft. All rights reserved.
 
-using System;
-using System.Threading.Tasks;
 using AgentConformance.IntegrationTests;
 
 namespace AnthropicChatCompletion.IntegrationTests;
 
-public abstract class SkipAllRun(Func<AnthropicChatCompletionFixture> func) : RunTests<AnthropicChatCompletionFixture>(func)
-{
-    [Fact(Skip = AnthropicChatCompletionFixture.SkipReason)]
-    public override Task RunWithChatMessageReturnsExpectedResultAsync() => base.RunWithChatMessageReturnsExpectedResultAsync();
-
-    [Fact(Skip = AnthropicChatCompletionFixture.SkipReason)]
-    public override Task RunWithNoMessageDoesNotFailAsync() => base.RunWithNoMessageDoesNotFailAsync();
-
-    [Fact(Skip = AnthropicChatCompletionFixture.SkipReason)]
-    public override Task RunWithChatMessagesReturnsExpectedResultAsync() => base.RunWithChatMessagesReturnsExpectedResultAsync();
-
-    [Fact(Skip = AnthropicChatCompletionFixture.SkipReason)]
-    public override Task RunWithStringReturnsExpectedResultAsync() => base.RunWithStringReturnsExpectedResultAsync();
-
-    [Fact(Skip = AnthropicChatCompletionFixture.SkipReason)]
-    public override Task SessionMaintainsHistoryAsync() => base.SessionMaintainsHistoryAsync();
-}
-
 public class AnthropicBetaChatCompletionRunTests()
-    : SkipAllRun(() => new(useReasoningChatModel: false, useBeta: true));
+    : RunTests<AnthropicChatCompletionFixture>(() => new(useReasoningChatModel: false, useBeta: true));
 
 public class AnthropicBetaChatCompletionReasoningRunTests()
-    : SkipAllRun(() => new(useReasoningChatModel: true, useBeta: true));
+    : RunTests<AnthropicChatCompletionFixture>(() => new(useReasoningChatModel: true, useBeta: true));
 
 public class AnthropicChatCompletionRunTests()
-    : SkipAllRun(() => new(useReasoningChatModel: false, useBeta: false));
+    : RunTests<AnthropicChatCompletionFixture>(() => new(useReasoningChatModel: false, useBeta: false));
 
 public class AnthropicChatCompletionReasoningRunTests()
-    : SkipAllRun(() => new(useReasoningChatModel: true, useBeta: false));
+    : RunTests<AnthropicChatCompletionFixture>(() => new(useReasoningChatModel: true, useBeta: false));

dotnet/tests/AnthropicChatCompletion.IntegrationTests/AnthropicSkillsIntegrationTests.cs

@@ -22,9 +22,11 @@ public sealed class AnthropicSkillsIntegrationTests
     // All tests for Anthropic are intended to be ran locally as the CI pipeline for Anthropic is not setup.
     private const string SkipReason = "Integrations tests for local execution only";
 
-    [Fact(Skip = SkipReason)]
+    [Fact]
     public async Task CreateAgentWithPptxSkillAsync()
     {
+        Assert.SkipWhen(SkipReason is not null, SkipReason ?? string.Empty);
+
         // Arrange
         AnthropicClient anthropicClient = new() { ApiKey = TestConfiguration.GetRequiredValue(TestSettings.AnthropicApiKey) };
         string model = TestConfiguration.GetRequiredValue(TestSettings.AnthropicChatModelName);
@@ -51,9 +53,11 @@ public sealed class AnthropicSkillsIntegrationTests
         Assert.NotEmpty(response.Text);
     }
 
-    [Fact(Skip = SkipReason)]
+    [Fact]
     public async Task ListAnthropicManagedSkillsAsync()
     {
+        Assert.SkipWhen(SkipReason is not null, SkipReason ?? string.Empty);
+
         // Arrange
         AnthropicClient anthropicClient = new() { ApiKey = TestConfiguration.GetRequiredValue(TestSettings.AnthropicApiKey) };
 

dotnet/tests/AzureAI.IntegrationTests/AIProjectClientAgentRunStreamingTests.cs

@@ -9,10 +9,10 @@ namespace AzureAI.IntegrationTests;
 
 public class AIProjectClientAgentRunStreamingPreviousResponseTests() : RunStreamingTests<AIProjectClientFixture>(() => new())
 {
-    [Fact(Skip = "No messages is not supported")]
     public override Task RunWithNoMessageDoesNotFailAsync()
     {
-        return Task.CompletedTask;
+        Assert.Skip("No messages is not supported");
+        return base.RunWithNoMessageDoesNotFailAsync();
     }
 }
 
@@ -24,9 +24,9 @@ public class AIProjectClientAgentRunStreamingConversationTests() : RunTests<AIPr
         return new ChatClientAgentRunOptions(new() { ConversationId = conversationId });
     };
 
-    [Fact(Skip = "No messages is not supported")]
     public override Task RunWithNoMessageDoesNotFailAsync()
     {
-        return Task.CompletedTask;
+        Assert.Skip("No messages is not supported");
+        return base.RunWithNoMessageDoesNotFailAsync();
     }
 }

dotnet/tests/AzureAI.IntegrationTests/AIProjectClientAgentRunTests.cs

@@ -9,10 +9,10 @@ namespace AzureAI.IntegrationTests;
 
 public class AIProjectClientAgentRunPreviousResponseTests() : RunTests<AIProjectClientFixture>(() => new())
 {
-    [Fact(Skip = "No messages is not supported")]
     public override Task RunWithNoMessageDoesNotFailAsync()
     {
-        return Task.CompletedTask;
+        Assert.Skip("No messages is not supported");
+        return base.RunWithNoMessageDoesNotFailAsync();
     }
 }
 
@@ -24,9 +24,9 @@ public class AIProjectClientAgentRunConversationTests() : RunTests<AIProjectClie
         return new ChatClientAgentRunOptions(new() { ConversationId = conversationId });
     };
 
-    [Fact(Skip = "No messages is not supported")]
     public override Task RunWithNoMessageDoesNotFailAsync()
     {
-        return Task.CompletedTask;
+        Assert.Skip("No messages is not supported");
+        return base.RunWithNoMessageDoesNotFailAsync();
     }
 }

dotnet/tests/AzureAI.IntegrationTests/AIProjectClientAgentStructuredOutputRunTests.cs

@@ -1,6 +1,5 @@
 // Copyright (c) Microsoft. All rights reserved.
 
-using System;
 using System.Threading.Tasks;
 using AgentConformance.IntegrationTests;
 using AgentConformance.IntegrationTests.Support;
@@ -66,17 +65,23 @@ public class AIProjectClientAgentStructuredOutputRunTests() : StructuredOutputRu
         Assert.Equal("Paris", response.Result.Name);
     }
 
-    [Fact(Skip = NotSupported)]
-    public override Task RunWithGenericTypeReturnsExpectedResultAsync() =>
-        base.RunWithGenericTypeReturnsExpectedResultAsync();
+    public override Task RunWithGenericTypeReturnsExpectedResultAsync()
+    {
+        Assert.Skip(NotSupported);
+        return base.RunWithGenericTypeReturnsExpectedResultAsync();
+    }
 
-    [Fact(Skip = NotSupported)]
-    public override Task RunWithResponseFormatReturnsExpectedResultAsync() =>
-        base.RunWithResponseFormatReturnsExpectedResultAsync();
+    public override Task RunWithResponseFormatReturnsExpectedResultAsync()
+    {
+        Assert.Skip(NotSupported);
+        return base.RunWithResponseFormatReturnsExpectedResultAsync();
+    }
 
-    [Fact(Skip = NotSupported)]
-    public override Task RunWithPrimitiveTypeReturnsExpectedResultAsync() =>
-        base.RunWithPrimitiveTypeReturnsExpectedResultAsync();
+    public override Task RunWithPrimitiveTypeReturnsExpectedResultAsync()
+    {
+        Assert.Skip(NotSupported);
+        return base.RunWithPrimitiveTypeReturnsExpectedResultAsync();
+    }
 }
 
 /// <summary>
@@ -84,7 +89,7 @@ public class AIProjectClientAgentStructuredOutputRunTests() : StructuredOutputRu
 /// </summary>
 public class AIProjectClientStructuredOutputFixture<T> : AIProjectClientFixture
 {
-    public override Task InitializeAsync()
+    public override async ValueTask InitializeAsync()
     {
         var agentOptions = new ChatClientAgentOptions
         {
@@ -94,6 +99,6 @@ public class AIProjectClientStructuredOutputFixture<T> : AIProjectClientFixture
             },
         };
 
-        return this.InitializeAsync(agentOptions);
+        await this.InitializeAsync(agentOptions);
     }
 }

dotnet/tests/AzureAI.IntegrationTests/AIProjectClientChatClientAgentRunStreamingTests.cs

@@ -7,9 +7,9 @@ namespace AzureAI.IntegrationTests;
 
 public class AIProjectClientChatClientAgentRunStreamingTests() : ChatClientAgentRunStreamingTests<AIProjectClientFixture>(() => new())
 {
-    [Fact(Skip = "No messages is not supported")]
     public override Task RunWithInstructionsAndNoMessageReturnsExpectedResultAsync()
     {
-        return Task.CompletedTask;
+        Assert.Skip("No messages is not supported");
+        return base.RunWithInstructionsAndNoMessageReturnsExpectedResultAsync();
     }
 }

dotnet/tests/AzureAI.IntegrationTests/AIProjectClientChatClientAgentRunTests.cs

@@ -7,9 +7,9 @@ namespace AzureAI.IntegrationTests;
 
 public class AIProjectClientChatClientAgentRunTests() : ChatClientAgentRunTests<AIProjectClientFixture>(() => new())
 {
-    [Fact(Skip = "No messages is not supported")]
     public override Task RunWithInstructionsAndNoMessageReturnsExpectedResultAsync()
     {
-        return Task.CompletedTask;
+        Assert.Skip("No messages is not supported");
+        return base.RunWithInstructionsAndNoMessageReturnsExpectedResultAsync();
     }
 }

dotnet/tests/AzureAI.IntegrationTests/AIProjectClientCreateTests.cs

@@ -6,7 +6,6 @@ using System.Threading.Tasks;
 using AgentConformance.IntegrationTests.Support;
 using Azure.AI.Projects;
 using Azure.AI.Projects.OpenAI;
-using Azure.Identity;
 using Microsoft.Agents.AI;
 using Microsoft.Extensions.AI;
 using OpenAI.Files;
@@ -17,7 +16,7 @@ namespace AzureAI.IntegrationTests;
 
 public class AIProjectClientCreateTests
 {
-    private readonly AIProjectClient _client = new(new Uri(TestConfiguration.GetRequiredValue(TestSettings.AzureAIProjectEndpoint)), new AzureCliCredential());
+    private readonly AIProjectClient _client = new(new Uri(TestConfiguration.GetRequiredValue(TestSettings.AzureAIProjectEndpoint)), TestAzureCliCredentials.CreateAzureCliCredential());
 
     [Theory]
     [InlineData("CreateWithChatClientAgentOptionsAsync")]

dotnet/tests/AzureAI.IntegrationTests/AIProjectClientFixture.cs

@@ -8,7 +8,6 @@ using AgentConformance.IntegrationTests;
 using AgentConformance.IntegrationTests.Support;
 using Azure.AI.Projects;
 using Azure.AI.Projects.OpenAI;
-using Azure.Identity;
 using Microsoft.Agents.AI;
 using Microsoft.Extensions.AI;
 using OpenAI.Responses;
@@ -156,25 +155,27 @@ public class AIProjectClientFixture : IChatClientAgentFixture
         }
     }
 
-    public Task DisposeAsync()
+    public ValueTask DisposeAsync()
     {
+        GC.SuppressFinalize(this);
+
         if (this._client is not null && this._agent is not null)
         {
-            return this._client.Agents.DeleteAgentAsync(this._agent.Name);
+            return new ValueTask(this._client.Agents.DeleteAgentAsync(this._agent.Name));
         }
 
-        return Task.CompletedTask;
+        return default;
     }
 
-    public virtual async Task InitializeAsync()
+    public virtual async ValueTask InitializeAsync()
     {
-        this._client = new(new Uri(TestConfiguration.GetRequiredValue(TestSettings.AzureAIProjectEndpoint)), new AzureCliCredential());
+        this._client = new(new Uri(TestConfiguration.GetRequiredValue(TestSettings.AzureAIProjectEndpoint)), TestAzureCliCredentials.CreateAzureCliCredential());
         this._agent = await this.CreateChatClientAgentAsync();
     }
 
     public async Task InitializeAsync(ChatClientAgentOptions options)
     {
-        this._client = new(new Uri(TestConfiguration.GetRequiredValue(TestSettings.AzureAIProjectEndpoint)), new AzureCliCredential());
+        this._client = new(new Uri(TestConfiguration.GetRequiredValue(TestSettings.AzureAIProjectEndpoint)), TestAzureCliCredentials.CreateAzureCliCredential());
         this._agent = await this.CreateChatClientAgentAsync(options);
     }
 }

dotnet/tests/AzureAI.IntegrationTests/AzureAI.IntegrationTests.csproj

@@ -1,7 +1,9 @@
 <Project Sdk="Microsoft.NET.Sdk">
 
   <PropertyGroup>
+    <NoWarn>$(NoWarn);CS8793</NoWarn>
     <InjectSharedIntegrationTestCode>True</InjectSharedIntegrationTestCode>
+    <InjectSharedIntegrationTestAzureCredentialsCode>True</InjectSharedIntegrationTestAzureCredentialsCode>
   </PropertyGroup>
 
   <ItemGroup>

dotnet/tests/AzureAIAgentsPersistent.IntegrationTests/AzureAIAgentsPersistent.IntegrationTests.csproj

@@ -1,7 +1,9 @@
 <Project Sdk="Microsoft.NET.Sdk">
 
   <PropertyGroup>
+    <NoWarn>$(NoWarn);CS8793</NoWarn>
     <InjectSharedIntegrationTestCode>True</InjectSharedIntegrationTestCode>
+    <InjectSharedIntegrationTestAzureCredentialsCode>True</InjectSharedIntegrationTestAzureCredentialsCode>
   </PropertyGroup>
 
   <ItemGroup>

dotnet/tests/AzureAIAgentsPersistent.IntegrationTests/AzureAIAgentsPersistentCreateTests.cs

@@ -6,7 +6,6 @@ using System.IO;
 using System.Threading.Tasks;
 using AgentConformance.IntegrationTests.Support;
 using Azure.AI.Agents.Persistent;
-using Azure.Identity;
 using Microsoft.Agents.AI;
 using Microsoft.Extensions.AI;
 using Shared.IntegrationTests;
@@ -15,7 +14,7 @@ namespace AzureAIAgentsPersistent.IntegrationTests;
 
 public class AzureAIAgentsPersistentCreateTests
 {
-    private readonly PersistentAgentsClient _persistentAgentsClient = new(TestConfiguration.GetRequiredValue(TestSettings.AzureAIProjectEndpoint), new AzureCliCredential());
+    private readonly PersistentAgentsClient _persistentAgentsClient = new(TestConfiguration.GetRequiredValue(TestSettings.AzureAIProjectEndpoint), TestAzureCliCredentials.CreateAzureCliCredential());
 
     [Theory]
     [InlineData("CreateWithChatClientAgentOptionsAsync")]

dotnet/tests/AzureAIAgentsPersistent.IntegrationTests/AzureAIAgentsPersistentFixture.cs

@@ -1,12 +1,12 @@
 // Copyright (c) Microsoft. All rights reserved.
 
+using System;
 using System.Collections.Generic;
 using System.Threading.Tasks;
 using AgentConformance.IntegrationTests;
 using AgentConformance.IntegrationTests.Support;
 using Azure;
 using Azure.AI.Agents.Persistent;
-using Azure.Identity;
 using Microsoft.Agents.AI;
 using Microsoft.Extensions.AI;
 using Shared.IntegrationTests;
@@ -84,19 +84,21 @@ public class AzureAIAgentsPersistentFixture : IChatClientAgentFixture
         return Task.CompletedTask;
     }
 
-    public Task DisposeAsync()
+    public ValueTask DisposeAsync()
     {
+        GC.SuppressFinalize(this);
+
         if (this._persistentAgentsClient is not null && this._agent is not null)
         {
-            return this._persistentAgentsClient.Administration.DeleteAgentAsync(this._agent.Id);
+            return new ValueTask(this._persistentAgentsClient.Administration.DeleteAgentAsync(this._agent.Id));
         }
 
-        return Task.CompletedTask;
+        return default;
     }
 
-    public async Task InitializeAsync()
+    public async ValueTask InitializeAsync()
     {
-        this._persistentAgentsClient = new(TestConfiguration.GetRequiredValue(TestSettings.AzureAIProjectEndpoint), new AzureCliCredential());
+        this._persistentAgentsClient = new(TestConfiguration.GetRequiredValue(TestSettings.AzureAIProjectEndpoint), TestAzureCliCredentials.CreateAzureCliCredential());
         this._agent = await this.CreateChatClientAgentAsync();
     }
 }

dotnet/tests/AzureAIAgentsPersistent.IntegrationTests/AzureAIAgentsPersistentStructuredOutputRunTests.cs

@@ -9,15 +9,21 @@ public class AzureAIAgentsPersistentStructuredOutputRunTests() : StructuredOutpu
 {
     private const string SkipReason = "Fails intermittently on the build agent/CI";
 
-    [Fact(Skip = SkipReason)]
-    public override Task RunWithResponseFormatReturnsExpectedResultAsync() =>
-        base.RunWithResponseFormatReturnsExpectedResultAsync();
+    public override Task RunWithResponseFormatReturnsExpectedResultAsync()
+    {
+        Assert.SkipWhen(SkipReason is not null, SkipReason ?? string.Empty);
+        return base.RunWithResponseFormatReturnsExpectedResultAsync();
+    }
 
-    [Fact(Skip = SkipReason)]
-    public override Task RunWithGenericTypeReturnsExpectedResultAsync() =>
-        base.RunWithGenericTypeReturnsExpectedResultAsync();
+    public override Task RunWithGenericTypeReturnsExpectedResultAsync()
+    {
+        Assert.SkipWhen(SkipReason is not null, SkipReason ?? string.Empty);
+        return base.RunWithGenericTypeReturnsExpectedResultAsync();
+    }
 
-    [Fact(Skip = SkipReason)]
-    public override Task RunWithPrimitiveTypeReturnsExpectedResultAsync() =>
-        base.RunWithPrimitiveTypeReturnsExpectedResultAsync();
+    public override Task RunWithPrimitiveTypeReturnsExpectedResultAsync()
+    {
+        Assert.SkipWhen(SkipReason is not null, SkipReason ?? string.Empty);
+        return base.RunWithPrimitiveTypeReturnsExpectedResultAsync();
+    }
 }

dotnet/tests/CopilotStudio.IntegrationTests/CopilotStudio.IntegrationTests.csproj

@@ -1,6 +1,7 @@
 <Project Sdk="Microsoft.NET.Sdk">
 
   <PropertyGroup>
+    <NoWarn>$(NoWarn);CS8793</NoWarn>
     <InjectSharedIntegrationTestCode>True</InjectSharedIntegrationTestCode>
     <InjectSharedThrow>true</InjectSharedThrow>
   </PropertyGroup>

dotnet/tests/CopilotStudio.IntegrationTests/CopilotStudioFixture.cs

@@ -28,16 +28,24 @@ public class CopilotStudioFixture : IAgentFixture
         // Chat Completion does not require/support deleting threads, so this is a no-op.
         Task.CompletedTask;
 
-    public Task InitializeAsync()
+    public ValueTask InitializeAsync()
     {
         const string CopilotStudioHttpClientName = nameof(CopilotStudioAgent);
 
-        var settings = new CopilotStudioConnectionSettings(
-            TestConfiguration.GetRequiredValue(TestSettings.CopilotStudioTenantId),
-            TestConfiguration.GetRequiredValue(TestSettings.CopilotStudioAgentAppId))
+        CopilotStudioConnectionSettings? settings = null;
+        try
         {
-            DirectConnectUrl = TestConfiguration.GetRequiredValue(TestSettings.CopilotStudioDirectConnectUrl),
-        };
+            settings = new CopilotStudioConnectionSettings(
+                TestConfiguration.GetRequiredValue(TestSettings.CopilotStudioTenantId),
+                TestConfiguration.GetRequiredValue(TestSettings.CopilotStudioAgentAppId))
+            {
+                DirectConnectUrl = TestConfiguration.GetRequiredValue(TestSettings.CopilotStudioDirectConnectUrl),
+            };
+        }
+        catch (InvalidOperationException ex)
+        {
+            Assert.Skip("CopilotStudio configuration could not be loaded. Error:" + ex.Message);
+        }
 
         ServiceCollection services = new();
 
@@ -56,8 +64,12 @@ public class CopilotStudioFixture : IAgentFixture
 
         this.Agent = new CopilotStudioAgent(client);
 
-        return Task.CompletedTask;
+        return default;
     }
 
-    public Task DisposeAsync() => Task.CompletedTask;
+    public ValueTask DisposeAsync()
+    {
+        GC.SuppressFinalize(this);
+        return default;
+    }
 }

dotnet/tests/CopilotStudio.IntegrationTests/CopilotStudioRunStreamingTests.cs

@@ -10,23 +10,33 @@ public class CopilotStudioRunStreamingTests() : RunStreamingTests<CopilotStudioF
     // Set to null to run the tests.
     private const string ManualVerification = "For manual verification";
 
-    [Fact(Skip = "Copilot Studio does not support session history retrieval, so this test is not applicable.")]
-    public override Task SessionMaintainsHistoryAsync() =>
-        Task.CompletedTask;
+    public override Task SessionMaintainsHistoryAsync()
+    {
+        Assert.Skip("Copilot Studio does not support session history retrieval, so this test is not applicable.");
+        return base.SessionMaintainsHistoryAsync();
+    }
 
-    [Fact(Skip = ManualVerification)]
-    public override Task RunWithChatMessageReturnsExpectedResultAsync() =>
-        base.RunWithChatMessageReturnsExpectedResultAsync();
+    public override Task RunWithChatMessageReturnsExpectedResultAsync()
+    {
+        Assert.SkipWhen(ManualVerification is not null, ManualVerification ?? string.Empty);
+        return base.RunWithChatMessageReturnsExpectedResultAsync();
+    }
 
-    [Fact(Skip = ManualVerification)]
-    public override Task RunWithChatMessagesReturnsExpectedResultAsync() =>
-        base.RunWithChatMessagesReturnsExpectedResultAsync();
+    public override Task RunWithChatMessagesReturnsExpectedResultAsync()
+    {
+        Assert.SkipWhen(ManualVerification is not null, ManualVerification ?? string.Empty);
+        return base.RunWithChatMessagesReturnsExpectedResultAsync();
+    }
 
-    [Fact(Skip = ManualVerification)]
-    public override Task RunWithNoMessageDoesNotFailAsync() =>
-        base.RunWithNoMessageDoesNotFailAsync();
+    public override Task RunWithNoMessageDoesNotFailAsync()
+    {
+        Assert.SkipWhen(ManualVerification is not null, ManualVerification ?? string.Empty);
+        return base.RunWithNoMessageDoesNotFailAsync();
+    }
 
-    [Fact(Skip = ManualVerification)]
-    public override Task RunWithStringReturnsExpectedResultAsync() =>
-        base.RunWithStringReturnsExpectedResultAsync();
+    public override Task RunWithStringReturnsExpectedResultAsync()
+    {
+        Assert.SkipWhen(ManualVerification is not null, ManualVerification ?? string.Empty);
+        return base.RunWithStringReturnsExpectedResultAsync();
+    }
 }

dotnet/tests/CopilotStudio.IntegrationTests/CopilotStudioRunTests.cs

@@ -10,23 +10,33 @@ public class CopilotStudioRunTests() : RunTests<CopilotStudioFixture>(() => new(
     // Set to null to run the tests.
     private const string ManualVerification = "For manual verification";
 
-    [Fact(Skip = "Copilot Studio does not support session history retrieval, so this test is not applicable.")]
-    public override Task SessionMaintainsHistoryAsync() =>
-        Task.CompletedTask;
+    public override Task SessionMaintainsHistoryAsync()
+    {
+        Assert.Skip("Copilot Studio does not support session history retrieval, so this test is not applicable.");
+        return base.SessionMaintainsHistoryAsync();
+    }
 
-    [Fact(Skip = ManualVerification)]
-    public override Task RunWithChatMessageReturnsExpectedResultAsync() => base.RunWithChatMessageReturnsExpectedResultAsync();
+    public override Task RunWithChatMessageReturnsExpectedResultAsync()
+    {
+        Assert.SkipWhen(ManualVerification is not null, ManualVerification ?? string.Empty);
+        return base.RunWithChatMessageReturnsExpectedResultAsync();
+    }
 
-    [Fact(Skip = ManualVerification)]
-    public override Task RunWithChatMessagesReturnsExpectedResultAsync() =>
+    public override Task RunWithChatMessagesReturnsExpectedResultAsync()
+    {
+        Assert.SkipWhen(ManualVerification is not null, ManualVerification ?? string.Empty);
+        return base.RunWithChatMessagesReturnsExpectedResultAsync();
+    }
 
-        base.RunWithChatMessagesReturnsExpectedResultAsync();
+    public override Task RunWithNoMessageDoesNotFailAsync()
+    {
+        Assert.SkipWhen(ManualVerification is not null, ManualVerification ?? string.Empty);
+        return base.RunWithNoMessageDoesNotFailAsync();
+    }
 
-    [Fact(Skip = ManualVerification)]
-    public override Task RunWithNoMessageDoesNotFailAsync() =>
-        base.RunWithNoMessageDoesNotFailAsync();
-
-    [Fact(Skip = ManualVerification)]
-    public override Task RunWithStringReturnsExpectedResultAsync() =>
-        base.RunWithStringReturnsExpectedResultAsync();
+    public override Task RunWithStringReturnsExpectedResultAsync()
+    {
+        Assert.SkipWhen(ManualVerification is not null, ManualVerification ?? string.Empty);
+        return base.RunWithStringReturnsExpectedResultAsync();
+    }
 }

dotnet/tests/Directory.Build.props

@@ -6,22 +6,25 @@
     <IsPackable>false</IsPackable>
     <IsTestProject>true</IsTestProject>
     <IsAotCompatible>false</IsAotCompatible>
+    <OutputType>Exe</OutputType>
     <TargetFrameworks>net10.0;net472</TargetFrameworks>
     <UserSecretsId>b7762d10-e29b-4bb1-8b74-b6d69a667dd4</UserSecretsId>
-    <NoWarn>$(NoWarn);Moq1410;xUnit2023;MAAI001</NoWarn>
+    <UseMicrosoftTestingPlatformRunner>true</UseMicrosoftTestingPlatformRunner>
+    <TestingPlatformDotnetTestSupport>true</TestingPlatformDotnetTestSupport>
+    <NoWarn>$(NoWarn);Moq1410;xUnit1051;MAAI001</NoWarn>
   </PropertyGroup>
 
   <ItemGroup>
-    <PackageReference Include="coverlet.collector" />
+    <PackageReference Include="Microsoft.Testing.Extensions.CodeCoverage" />
     <PackageReference Include="Microsoft.NET.Test.Sdk" />
     <PackageReference Include="Moq" />
-    <PackageReference Include="xRetry" />
-    <PackageReference Include="xunit" />
+    <PackageReference Include="xRetry.v3" />
+    <PackageReference Include="xunit.v3.mtp-v2" />
     <PackageReference Include="xunit.runner.visualstudio" />
   </ItemGroup>
 
   <ItemGroup>
-    <Using Include="xRetry" />
+    <Using Include="xRetry.v3" />
     <Using Include="Xunit" />
   </ItemGroup>
 

dotnet/tests/Microsoft.Agents.AI.Abstractions.UnitTests/Compaction/ChatHistoryCompactionPipelineTests.cs

@@ -0,0 +1,136 @@
+// Copyright (c) Microsoft. All rights reserved.
+
+using System.Collections.Generic;
+using System.Linq;
+using System.Threading.Tasks;
+using Microsoft.Agents.AI.Abstractions.UnitTests.Compaction.Internal;
+using Microsoft.Agents.AI.Compaction;
+using Microsoft.Extensions.AI;
+
+namespace Microsoft.Agents.AI.Abstractions.UnitTests.Compaction;
+
+public class ChatHistoryCompactionPipelineTests
+{
+    [Fact]
+    public async Task EmptyStrategies_ReturnsUnmodifiedAsync()
+    {
+        // Arrange
+        ChatHistoryCompactionPipeline pipeline = new([]);
+        List<ChatMessage> messages = [new(ChatRole.User, "Hello")];
+
+        // Act
+        CompactionPipelineResult result = await pipeline.CompactAsync(messages);
+
+        // Assert
+        Assert.False(result.AnyApplied);
+        Assert.Equal(1, result.Before.MessageCount);
+        Assert.Equal(1, result.After.MessageCount);
+        Assert.Empty(result.StrategyResults);
+    }
+
+    [Fact]
+    public async Task ChainsStrategies_InOrderAsync()
+    {
+        // Arrange
+        ChatHistoryCompactionStrategy[] strategies =
+        [
+            new NeverCompactStrategy(),
+            new RemoveFirstMessageStrategy(),
+        ];
+        ChatHistoryCompactionPipeline pipeline = new(strategies);
+        List<ChatMessage> messages =
+        [
+            new(ChatRole.User, "First"),
+            new(ChatRole.User, "Second"),
+        ];
+
+        // Act
+        CompactionPipelineResult result = await pipeline.CompactAsync(messages);
+
+        // Assert
+        Assert.True(result.AnyApplied);
+        Assert.Equal(2, result.StrategyResults.Count);
+        Assert.False(result.StrategyResults[0].Applied);
+        Assert.True(result.StrategyResults[1].Applied);
+        Assert.Single(messages);
+    }
+
+    [Fact]
+    public async Task ReportsOverallMetricsAsync()
+    {
+        // Arrange
+        ChatHistoryCompactionPipeline pipeline = new([new RemoveFirstMessageStrategy()]);
+        List<ChatMessage> messages =
+        [
+            new(ChatRole.User, "First"),
+            new(ChatRole.User, "Second"),
+            new(ChatRole.User, "Third"),
+        ];
+
+        // Act
+        CompactionPipelineResult result = await pipeline.CompactAsync(messages);
+
+        // Assert
+        Assert.Equal(3, result.Before.MessageCount);
+        Assert.Equal(2, result.After.MessageCount);
+    }
+
+    [Fact]
+    public async Task CustomMetricsCalculator_IsUsedAsync()
+    {
+        // Arrange
+        Moq.Mock<IChatHistoryMetricsCalculator> calcMock = new();
+        calcMock
+            .Setup(c => c.Calculate(Moq.It.IsAny<IReadOnlyList<ChatMessage>>()))
+            .Returns(new ChatHistoryMetric { MessageCount = 42 });
+        ChatHistoryCompactionPipeline pipeline = new(calcMock.Object, []);
+        List<ChatMessage> messages = [new(ChatRole.User, "Hello")];
+
+        // Act
+        CompactionPipelineResult result = await pipeline.CompactAsync(messages);
+
+        // Assert
+        Assert.Equal(42, result.Before.MessageCount);
+        calcMock.Verify(c => c.Calculate(Moq.It.IsAny<IReadOnlyList<ChatMessage>>()), Moq.Times.Once);
+    }
+
+    [Fact]
+    public async Task ReduceAsync_DelegatesCompactionAsync()
+    {
+        // Arrange
+        ChatHistoryCompactionPipeline pipeline = new([new RemoveFirstMessageStrategy()]);
+        List<ChatMessage> messages =
+        [
+            new(ChatRole.User, "First"),
+            new(ChatRole.User, "Second"),
+            new(ChatRole.User, "Third"),
+        ];
+
+        // Act
+        IEnumerable<ChatMessage> result = await pipeline.ReduceAsync(messages, default);
+        List<ChatMessage> resultList = result.ToList();
+
+        // Assert
+        Assert.Equal(2, resultList.Count);
+        Assert.Equal("Second", resultList[0].Text);
+        Assert.Equal("Third", resultList[1].Text);
+    }
+
+    [Fact]
+    public async Task ReduceAsync_EmptyStrategies_ReturnsAllMessagesAsync()
+    {
+        // Arrange
+        ChatHistoryCompactionPipeline pipeline = new([]);
+        ChatMessage[] messages =
+        [
+            new(ChatRole.User, "Hello"),
+            new(ChatRole.User, "World"),
+        ];
+
+        // Act
+        IEnumerable<ChatMessage> result = await pipeline.ReduceAsync(messages, default);
+
+        // Assert
+        Assert.Equal(2, result.Count());
+    }
+}

dotnet/tests/Microsoft.Agents.AI.Abstractions.UnitTests/Compaction/ChatHistoryCompactionStrategyTests.cs

@@ -0,0 +1,144 @@
+// Copyright (c) Microsoft. All rights reserved.
+
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Threading;
+using System.Threading.Tasks;
+using Microsoft.Agents.AI.Abstractions.UnitTests.Compaction.Internal;
+using Microsoft.Agents.AI.Compaction;
+using Microsoft.Extensions.AI;
+using Moq;
+
+namespace Microsoft.Agents.AI.Abstractions.UnitTests.Compaction;
+
+public class ChatHistoryCompactionStrategyTests
+{
+    [Fact]
+    public async Task ShouldCompactReturnsFalse_SkipsAsync()
+    {
+        // Arrange
+        List<ChatMessage> messages = [new(ChatRole.User, "Hello")];
+        NeverCompactStrategy strategy = new();
+
+        // Act
+        CompactionResult result = await RunCompactionStrategyAsync(strategy, messages);
+
+        // Assert
+        Assert.False(result.Applied);
+    }
+
+    [Fact]
+    public async Task ShouldCompactReturnsTrue_RunsCompactionAsync()
+    {
+        // Arrange
+        List<ChatMessage> messages =
+        [
+            new(ChatRole.User, "First"),
+            new(ChatRole.User, "Second"),
+        ];
+        RemoveFirstMessageStrategy strategy = new();
+
+        // Act
+        CompactionResult result = await RunCompactionStrategyAsync(strategy, messages);
+
+        // Assert
+        Assert.True(result.Applied);
+        Assert.Single(messages);
+        Assert.Equal("Second", messages[0].Text);
+        Assert.Equal(2, result.Before.MessageCount);
+        Assert.Equal(1, result.After.MessageCount);
+    }
+
+    [Fact]
+    public async Task DelegatesToReducerAsync()
+    {
+        // Arrange
+        List<ChatMessage> messages =
+        [
+            new(ChatRole.User, "First"),
+            new(ChatRole.User, "Second"),
+        ];
+        Mock<IChatReducer> reducerMock = new();
+        reducerMock
+            .Setup(r => r.ReduceAsync(It.IsAny<IEnumerable<ChatMessage>>(), It.IsAny<CancellationToken>()))
+            .ReturnsAsync((IEnumerable<ChatMessage> messages, CancellationToken _) => messages.Skip(1));
+        TestCompactionStrategy strategy = new(reducerMock.Object);
+
+        // Act
+        CompactionResult result = await RunCompactionStrategyAsync(strategy, messages);
+
+        // Assert
+        Assert.True(result.Applied);
+        Assert.Single(messages);
+        Assert.Equal("Second", messages[0].Text);
+        reducerMock.Verify(r => r.ReduceAsync(It.IsAny<IEnumerable<ChatMessage>>(), It.IsAny<CancellationToken>()), Times.Once);
+    }
+
+    [Fact]
+    public async Task ReducerNoChange_ReturnsFalseAsync()
+    {
+        // Arrange
+        List<ChatMessage> messages =
+        [
+            new(ChatRole.User, "Hello"),
+        ];
+        Mock<IChatReducer> reducerMock = new();
+        reducerMock
+            .Setup(r => r.ReduceAsync(It.IsAny<IEnumerable<ChatMessage>>(), It.IsAny<CancellationToken>()))
+            .ReturnsAsync((IEnumerable<ChatMessage> msgs, CancellationToken _) => msgs);
+        TestCompactionStrategy strategy = new(reducerMock.Object, shouldCompact: false);
+
+        // Act
+        CompactionResult result = await RunCompactionStrategyAsync(strategy, messages);
+
+        // Assert
+        Assert.False(result.Applied);
+        Assert.Single(messages);
+    }
+
+    [Fact]
+    public void ReducerLifecycle()
+    {
+        // Arrange
+        Mock<IChatReducer> reducerMock = new();
+
+        // Act
+        TestCompactionStrategy strategy = new(reducerMock.Object);
+
+        // Assert
+        Assert.Same(reducerMock.Object, strategy.Reducer);
+        Assert.NotNull(strategy.Name);
+        Assert.NotEmpty(strategy.Name);
+        Assert.Equal(reducerMock.Object.GetType().Name, strategy.Name);
+    }
+
+    [Fact]
+    public void CurrentMetrics_OutsideStrategy_Throws()
+    {
+        // Act & Assert
+        Assert.Throws<InvalidOperationException>(() => TestCompactionStrategy.GetCurrentMetrics());
+    }
+
+    public static async ValueTask<CompactionResult> RunCompactionStrategyAsync(ChatHistoryCompactionStrategy strategy, List<ChatMessage> messages)
+    {
+        // Act
+        ChatHistoryCompactionStrategy.s_currentMetrics.Value = DefaultChatHistoryMetricsCalculator.Instance.Calculate(messages);
+        return await strategy.CompactAsync(messages, DefaultChatHistoryMetricsCalculator.Instance);
+    }
+
+    private sealed class TestCompactionStrategy : ChatHistoryCompactionStrategy
+    {
+        private readonly bool _shouldCompact;
+
+        public TestCompactionStrategy(IChatReducer reducer, bool shouldCompact = true)
+            : base(reducer)
+        {
+            this._shouldCompact = shouldCompact;
+        }
+
+        protected override bool ShouldCompact(ChatHistoryMetric metrics) => this._shouldCompact;
+
+        public static ChatHistoryMetric GetCurrentMetrics() => CurrentMetrics;
+    }
+}

dotnet/tests/Microsoft.Agents.AI.Abstractions.UnitTests/Compaction/ChatReducerCompactionStrategyTests.cs

@@ -0,0 +1,114 @@
+// Copyright (c) Microsoft. All rights reserved.
+
+using System.Collections.Generic;
+using System.Linq;
+using System.Threading;
+using System.Threading.Tasks;
+using Microsoft.Agents.AI.Compaction;
+using Microsoft.Extensions.AI;
+using Moq;
+
+namespace Microsoft.Agents.AI.Abstractions.UnitTests.Compaction;
+
+public class ChatReducerCompactionStrategyTests : CompactionStrategyTestBase
+{
+    [Fact]
+    public async Task ConditionFalse_SkipsAsync()
+    {
+        // Arrange
+        List<ChatMessage> messages = [new(ChatRole.User, "Hello")];
+        Mock<IChatReducer> reducerMock = new();
+        ChatReducerCompactionStrategy strategy = new(reducerMock.Object, _ => false);
+
+        // Act & Assert
+        await RunCompactionStrategySkippedAsync(strategy, messages);
+
+        // Assert
+        reducerMock.Verify(
+            r => r.ReduceAsync(It.IsAny<IEnumerable<ChatMessage>>(), It.IsAny<CancellationToken>()),
+            Times.Never);
+    }
+
+    [Fact]
+    public async Task ConditionTrue_RunsReducerAsync()
+    {
+        // Arrange
+        List<ChatMessage> messages =
+        [
+            new(ChatRole.User, "First"),
+            new(ChatRole.User, "Second"),
+        ];
+        Mock<IChatReducer> reducerMock = new();
+        reducerMock
+            .Setup(r => r.ReduceAsync(It.IsAny<IEnumerable<ChatMessage>>(), It.IsAny<CancellationToken>()))
+            .ReturnsAsync((IEnumerable<ChatMessage> msgs, CancellationToken _) => msgs.Skip(1));
+        ChatReducerCompactionStrategy strategy = new(reducerMock.Object, _ => true);
+
+        // Act & Assert
+        await RunCompactionStrategyReducedAsync(strategy, messages, expectedCount: 1);
+
+        // Assert
+        Assert.Equal("Second", messages[0].Text);
+        reducerMock.Verify(
+            r => r.ReduceAsync(It.IsAny<IEnumerable<ChatMessage>>(), It.IsAny<CancellationToken>()),
+            Times.Once);
+    }
+
+    [Fact]
+    public async Task ConditionReceivesMetricsAsync()
+    {
+        // Arrange
+        List<ChatMessage> messages =
+        [
+            new(ChatRole.User, "Hello"),
+            new(ChatRole.Assistant, "Hi"),
+        ];
+        ChatHistoryMetric? capturedMetrics = null;
+        Mock<IChatReducer> reducerMock = new();
+        reducerMock
+            .Setup(r => r.ReduceAsync(It.IsAny<IEnumerable<ChatMessage>>(), It.IsAny<CancellationToken>()))
+            .ReturnsAsync((IEnumerable<ChatMessage> msgs, CancellationToken _) => msgs);
+        ChatReducerCompactionStrategy strategy = new(
+            reducerMock.Object,
+            metrics =>
+            {
+                capturedMetrics = metrics;
+                return false;
+            });
+
+        // Act & Assert
+        await RunCompactionStrategySkippedAsync(strategy, messages);
+
+        // Assert
+        Assert.NotNull(capturedMetrics);
+        Assert.Equal(2, capturedMetrics!.MessageCount);
+    }
+
+    [Fact]
+    public async Task ReducerNoChange_AppliedFalseAsync()
+    {
+        // Arrange
+        List<ChatMessage> messages = [new(ChatRole.User, "Hello")];
+        Mock<IChatReducer> reducerMock = new();
+        reducerMock
+            .Setup(r => r.ReduceAsync(It.IsAny<IEnumerable<ChatMessage>>(), It.IsAny<CancellationToken>()))
+            .ReturnsAsync((IEnumerable<ChatMessage> msgs, CancellationToken _) => msgs);
+        ChatReducerCompactionStrategy strategy = new(reducerMock.Object, _ => true);
+
+        // Act & Assert
+        await RunCompactionStrategySkippedAsync(strategy, messages);
+    }
+
+    [Fact]
+    public void Name_ReturnsReducerTypeName()
+    {
+        // Arrange
+        Mock<IChatReducer> reducerMock = new();
+
+        // Act
+        ChatReducerCompactionStrategy strategy = new(reducerMock.Object, _ => true);
+
+        // Assert
+        Assert.Equal(reducerMock.Object.GetType().Name, strategy.Name);
+    }
+}

dotnet/tests/Microsoft.Agents.AI.Abstractions.UnitTests/Compaction/CompactionMetricTests.cs

@@ -0,0 +1,44 @@
+// Copyright (c) Microsoft. All rights reserved.
+
+using Microsoft.Agents.AI.Compaction;
+
+namespace Microsoft.Agents.AI.Abstractions.UnitTests.Compaction;
+
+public class CompactionMetricTests
+{
+    [Fact]
+    public void DefaultValues_AreZero()
+    {
+        // Arrange & Act
+        ChatHistoryMetric metrics = new();
+
+        // Assert
+        Assert.Equal(0, metrics.TokenCount);
+        Assert.Equal(0L, metrics.ByteCount);
+        Assert.Equal(0, metrics.MessageCount);
+        Assert.Equal(0, metrics.ToolCallCount);
+        Assert.Equal(0, metrics.UserTurnCount);
+        Assert.Empty(metrics.Groups);
+    }
+
+    [Fact]
+    public void InitProperties_SetCorrectly()
+    {
+        // Arrange & Act
+        ChatHistoryMetric metrics = new()
+        {
+            TokenCount = 100,
+            ByteCount = 500,
+            MessageCount = 5,
+            ToolCallCount = 2,
+            UserTurnCount = 3
+        };
+
+        // Assert
+        Assert.Equal(100, metrics.TokenCount);
+        Assert.Equal(500L, metrics.ByteCount);
+        Assert.Equal(5, metrics.MessageCount);
+        Assert.Equal(2, metrics.ToolCallCount);
+        Assert.Equal(3, metrics.UserTurnCount);
+    }
+}

dotnet/tests/Microsoft.Agents.AI.Abstractions.UnitTests/Compaction/CompactionPipelineResultTests.cs

@@ -0,0 +1,57 @@
+// Copyright (c) Microsoft. All rights reserved.
+
+using System.Collections.Generic;
+
+using Microsoft.Agents.AI.Compaction;
+
+namespace Microsoft.Agents.AI.Abstractions.UnitTests.Compaction;
+
+public class CompactionPipelineResultTests
+{
+    [Fact]
+    public void Properties_AreReadable()
+    {
+        // Arrange
+        ChatHistoryMetric before = new() { MessageCount = 10 };
+        ChatHistoryMetric after = new() { MessageCount = 5 };
+        CompactionResult strategyResult = new("Test", applied: true, before, after);
+        List<CompactionResult> results = [strategyResult];
+
+        // Act
+        CompactionPipelineResult pipelineResult = new(before, after, results);
+
+        // Assert
+        Assert.Same(before, pipelineResult.Before);
+        Assert.Same(after, pipelineResult.After);
+        Assert.Single(pipelineResult.StrategyResults);
+    }
+
+    [Fact]
+    public void AnyApplied_AllFalse_ReturnsFalse()
+    {
+        // Arrange
+        ChatHistoryMetric metrics = new() { MessageCount = 5 };
+        CompactionResult skipped = CompactionResult.Skipped("Skip", metrics);
+
+        // Act
+        CompactionPipelineResult result = new(metrics, metrics, [skipped]);
+
+        // Assert
+        Assert.False(result.AnyApplied);
+    }
+
+    [Fact]
+    public void AnyApplied_SomeTrue_ReturnsTrue()
+    {
+        // Arrange
+        ChatHistoryMetric before = new() { MessageCount = 10 };
+        ChatHistoryMetric after = new() { MessageCount = 5 };
+        CompactionResult applied = new("Applied", applied: true, before, after);
+
+        // Act
+        CompactionPipelineResult result = new(before, after, [applied]);
+
+        // Assert
+        Assert.True(result.AnyApplied);
+    }
+}

dotnet/tests/Microsoft.Agents.AI.Abstractions.UnitTests/Compaction/CompactionResultTests.cs

@@ -0,0 +1,24 @@
+// Copyright (c) Microsoft. All rights reserved.
+
+using Microsoft.Agents.AI.Compaction;
+
+namespace Microsoft.Agents.AI.Abstractions.UnitTests.Compaction;
+
+public class CompactionResultTests
+{
+    [Fact]
+    public void Skipped_HasSameBeforeAndAfter()
+    {
+        // Arrange
+        ChatHistoryMetric metrics = new() { MessageCount = 5, TokenCount = 100 };
+
+        // Act
+        CompactionResult result = CompactionResult.Skipped("Test", metrics);
+
+        // Assert
+        Assert.Equal("Test", result.StrategyName);
+        Assert.False(result.Applied);
+        Assert.Same(metrics, result.Before);
+        Assert.Same(metrics, result.After);
+    }
+}

dotnet/tests/Microsoft.Agents.AI.Abstractions.UnitTests/Compaction/CompactionStrategyTestBase.cs

@@ -0,0 +1,40 @@
+// Copyright (c) Microsoft. All rights reserved.
+
+using System.Collections.Generic;
+using System.Threading.Tasks;
+using Microsoft.Agents.AI.Compaction;
+using Microsoft.Extensions.AI;
+
+namespace Microsoft.Agents.AI.Abstractions.UnitTests.Compaction;
+
+public abstract class CompactionStrategyTestBase
+{
+    public static async ValueTask<CompactionResult> RunCompactionStrategyReducedAsync(ChatHistoryCompactionStrategy strategy, List<ChatMessage> messages, int expectedCount)
+    {
+        // Act
+        ChatHistoryCompactionStrategy.s_currentMetrics.Value = DefaultChatHistoryMetricsCalculator.Instance.Calculate(messages);
+        CompactionResult result = await strategy.CompactAsync(messages, DefaultChatHistoryMetricsCalculator.Instance);
+
+        // Assert
+        Assert.True(result.Applied);
+        Assert.NotEqual(result.Before, result.After);
+        Assert.Equal(expectedCount, messages.Count);
+
+        return result;
+    }
+
+    public static async ValueTask<CompactionResult> RunCompactionStrategySkippedAsync(ChatHistoryCompactionStrategy strategy, List<ChatMessage> messages)
+    {
+        // Act
+        int initialCount = messages.Count;
+        ChatHistoryCompactionStrategy.s_currentMetrics.Value = DefaultChatHistoryMetricsCalculator.Instance.Calculate(messages);
+        CompactionResult result = await strategy.CompactAsync(messages, DefaultChatHistoryMetricsCalculator.Instance);
+
+        // Assert
+        Assert.False(result.Applied);
+        Assert.Equal(result.Before, result.After);
+        Assert.Equal(initialCount, messages.Count);
+
+        return result;
+    }
+}

dotnet/tests/Microsoft.Agents.AI.Abstractions.UnitTests/Compaction/DefaultChatHistoryMetricsCalculatorTests.cs

@@ -0,0 +1,399 @@
+// Copyright (c) Microsoft. All rights reserved.
+
+using System.Collections.Generic;
+using Microsoft.Agents.AI.Compaction;
+using Microsoft.Extensions.AI;
+
+namespace Microsoft.Agents.AI.Abstractions.UnitTests.Compaction;
+
+public class DefaultChatHistoryMetricsCalculatorTests
+{
+    [Fact]
+    public void EmptyList_ReturnsZeroMetrics()
+    {
+        // Arrange
+        DefaultChatHistoryMetricsCalculator calculator = new();
+
+        // Act
+        ChatHistoryMetric metrics = calculator.Calculate([]);
+
+        // Assert
+        Assert.Equal(0, metrics.TokenCount);
+        Assert.Equal(0L, metrics.ByteCount);
+        Assert.Equal(0, metrics.MessageCount);
+        Assert.Equal(0, metrics.ToolCallCount);
+        Assert.Equal(0, metrics.UserTurnCount);
+    }
+
+    [Fact]
+    public void CountsMessages()
+    {
+        // Arrange
+        DefaultChatHistoryMetricsCalculator calculator = new();
+        List<ChatMessage> messages =
+        [
+            new(ChatRole.User, "Hello"),
+            new(ChatRole.Assistant, "Hi there"),
+        ];
+
+        // Act
+        ChatHistoryMetric metrics = calculator.Calculate(messages);
+
+        // Assert
+        Assert.Equal(2, metrics.MessageCount);
+    }
+
+    [Fact]
+    public void CountsUserTurns()
+    {
+        // Arrange
+        DefaultChatHistoryMetricsCalculator calculator = new();
+        List<ChatMessage> messages =
+        [
+            new(ChatRole.User, "Hello"),
+            new(ChatRole.Assistant, "Hi"),
+            new(ChatRole.User, "How are you?"),
+            new(ChatRole.Assistant, "Good"),
+        ];
+
+        // Act
+        ChatHistoryMetric metrics = calculator.Calculate(messages);
+
+        // Assert
+        Assert.Equal(2, metrics.UserTurnCount);
+    }
+
+    [Fact]
+    public void CountsToolCalls()
+    {
+        // Arrange
+        DefaultChatHistoryMetricsCalculator calculator = new();
+        ChatMessage assistantMsg = new(ChatRole.Assistant, [
+            new FunctionCallContent("call1", "get_weather", new Dictionary<string, object?> { ["city"] = "NYC" }),
+            new FunctionCallContent("call2", "get_time"),
+        ]);
+        List<ChatMessage> messages =
+        [
+            new(ChatRole.User, "What's the weather?"),
+            assistantMsg,
+        ];
+
+        // Act
+        ChatHistoryMetric metrics = calculator.Calculate(messages);
+
+        // Assert
+        Assert.Equal(2, metrics.ToolCallCount);
+    }
+
+    [Fact]
+    public void ConsecutiveUserMessages_CountAsOneTurn()
+    {
+        // Arrange
+        DefaultChatHistoryMetricsCalculator calculator = new();
+        List<ChatMessage> messages =
+        [
+            new(ChatRole.User, "First"),
+            new(ChatRole.User, "Second"),
+            new(ChatRole.Assistant, "Reply"),
+        ];
+
+        // Act
+        ChatHistoryMetric metrics = calculator.Calculate(messages);
+
+        // Assert
+        Assert.Equal(1, metrics.UserTurnCount);
+    }
+
+    [Fact]
+    public void TokenCount_IsPositive()
+    {
+        // Arrange
+        DefaultChatHistoryMetricsCalculator calculator = new();
+        List<ChatMessage> messages =
+        [
+            new(ChatRole.User, "Hello world"),
+        ];
+
+        // Act
+        ChatHistoryMetric metrics = calculator.Calculate(messages);
+
+        // Assert
+        Assert.True(metrics.TokenCount > 0);
+        Assert.True(metrics.ByteCount > 0);
+    }
+
+    [Fact]
+    public void NullInput_ReturnsZeroMetrics()
+    {
+        // Arrange
+        DefaultChatHistoryMetricsCalculator calculator = new();
+
+        // Act
+        ChatHistoryMetric metrics = calculator.Calculate(null!);
+
+        // Assert
+        Assert.Equal(0, metrics.TokenCount);
+        Assert.Equal(0L, metrics.ByteCount);
+        Assert.Equal(0, metrics.MessageCount);
+        Assert.Empty(metrics.Groups);
+    }
+
+    [Fact]
+    public void InvalidCharsPerToken_UsesDefault()
+    {
+        // Arrange
+        DefaultChatHistoryMetricsCalculator calculator = new(charsPerToken: 0);
+        List<ChatMessage> messages =
+        [
+            new(ChatRole.User, "Hello world"),
+        ];
+
+        // Act
+        ChatHistoryMetric metrics = calculator.Calculate(messages);
+
+        // Assert
+        Assert.True(metrics.TokenCount > 0);
+    }
+
+    [Fact]
+    public void NullMessageText_HandledGracefully()
+    {
+        // Arrange
+        DefaultChatHistoryMetricsCalculator calculator = new();
+        ChatMessage msg = new() { Role = ChatRole.User };
+        List<ChatMessage> messages = [msg];
+
+        // Act
+        ChatHistoryMetric metrics = calculator.Calculate(messages);
+
+        // Assert
+        Assert.Equal(1, metrics.MessageCount);
+        Assert.True(metrics.TokenCount > 0);
+        Assert.Equal(0L, metrics.ByteCount);
+    }
+
+    [Fact]
+    public void NullContents_SkipsToolCounting()
+    {
+        // Arrange
+        DefaultChatHistoryMetricsCalculator calculator = new();
+        ChatMessage msg = new(ChatRole.User, "text");
+        msg.Contents = null!;
+        List<ChatMessage> messages = [msg];
+
+        // Act
+        ChatHistoryMetric metrics = calculator.Calculate(messages);
+
+        // Assert
+        Assert.Equal(1, metrics.MessageCount);
+        Assert.Equal(0, metrics.ToolCallCount);
+    }
+
+    [Fact]
+    public void MessageWithOnlyNonTextContent_NullTextHandled()
+    {
+        // Arrange
+        DefaultChatHistoryMetricsCalculator calculator = new();
+        ChatMessage msg = new(ChatRole.Assistant,
+        [
+            new FunctionCallContent("c1", "func"),
+        ]);
+        List<ChatMessage> messages = [msg];
+
+        // Act
+        ChatHistoryMetric metrics = calculator.Calculate(messages);
+
+        // Assert
+        Assert.Equal(1, metrics.MessageCount);
+        Assert.Equal(1, metrics.ToolCallCount);
+    }
+
+    [Fact]
+    public void Calculate_PopulatesGroupIndex()
+    {
+        // Arrange
+        DefaultChatHistoryMetricsCalculator calculator = new();
+        List<ChatMessage> messages =
+        [
+            new(ChatRole.System, "System prompt"),
+            new(ChatRole.User, "Hello"),
+            new(ChatRole.Assistant, "Hi there"),
+        ];
+
+        // Act
+        ChatHistoryMetric metrics = calculator.Calculate(messages);
+
+        // Assert
+        Assert.Equal(3, metrics.Groups.Count);
+        Assert.Equal(ChatMessageGroupKind.System, metrics.Groups[0].Kind);
+        Assert.Equal(ChatMessageGroupKind.UserTurn, metrics.Groups[1].Kind);
+        Assert.Equal(ChatMessageGroupKind.AssistantPlain, metrics.Groups[2].Kind);
+    }
+
+    [Fact]
+    public void EmptyList_GroupIndexIsEmpty()
+    {
+        // Arrange
+        DefaultChatHistoryMetricsCalculator calculator = new();
+
+        // Act
+        ChatHistoryMetric metrics = calculator.Calculate([]);
+
+        // Assert
+        Assert.Empty(metrics.Groups);
+    }
+
+    [Fact]
+    public void GroupIndex_SystemMessage_IdentifiedCorrectly()
+    {
+        // Arrange
+        DefaultChatHistoryMetricsCalculator calculator = new();
+        List<ChatMessage> messages =
+        [
+            new(ChatRole.System, "You are a helpful assistant"),
+        ];
+
+        // Act
+        IReadOnlyList<ChatMessageGroup> groups = calculator.Calculate(messages).Groups;
+
+        // Assert
+        Assert.Single(groups);
+        Assert.Equal(ChatMessageGroupKind.System, groups[0].Kind);
+        Assert.Equal(0, groups[0].StartIndex);
+        Assert.Equal(1, groups[0].Count);
+    }
+
+    [Fact]
+    public void GroupIndex_AssistantWithToolCalls_GroupedWithResults()
+    {
+        // Arrange
+        DefaultChatHistoryMetricsCalculator calculator = new();
+        ChatMessage assistantMsg = new(ChatRole.Assistant, [
+            new FunctionCallContent("call1", "get_weather", new Dictionary<string, object?> { ["city"] = "NYC" }),
+        ]);
+        ChatMessage toolResult = new(ChatRole.Tool, [
+            new FunctionResultContent("call1", "Sunny, 72°F"),
+        ]);
+        List<ChatMessage> messages =
+        [
+            new(ChatRole.User, "What's the weather?"),
+            assistantMsg,
+            toolResult,
+        ];
+
+        // Act
+        IReadOnlyList<ChatMessageGroup> groups = calculator.Calculate(messages).Groups;
+
+        // Assert
+        Assert.Equal(2, groups.Count);
+        Assert.Equal(ChatMessageGroupKind.UserTurn, groups[0].Kind);
+        Assert.Equal(ChatMessageGroupKind.AssistantToolGroup, groups[1].Kind);
+        Assert.Equal(1, groups[1].StartIndex);
+        Assert.Equal(2, groups[1].Count);
+    }
+
+    [Fact]
+    public void GroupIndex_MultipleToolResults_GroupedTogether()
+    {
+        // Arrange
+        DefaultChatHistoryMetricsCalculator calculator = new();
+        ChatMessage assistantMsg = new(ChatRole.Assistant, [
+            new FunctionCallContent("c1", "func1"),
+            new FunctionCallContent("c2", "func2"),
+        ]);
+        ChatMessage tool1 = new(ChatRole.Tool, [new FunctionResultContent("c1", "result1")]);
+        ChatMessage tool2 = new(ChatRole.Tool, [new FunctionResultContent("c2", "result2")]);
+        List<ChatMessage> messages = [assistantMsg, tool1, tool2];
+
+        // Act
+        IReadOnlyList<ChatMessageGroup> groups = calculator.Calculate(messages).Groups;
+
+        // Assert
+        Assert.Single(groups);
+        Assert.Equal(ChatMessageGroupKind.AssistantToolGroup, groups[0].Kind);
+        Assert.Equal(3, groups[0].Count);
+    }
+
+    [Fact]
+    public void GroupIndex_ComplexConversation_CorrectGrouping()
+    {
+        // Arrange
+        DefaultChatHistoryMetricsCalculator calculator = new();
+        List<ChatMessage> messages =
+        [
+            new(ChatRole.System, "You are a helper"),
+            new(ChatRole.User, "Hi"),
+            new(ChatRole.Assistant, "Hello!"),
+            new(ChatRole.User, "Get weather"),
+            new ChatMessage(ChatRole.Assistant, [new FunctionCallContent("c1", "get_weather")]),
+            new ChatMessage(ChatRole.Tool, [new FunctionResultContent("c1", "Sunny")]),
+            new(ChatRole.Assistant, "It's sunny!"),
+        ];
+
+        // Act
+        IReadOnlyList<ChatMessageGroup> groups = calculator.Calculate(messages).Groups;
+
+        // Assert
+        Assert.Equal(6, groups.Count);
+        Assert.Equal(ChatMessageGroupKind.System, groups[0].Kind);
+        Assert.Equal(ChatMessageGroupKind.UserTurn, groups[1].Kind);
+        Assert.Equal(ChatMessageGroupKind.AssistantPlain, groups[2].Kind);
+        Assert.Equal(ChatMessageGroupKind.UserTurn, groups[3].Kind);
+        Assert.Equal(ChatMessageGroupKind.AssistantToolGroup, groups[4].Kind);
+        Assert.Equal(2, groups[4].Count);
+        Assert.Equal(ChatMessageGroupKind.AssistantPlain, groups[5].Kind);
+    }
+
+    [Fact]
+    public void GroupIndex_OrphanToolResult_IdentifiedCorrectly()
+    {
+        // Arrange
+        DefaultChatHistoryMetricsCalculator calculator = new();
+        List<ChatMessage> messages =
+        [
+            new ChatMessage(ChatRole.Tool, [new FunctionResultContent("c1", "orphan result")]),
+        ];
+
+        // Act
+        IReadOnlyList<ChatMessageGroup> groups = calculator.Calculate(messages).Groups;
+
+        // Assert
+        Assert.Single(groups);
+        Assert.Equal(ChatMessageGroupKind.ToolResult, groups[0].Kind);
+    }
+
+    [Fact]
+    public void GroupIndex_UnknownRole_IdentifiedAsOther()
+    {
+        // Arrange
+        DefaultChatHistoryMetricsCalculator calculator = new();
+        List<ChatMessage> messages =
+        [
+            new(new ChatRole("custom"), "custom message"),
+        ];
+
+        // Act
+        IReadOnlyList<ChatMessageGroup> groups = calculator.Calculate(messages).Groups;
+
+        // Assert
+        Assert.Single(groups);
+        Assert.Equal(ChatMessageGroupKind.Other, groups[0].Kind);
+    }
+
+    [Fact]
+    public void GroupIndex_AssistantWithNullContents_ClassifiedAsPlain()
+    {
+        // Arrange
+        DefaultChatHistoryMetricsCalculator calculator = new();
+        ChatMessage msg = new(ChatRole.Assistant, "reply");
+        msg.Contents = null!;
+        List<ChatMessage> messages = [msg];
+
+        // Act
+        IReadOnlyList<ChatMessageGroup> groups = calculator.Calculate(messages).Groups;
+
+        // Assert
+        Assert.Single(groups);
+        Assert.Equal(ChatMessageGroupKind.AssistantPlain, groups[0].Kind);
+    }
+}

dotnet/tests/Microsoft.Agents.AI.Abstractions.UnitTests/Compaction/Internal/AgentRunContextHarness.cs

@@ -0,0 +1,52 @@
+// Copyright (c) Microsoft. All rights reserved.
+
+using System;
+using System.Collections.Generic;
+using System.Text.Json;
+using System.Threading;
+using System.Threading.Tasks;
+using Microsoft.Extensions.AI;
+
+namespace Microsoft.Agents.AI.Abstractions.UnitTests.Compaction.Internal;
+
+/// <summary>
+/// Provides a way to set <see cref="AIAgent.CurrentRunContext"/> in unit tests
+/// so that the underlying <c>AsyncLocal</c> is populated for code that reads it.
+/// </summary>
+internal static class AgentRunContextHarness
+{
+    private static readonly ContextAgentShim s_instance = new();
+
+    /// <summary>
+    /// Sets <see cref="AIAgent.CurrentRunContext"/> and invokes the provided action.
+    /// </summary>
+    public static void ExecuteWithRunContext(AgentRunContext context, Action action)
+    {
+        Assert.NotNull(context);
+        Assert.NotNull(action);
+        //AgentRunContext context = new(agent, session, messages ?? [], options); // %%% TODO
+        s_instance.Set(context);
+        action.Invoke();
+    }
+
+    // Derived class that exposes the protected setter.
+    private sealed class ContextAgentShim : AIAgent
+    {
+        public void Set(AgentRunContext? value) => CurrentRunContext = value;
+
+        protected override ValueTask<AgentSession> CreateSessionCoreAsync(CancellationToken cancellationToken = default)
+            => throw new NotSupportedException();
+
+        protected override ValueTask<JsonElement> SerializeSessionCoreAsync(AgentSession session, JsonSerializerOptions? jsonSerializerOptions = null, CancellationToken cancellationToken = default)
+            => throw new NotSupportedException();
+
+        protected override ValueTask<AgentSession> DeserializeSessionCoreAsync(JsonElement serializedState, JsonSerializerOptions? jsonSerializerOptions = null, CancellationToken cancellationToken = default)
+            => throw new NotSupportedException();
+
+        protected override Task<AgentResponse> RunCoreAsync(IEnumerable<ChatMessage> messages, AgentSession? session = null, AgentRunOptions? options = null, CancellationToken cancellationToken = default)
+            => throw new NotSupportedException();
+
+        protected override IAsyncEnumerable<AgentResponseUpdate> RunCoreStreamingAsync(IEnumerable<ChatMessage> messages, AgentSession? session = null, AgentRunOptions? options = null, CancellationToken cancellationToken = default)
+            => throw new NotSupportedException();
+    }
+}

dotnet/tests/Microsoft.Agents.AI.Abstractions.UnitTests/Compaction/Internal/NeverCompactStrategy.cs

@@ -0,0 +1,27 @@
+// Copyright (c) Microsoft. All rights reserved.
+
+using System.Collections.Generic;
+using System.Threading;
+using System.Threading.Tasks;
+using Microsoft.Agents.AI.Compaction;
+using Microsoft.Extensions.AI;
+
+namespace Microsoft.Agents.AI.Abstractions.UnitTests.Compaction.Internal;
+
+internal sealed class NeverCompactStrategy : ChatHistoryCompactionStrategy
+{
+    public NeverCompactStrategy()
+        : base(new NoOpReducer())
+    {
+    }
+
+    public override string Name => "NeverCompact";
+
+    protected override bool ShouldCompact(ChatHistoryMetric metrics) => false;
+
+    private sealed class NoOpReducer : IChatReducer
+    {
+        public Task<IEnumerable<ChatMessage>> ReduceAsync(IEnumerable<ChatMessage> messages, CancellationToken cancellationToken = default)
+            => Task.FromResult(messages);
+    }
+}

dotnet/tests/Microsoft.Agents.AI.Abstractions.UnitTests/Compaction/Internal/RemoveFirstMessageStrategy.cs

@@ -0,0 +1,36 @@
+// Copyright (c) Microsoft. All rights reserved.
+
+using System.Collections.Generic;
+using System.Linq;
+using System.Threading;
+using System.Threading.Tasks;
+using Microsoft.Agents.AI.Compaction;
+using Microsoft.Extensions.AI;
+
+namespace Microsoft.Agents.AI.Abstractions.UnitTests.Compaction.Internal;
+
+internal sealed class RemoveFirstMessageStrategy : ChatHistoryCompactionStrategy
+{
+    public RemoveFirstMessageStrategy()
+        : base(new RemoveFirstReducer())
+    {
+    }
+
+    public override string Name => "RemoveFirst";
+
+    protected override bool ShouldCompact(ChatHistoryMetric metrics) => metrics.MessageCount > 0;
+
+    private sealed class RemoveFirstReducer : IChatReducer
+    {
+        public Task<IEnumerable<ChatMessage>> ReduceAsync(IEnumerable<ChatMessage> messages, CancellationToken cancellationToken = default)
+        {
+            List<ChatMessage> list = messages.ToList();
+            if (list.Count > 1)
+            {
+                list.RemoveAt(0);
+            }
+
+            return Task.FromResult<IEnumerable<ChatMessage>>(list);
+        }
+    }
+}

dotnet/tests/Microsoft.Agents.AI.Abstractions.UnitTests/Compaction/MessageGroupTests.cs

@@ -0,0 +1,65 @@
+// Copyright (c) Microsoft. All rights reserved.
+
+using Microsoft.Agents.AI.Compaction;
+
+namespace Microsoft.Agents.AI.Abstractions.UnitTests.Compaction;
+
+public class MessageGroupTests
+{
+    [Fact]
+    public void Equality_Works()
+    {
+        // Arrange
+        ChatMessageGroup a = new(0, 2, ChatMessageGroupKind.AssistantToolGroup);
+        ChatMessageGroup b = new(0, 2, ChatMessageGroupKind.AssistantToolGroup);
+        ChatMessageGroup c = new(1, 2, ChatMessageGroupKind.AssistantToolGroup);
+
+        // Act & Assert
+        Assert.Equal(a, b);
+        Assert.True(a == b);
+        Assert.NotEqual(a, c);
+        Assert.True(a != c);
+    }
+
+    [Fact]
+    public void Equals_Object_NullReturnsFalse()
+    {
+        // Arrange
+        ChatMessageGroup group = new(0, 1, ChatMessageGroupKind.System);
+
+        // Act & Assert
+        Assert.False(group.Equals(null));
+    }
+
+    [Fact]
+    public void Equals_Object_BoxedMessageGroupReturnsTrue()
+    {
+        // Arrange
+        ChatMessageGroup group = new(0, 2, ChatMessageGroupKind.AssistantToolGroup);
+        object boxed = new ChatMessageGroup(0, 2, ChatMessageGroupKind.AssistantToolGroup);
+
+        // Act & Assert
+        Assert.True(group.Equals(boxed));
+    }
+
+    [Fact]
+    public void Equals_Object_WrongTypeReturnsFalse()
+    {
+        // Arrange
+        ChatMessageGroup group = new(0, 1, ChatMessageGroupKind.System);
+
+        // Act & Assert
+        Assert.False(group.Equals("not a MessageGroup"));
+    }
+
+    [Fact]
+    public void GetHashCode_ConsistentForEqualInstances()
+    {
+        // Arrange
+        ChatMessageGroup a = new(0, 2, ChatMessageGroupKind.AssistantToolGroup);
+        ChatMessageGroup b = new(0, 2, ChatMessageGroupKind.AssistantToolGroup);
+
+        // Act & Assert
+        Assert.Equal(a.GetHashCode(), b.GetHashCode());
+    }
+}

dotnet/tests/Microsoft.Agents.AI.Abstractions.UnitTests/Compaction/SlidingWindowCompactionStrategyTests.cs

@@ -0,0 +1,135 @@
+// Copyright (c) Microsoft. All rights reserved.
+
+using System.Collections.Generic;
+using System.Threading.Tasks;
+using Microsoft.Agents.AI.Compaction;
+using Microsoft.Extensions.AI;
+
+namespace Microsoft.Agents.AI.Abstractions.UnitTests.Compaction;
+
+public class SlidingWindowCompactionStrategyTests : CompactionStrategyTestBase
+{
+    [Fact]
+    public async Task UnderLimit_NoChangeAsync()
+    {
+        // Arrange
+        List<ChatMessage> messages =
+        [
+            new(ChatRole.User, "Hello"),
+            new(ChatRole.Assistant, "Hi"),
+        ];
+        SlidingWindowCompactionStrategy strategy = new(maxTurns: 10);
+
+        // Act & Assert
+        await RunCompactionStrategySkippedAsync(strategy, messages);
+    }
+
+    [Fact]
+    public async Task KeepsLastNTurnsAsync()
+    {
+        // Arrange
+        List<ChatMessage> messages =
+        [
+            new(ChatRole.User, "Turn 1"),
+            new(ChatRole.Assistant, "Reply 1"),
+            new(ChatRole.User, "Turn 2"),
+            new(ChatRole.Assistant, "Reply 2"),
+            new(ChatRole.User, "Turn 3"),
+            new(ChatRole.Assistant, "Reply 3"),
+        ];
+        SlidingWindowCompactionStrategy strategy = new(maxTurns: 2);
+
+        // Act & Assert
+        await RunCompactionStrategyReducedAsync(strategy, messages, expectedCount: 4);
+
+        // Assert
+        Assert.Equal("Turn 2", messages[0].Text);
+        Assert.Equal("Reply 2", messages[1].Text);
+        Assert.Equal("Turn 3", messages[2].Text);
+        Assert.Equal("Reply 3", messages[3].Text);
+    }
+
+    [Fact]
+    public async Task PreservesSystemMessagesAsync()
+    {
+        // Arrange
+        List<ChatMessage> messages =
+        [
+            new(ChatRole.System, "You are a helper"),
+            new(ChatRole.User, "Turn 1"),
+            new(ChatRole.Assistant, "Reply 1"),
+            new(ChatRole.User, "Turn 2"),
+            new(ChatRole.Assistant, "Reply 2"),
+        ];
+        SlidingWindowCompactionStrategy strategy = new(maxTurns: 1);
+
+        // Act & Assert
+        await RunCompactionStrategyReducedAsync(strategy, messages, expectedCount: 3);
+
+        // Assert
+        Assert.Equal(ChatRole.System, messages[0].Role);
+        Assert.Equal("You are a helper", messages[0].Text);
+        Assert.Equal("Turn 2", messages[1].Text);
+        Assert.Equal("Reply 2", messages[2].Text);
+    }
+
+    [Fact]
+    public async Task PreservesToolGroupsWithinKeptTurnsAsync()
+    {
+        // Arrange
+        List<ChatMessage> messages =
+        [
+            new(ChatRole.User, "Turn 1"),
+            new(ChatRole.Assistant, "Reply 1"),
+            new(ChatRole.User, "Get weather"),
+            new ChatMessage(ChatRole.Assistant, [new FunctionCallContent("c1", "get_weather")]),
+            new ChatMessage(ChatRole.Tool, [new FunctionResultContent("c1", "Sunny")]),
+            new(ChatRole.Assistant, "It's sunny!"),
+        ];
+        SlidingWindowCompactionStrategy strategy = new(maxTurns: 1);
+
+        // Act & Assert
+        await RunCompactionStrategyReducedAsync(strategy, messages, expectedCount: 4);
+
+        // Assert
+        Assert.Equal("Get weather", messages[0].Text);
+    }
+
+    [Fact]
+    public async Task SingleTurn_AtLimit_NoChangeAsync()
+    {
+        // Arrange
+        List<ChatMessage> messages =
+        [
+            new(ChatRole.User, "Hello"),
+            new(ChatRole.Assistant, "Hi"),
+        ];
+        SlidingWindowCompactionStrategy strategy = new(maxTurns: 1);
+
+        // Act & Assert
+        await RunCompactionStrategySkippedAsync(strategy, messages);
+    }
+
+    [Fact]
+    public async Task DropsResponseGroupsFromOldTurnsAsync()
+    {
+        // Arrange
+        List<ChatMessage> messages =
+        [
+            new(ChatRole.User, "Turn 1"),
+            new ChatMessage(ChatRole.Assistant, [new FunctionCallContent("c1", "search")]),
+            new ChatMessage(ChatRole.Tool, [new FunctionResultContent("c1", "result")]),
+            new(ChatRole.Assistant, "Here's what I found"),
+            new(ChatRole.User, "Turn 2"),
+            new(ChatRole.Assistant, "Reply 2"),
+        ];
+        SlidingWindowCompactionStrategy strategy = new(maxTurns: 1);
+
+        // Act & Assert
+        await RunCompactionStrategyReducedAsync(strategy, messages, expectedCount: 2);
+
+        // Assert
+        Assert.Equal("Turn 2", messages[0].Text);
+        Assert.Equal("Reply 2", messages[1].Text);
+    }
+}

dotnet/tests/Microsoft.Agents.AI.Abstractions.UnitTests/Compaction/SummarizationCompactionStrategyTests.cs

@@ -0,0 +1,164 @@
+// Copyright (c) Microsoft. All rights reserved.
+
+using System.Collections.Generic;
+using System.Threading;
+using System.Threading.Tasks;
+using Microsoft.Agents.AI.Compaction;
+using Microsoft.Extensions.AI;
+using Moq;
+
+namespace Microsoft.Agents.AI.Abstractions.UnitTests.Compaction;
+
+public class SummarizationCompactionStrategyTests : CompactionStrategyTestBase
+{
+    [Fact]
+    public async Task UnderLimit_NoChangeAsync()
+    {
+        // Arrange
+        List<ChatMessage> messages =
+        [
+            new(ChatRole.User, "Hello"),
+            new(ChatRole.Assistant, "Hi"),
+        ];
+        Mock<IChatClient> chatClientMock = new();
+        SummarizationCompactionStrategy strategy = new(chatClientMock.Object, maxTokens: 100000);
+
+        // Act & Assert
+        await RunCompactionStrategySkippedAsync(strategy, messages);
+
+        // Assert
+        chatClientMock.Verify(
+            c => c.GetResponseAsync(It.IsAny<IEnumerable<ChatMessage>>(), It.IsAny<ChatOptions>(), It.IsAny<CancellationToken>()),
+            Times.Never);
+    }
+
+    [Fact]
+    public async Task SummarizesOldGroupsAsync()
+    {
+        // Arrange
+        List<ChatMessage> messages =
+        [
+            new(ChatRole.User, "What's the weather?"),
+            new(ChatRole.Assistant, "The weather is sunny and 72°F."),
+            new(ChatRole.User, "How about tomorrow?"),
+            new(ChatRole.Assistant, "Tomorrow will be cloudy."),
+            new(ChatRole.User, "Thanks!"),
+            new(ChatRole.Assistant, "You're welcome!"),
+        ];
+        Mock<IChatClient> chatClientMock = new();
+        chatClientMock
+            .Setup(c => c.GetResponseAsync(It.IsAny<IEnumerable<ChatMessage>>(), It.IsAny<ChatOptions>(), It.IsAny<CancellationToken>()))
+            .ReturnsAsync(new ChatResponse(new ChatMessage(ChatRole.Assistant, "User asked about weather. It was sunny.")));
+        SummarizationCompactionStrategy strategy = new(chatClientMock.Object, maxTokens: 1, preserveRecentGroups: 2);
+
+        // Act & Assert
+        await RunCompactionStrategyReducedAsync(strategy, messages, expectedCount: 3);
+
+        // Assert
+        Assert.Contains("[Summary]", messages[0].Text);
+        Assert.Contains("sunny", messages[0].Text);
+        Assert.Equal("Thanks!", messages[1].Text);
+        Assert.Equal("You're welcome!", messages[2].Text);
+    }
+
+    [Fact]
+    public async Task PreservesSystemMessagesAsync()
+    {
+        // Arrange
+        List<ChatMessage> messages =
+        [
+            new(ChatRole.System, "You are a helper"),
+            new(ChatRole.User, "Turn 1"),
+            new(ChatRole.Assistant, "Reply 1"),
+            new(ChatRole.User, "Turn 2"),
+            new(ChatRole.Assistant, "Reply 2"),
+        ];
+        Mock<IChatClient> chatClientMock = new();
+        chatClientMock
+            .Setup(c => c.GetResponseAsync(It.IsAny<IEnumerable<ChatMessage>>(), It.IsAny<ChatOptions>(), It.IsAny<CancellationToken>()))
+            .ReturnsAsync(new ChatResponse(new ChatMessage(ChatRole.Assistant, "Summary of earlier discussion.")));
+        SummarizationCompactionStrategy strategy = new(chatClientMock.Object, maxTokens: 1, preserveRecentGroups: 1);
+
+        // Act & Assert
+        await RunCompactionStrategyReducedAsync(strategy, messages, expectedCount: 3);
+
+        // Assert
+        Assert.Equal(ChatRole.System, messages[0].Role);
+        Assert.Equal("You are a helper", messages[0].Text);
+        Assert.Contains("[Summary]", messages[1].Text);
+    }
+
+    [Fact]
+    public async Task AllGroupsProtected_NoChangeAsync()
+    {
+        // Arrange
+        List<ChatMessage> messages =
+        [
+            new(ChatRole.User, "Hello"),
+            new(ChatRole.Assistant, "Hi"),
+        ];
+        Mock<IChatClient> chatClientMock = new();
+        SummarizationCompactionStrategy strategy = new(chatClientMock.Object, maxTokens: 1, preserveRecentGroups: 10);
+
+        // Act & Assert
+        await RunCompactionStrategySkippedAsync(strategy, messages);
+
+        // Assert
+        chatClientMock.Verify(
+            c => c.GetResponseAsync(It.IsAny<IEnumerable<ChatMessage>>(), It.IsAny<ChatOptions>(), It.IsAny<CancellationToken>()),
+            Times.Never);
+    }
+
+    [Fact]
+    public async Task CustomPrompt_UsedInRequestAsync()
+    {
+        // Arrange
+        const string CustomPrompt = "Summarize briefly.";
+        List<ChatMessage> messages =
+        [
+            new(ChatRole.User, "First"),
+            new(ChatRole.Assistant, "Reply"),
+            new(ChatRole.User, "Second"),
+            new(ChatRole.Assistant, "Reply 2"),
+        ];
+        List<ChatMessage>? capturedMessages = null;
+        Mock<IChatClient> chatClientMock = new();
+        chatClientMock
+            .Setup(c => c.GetResponseAsync(It.IsAny<IEnumerable<ChatMessage>>(), It.IsAny<ChatOptions>(), It.IsAny<CancellationToken>()))
+            .Callback<IEnumerable<ChatMessage>, ChatOptions, CancellationToken>((msgs, _, _) => capturedMessages = [.. msgs])
+            .ReturnsAsync(new ChatResponse(new ChatMessage(ChatRole.Assistant, "Brief summary.")));
+        SummarizationCompactionStrategy strategy = new(chatClientMock.Object, maxTokens: 1, preserveRecentGroups: 1, summarizationPrompt: CustomPrompt);
+
+        // Act & Assert
+        await RunCompactionStrategyReducedAsync(strategy, messages, expectedCount: 2);
+
+        // Assert
+        Assert.NotNull(capturedMessages);
+        Assert.Equal(ChatRole.System, capturedMessages![0].Role);
+        Assert.Equal(CustomPrompt, capturedMessages[0].Text);
+    }
+
+    [Fact]
+    public async Task NullResponseText_UsesFallbackAsync()
+    {
+        // Arrange
+        List<ChatMessage> messages =
+        [
+            new(ChatRole.User, "First"),
+            new(ChatRole.Assistant, "Reply"),
+            new(ChatRole.User, "Second"),
+            new(ChatRole.Assistant, "Reply 2"),
+        ];
+        Mock<IChatClient> chatClientMock = new();
+        chatClientMock
+            .Setup(c => c.GetResponseAsync(It.IsAny<IEnumerable<ChatMessage>>(), It.IsAny<ChatOptions>(), It.IsAny<CancellationToken>()))
+            .ReturnsAsync(new ChatResponse(new ChatMessage(ChatRole.Assistant, (string?)null)));
+        SummarizationCompactionStrategy strategy = new(chatClientMock.Object, maxTokens: 1, preserveRecentGroups: 1);
+
+        // Act & Assert
+        await RunCompactionStrategyReducedAsync(strategy, messages, expectedCount: 2);
+
+        // Assert
+        Assert.Contains("[Summary unavailable]", messages[0].Text);
+    }
+}

dotnet/tests/Microsoft.Agents.AI.Abstractions.UnitTests/Compaction/ToolResultCompactionStrategyTests.cs

@@ -0,0 +1,131 @@
+// Copyright (c) Microsoft. All rights reserved.
+
+using System.Collections.Generic;
+using System.Threading.Tasks;
+using Microsoft.Agents.AI.Compaction;
+using Microsoft.Extensions.AI;
+
+namespace Microsoft.Agents.AI.Abstractions.UnitTests.Compaction;
+
+public class ToolResultCompactionStrategyTests : CompactionStrategyTestBase
+{
+    [Fact]
+    public async Task UnderLimit_NoChangeAsync()
+    {
+        // Arrange
+        List<ChatMessage> messages =
+        [
+            new(ChatRole.User, "Hello"),
+            new ChatMessage(ChatRole.Assistant, [new FunctionCallContent("c1", "get_weather")]),
+            new ChatMessage(ChatRole.Tool, [new FunctionResultContent("c1", "Sunny")]),
+        ];
+        ToolResultCompactionStrategy strategy = new(maxTokens: 100000);
+
+        // Act & Assert
+        await RunCompactionStrategySkippedAsync(strategy, messages);
+    }
+
+    [Fact]
+    public async Task CollapsesOldToolGroupAsync()
+    {
+        // Arrange
+        List<ChatMessage> messages =
+        [
+            new(ChatRole.User, "Check weather"),
+            new ChatMessage(ChatRole.Assistant, [new FunctionCallContent("c1", "get_weather")]),
+            new ChatMessage(ChatRole.Tool, [new FunctionResultContent("c1", "Sunny, 72°F")]),
+            new(ChatRole.User, "Thanks"),
+            new(ChatRole.Assistant, "You're welcome!"),
+        ];
+        ToolResultCompactionStrategy strategy = new(maxTokens: 1, preserveRecentGroups: 1);
+
+        // Act & Assert
+        await RunCompactionStrategyReducedAsync(strategy, messages, expectedCount: 4);
+
+        // Assert
+        Assert.Contains("[Tool calls: get_weather]", messages[1].Text);
+        Assert.Equal(ChatRole.Assistant, messages[1].Role);
+    }
+
+    [Fact]
+    public async Task ProtectsRecentGroupsAsync()
+    {
+        // Arrange
+        List<ChatMessage> messages =
+        [
+            new(ChatRole.User, "Check weather"),
+            new ChatMessage(ChatRole.Assistant, [new FunctionCallContent("c1", "get_weather")]),
+            new ChatMessage(ChatRole.Tool, [new FunctionResultContent("c1", "Sunny")]),
+            new(ChatRole.User, "Thanks"),
+            new(ChatRole.Assistant, "You're welcome!"),
+        ];
+        ToolResultCompactionStrategy strategy = new(maxTokens: 1, preserveRecentGroups: 10);
+
+        // Act & Assert
+        await RunCompactionStrategySkippedAsync(strategy, messages);
+    }
+
+    [Fact]
+    public async Task PreservesSystemMessagesAsync()
+    {
+        // Arrange
+        List<ChatMessage> messages =
+        [
+            new(ChatRole.System, "You are a helper"),
+            new(ChatRole.User, "Check weather"),
+            new ChatMessage(ChatRole.Assistant, [new FunctionCallContent("c1", "get_weather")]),
+            new ChatMessage(ChatRole.Tool, [new FunctionResultContent("c1", "Sunny")]),
+            new(ChatRole.User, "Thanks"),
+            new(ChatRole.Assistant, "You're welcome!"),
+        ];
+        ToolResultCompactionStrategy strategy = new(maxTokens: 1, preserveRecentGroups: 1);
+
+        // Act & Assert
+        await RunCompactionStrategyReducedAsync(strategy, messages, expectedCount: 5);
+
+        // Assert
+        Assert.Equal(ChatRole.System, messages[0].Role);
+        Assert.Equal("You are a helper", messages[0].Text);
+    }
+
+    [Fact]
+    public async Task MultipleToolCalls_ListedInSummaryAsync()
+    {
+        // Arrange
+        List<ChatMessage> messages =
+        [
+            new(ChatRole.User, "Do research"),
+            new ChatMessage(ChatRole.Assistant, [
+                new FunctionCallContent("c1", "search"),
+                new FunctionCallContent("c2", "fetch_page"),
+            ]),
+            new ChatMessage(ChatRole.Tool, [new FunctionResultContent("c1", "results...")]),
+            new ChatMessage(ChatRole.Tool, [new FunctionResultContent("c2", "page content...")]),
+            new(ChatRole.User, "Summarize"),
+            new(ChatRole.Assistant, "Here's the summary."),
+        ];
+        ToolResultCompactionStrategy strategy = new(maxTokens: 1, preserveRecentGroups: 1);
+
+        // Act & Assert
+        await RunCompactionStrategyReducedAsync(strategy, messages, expectedCount: 4);
+
+        // Assert
+        Assert.Contains("search", messages[1].Text);
+        Assert.Contains("fetch_page", messages[1].Text);
+    }
+
+    [Fact]
+    public async Task NoToolGroups_NoChangeAsync()
+    {
+        // Arrange
+        List<ChatMessage> messages =
+        [
+            new(ChatRole.User, "Hello"),
+            new(ChatRole.Assistant, "Hi there"),
+        ];
+        ToolResultCompactionStrategy strategy = new(maxTokens: 1);
+
+        // Act & Assert
+        await RunCompactionStrategySkippedAsync(strategy, messages);
+    }
+}

dotnet/tests/Microsoft.Agents.AI.Abstractions.UnitTests/Compaction/TruncationCompactionStrategyTests.cs

@@ -0,0 +1,93 @@
+// Copyright (c) Microsoft. All rights reserved.
+
+using System.Collections.Generic;
+using System.Threading.Tasks;
+using Microsoft.Agents.AI.Compaction;
+using Microsoft.Extensions.AI;
+
+namespace Microsoft.Agents.AI.Abstractions.UnitTests.Compaction;
+
+public class TruncationCompactionStrategyTests : CompactionStrategyTestBase
+{
+    [Fact]
+    public async Task UnderLimit_NoChangeAsync()
+    {
+        // Arrange
+        List<ChatMessage> messages =
+        [
+            new(ChatRole.User, "Hello"),
+        ];
+        TruncationCompactionStrategy strategy = new(maxTokens: 100000);
+
+        // Act & Assert
+        await RunCompactionStrategySkippedAsync(strategy, messages);
+    }
+
+    [Fact]
+    public async Task OverLimit_RemovesOldestGroupsAsync()
+    {
+        // Arrange
+        List<ChatMessage> messages =
+        [
+            new(ChatRole.User, "First message"),
+            new(ChatRole.Assistant, "First reply"),
+            new(ChatRole.User, "Second message"),
+            new(ChatRole.Assistant, "Second reply"),
+        ];
+        TruncationCompactionStrategy strategy = new(maxTokens: 1);
+
+        // Act & Assert
+        await RunCompactionStrategyReducedAsync(strategy, messages, expectedCount: 1);
+    }
+
+    [Fact]
+    public async Task SystemOnlyMessages_NoChangeAsync()
+    {
+        // Arrange
+        List<ChatMessage> messages =
+        [
+            new(ChatRole.System, "You are a helper"),
+        ];
+        TruncationCompactionStrategy strategy = new(maxTokens: 1);
+
+        // Act & Assert
+        await RunCompactionStrategySkippedAsync(strategy, messages);
+    }
+
+    [Fact]
+    public async Task SingleNonSystemGroup_NoChangeAsync()
+    {
+        // Arrange
+        List<ChatMessage> messages =
+        [
+            new(ChatRole.System, "System prompt"),
+            new(ChatRole.User, "Only user message"),
+        ];
+        TruncationCompactionStrategy strategy = new(maxTokens: 1);
+
+        // Act & Assert
+        await RunCompactionStrategySkippedAsync(strategy, messages);
+    }
+
+    [Fact]
+    public async Task PreserveRecentGroups_KeepsMultipleGroupsAsync()
+    {
+        // Arrange
+        List<ChatMessage> messages =
+        [
+            new(ChatRole.User, "Turn 1"),
+            new(ChatRole.Assistant, "Reply 1"),
+            new(ChatRole.User, "Turn 2"),
+            new(ChatRole.Assistant, "Reply 2"),
+            new(ChatRole.User, "Turn 3"),
+            new(ChatRole.Assistant, "Reply 3"),
+        ];
+        TruncationCompactionStrategy strategy = new(maxTokens: 1, preserveRecentGroups: 2);
+
+        // Act & Assert
+        await RunCompactionStrategyReducedAsync(strategy, messages, expectedCount: 2);
+
+        // Assert
+        Assert.Equal("Reply 3", messages[^1].Text);
+    }
+}

dotnet/tests/Microsoft.Agents.AI.CosmosNoSql.UnitTests/CosmosChatHistoryProviderTests.cs

@@ -58,7 +58,7 @@ public sealed class CosmosChatHistoryProviderTests : IAsyncLifetime, IDisposable
     private bool _preserveContainer;
     private CosmosClient? _setupClient; // Only used for test setup/cleanup
 
-    public async Task InitializeAsync()
+    public async ValueTask InitializeAsync()
     {
         // Fail fast if emulator is not available
         this.SkipIfEmulatorNotAvailable();
@@ -100,8 +100,10 @@ public sealed class CosmosChatHistoryProviderTests : IAsyncLifetime, IDisposable
         }
     }
 
-    public async Task DisposeAsync()
+    public async ValueTask DisposeAsync()
     {
+        GC.SuppressFinalize(this);
+
         if (this._setupClient != null && this._emulatorAvailable)
         {
             try
@@ -143,12 +145,12 @@ public sealed class CosmosChatHistoryProviderTests : IAsyncLifetime, IDisposable
         // Locally: Skip if emulator connection check failed
         var ciEmulatorAvailable = string.Equals(Environment.GetEnvironmentVariable("COSMOSDB_EMULATOR_AVAILABLE"), bool.TrueString, StringComparison.OrdinalIgnoreCase);
 
-        Xunit.Skip.If(!ciEmulatorAvailable && !this._emulatorAvailable, "Cosmos DB Emulator is not available");
+        Assert.SkipWhen(!ciEmulatorAvailable && !this._emulatorAvailable, "Cosmos DB Emulator is not available");
     }
 
     #region Constructor Tests
 
-    [SkippableFact]
+    [Fact]
     [Trait("Category", "CosmosDB")]
     public void StateKeys_ReturnsDefaultKey_WhenNoStateKeyProvided()
     {
@@ -163,7 +165,7 @@ public sealed class CosmosChatHistoryProviderTests : IAsyncLifetime, IDisposable
         Assert.Contains("CosmosChatHistoryProvider", provider.StateKeys);
     }
 
-    [SkippableFact]
+    [Fact]
     [Trait("Category", "CosmosDB")]
     public void StateKeys_ReturnsCustomKey_WhenSetViaConstructor()
     {
@@ -179,7 +181,7 @@ public sealed class CosmosChatHistoryProviderTests : IAsyncLifetime, IDisposable
         Assert.Contains("custom-key", provider.StateKeys);
     }
 
-    [SkippableFact]
+    [Fact]
     [Trait("Category", "CosmosDB")]
     public void Constructor_WithConnectionString_ShouldCreateInstance()
     {
@@ -196,7 +198,7 @@ public sealed class CosmosChatHistoryProviderTests : IAsyncLifetime, IDisposable
         Assert.Equal(TestContainerId, provider.ContainerId);
     }
 
-    [SkippableFact]
+    [Fact]
     [Trait("Category", "CosmosDB")]
     public void Constructor_WithNullConnectionString_ShouldThrowArgumentException()
     {
@@ -206,7 +208,7 @@ public sealed class CosmosChatHistoryProviderTests : IAsyncLifetime, IDisposable
                 _ => new CosmosChatHistoryProvider.State("test-conversation")));
     }
 
-    [SkippableFact]
+    [Fact]
     [Trait("Category", "CosmosDB")]
     public void Constructor_WithNullStateInitializer_ShouldThrowArgumentNullException()
     {
@@ -221,7 +223,7 @@ public sealed class CosmosChatHistoryProviderTests : IAsyncLifetime, IDisposable
 
     #region InvokedAsync Tests
 
-    [SkippableFact]
+    [Fact]
     [Trait("Category", "CosmosDB")]
     public async Task InvokedAsync_WithSingleMessage_ShouldAddMessageAsync()
     {
@@ -286,7 +288,7 @@ public sealed class CosmosChatHistoryProviderTests : IAsyncLifetime, IDisposable
         Assert.Equal(ChatRole.User, messageList[0].Role);
     }
 
-    [SkippableFact]
+    [Fact]
     [Trait("Category", "CosmosDB")]
     public async Task InvokedAsync_WithMultipleMessages_ShouldAddAllMessagesAsync()
     {
@@ -329,7 +331,7 @@ public sealed class CosmosChatHistoryProviderTests : IAsyncLifetime, IDisposable
 
     #region InvokingAsync Tests
 
-    [SkippableFact]
+    [Fact]
     [Trait("Category", "CosmosDB")]
     public async Task InvokingAsync_WithNoMessages_ShouldReturnEmptyAsync()
     {
@@ -347,7 +349,7 @@ public sealed class CosmosChatHistoryProviderTests : IAsyncLifetime, IDisposable
         Assert.Empty(messages);
     }
 
-    [SkippableFact]
+    [Fact]
     [Trait("Category", "CosmosDB")]
     public async Task InvokingAsync_WithConversationIsolation_ShouldOnlyReturnMessagesForConversationAsync()
     {
@@ -391,7 +393,7 @@ public sealed class CosmosChatHistoryProviderTests : IAsyncLifetime, IDisposable
 
     #region Integration Tests
 
-    [SkippableFact]
+    [Fact]
     [Trait("Category", "CosmosDB")]
     public async Task FullWorkflow_AddAndGet_ShouldWorkCorrectlyAsync()
     {
@@ -442,7 +444,7 @@ public sealed class CosmosChatHistoryProviderTests : IAsyncLifetime, IDisposable
 
     #region Disposal Tests
 
-    [SkippableFact]
+    [Fact]
     [Trait("Category", "CosmosDB")]
     public void Dispose_AfterUse_ShouldNotThrow()
     {
@@ -455,7 +457,7 @@ public sealed class CosmosChatHistoryProviderTests : IAsyncLifetime, IDisposable
         provider.Dispose(); // Should not throw
     }
 
-    [SkippableFact]
+    [Fact]
     [Trait("Category", "CosmosDB")]
     public void Dispose_MultipleCalls_ShouldNotThrow()
     {
@@ -473,7 +475,7 @@ public sealed class CosmosChatHistoryProviderTests : IAsyncLifetime, IDisposable
 
     #region Hierarchical Partitioning Tests
 
-    [SkippableFact]
+    [Fact]
     [Trait("Category", "CosmosDB")]
     public void Constructor_WithHierarchicalConnectionString_ShouldCreateInstance()
     {
@@ -490,7 +492,7 @@ public sealed class CosmosChatHistoryProviderTests : IAsyncLifetime, IDisposable
         Assert.Equal(HierarchicalTestContainerId, provider.ContainerId);
     }
 
-    [SkippableFact]
+    [Fact]
     [Trait("Category", "CosmosDB")]
     public void Constructor_WithHierarchicalEndpoint_ShouldCreateInstance()
     {
@@ -508,7 +510,7 @@ public sealed class CosmosChatHistoryProviderTests : IAsyncLifetime, IDisposable
         Assert.Equal(HierarchicalTestContainerId, provider.ContainerId);
     }
 
-    [SkippableFact]
+    [Fact]
     [Trait("Category", "CosmosDB")]
     public void Constructor_WithHierarchicalCosmosClient_ShouldCreateInstance()
     {
@@ -525,7 +527,7 @@ public sealed class CosmosChatHistoryProviderTests : IAsyncLifetime, IDisposable
         Assert.Equal(HierarchicalTestContainerId, provider.ContainerId);
     }
 
-    [SkippableFact]
+    [Fact]
     [Trait("Category", "CosmosDB")]
     public void State_WithEmptyConversationId_ShouldThrowArgumentException()
     {
@@ -534,7 +536,7 @@ public sealed class CosmosChatHistoryProviderTests : IAsyncLifetime, IDisposable
             new CosmosChatHistoryProvider.State(""));
     }
 
-    [SkippableFact]
+    [Fact]
     [Trait("Category", "CosmosDB")]
     public void State_WithWhitespaceConversationId_ShouldThrowArgumentException()
     {
@@ -543,7 +545,7 @@ public sealed class CosmosChatHistoryProviderTests : IAsyncLifetime, IDisposable
             new CosmosChatHistoryProvider.State("   "));
     }
 
-    [SkippableFact]
+    [Fact]
     [Trait("Category", "CosmosDB")]
     public async Task InvokedAsync_WithHierarchicalPartitioning_ShouldAddMessageWithMetadataAsync()
     {
@@ -597,7 +599,7 @@ public sealed class CosmosChatHistoryProviderTests : IAsyncLifetime, IDisposable
         Assert.Equal(SessionId, (string)document!.sessionId);
     }
 
-    [SkippableFact]
+    [Fact]
     [Trait("Category", "CosmosDB")]
     public async Task InvokedAsync_WithHierarchicalMultipleMessages_ShouldAddAllMessagesAsync()
     {
@@ -636,7 +638,7 @@ public sealed class CosmosChatHistoryProviderTests : IAsyncLifetime, IDisposable
         Assert.Equal("Third hierarchical message", messageList[2].Text);
     }
 
-    [SkippableFact]
+    [Fact]
     [Trait("Category", "CosmosDB")]
     public async Task InvokingAsync_WithHierarchicalPartitionIsolation_ShouldIsolateMessagesByUserIdAsync()
     {
@@ -682,7 +684,7 @@ public sealed class CosmosChatHistoryProviderTests : IAsyncLifetime, IDisposable
         Assert.Equal("Message from user 2", messageList2[0].Text);
     }
 
-    [SkippableFact]
+    [Fact]
     [Trait("Category", "CosmosDB")]
     public async Task StateBag_WithHierarchicalPartitioning_ShouldPreserveStateAcrossProviderInstancesAsync()
     {
@@ -717,7 +719,7 @@ public sealed class CosmosChatHistoryProviderTests : IAsyncLifetime, IDisposable
         Assert.Equal(HierarchicalTestContainerId, newStore.ContainerId);
     }
 
-    [SkippableFact]
+    [Fact]
     [Trait("Category", "CosmosDB")]
     public async Task HierarchicalAndSimplePartitioning_ShouldCoexistAsync()
     {
@@ -759,7 +761,7 @@ public sealed class CosmosChatHistoryProviderTests : IAsyncLifetime, IDisposable
         Assert.Equal("Hierarchical partitioning message", hierarchicalMessageList[0].Text);
     }
 
-    [SkippableFact]
+    [Fact]
     [Trait("Category", "CosmosDB")]
     public async Task MaxMessagesToRetrieve_ShouldLimitAndReturnMostRecentAsync()
     {
@@ -800,7 +802,7 @@ public sealed class CosmosChatHistoryProviderTests : IAsyncLifetime, IDisposable
         Assert.Equal("Message 10", messageList[4].Text);
     }
 
-    [SkippableFact]
+    [Fact]
     [Trait("Category", "CosmosDB")]
     public async Task MaxMessagesToRetrieve_Null_ShouldReturnAllMessagesAsync()
     {
@@ -836,7 +838,7 @@ public sealed class CosmosChatHistoryProviderTests : IAsyncLifetime, IDisposable
         Assert.Equal("Message 10", messageList[9].Text);
     }
 
-    [SkippableFact]
+    [Fact]
     [Trait("Category", "CosmosDB")]
     public async Task GetMessageCountAsync_WithMessages_ShouldReturnCorrectCountAsync()
     {
@@ -868,7 +870,7 @@ public sealed class CosmosChatHistoryProviderTests : IAsyncLifetime, IDisposable
         Assert.Equal(5, count);
     }
 
-    [SkippableFact]
+    [Fact]
     [Trait("Category", "CosmosDB")]
     public async Task GetMessageCountAsync_WithNoMessages_ShouldReturnZeroAsync()
     {
@@ -887,7 +889,7 @@ public sealed class CosmosChatHistoryProviderTests : IAsyncLifetime, IDisposable
         Assert.Equal(0, count);
     }
 
-    [SkippableFact]
+    [Fact]
     [Trait("Category", "CosmosDB")]
     public async Task ClearMessagesAsync_WithMessages_ShouldDeleteAndReturnCountAsync()
     {
@@ -935,7 +937,7 @@ public sealed class CosmosChatHistoryProviderTests : IAsyncLifetime, IDisposable
         Assert.Empty(retrievedMessages);
     }
 
-    [SkippableFact]
+    [Fact]
     [Trait("Category", "CosmosDB")]
     public async Task ClearMessagesAsync_WithNoMessages_ShouldReturnZeroAsync()
     {
@@ -958,7 +960,7 @@ public sealed class CosmosChatHistoryProviderTests : IAsyncLifetime, IDisposable
 
     #region Message Filter Tests
 
-    [SkippableFact]
+    [Fact]
     [Trait("Category", "CosmosDB")]
     public async Task InvokedAsync_DefaultFilter_ExcludesChatHistoryMessagesFromStorageAsync()
     {
@@ -993,7 +995,7 @@ public sealed class CosmosChatHistoryProviderTests : IAsyncLifetime, IDisposable
         Assert.Equal("Response", messages[2].Text);
     }
 
-    [SkippableFact]
+    [Fact]
     [Trait("Category", "CosmosDB")]
     public async Task InvokedAsync_CustomStorageInputFilter_OverridesDefaultAsync()
     {
@@ -1031,7 +1033,7 @@ public sealed class CosmosChatHistoryProviderTests : IAsyncLifetime, IDisposable
         Assert.Equal("Response", messages[1].Text);
     }
 
-    [SkippableFact]
+    [Fact]
     [Trait("Category", "CosmosDB")]
     public async Task InvokingAsync_RetrievalOutputFilter_FiltersRetrievedMessagesAsync()
     {

dotnet/tests/Microsoft.Agents.AI.CosmosNoSql.UnitTests/CosmosCheckpointStoreTests.cs

@@ -55,7 +55,7 @@ public class CosmosCheckpointStoreTests : IAsyncLifetime, IDisposable
         return options;
     }
 
-    public async Task InitializeAsync()
+    public async ValueTask InitializeAsync()
     {
         // Fail fast if emulator is not available
         this.SkipIfEmulatorNotAvailable();
@@ -88,8 +88,10 @@ public class CosmosCheckpointStoreTests : IAsyncLifetime, IDisposable
         }
     }
 
-    public async Task DisposeAsync()
+    public async ValueTask DisposeAsync()
     {
+        GC.SuppressFinalize(this);
+
         if (this._cosmosClient != null && this._emulatorAvailable)
         {
             try
@@ -124,12 +126,12 @@ public class CosmosCheckpointStoreTests : IAsyncLifetime, IDisposable
         // Locally: Skip if emulator connection check failed
         var ciEmulatorAvailable = string.Equals(Environment.GetEnvironmentVariable("COSMOSDB_EMULATOR_AVAILABLE"), bool.TrueString, StringComparison.OrdinalIgnoreCase);
 
-        Xunit.Skip.If(!ciEmulatorAvailable && !this._emulatorAvailable, "Cosmos DB Emulator is not available");
+        Assert.SkipWhen(!ciEmulatorAvailable && !this._emulatorAvailable, "Cosmos DB Emulator is not available");
     }
 
     #region Constructor Tests
 
-    [SkippableFact]
+    [Fact]
     public void Constructor_WithCosmosClient_SetsProperties()
     {
         // Arrange
@@ -143,7 +145,7 @@ public class CosmosCheckpointStoreTests : IAsyncLifetime, IDisposable
         Assert.Equal(TestContainerId, store.ContainerId);
     }
 
-    [SkippableFact]
+    [Fact]
     public void Constructor_WithConnectionString_SetsProperties()
     {
         // Arrange
@@ -157,7 +159,7 @@ public class CosmosCheckpointStoreTests : IAsyncLifetime, IDisposable
         Assert.Equal(TestContainerId, store.ContainerId);
     }
 
-    [SkippableFact]
+    [Fact]
     public void Constructor_WithNullCosmosClient_ThrowsArgumentNullException()
     {
         // Act & Assert
@@ -165,7 +167,7 @@ public class CosmosCheckpointStoreTests : IAsyncLifetime, IDisposable
             new CosmosCheckpointStore((CosmosClient)null!, s_testDatabaseId, TestContainerId));
     }
 
-    [SkippableFact]
+    [Fact]
     public void Constructor_WithNullConnectionString_ThrowsArgumentException()
     {
         // Act & Assert
@@ -177,7 +179,7 @@ public class CosmosCheckpointStoreTests : IAsyncLifetime, IDisposable
 
     #region Checkpoint Operations Tests
 
-    [SkippableFact]
+    [Fact]
     public async Task CreateCheckpointAsync_NewCheckpoint_CreatesSuccessfullyAsync()
     {
         this.SkipIfEmulatorNotAvailable();
@@ -197,7 +199,7 @@ public class CosmosCheckpointStoreTests : IAsyncLifetime, IDisposable
         Assert.NotEmpty(checkpointInfo.CheckpointId);
     }
 
-    [SkippableFact]
+    [Fact]
     public async Task RetrieveCheckpointAsync_ExistingCheckpoint_ReturnsCorrectValueAsync()
     {
         this.SkipIfEmulatorNotAvailable();
@@ -218,7 +220,7 @@ public class CosmosCheckpointStoreTests : IAsyncLifetime, IDisposable
         Assert.Equal("Hello, World!", messageProp.GetString());
     }
 
-    [SkippableFact]
+    [Fact]
     public async Task RetrieveCheckpointAsync_NonExistentCheckpoint_ThrowsInvalidOperationExceptionAsync()
     {
         this.SkipIfEmulatorNotAvailable();
@@ -233,7 +235,7 @@ public class CosmosCheckpointStoreTests : IAsyncLifetime, IDisposable
             store.RetrieveCheckpointAsync(sessionId, fakeCheckpointInfo).AsTask());
     }
 
-    [SkippableFact]
+    [Fact]
     public async Task RetrieveIndexAsync_EmptyStore_ReturnsEmptyCollectionAsync()
     {
         this.SkipIfEmulatorNotAvailable();
@@ -250,7 +252,7 @@ public class CosmosCheckpointStoreTests : IAsyncLifetime, IDisposable
         Assert.Empty(index);
     }
 
-    [SkippableFact]
+    [Fact]
     public async Task RetrieveIndexAsync_WithCheckpoints_ReturnsAllCheckpointsAsync()
     {
         this.SkipIfEmulatorNotAvailable();
@@ -275,7 +277,7 @@ public class CosmosCheckpointStoreTests : IAsyncLifetime, IDisposable
         Assert.Contains(index, c => c.CheckpointId == checkpoint3.CheckpointId);
     }
 
-    [SkippableFact]
+    [Fact]
     public async Task CreateCheckpointAsync_WithParent_CreatesHierarchyAsync()
     {
         this.SkipIfEmulatorNotAvailable();
@@ -295,7 +297,7 @@ public class CosmosCheckpointStoreTests : IAsyncLifetime, IDisposable
         Assert.Equal(sessionId, childCheckpoint.SessionId);
     }
 
-    [SkippableFact]
+    [Fact]
     public async Task RetrieveIndexAsync_WithParentFilter_ReturnsFilteredResultsAsync()
     {
         this.SkipIfEmulatorNotAvailable();
@@ -331,7 +333,7 @@ public class CosmosCheckpointStoreTests : IAsyncLifetime, IDisposable
 
     #region Run Isolation Tests
 
-    [SkippableFact]
+    [Fact]
     public async Task CheckpointOperations_DifferentRuns_IsolatesDataAsync()
     {
         this.SkipIfEmulatorNotAvailable();
@@ -361,7 +363,7 @@ public class CosmosCheckpointStoreTests : IAsyncLifetime, IDisposable
 
     #region Error Handling Tests
 
-    [SkippableFact]
+    [Fact]
     public async Task CreateCheckpointAsync_WithNullSessionId_ThrowsArgumentExceptionAsync()
     {
         this.SkipIfEmulatorNotAvailable();
@@ -375,7 +377,7 @@ public class CosmosCheckpointStoreTests : IAsyncLifetime, IDisposable
             store.CreateCheckpointAsync(null!, checkpointValue).AsTask());
     }
 
-    [SkippableFact]
+    [Fact]
     public async Task CreateCheckpointAsync_WithEmptySessionId_ThrowsArgumentExceptionAsync()
     {
         this.SkipIfEmulatorNotAvailable();
@@ -389,7 +391,7 @@ public class CosmosCheckpointStoreTests : IAsyncLifetime, IDisposable
             store.CreateCheckpointAsync("", checkpointValue).AsTask());
     }
 
-    [SkippableFact]
+    [Fact]
     public async Task RetrieveCheckpointAsync_WithNullCheckpointInfo_ThrowsArgumentNullExceptionAsync()
     {
         this.SkipIfEmulatorNotAvailable();
@@ -407,7 +409,7 @@ public class CosmosCheckpointStoreTests : IAsyncLifetime, IDisposable
 
     #region Disposal Tests
 
-    [SkippableFact]
+    [Fact]
     public async Task Dispose_AfterDisposal_ThrowsObjectDisposedExceptionAsync()
     {
         this.SkipIfEmulatorNotAvailable();
@@ -424,7 +426,7 @@ public class CosmosCheckpointStoreTests : IAsyncLifetime, IDisposable
             store.CreateCheckpointAsync("test-run", checkpointValue).AsTask());
     }
 
-    [SkippableFact]
+    [Fact]
     public void Dispose_MultipleCalls_DoesNotThrow()
     {
         this.SkipIfEmulatorNotAvailable();

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

@@ -17,7 +17,6 @@
     <PackageReference Include="System.Linq.AsyncEnumerable" />
     <PackageReference Include="Azure.Identity" />
     <PackageReference Include="Microsoft.Azure.Cosmos" />
-    <PackageReference Include="Xunit.SkippableFact" />
   </ItemGroup>
 
 </Project>

dotnet/tests/Microsoft.Agents.AI.DurableTask.IntegrationTests/AgentEntityTests.cs

@@ -9,7 +9,6 @@ using Microsoft.DurableTask.Client.Entities;
 using Microsoft.DurableTask.Entities;
 using Microsoft.Extensions.Configuration;
 using OpenAI.Chat;
-using Xunit.Abstractions;
 
 namespace Microsoft.Agents.AI.DurableTask.IntegrationTests;
 

dotnet/tests/Microsoft.Agents.AI.DurableTask.IntegrationTests/ConsoleAppSamplesValidation.cs

@@ -6,7 +6,6 @@ using System.Reflection;
 using System.Text;
 using Microsoft.Extensions.Configuration;
 using Microsoft.Extensions.Logging;
-using Xunit.Abstractions;
 
 namespace Microsoft.Agents.AI.DurableTask.IntegrationTests;
 
@@ -30,7 +29,7 @@ public sealed class ConsoleAppSamplesValidation(ITestOutputHelper outputHelper)
 
     private readonly ITestOutputHelper _outputHelper = outputHelper;
 
-    async Task IAsyncLifetime.InitializeAsync()
+    async ValueTask IAsyncLifetime.InitializeAsync()
     {
         if (!s_infrastructureStarted)
         {
@@ -39,7 +38,7 @@ public sealed class ConsoleAppSamplesValidation(ITestOutputHelper outputHelper)
         }
     }
 
-    async Task IAsyncLifetime.DisposeAsync()
+    async ValueTask IAsyncDisposable.DisposeAsync()
     {
         // Nothing to clean up
         await Task.CompletedTask;
@@ -736,6 +735,9 @@ public sealed class ConsoleAppSamplesValidation(ITestOutputHelper outputHelper)
 
     private async Task RunSampleTestAsync(string samplePath, Func<Process, BlockingCollection<OutputLog>, Task> testAction)
     {
+        // Build the sample project first (it may not have been built as part of the solution)
+        await this.BuildSampleAsync(samplePath);
+
         // Generate a unique TaskHub name for this sample test to prevent cross-test interference
         // when multiple tests run together and share the same DTS emulator.
         string uniqueTaskHubName = $"sample-{Guid.NewGuid().ToString("N").Substring(0, 6)}";
@@ -814,12 +816,44 @@ public sealed class ConsoleAppSamplesValidation(ITestOutputHelper outputHelper)
         return null;
     }
 
+    private async Task BuildSampleAsync(string samplePath)
+    {
+        this._outputHelper.WriteLine($"Building sample at {samplePath}...");
+
+        ProcessStartInfo buildInfo = new()
+        {
+            FileName = "dotnet",
+            Arguments = $"build --framework {s_dotnetTargetFramework}",
+            WorkingDirectory = samplePath,
+            UseShellExecute = false,
+            RedirectStandardOutput = true,
+            RedirectStandardError = true,
+        };
+
+        using Process buildProcess = new() { StartInfo = buildInfo };
+        buildProcess.Start();
+
+        // Read both streams asynchronously to avoid deadlocks from filled pipe buffers
+        Task<string> stdoutTask = buildProcess.StandardOutput.ReadToEndAsync();
+        Task<string> stderrTask = buildProcess.StandardError.ReadToEndAsync();
+        await buildProcess.WaitForExitAsync();
+
+        string stderr = await stderrTask;
+        if (buildProcess.ExitCode != 0)
+        {
+            string stdout = await stdoutTask;
+            throw new InvalidOperationException($"Failed to build sample at {samplePath}:\n{stdout}\n{stderr}");
+        }
+
+        this._outputHelper.WriteLine($"Build completed for {samplePath}.");
+    }
+
     private Process StartConsoleApp(string samplePath, BlockingCollection<OutputLog> logs, string taskHubName)
     {
         ProcessStartInfo startInfo = new()
         {
             FileName = "dotnet",
-            Arguments = $"run --framework {s_dotnetTargetFramework}",
+            Arguments = $"run --no-build --framework {s_dotnetTargetFramework}",
             WorkingDirectory = samplePath,
             UseShellExecute = false,
             RedirectStandardOutput = true,

dotnet/tests/Microsoft.Agents.AI.DurableTask.IntegrationTests/ExternalClientTests.cs

@@ -9,7 +9,6 @@ using Microsoft.DurableTask.Client;
 using Microsoft.Extensions.AI;
 using Microsoft.Extensions.Configuration;
 using OpenAI.Chat;
-using Xunit.Abstractions;
 
 namespace Microsoft.Agents.AI.DurableTask.IntegrationTests;
 

dotnet/tests/Microsoft.Agents.AI.DurableTask.IntegrationTests/Logging/TestLogger.cs

@@ -2,7 +2,6 @@
 
 using System.Collections.Concurrent;
 using Microsoft.Extensions.Logging;
-using Xunit.Abstractions;
 
 namespace Microsoft.Agents.AI.DurableTask.IntegrationTests.Logging;
 

dotnet/tests/Microsoft.Agents.AI.DurableTask.IntegrationTests/Logging/TestLoggerProvider.cs

@@ -2,7 +2,6 @@
 
 using System.Collections.Concurrent;
 using Microsoft.Extensions.Logging;
-using Xunit.Abstractions;
 
 namespace Microsoft.Agents.AI.DurableTask.IntegrationTests.Logging;
 

dotnet/tests/Microsoft.Agents.AI.DurableTask.IntegrationTests/Microsoft.Agents.AI.DurableTask.IntegrationTests.csproj

@@ -3,6 +3,7 @@
   <PropertyGroup>
     <TargetFrameworks>$(TargetFrameworksCore)</TargetFrameworks>
     <ImplicitUsings>enable</ImplicitUsings>
+    <InjectSharedIntegrationTestAzureCredentialsCode>True</InjectSharedIntegrationTestAzureCredentialsCode>
   </PropertyGroup>
 
   <!-- Public packages required by integration tests -->

dotnet/tests/Microsoft.Agents.AI.DurableTask.IntegrationTests/OrchestrationTests.cs

@@ -7,7 +7,6 @@ using Microsoft.DurableTask.Client;
 using Microsoft.Extensions.AI;
 using Microsoft.Extensions.Configuration;
 using OpenAI.Chat;
-using Xunit.Abstractions;
 
 namespace Microsoft.Agents.AI.DurableTask.IntegrationTests;
 

dotnet/tests/Microsoft.Agents.AI.DurableTask.IntegrationTests/TestHelper.cs

@@ -2,7 +2,6 @@
 
 using Azure;
 using Azure.AI.OpenAI;
-using Azure.Identity;
 using Microsoft.Agents.AI.DurableTask.IntegrationTests.Logging;
 using Microsoft.DurableTask;
 using Microsoft.DurableTask.Client;
@@ -14,7 +13,7 @@ using Microsoft.Extensions.DependencyInjection;
 using Microsoft.Extensions.Hosting;
 using Microsoft.Extensions.Logging;
 using OpenAI.Chat;
-using Xunit.Abstractions;
+using Shared.IntegrationTests;
 
 namespace Microsoft.Agents.AI.DurableTask.IntegrationTests;
 
@@ -166,7 +165,7 @@ internal sealed class TestHelper : IDisposable
 
         AzureOpenAIClient client = !string.IsNullOrEmpty(azureOpenAiKey)
             ? new AzureOpenAIClient(new Uri(azureOpenAiEndpoint), new AzureKeyCredential(azureOpenAiKey))
-            : new AzureOpenAIClient(new Uri(azureOpenAiEndpoint), new AzureCliCredential());
+            : new AzureOpenAIClient(new Uri(azureOpenAiEndpoint), TestAzureCliCredentials.CreateAzureCliCredential());
 
         return client.GetChatClient(azureOpenAiDeploymentName);
     }

dotnet/tests/Microsoft.Agents.AI.DurableTask.IntegrationTests/TimeToLiveTests.cs

@@ -7,7 +7,6 @@ using Microsoft.DurableTask.Client;
 using Microsoft.DurableTask.Client.Entities;
 using Microsoft.Extensions.Configuration;
 using OpenAI.Chat;
-using Xunit.Abstractions;
 
 namespace Microsoft.Agents.AI.DurableTask.IntegrationTests;