Python: bump package versions for 1.6.0 release (#6017)

* Python: bump package versions for 1.6.0 release

- Released cohort (agent-framework, core, openai, foundry): 1.5.0 -> 1.6.0
- Beta packages (21 packages): 1.0.0b260519 -> 1.0.0b260521
- Alpha packages (azure-contentunderstanding, foundry-hosting, gemini, monty): 1.0.0a260518/19 -> 1.0.0a260521
- ag-ui stays at 1.0.0rc2, orchestrations at 1.0.0rc1 (dependency bounds updated)
- Inter-package dependency lower bounds updated (>=1.5.0,<2 -> >=1.6.0,<2)
- Update CHANGELOG compare links
- uv.lock refreshed

Co-authored-by: Copilot <223556219+Copilot@users.noreply.github.com>

* Address review: bump RC packages, add shell tool to changelog

- ag-ui: 1.0.0rc2 -> 1.0.0rc3
- orchestrations: 1.0.0rc1 -> 1.0.0rc2
- Add shell tool (#5664) to CHANGELOG
- uv.lock refreshed

Co-authored-by: Copilot <223556219+Copilot@users.noreply.github.com>

---------

Co-authored-by: Copilot <223556219+Copilot@users.noreply.github.com>

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

@@ -602,7 +602,7 @@ jobs:
           pattern: dotnet-test-results-*
           path: dotnet-test-results/
       - name: Restore report history cache
-        uses: actions/cache/restore@27d5ce7f107fe9357f9df03efb73ab90386fccae # v5.0.5
+        uses: actions/cache/restore@0057852bfaa89a56745cba8c7296529d2fc39830 # v4
         with:
           path: python/dotnet-integration-report-history.json
           key: dotnet-integration-report-history-${{ github.run_id }}
@@ -619,7 +619,7 @@ jobs:
         run: cat dotnet-integration-test-report.md >> $GITHUB_STEP_SUMMARY
       - name: Save report history cache
         if: always()
-        uses: actions/cache/save@27d5ce7f107fe9357f9df03efb73ab90386fccae # v5.0.5
+        uses: actions/cache/save@0057852bfaa89a56745cba8c7296529d2fc39830 # v4
         with:
           path: python/dotnet-integration-report-history.json
           key: dotnet-integration-report-history-${{ github.run_id }}

.github/workflows/python-integration-tests.yml

@@ -177,7 +177,7 @@ jobs:
         run: curl -fsSL https://ollama.com/install.sh | sh
         working-directory: .
       - name: Cache Ollama models
-        uses: actions/cache@27d5ce7f107fe9357f9df03efb73ab90386fccae # v5.0.5
+        uses: actions/cache@0057852bfaa89a56745cba8c7296529d2fc39830 # v4
         with:
           path: ~/.ollama/models
           key: ollama-models-qwen2.5-1.5b-nomic-embed-text-v1
@@ -511,7 +511,7 @@ jobs:
           pattern: test-results-*
           path: test-results/
       - name: Restore report history cache
-        uses: actions/cache/restore@27d5ce7f107fe9357f9df03efb73ab90386fccae # v5.0.5
+        uses: actions/cache/restore@0057852bfaa89a56745cba8c7296529d2fc39830 # v4
         with:
           path: python/integration-report-history.json
           key: integration-report-history-integration-${{ github.run_id }}
@@ -528,7 +528,7 @@ jobs:
         run: cat integration-test-report.md >> $GITHUB_STEP_SUMMARY
       - name: Save report history cache
         if: always()
-        uses: actions/cache/save@27d5ce7f107fe9357f9df03efb73ab90386fccae # v5.0.5
+        uses: actions/cache/save@0057852bfaa89a56745cba8c7296529d2fc39830 # v4
         with:
           path: python/integration-report-history.json
           key: integration-report-history-integration-${{ github.run_id }}

.github/workflows/python-merge-tests.yml

@@ -295,7 +295,7 @@ jobs:
         run: curl -fsSL https://ollama.com/install.sh | sh
         working-directory: .
       - name: Cache Ollama models
-        uses: actions/cache@27d5ce7f107fe9357f9df03efb73ab90386fccae # v5.0.5
+        uses: actions/cache@0057852bfaa89a56745cba8c7296529d2fc39830 # v4
         with:
           path: ~/.ollama/models
           key: ollama-models-qwen2.5-1.5b-nomic-embed-text-v1
@@ -692,7 +692,7 @@ jobs:
           pattern: test-results-*
           path: test-results/
       - name: Restore report history cache
-        uses: actions/cache/restore@27d5ce7f107fe9357f9df03efb73ab90386fccae # v5.0.5
+        uses: actions/cache/restore@0057852bfaa89a56745cba8c7296529d2fc39830 # v4
         with:
           path: python/integration-report-history.json
           key: integration-report-history-merge-${{ github.run_id }}
@@ -709,7 +709,7 @@ jobs:
         run: cat integration-test-report.md >> $GITHUB_STEP_SUMMARY
       - name: Save report history cache
         if: always()
-        uses: actions/cache/save@27d5ce7f107fe9357f9df03efb73ab90386fccae # v5.0.5
+        uses: actions/cache/save@0057852bfaa89a56745cba8c7296529d2fc39830 # v4
         with:
           path: python/integration-report-history.json
           key: integration-report-history-merge-${{ github.run_id }}

.github/workflows/python-sample-validation.yml

@@ -701,7 +701,7 @@ jobs:
 
       - name: Restore validation history
         id: cache-restore
-        uses: actions/cache/restore@27d5ce7f107fe9357f9df03efb73ab90386fccae # v5.0.5
+        uses: actions/cache/restore@0057852bfaa89a56745cba8c7296529d2fc39830 # v4
         with:
           path: validation-history/
           key: validation-history-${{ github.run_id }}
@@ -719,7 +719,7 @@ jobs:
         run: cat trend-report.md >> "$GITHUB_STEP_SUMMARY"
 
       - name: Save validation history
-        uses: actions/cache/save@27d5ce7f107fe9357f9df03efb73ab90386fccae # v5.0.5
+        uses: actions/cache/save@0057852bfaa89a56745cba8c7296529d2fc39830 # v4
         with:
           path: validation-history/
           key: validation-history-${{ github.run_id }}

dotnet/agent-framework-dotnet.slnx

@@ -121,6 +121,7 @@
   <Folder Name="/Samples/02-agents/Harness/">
     <File Path="samples/02-agents/Harness/README.md" />
     <Project Path="samples/02-agents/Harness/Harness_Shared_Console/Harness_Shared_Console.csproj" />
+    <Project Path="samples/02-agents/Harness/Harness_Shared_Console_OpenAI/Harness_Shared_Console_OpenAI.csproj" />
     <Project Path="samples/02-agents/Harness/Harness_Step01_Research/Harness_Step01_Research.csproj" />
     <Project Path="samples/02-agents/Harness/Harness_Step02_Research_WithBackgroundAgents/Harness_Step02_Research_WithBackgroundAgents.csproj" />
     <Project Path="samples/02-agents/Harness/Harness_Step03_DataProcessing/Harness_Step03_DataProcessing.csproj" />

dotnet/nuget/nuget-package.props

@@ -1,14 +1,14 @@
 <Project>
   <PropertyGroup>
     <!-- Central version prefix - applies to all nuget packages. -->
-    <VersionPrefix>1.6.1</VersionPrefix>
+    <VersionPrefix>1.6.2</VersionPrefix>
     <RCNumber>1</RCNumber>
-    <DateSuffix>260514</DateSuffix>
+    <DateSuffix>260521</DateSuffix>
     <PackageVersion Condition="'$(IsReleaseCandidate)' == 'true'">$(VersionPrefix)-rc$(RCNumber)</PackageVersion>
     <PackageVersion Condition="'$(IsReleaseCandidate)' != 'true' AND '$(VersionSuffix)' != ''">$(VersionPrefix)-$(VersionSuffix).$(DateSuffix).1</PackageVersion>
     <PackageVersion Condition="'$(IsReleaseCandidate)' != 'true' AND '$(VersionSuffix)' == ''">$(VersionPrefix)-preview.$(DateSuffix).1</PackageVersion>
     <PackageVersion Condition="'$(IsReleased)' == 'true'">$(VersionPrefix)</PackageVersion>
-    <GitTag>1.6.1</GitTag>
+    <GitTag>1.6.2</GitTag>
 
     <Configurations>Debug;Release;Publish</Configurations>
     <IsPackable>true</IsPackable>

dotnet/samples/02-agents/Harness/Harness_Shared_Console/HarnessAgentRunner.cs

@@ -192,6 +192,11 @@ public sealed class HarnessAgentRunner : IDisposable
                         }
                     }
 
+                    foreach (var observer in this._observers)
+                    {
+                        await observer.OnResponseUpdateAsync(this._ux, update, this._agent, this._session).ConfigureAwait(false);
+                    }
+
                     if (!string.IsNullOrEmpty(update.Text))
                     {
                         foreach (var observer in this._observers)

dotnet/samples/02-agents/Harness/Harness_Shared_Console/Observers/ConsoleObserver.cs

@@ -24,6 +24,17 @@ public abstract class ConsoleObserver
     {
     }
 
+    /// <summary>
+    /// Called for each <see cref="AgentResponseUpdate"/> in the response stream, regardless of
+    /// whether it contains content. Override to inspect update-level metadata such as
+    /// <see cref="AgentResponseUpdate.RawRepresentation"/> for provider-specific events.
+    /// </summary>
+    /// <param name="ux">The UX state driver, used for rendering output.</param>
+    /// <param name="update">The streaming response update.</param>
+    /// <param name="agent">The agent being interacted with.</param>
+    /// <param name="session">The current agent session.</param>
+    public virtual Task OnResponseUpdateAsync(IUXStateDriver ux, AgentResponseUpdate update, AIAgent agent, AgentSession session) => Task.CompletedTask;
+
     /// <summary>
     /// Called for each <see cref="AIContent"/> item in the response stream.
     /// </summary>

dotnet/samples/02-agents/Harness/Harness_Shared_Console_OpenAI/Harness_Shared_Console_OpenAI.csproj

@@ -0,0 +1,19 @@
+<Project Sdk="Microsoft.NET.Sdk">
+
+  <PropertyGroup>
+    <TargetFrameworks>net10.0</TargetFrameworks>
+
+    <Nullable>enable</Nullable>
+    <ImplicitUsings>enable</ImplicitUsings>
+  </PropertyGroup>
+
+  <ItemGroup>
+    <PackageReference Include="OpenAI" />
+    <PackageReference Include="Microsoft.Extensions.AI" />
+  </ItemGroup>
+
+  <ItemGroup>
+    <ProjectReference Include="..\Harness_Shared_Console\Harness_Shared_Console.csproj" />
+  </ItemGroup>
+
+</Project>

dotnet/samples/02-agents/Harness/Harness_Shared_Console_OpenAI/OpenAIResponsesErrorObserver.cs

@@ -0,0 +1,61 @@
+// Copyright (c) Microsoft. All rights reserved.
+
+#pragma warning disable OPENAI001 // Suppress experimental API warnings for Responses API usage.
+
+using Harness.Shared.Console.Observers;
+using Microsoft.Agents.AI;
+using Microsoft.Extensions.AI;
+using OpenAI.Responses;
+
+namespace Harness.Shared.Console.OpenAI;
+
+/// <summary>
+/// Detects and displays error/incomplete status from OpenAI Responses API streaming updates.
+/// Handles <see cref="StreamingResponseFailedUpdate"/> and <see cref="StreamingResponseIncompleteUpdate"/>
+/// which are not surfaced as <see cref="ErrorContent"/> by the chat client.
+/// </summary>
+/// <remarks>
+/// Note: <see cref="StreamingResponseErrorUpdate"/> is already handled by the SDK — it produces
+/// an <see cref="ErrorContent"/> which is displayed by <see cref="ErrorDisplayObserver"/>.
+/// This observer covers the cases where the SDK does not produce <see cref="ErrorContent"/>.
+/// </remarks>
+public sealed class OpenAIResponsesErrorObserver : ConsoleObserver
+{
+    /// <inheritdoc/>
+    public override async Task OnResponseUpdateAsync(IUXStateDriver ux, AgentResponseUpdate update, AIAgent agent, AgentSession session)
+    {
+        // AgentResponseUpdate.RawRepresentation is the ChatResponseUpdate,
+        // whose RawRepresentation is the underlying StreamingResponseUpdate.
+        object? rawUpdate = (update.RawRepresentation as ChatResponseUpdate)?.RawRepresentation
+            ?? update.RawRepresentation;
+
+        switch (rawUpdate)
+        {
+            case StreamingResponseFailedUpdate failedUpdate:
+                // Only display if the response has error details populated.
+                // When error is null, a follow-up StreamingResponseErrorUpdate typically
+                // carries the real error — the SDK surfaces that as ErrorContent,
+                // which is displayed by ErrorDisplayObserver.
+                if (failedUpdate.Response?.Error is { } error)
+                {
+                    string errorMessage = error.Message ?? "Unknown error";
+                    string? errorCode = error.Code.ToString();
+                    string errorText = $"❌ Response failed: {errorMessage}";
+                    if (!string.IsNullOrEmpty(errorCode))
+                    {
+                        errorText += $" (code: {errorCode})";
+                    }
+
+                    await ux.WriteInfoLineAsync(errorText, ConsoleColor.Red);
+                }
+
+                break;
+
+            case StreamingResponseIncompleteUpdate incompleteUpdate:
+                string? reason = incompleteUpdate.Response?.IncompleteStatusDetails?.Reason?.ToString();
+                string incompleteText = $"⚠️ Response incomplete: {reason ?? "unknown reason"}";
+                await ux.WriteInfoLineAsync(incompleteText, ConsoleColor.Yellow);
+                break;
+        }
+    }
+}

dotnet/samples/02-agents/Harness/Harness_Shared_Console_OpenAI/OpenAIResponsesWebSearchDisplayObserver.cs

@@ -3,19 +3,18 @@
 #pragma warning disable OPENAI001 // Suppress experimental API warnings for Responses API usage.
 
 using System.Text;
-using Harness.Shared.Console;
 using Harness.Shared.Console.Observers;
 using Microsoft.Agents.AI;
 using Microsoft.Extensions.AI;
 using OpenAI.Responses;
 
-namespace SampleApp;
+namespace Harness.Shared.Console.OpenAI;
 
 /// <summary>
 /// Displays web search activity in the scroll area. Shows search queries,
 /// page opens, and find-in-page actions as they stream in from the API.
 /// </summary>
-internal sealed class OpenAIResponsesWebSearchDisplayObserver : ConsoleObserver
+public sealed class OpenAIResponsesWebSearchDisplayObserver : ConsoleObserver
 {
     private const int MaxQueryDisplayLength = 120;
 

dotnet/samples/02-agents/Harness/Harness_Step01_Research/Harness_Step01_Research.csproj

@@ -16,6 +16,7 @@
     <ProjectReference Include="..\..\..\..\src\Microsoft.Agents.AI.Foundry\Microsoft.Agents.AI.Foundry.csproj" />
     <ProjectReference Include="..\..\..\..\src\Microsoft.Agents.AI.Harness\Microsoft.Agents.AI.Harness.csproj" />
     <ProjectReference Include="..\Harness_Shared_Console\Harness_Shared_Console.csproj" />
+    <ProjectReference Include="..\Harness_Shared_Console_OpenAI\Harness_Shared_Console_OpenAI.csproj" />
   </ItemGroup>
 
 </Project>

dotnet/samples/02-agents/Harness/Harness_Step01_Research/Program.cs

@@ -19,6 +19,7 @@ using System.ClientModel.Primitives;
 using Azure.AI.Projects;
 using Azure.Identity;
 using Harness.Shared.Console;
+using Harness.Shared.Console.OpenAI;
 using Harness.Shared.Console.ToolFormatters;
 using Microsoft.Agents.AI;
 using Microsoft.Extensions.AI;
@@ -107,6 +108,7 @@ await HarnessConsole.RunAgentAsync(
     {
         Observers = [
             new OpenAIResponsesWebSearchDisplayObserver(),
+            new OpenAIResponsesErrorObserver(),
             .. HarnessConsoleOptions.BuildObserversWithPlanning(
                 agent,
                 planModeName: "plan",

dotnet/samples/02-agents/Harness/Harness_Step02_Research_WithBackgroundAgents/Harness_Step02_Research_WithBackgroundAgents.csproj

@@ -16,6 +16,7 @@
     <ProjectReference Include="..\..\..\..\src\Microsoft.Agents.AI.Foundry\Microsoft.Agents.AI.Foundry.csproj" />
     <ProjectReference Include="..\..\..\..\src\Microsoft.Agents.AI.Harness\Microsoft.Agents.AI.Harness.csproj" />
     <ProjectReference Include="..\Harness_Shared_Console\Harness_Shared_Console.csproj" />
+    <ProjectReference Include="..\Harness_Shared_Console_OpenAI\Harness_Shared_Console_OpenAI.csproj" />
   </ItemGroup>
 
 </Project>

dotnet/samples/02-agents/Harness/Harness_Step02_Research_WithBackgroundAgents/Program.cs

@@ -16,6 +16,7 @@ using System.ClientModel.Primitives;
 using Azure.AI.Projects;
 using Azure.Identity;
 using Harness.Shared.Console;
+using Harness.Shared.Console.OpenAI;
 using Microsoft.Agents.AI;
 using Microsoft.Extensions.AI;
 
@@ -102,10 +103,7 @@ AIAgent parentAgent =
         DisableFileAccess = true,   // If enabled, this would allow the agent to read/write files in a working directory
         DisableToolApproval = true, // If enabled, this allows don't-ask-again approval functionality.
         DisableWebSearch = true,
-        AIContextProviders =
-        [
-            new BackgroundAgentsProvider([webSearchAgent]),
-        ],
+        BackgroundAgents = [webSearchAgent],
         ChatOptions = new ChatOptions
         {
             Instructions = parentInstructions,
@@ -116,4 +114,8 @@ AIAgent parentAgent =
 // Run the interactive console session.
 await HarnessConsole.RunAgentAsync(
     parentAgent,
-    userPrompt: "Enter a list of stock tickers (e.g., BAC, MSFT, BA):");
+    userPrompt: "Enter a list of stock tickers (e.g., BAC, MSFT, BA):",
+    options: new HarnessConsoleOptions
+    {
+        Observers = [new OpenAIResponsesErrorObserver(), .. HarnessConsoleOptions.BuildDefaultObservers()],
+    });

dotnet/src/Microsoft.Agents.AI.Foundry.Hosting/HostedAgentUserAgentPolicy.cs

@@ -1,5 +1,6 @@
 // Copyright (c) Microsoft. All rights reserved.
 
+using System;
 using System.ClientModel.Primitives;
 using System.Collections.Generic;
 using System.Reflection;
@@ -9,8 +10,11 @@ using Microsoft.Extensions.AI;
 namespace Microsoft.Agents.AI.Foundry.Hosting;
 
 /// <summary>
-/// Pipeline policy that appends the hosted-agent <c>User-Agent</c> segment
-/// (e.g. <c>"foundry-hosting/agent-framework-dotnet/{version}"</c>) to outgoing requests.
+/// Pipeline policy that emits the hosted-agent <c>User-Agent</c> segment
+/// (<c>"foundry-hosting/agent-framework-dotnet/{version}"</c>), matching Python's hosted
+/// contract (<c>foundry-hosting/agent-framework-python/{version}</c>, see
+/// <c>python/packages/core/agent_framework/_telemetry.py</c>: the hosted prefix is joined
+/// with the base agent-framework segment into a single combined User-Agent value).
 /// </summary>
 /// <remarks>
 /// <para>
@@ -19,6 +23,12 @@ namespace Microsoft.Agents.AI.Foundry.Hosting;
 /// is already present in the <c>User-Agent</c> header, the policy does not append it again.
 /// </para>
 /// <para>
+/// When a bare <c>agent-framework-dotnet/{version}</c> segment is already present (stamped by
+/// the framework-wide <c>AgentFrameworkUserAgentPolicy</c> registered by
+/// <c>FoundryChatClient</c>), this policy <em>replaces</em> that segment with the combined
+/// hosted form so the wire never carries both forms simultaneously, preserving Python parity.
+/// </para>
+/// <para>
 /// This policy is added at hosted-agent resolution time via the MEAI 10.5.1
 /// <see cref="OpenAIRequestPolicies"/> hook on the agent's underlying chat client. It is only
 /// registered when an agent is resolved by the Foundry hosting layer.
@@ -30,6 +40,12 @@ internal sealed class HostedAgentUserAgentPolicy : PipelinePolicy
 
     private static readonly string s_supplementValue = CreateSupplementValue();
 
+    /// <summary>Bare segment stamped by <c>AgentFrameworkUserAgentPolicy</c> in the non-hosted scenario; this policy upgrades it in-place when both run.</summary>
+    private const string BareAgentFrameworkPrefix = "agent-framework-dotnet/";
+
+    /// <summary>Combined hosted segment that this policy emits. Recognized in-place so callers whose pipelines already carry a (possibly different-version) combined segment get it replaced rather than double-prefixed (Q-D fix).</summary>
+    private const string CombinedHostedPrefix = "foundry-hosting/agent-framework-dotnet/";
+
     public override void Process(PipelineMessage message, IReadOnlyList<PipelinePolicy> pipeline, int currentIndex)
     {
         AppendHeader(message);
@@ -46,13 +62,52 @@ internal sealed class HostedAgentUserAgentPolicy : PipelinePolicy
     {
         if (message.Request.Headers.TryGetValue("User-Agent", out var existing) && !string.IsNullOrEmpty(existing))
         {
-            // Guard against double-append on retries or when the policy
-            // is registered on multiple pipeline positions.
-            if (existing.Contains(s_supplementValue))
+            // Guard against double-append on retries or when the policy is registered on
+            // multiple pipeline positions.
+            if (existing!.Contains(s_supplementValue))
             {
                 return;
             }
 
+            // Combined-form check first: if the caller's pipeline already has
+            // `foundry-hosting/agent-framework-dotnet/{version}` (with a version that differs
+            // from ours — otherwise the .Contains above would have returned early), replace the
+            // entire combined span in place. Without this, the bare-prefix search below would
+            // match `agent-framework-dotnet/` *inside* the combined segment and produce a
+            // malformed `foundry-hosting/foundry-hosting/agent-framework-dotnet/...` value.
+            var combinedIdx = existing.IndexOf(CombinedHostedPrefix, StringComparison.Ordinal);
+            if (combinedIdx >= 0)
+            {
+                var combinedEnd = existing.IndexOf(' ', combinedIdx);
+                if (combinedEnd < 0)
+                {
+                    combinedEnd = existing.Length;
+                }
+
+                var replacedCombined = string.Concat(existing.AsSpan(0, combinedIdx), s_supplementValue.AsSpan(), existing.AsSpan(combinedEnd));
+                message.Request.Headers.Set("User-Agent", replacedCombined);
+                return;
+            }
+
+            // If the bare agent-framework segment is present (stamped by
+            // AgentFrameworkUserAgentPolicy when not hosted), upgrade it in place to the
+            // combined hosted form so the wire never carries both segments simultaneously.
+            // Mirrors Python where get_user_agent() returns a single combined string when the
+            // hosted prefix is registered.
+            var idx = existing.IndexOf(BareAgentFrameworkPrefix, StringComparison.Ordinal);
+            if (idx >= 0)
+            {
+                var end = existing.IndexOf(' ', idx);
+                if (end < 0)
+                {
+                    end = existing.Length;
+                }
+
+                var replaced = string.Concat(existing.AsSpan(0, idx), s_supplementValue.AsSpan(), existing.AsSpan(end));
+                message.Request.Headers.Set("User-Agent", replaced);
+                return;
+            }
+
             message.Request.Headers.Set("User-Agent", $"{existing} {s_supplementValue}");
         }
         else

dotnet/src/Microsoft.Agents.AI.Foundry/AIProjectClientExtensions.cs

@@ -23,7 +23,7 @@ namespace Azure.AI.Projects;
 /// Provides extension methods for <see cref="AIProjectClient"/>.
 /// </summary>
 [Experimental(DiagnosticIds.Experiments.AIOpenAIResponses)]
-public static partial class AzureAIProjectChatClientExtensions
+public static partial class AIProjectClientExtensions
 {
     /// <summary>
     /// Uses an existing server side agent, wrapped as a <see cref="ChatClientAgent"/> using the provided <see cref="AIProjectClient"/> and <see cref="AgentReference"/>.
@@ -63,7 +63,7 @@ public static partial class AzureAIProjectChatClientExtensions
             clientFactory,
             services);
 
-        return new FoundryAgent(aiProjectClient, innerAgent);
+        return new FoundryAgent(innerAgent);
     }
 
     /// <summary>
@@ -132,7 +132,7 @@ public static partial class AzureAIProjectChatClientExtensions
             !allowDeclarativeMode,
             services);
 
-        return new FoundryAgent(aiProjectClient, innerAgent);
+        return new FoundryAgent(innerAgent);
     }
 
     /// <summary>
@@ -165,7 +165,7 @@ public static partial class AzureAIProjectChatClientExtensions
             !allowDeclarativeMode,
             services);
 
-        return new FoundryAgent(aiProjectClient, innerAgent);
+        return new FoundryAgent(innerAgent);
     }
 
     /// <summary>
@@ -246,7 +246,7 @@ public static partial class AzureAIProjectChatClientExtensions
         Func<IChatClient, IChatClient>? clientFactory,
         IServiceProvider? services)
     {
-        IChatClient chatClient = new AzureAIProjectChatClient(aiProjectClient, agentVersion, agentOptions.ChatOptions);
+        IChatClient chatClient = new FoundryChatClient(aiProjectClient, agentVersion, agentOptions.ChatOptions);
 
         if (clientFactory is not null)
         {
@@ -268,10 +268,7 @@ public static partial class AzureAIProjectChatClientExtensions
         Throw.IfNull(agentOptions.ChatOptions);
         Throw.IfNullOrWhitespace(agentOptions.ChatOptions.ModelId);
 
-        IChatClient chatClient = aiProjectClient
-            .GetProjectOpenAIClient()
-            .GetResponsesClient()
-            .AsIChatClient(agentOptions.ChatOptions.ModelId);
+        IChatClient chatClient = new FoundryChatClient(aiProjectClient, agentOptions.ChatOptions.ModelId);
 
         if (clientFactory is not null)
         {
@@ -298,7 +295,7 @@ public static partial class AzureAIProjectChatClientExtensions
         Func<IChatClient, IChatClient>? clientFactory,
         IServiceProvider? services)
     {
-        IChatClient chatClient = new AzureAIProjectChatClient(aiProjectClient, agentRecord, agentOptions.ChatOptions);
+        IChatClient chatClient = new FoundryChatClient(aiProjectClient, agentRecord, agentOptions.ChatOptions);
 
         if (clientFactory is not null)
         {
@@ -316,7 +313,7 @@ public static partial class AzureAIProjectChatClientExtensions
         Func<IChatClient, IChatClient>? clientFactory,
         IServiceProvider? services)
     {
-        IChatClient chatClient = new AzureAIProjectChatClient(aiProjectClient, agentReference, defaultModelId: null, agentOptions.ChatOptions);
+        IChatClient chatClient = new FoundryChatClient(aiProjectClient, agentReference, defaultModelId: null, agentOptions.ChatOptions);
 
         if (clientFactory is not null)
         {

dotnet/src/Microsoft.Agents.AI.Foundry/AgentFrameworkUserAgentPolicy.cs

@@ -0,0 +1,88 @@
+// Copyright (c) Microsoft. All rights reserved.
+
+using System.ClientModel.Primitives;
+using System.Collections.Generic;
+using System.Reflection;
+using System.Threading.Tasks;
+
+namespace Microsoft.Agents.AI.Foundry;
+
+/// <summary>
+/// Framework-wide pipeline policy that appends the <c>agent-framework-dotnet/{version}</c>
+/// segment to outgoing <c>User-Agent</c> headers, mirroring the
+/// <c>agent-framework-python/{version}</c> contract used by every Python provider package.
+/// </summary>
+/// <remarks>
+/// <para>
+/// The segment value is computed once from the <c>Microsoft.Agents.AI.Foundry</c> assembly's
+/// <see cref="AssemblyInformationalVersionAttribute"/>. The policy is idempotent on retries: if
+/// the segment is already present in the <c>User-Agent</c> header, the policy does not append
+/// it again.
+/// </para>
+/// <para>
+/// The policy is registered by <c>FoundryChatClient</c> on the underlying chat client's
+/// <c>OpenAIRequestPolicies</c> hook so every outbound Foundry call carries the segment. The
+/// policy is currently colocated with the Foundry package; it is expected to migrate to a
+/// framework-wide location (such as <c>Microsoft.Agents.AI</c>) once another provider package
+/// adopts the same User-Agent contract.
+/// </para>
+/// </remarks>
+internal sealed class AgentFrameworkUserAgentPolicy : PipelinePolicy
+{
+    /// <summary>Gets the singleton policy instance.</summary>
+    public static AgentFrameworkUserAgentPolicy Instance { get; } = new AgentFrameworkUserAgentPolicy();
+
+    private static readonly string s_segmentValue = CreateSegmentValue();
+
+    public override void Process(PipelineMessage message, IReadOnlyList<PipelinePolicy> pipeline, int currentIndex)
+    {
+        AppendHeader(message);
+        ProcessNext(message, pipeline, currentIndex);
+    }
+
+    public override async ValueTask ProcessAsync(PipelineMessage message, IReadOnlyList<PipelinePolicy> pipeline, int currentIndex)
+    {
+        AppendHeader(message);
+        await ProcessNextAsync(message, pipeline, currentIndex).ConfigureAwait(false);
+    }
+
+    private static void AppendHeader(PipelineMessage message)
+    {
+        if (message.Request.Headers.TryGetValue("User-Agent", out var existing) && !string.IsNullOrEmpty(existing))
+        {
+            // Guard against double-append on retries or when the policy
+            // is registered on multiple pipeline positions.
+            if (existing!.Contains(s_segmentValue))
+            {
+                return;
+            }
+
+            message.Request.Headers.Set("User-Agent", $"{existing} {s_segmentValue}");
+        }
+        else
+        {
+            message.Request.Headers.Set("User-Agent", s_segmentValue);
+        }
+    }
+
+    private static string CreateSegmentValue()
+    {
+        const string Name = "agent-framework-dotnet";
+
+        if (typeof(AgentFrameworkUserAgentPolicy).Assembly.GetCustomAttribute<AssemblyInformationalVersionAttribute>()?.InformationalVersion is string version)
+        {
+            int pos = version.IndexOf('+');
+            if (pos >= 0)
+            {
+                version = version.Substring(0, pos);
+            }
+
+            if (version.Length > 0)
+            {
+                return $"{Name}/{version}";
+            }
+        }
+
+        return Name;
+    }
+}

dotnet/src/Microsoft.Agents.AI.Foundry/AzureAIProjectChatClient.cs

@@ -1,165 +0,0 @@
-// Copyright (c) Microsoft. All rights reserved.
-
-using System;
-using System.Collections.Generic;
-using System.Diagnostics.CodeAnalysis;
-using System.Runtime.CompilerServices;
-using System.Threading;
-using System.Threading.Tasks;
-using Azure.AI.Extensions.OpenAI;
-using Azure.AI.Projects;
-using Azure.AI.Projects.Agents;
-using Microsoft.Extensions.AI;
-using Microsoft.Shared.DiagnosticIds;
-using Microsoft.Shared.Diagnostics;
-using OpenAI.Responses;
-
-namespace Microsoft.Agents.AI.Foundry;
-
-/// <summary>
-/// Provides a chat client implementation that integrates with Azure AI Agents, enabling chat interactions using
-/// Azure-specific agent capabilities.
-/// </summary>
-[Experimental(DiagnosticIds.Experiments.AIOpenAIResponses)]
-internal sealed class AzureAIProjectChatClient : DelegatingChatClient
-{
-    private readonly ChatClientMetadata? _metadata;
-    private readonly AIProjectClient _agentClient;
-    private readonly ProjectsAgentVersion? _agentVersion;
-    private readonly ProjectsAgentRecord? _agentRecord;
-    private readonly ChatOptions? _chatOptions;
-    private readonly AgentReference _agentReference;
-
-    /// <summary>
-    /// Initializes a new instance of the <see cref="AzureAIProjectChatClient"/> class.
-    /// </summary>
-    /// <param name="aiProjectClient">An instance of <see cref="AIProjectClient"/> to interact with Azure AI Agents services.</param>
-    /// <param name="agentReference">An instance of <see cref="AgentReference"/> representing the specific agent to use.</param>
-    /// <param name="defaultModelId">The default model to use for the agent, if applicable.</param>
-    /// <param name="chatOptions">An instance of <see cref="ChatOptions"/> representing the options on how the agent was predefined.</param>
-    /// <remarks>
-    /// The <see cref="IChatClient"/> provided should be decorated with a <see cref="AzureAIProjectChatClient"/> for proper functionality.
-    /// </remarks>
-    internal AzureAIProjectChatClient(AIProjectClient aiProjectClient, AgentReference agentReference, string? defaultModelId, ChatOptions? chatOptions)
-        : base(Throw.IfNull(aiProjectClient)
-            .GetProjectOpenAIClient()
-            .GetProjectResponsesClientForAgent(agentReference)
-            .AsIChatClient())
-    {
-        this._agentClient = aiProjectClient;
-        this._agentReference = Throw.IfNull(agentReference);
-        this._metadata = new ChatClientMetadata("microsoft.foundry", defaultModelId: defaultModelId);
-        this._chatOptions = chatOptions;
-    }
-
-    /// <summary>
-    /// Initializes a new instance of the <see cref="AzureAIProjectChatClient"/> class.
-    /// </summary>
-    /// <param name="aiProjectClient">An instance of <see cref="AIProjectClient"/> to interact with Azure AI Agents services.</param>
-    /// <param name="agentRecord">An instance of <see cref="ProjectsAgentRecord"/> representing the specific agent to use.</param>
-    /// <param name="chatOptions">An instance of <see cref="ChatOptions"/> representing the options on how the agent was predefined.</param>
-    /// <remarks>
-    /// The <see cref="IChatClient"/> provided should be decorated with a <see cref="AzureAIProjectChatClient"/> for proper functionality.
-    /// </remarks>
-    internal AzureAIProjectChatClient(AIProjectClient aiProjectClient, ProjectsAgentRecord agentRecord, ChatOptions? chatOptions)
-        : this(aiProjectClient, Throw.IfNull(agentRecord).GetLatestVersion(), chatOptions)
-    {
-        this._agentRecord = agentRecord;
-    }
-
-    internal AzureAIProjectChatClient(AIProjectClient aiProjectClient, ProjectsAgentVersion agentVersion, ChatOptions? chatOptions)
-        : this(
-              aiProjectClient,
-              CreateAgentReference(Throw.IfNull(agentVersion)),
-              (agentVersion.Definition as DeclarativeAgentDefinition)?.Model,
-              chatOptions)
-    {
-        this._agentVersion = agentVersion;
-    }
-
-    /// <summary>
-    /// Creates an <see cref="AgentReference"/> from an <see cref="ProjectsAgentVersion"/>.
-    /// Uses the agent version's version if available, otherwise defaults to "latest".
-    /// </summary>
-    /// <param name="agentVersion">The agent version to create a reference from.</param>
-    /// <returns>An <see cref="AgentReference"/> for the specified agent version.</returns>
-    private static AgentReference CreateAgentReference(ProjectsAgentVersion agentVersion)
-    {
-        // If the version is null, empty, or whitespace, use "latest" as the default.
-        // This handles cases where hosted agents (like MCP agents) may not have a version assigned.
-        var version = string.IsNullOrWhiteSpace(agentVersion.Version) ? "latest" : agentVersion.Version;
-        return new AgentReference(agentVersion.Name, version);
-    }
-
-    /// <inheritdoc/>
-    public override object? GetService(Type serviceType, object? serviceKey = null)
-    {
-        return (serviceKey is null && serviceType == typeof(ChatClientMetadata))
-            ? this._metadata
-            : (serviceKey is null && serviceType == typeof(AIProjectClient))
-            ? this._agentClient
-            : (serviceKey is null && serviceType == typeof(ProjectsAgentVersion))
-            ? this._agentVersion
-            : (serviceKey is null && serviceType == typeof(ProjectsAgentRecord))
-            ? this._agentRecord
-            : (serviceKey is null && serviceType == typeof(AgentReference))
-            ? this._agentReference
-            : base.GetService(serviceType, serviceKey);
-    }
-
-    /// <inheritdoc/>
-    public override async Task<ChatResponse> GetResponseAsync(IEnumerable<ChatMessage> messages, ChatOptions? options = null, CancellationToken cancellationToken = default)
-    {
-        var agentOptions = this.GetAgentEnabledChatOptions(options);
-
-        return await base.GetResponseAsync(messages, agentOptions, cancellationToken).ConfigureAwait(false);
-    }
-
-    /// <inheritdoc/>
-    public override async IAsyncEnumerable<ChatResponseUpdate> GetStreamingResponseAsync(IEnumerable<ChatMessage> messages, ChatOptions? options = null, [EnumeratorCancellation] CancellationToken cancellationToken = default)
-    {
-        var agentOptions = this.GetAgentEnabledChatOptions(options);
-
-        await foreach (var chunk in base.GetStreamingResponseAsync(messages, agentOptions, cancellationToken).ConfigureAwait(false))
-        {
-            yield return chunk;
-        }
-    }
-
-    private ChatOptions GetAgentEnabledChatOptions(ChatOptions? options)
-    {
-        // Start with a clone of the base chat options defined for the agent, if any.
-        ChatOptions agentEnabledChatOptions = this._chatOptions?.Clone() ?? new();
-
-        // Ignore per-request all options that can't be overridden.
-        agentEnabledChatOptions.Instructions = null;
-        agentEnabledChatOptions.Tools = null;
-        agentEnabledChatOptions.Temperature = null;
-        agentEnabledChatOptions.TopP = null;
-        agentEnabledChatOptions.PresencePenalty = null;
-        agentEnabledChatOptions.ResponseFormat = null;
-
-        // Use the conversation from the request, or the one defined at the client level.
-        agentEnabledChatOptions.ConversationId = options?.ConversationId ?? this._chatOptions?.ConversationId;
-
-        // Preserve the original RawRepresentationFactory
-        var originalFactory = options?.RawRepresentationFactory;
-
-        agentEnabledChatOptions.RawRepresentationFactory = (client) =>
-        {
-            if (originalFactory?.Invoke(this) is not CreateResponseOptions responseCreationOptions)
-            {
-                responseCreationOptions = new CreateResponseOptions();
-            }
-
-            responseCreationOptions.Agent = this._agentReference;
-#pragma warning disable SCME0001 // Type is for evaluation purposes only and is subject to change or removal in future updates. Suppress this diagnostic to proceed.
-            responseCreationOptions.Patch.Remove("$.model"u8);
-#pragma warning restore SCME0001 // Type is for evaluation purposes only and is subject to change or removal in future updates. Suppress this diagnostic to proceed.
-
-            return responseCreationOptions;
-        };
-
-        return agentEnabledChatOptions;
-    }
-}

dotnet/src/Microsoft.Agents.AI.Foundry/AzureAIProjectResponsesChatClient.cs

@@ -1,35 +0,0 @@
-// Copyright (c) Microsoft. All rights reserved.
-
-using System;
-using Azure.AI.Projects;
-using Microsoft.Extensions.AI;
-using Microsoft.Shared.Diagnostics;
-
-namespace Microsoft.Agents.AI.Foundry;
-
-#pragma warning disable OPENAI001
-internal sealed class AzureAIProjectResponsesChatClient : DelegatingChatClient
-{
-    private readonly ChatClientMetadata _metadata;
-    private readonly AIProjectClient _aiProjectClient;
-
-    internal AzureAIProjectResponsesChatClient(AIProjectClient aiProjectClient, string defaultModelId)
-        : base(Throw.IfNull(aiProjectClient)
-            .GetProjectOpenAIClient()
-            .GetProjectResponsesClientForModel(Throw.IfNullOrWhitespace(defaultModelId))
-            .AsIChatClient())
-    {
-        this._aiProjectClient = aiProjectClient;
-        this._metadata = new ChatClientMetadata("microsoft.foundry", defaultModelId: defaultModelId);
-    }
-
-    public override object? GetService(Type serviceType, object? serviceKey = null)
-    {
-        return (serviceKey is null && serviceType == typeof(ChatClientMetadata))
-            ? this._metadata
-            : (serviceKey is null && serviceType == typeof(AIProjectClient))
-            ? this._aiProjectClient
-            : base.GetService(serviceType, serviceKey);
-    }
-}
-#pragma warning restore OPENAI001

dotnet/src/Microsoft.Agents.AI.Foundry/ChatClientAgentFoundryExtensions.cs

@@ -0,0 +1,42 @@
+// Copyright (c) Microsoft. All rights reserved.
+
+using System;
+using System.Diagnostics.CodeAnalysis;
+using System.Threading;
+using System.Threading.Tasks;
+using Azure.AI.Extensions.OpenAI;
+using Azure.AI.Projects.Agents;
+using Microsoft.Extensions.AI;
+using Microsoft.Shared.DiagnosticIds;
+using Microsoft.Shared.Diagnostics;
+
+namespace Microsoft.Agents.AI.Foundry;
+
+/// <summary>
+/// Foundry-specific extensions on <see cref="ChatClientAgent"/>. Mirrors Python's free
+/// <c>to_prompt_agent(agent)</c> function for agents whose underlying chat client is a
+/// <see cref="FoundryChatClient"/>.
+/// </summary>
+[Experimental(DiagnosticIds.Experiments.AIOpenAIResponses)]
+public static class ChatClientAgentFoundryExtensions
+{
+    /// <summary>
+    /// Converts the supplied agent into a <see cref="ProjectsAgentDefinition"/> ready to publish
+    /// via <c>AgentAdministrationClient.CreateAgentVersionAsync</c>.
+    /// </summary>
+    /// <remarks>
+    /// Only works on agents whose chat client is a <see cref="FoundryChatClient"/> and whose
+    /// construction mode is convertible. The Agent Endpoint construction mode (Mode 3) is not
+    /// convertible because no local definition exists; conversion in that case throws.
+    /// </remarks>
+    /// <param name="agent">The chat client agent to convert.</param>
+    /// <param name="cancellationToken">A token that can cancel an internal server-side fetch when the agent was constructed from a bare <see cref="AgentReference"/>.</param>
+    /// <returns>A <see cref="ProjectsAgentDefinition"/> suitable for publishing.</returns>
+    /// <exception cref="ArgumentNullException"><paramref name="agent"/> is <see langword="null"/>.</exception>
+    /// <exception cref="InvalidOperationException">The agent's chat client is not a <see cref="FoundryChatClient"/>; the agent was constructed via the Agent Endpoint mode (Mode 3); no model id is set on the agent's <see cref="ChatOptions"/> for the Responses Agent mode (Mode 1); or the agent contains an <see cref="AITool"/> that cannot be converted to a <c>ResponseTool</c>.</exception>
+    public static Task<ProjectsAgentDefinition> ToPromptAgentAsync(this ChatClientAgent agent, CancellationToken cancellationToken = default)
+    {
+        Throw.IfNull(agent);
+        return FoundryPromptAgentConverter.ConvertAsync(agent.ChatClient, agent.GetService<ChatOptions>(), cancellationToken);
+    }
+}

dotnet/src/Microsoft.Agents.AI.Foundry/FoundryAgent.cs

@@ -39,11 +39,6 @@ namespace Microsoft.Agents.AI.Foundry;
 [Experimental(DiagnosticIds.Experiments.AIOpenAIResponses)]
 public sealed class FoundryAgent : DelegatingAIAgent
 {
-    /// <summary>
-    /// The cached <see cref="AIProjectClient"/> supplied to or constructed by the active constructor.
-    /// </summary>
-    private readonly AIProjectClient _aiProjectClient;
-
     /// <summary>
     /// Initializes a new instance of the <see cref="FoundryAgent"/> class using the direct Responses API path.
     /// </summary>
@@ -73,9 +68,8 @@ public sealed class FoundryAgent : DelegatingAIAgent
         : base(CreateInnerAgent(
             CreateProjectClient(projectEndpoint, credential, clientOptions),
             model, instructions, name, description, tools, clientFactory, loggerFactory, services,
-            out var aiProjectClient))
+            out _))
     {
-        this._aiProjectClient = aiProjectClient;
     }
 
     /// <summary>
@@ -87,9 +81,11 @@ public sealed class FoundryAgent : DelegatingAIAgent
     /// </param>
     /// <param name="credential">The authentication credential.</param>
     /// <param name="clientOptions">
-    /// Optional configuration for the underlying <see cref="ProjectResponsesClient"/>. When supplied:
+    /// Optional configuration for the underlying <see cref="ProjectOpenAIClient"/>. When supplied:
     /// <list type="bullet">
     ///   <item><description>The instance is passed through to the per-agent client; pipeline policies added via <c>AddPolicy(...)</c> on it execute on the per-agent traffic.</description></item>
+    ///   <item><description><c>Endpoint</c> and <see cref="ProjectOpenAIClientOptions.AgentName"/> are owned by this constructor and are overwritten with values derived from <paramref name="agentEndpoint"/>; any caller value is replaced.</description></item>
+    ///   <item><description>For the project-level conversations client a separate fresh options bag is built that copies only <see cref="ClientPipelineOptions.RetryPolicy"/>, <see cref="ClientPipelineOptions.NetworkTimeout"/>, <see cref="ClientPipelineOptions.Transport"/>, and <c>UserAgentApplicationId</c>; pipeline policies added via <c>AddPolicy(...)</c> do <strong>not</strong> propagate to the conversations pipeline.</description></item>
     /// </list>
     /// </param>
     /// <param name="tools">Optional tools to use when interacting with the agent.</param>
@@ -113,43 +109,37 @@ public sealed class FoundryAgent : DelegatingAIAgent
         IList<AITool>? tools = null,
         Func<IChatClient, IChatClient>? clientFactory = null,
         IServiceProvider? services = null)
-        : base(CreateInnerAgentFromAgentEndpoint(agentEndpoint, credential, clientOptions, tools, clientFactory, services, out var aiProjectClient))
+        : base(CreateInnerAgentFromAgentEndpoint(agentEndpoint, credential, clientOptions, tools, clientFactory, services))
     {
-        this._aiProjectClient = aiProjectClient;
     }
 
     /// <summary>
-    /// Initializes a new instance of the <see cref="FoundryAgent"/> class from an agent-specific
-    /// endpoint while reusing an existing <see cref="AIProjectClient"/>.
+    /// Internal constructor used by the <c>AsAIAgent(this AIProjectClient, Uri, ...)</c>
+    /// extension where the caller already has an <see cref="AIProjectClient"/> and the agent
+    /// endpoint URI. Reuses the supplied client's pipeline (no new credential or transport is
+    /// stamped) and surfaces the agent through a <see cref="FoundryChatClient"/> just like the
+    /// public agent-endpoint ctor.
     /// </summary>
-    /// <param name="aiProjectClient">An existing <see cref="AIProjectClient"/> rooted at the same project as <paramref name="agentEndpoint"/>.</param>
-    /// <param name="agentEndpoint">
-    /// The agent-specific endpoint URI. Must be of the shape
-    /// <c>https://&lt;host&gt;/.../projects/&lt;project&gt;/agents/&lt;agentName&gt;/endpoint/protocols/openai</c>.
-    /// </param>
-    /// <param name="tools">Optional tools to use when interacting with the agent.</param>
-    /// <param name="clientFactory">Provides a way to customize the creation of the underlying <see cref="IChatClient"/>.</param>
-    /// <param name="services">Optional service provider for resolving dependencies required by AI functions.</param>
-    /// <exception cref="ArgumentNullException"><paramref name="aiProjectClient"/> or <paramref name="agentEndpoint"/> is null.</exception>
-    /// <exception cref="ArgumentException"><paramref name="agentEndpoint"/> does not match the expected agent-endpoint shape.</exception>
     internal FoundryAgent(
         AIProjectClient aiProjectClient,
         Uri agentEndpoint,
         IList<AITool>? tools = null,
         Func<IChatClient, IChatClient>? clientFactory = null,
         IServiceProvider? services = null)
-        : base(BuildAgentEndpointInnerAgent(aiProjectClient, agentEndpoint, clientOptions: null, tools, clientFactory, services))
+        : base(CreateInnerAgentFromAgentEndpointReusingProjectClient(aiProjectClient, agentEndpoint, tools, clientFactory, services))
     {
-        this._aiProjectClient = Throw.IfNull(aiProjectClient);
     }
 
     /// <summary>
-    /// Internal constructor used by <c>AsAIAgent</c> extension methods that already have an <see cref="AIProjectClient"/> and a configured <see cref="ChatClientAgent"/>.
+    /// Internal constructor used by <c>AsAIAgent</c> extension methods that already have a
+    /// configured <see cref="ChatClientAgent"/>. The inner agent already routes through a
+    /// <see cref="FoundryChatClient"/> whose <c>GetService&lt;AIProjectClient&gt;()</c> surfaces
+    /// the project client to downstream callers, so the agent does not also need a private
+    /// <see cref="AIProjectClient"/> reference here.
     /// </summary>
-    internal FoundryAgent(AIProjectClient aiProjectClient, ChatClientAgent innerAgent)
+    internal FoundryAgent(ChatClientAgent innerAgent)
         : base(WireClientHeaders(Throw.IfNull(innerAgent)))
     {
-        this._aiProjectClient = Throw.IfNull(aiProjectClient);
     }
 
     #region Convenience methods
@@ -182,7 +172,13 @@ public sealed class FoundryAgent : DelegatingAIAgent
     /// <returns>A <see cref="ChatClientAgentSession"/> linked to the newly created server-side conversation.</returns>
     public async Task<ChatClientAgentSession> CreateConversationSessionAsync(CancellationToken cancellationToken = default)
     {
-        var conversationsClient = this._aiProjectClient.ProjectOpenAIClient.GetProjectConversationsClient();
+        // The inner FoundryChatClient surfaces an AIProjectClient via GetService for all
+        // three construction modes (Plan #2 Agent Endpoint mode materialization). Resolve it through the
+        // delegating chain at call time instead of caching a private reference on this agent.
+        var aiProjectClient = this.GetService<AIProjectClient>()
+            ?? throw new InvalidOperationException(
+                "FoundryAgent inner chain does not expose an AIProjectClient; cannot create a project-level conversation session.");
+        var conversationsClient = aiProjectClient.GetProjectOpenAIClient().GetProjectConversationsClient();
 
         var conversation = (await conversationsClient.CreateProjectConversationAsync(options: null, cancellationToken).ConfigureAwait(false)).Value;
 
@@ -196,17 +192,6 @@ public sealed class FoundryAgent : DelegatingAIAgent
 
     #endregion
 
-    /// <inheritdoc/>
-    public override object? GetService(Type serviceType, object? serviceKey = null)
-    {
-        if (serviceKey is null && serviceType == typeof(AIProjectClient))
-        {
-            return this._aiProjectClient;
-        }
-
-        return base.GetService(serviceType, serviceKey);
-    }
-
     #region Private helpers
 
     private static AIAgent CreateInnerAgent(
@@ -251,7 +236,7 @@ public sealed class FoundryAgent : DelegatingAIAgent
         Throw.IfNull(agentOptions.ChatOptions);
         Throw.IfNullOrWhitespace(agentOptions.ChatOptions.ModelId);
 
-        IChatClient chatClient = new AzureAIProjectResponsesChatClient(aiProjectClient, agentOptions.ChatOptions.ModelId);
+        IChatClient chatClient = new FoundryChatClient(aiProjectClient, agentOptions.ChatOptions.ModelId);
 
         if (clientFactory is not null)
         {
@@ -288,16 +273,10 @@ public sealed class FoundryAgent : DelegatingAIAgent
     }
 
     /// <summary>
-    /// Builds the inner <see cref="ChatClientAgent"/> for the agent-endpoint constructor by
-    /// constructing a project-scoped <see cref="ProjectOpenAIClient"/> and using
-    /// <see cref="ProjectOpenAIClient.GetProjectResponsesClientForAgentEndpoint(string, string?, ProjectOpenAIClientOptions?)"/>.
-    /// This routes the outbound URL through the per-agent endpoint shape that the Foundry service
-    /// expects for hosted agents and lets the SDK auto-append the <c>api-version</c> query string.
-    /// Caller-supplied <paramref name="clientOptions"/> are passed through to the per-agent
-    /// client with <c>Endpoint</c> and
-    /// <see cref="ProjectOpenAIClientOptions.AgentName"/> overridden by values derived from
-    /// <paramref name="agentEndpoint"/>; any policies the caller added via <c>AddPolicy</c>
-    /// remain in effect on the per-agent pipeline. The MEAI user-agent policy is appended last.
+    /// Builds the inner <see cref="ChatClientAgent"/> for the agent-endpoint constructor. The
+    /// per-agent <see cref="ProjectOpenAIClient"/> shape and URL parsing are owned by
+    /// <see cref="FoundryChatClient"/>; we just construct it in the Agent Endpoint mode (Mode 3)
+    /// and pass the inner chat client through any caller-provided <paramref name="clientFactory"/>.
     /// </summary>
     private static AIAgent CreateInnerAgentFromAgentEndpoint(
         Uri agentEndpoint,
@@ -305,44 +284,14 @@ public sealed class FoundryAgent : DelegatingAIAgent
         ProjectOpenAIClientOptions? clientOptions,
         IList<AITool>? tools,
         Func<IChatClient, IChatClient>? clientFactory,
-        IServiceProvider? services,
-        out AIProjectClient outClient)
+        IServiceProvider? services)
     {
         Throw.IfNull(agentEndpoint);
         Throw.IfNull(credential);
 
-        var (_, projectRoot) = ParseAgentEndpoint(agentEndpoint);
-        outClient = CreateProjectClient(projectRoot, credential, CreateProjectClientOptions(clientOptions));
+        IChatClient chatClient = new FoundryChatClient(agentEndpoint, credential, clientOptions);
+        var agentName = ((FoundryChatClient)chatClient).AgentName!;
 
-        return BuildAgentEndpointInnerAgent(outClient, agentEndpoint, clientOptions, tools, clientFactory, services);
-    }
-
-    /// <summary>
-    /// Builds the inner <see cref="ChatClientAgent"/> for an agent endpoint against a pre-built
-    /// <see cref="AIProjectClient"/>. The caller is responsible for ensuring the supplied client
-    /// is rooted at the same project as <paramref name="agentEndpoint"/>; the agent name is
-    /// parsed from the endpoint URI and passed to
-    /// <see cref="ProjectOpenAIClient.GetProjectResponsesClientForAgentEndpoint(string, string?, ProjectOpenAIClientOptions?)"/>.
-    /// </summary>
-    private static AIAgent BuildAgentEndpointInnerAgent(
-        AIProjectClient aiProjectClient,
-        Uri agentEndpoint,
-        ProjectOpenAIClientOptions? clientOptions,
-        IList<AITool>? tools,
-        Func<IChatClient, IChatClient>? clientFactory,
-        IServiceProvider? services)
-    {
-        Throw.IfNull(aiProjectClient);
-        Throw.IfNull(agentEndpoint);
-
-        var (agentName, _) = ParseAgentEndpoint(agentEndpoint);
-
-        var perAgentOptions = clientOptions ?? new ProjectOpenAIClientOptions();
-        perAgentOptions.AddPolicy(RequestOptionsExtensions.UserAgentPolicy, PipelinePosition.PerCall);
-
-        IChatClient chatClient = aiProjectClient.ProjectOpenAIClient
-            .GetProjectResponsesClientForAgentEndpoint(agentName, options: perAgentOptions)
-            .AsIChatClient();
         if (clientFactory is not null)
         {
             chatClient = clientFactory(chatClient);
@@ -358,6 +307,46 @@ public sealed class FoundryAgent : DelegatingAIAgent
         return WireClientHeaders(new ChatClientAgent(chatClient, agentOptions, services: services));
     }
 
+    /// <summary>
+    /// Variant of <see cref="CreateInnerAgentFromAgentEndpoint"/> that reuses an existing
+    /// <see cref="AIProjectClient"/>'s pipeline instead of stamping a fresh credential. Used by
+    /// the <c>AsAIAgent(AIProjectClient, Uri agentEndpoint, ...)</c> extension overload.
+    /// </summary>
+    private static AIAgent CreateInnerAgentFromAgentEndpointReusingProjectClient(
+        AIProjectClient aiProjectClient,
+        Uri agentEndpoint,
+        IList<AITool>? tools,
+        Func<IChatClient, IChatClient>? clientFactory,
+        IServiceProvider? services)
+    {
+        Throw.IfNull(aiProjectClient);
+        Throw.IfNull(agentEndpoint);
+
+        IChatClient chatClient = new FoundryChatClient(aiProjectClient, agentEndpoint, clientOptions: null);
+        var agentName = ((FoundryChatClient)chatClient).AgentName!;
+
+        if (clientFactory is not null)
+        {
+            chatClient = clientFactory(chatClient);
+        }
+
+        ChatClientAgentOptions agentOptions = new()
+        {
+            Id = agentName,
+            Name = agentName,
+            ChatOptions = new() { Tools = tools },
+        };
+
+        return WireClientHeaders(new ChatClientAgent(chatClient, agentOptions, services: services));
+    }
+
+    /// <summary>
+    /// Parses an agent endpoint URI. Delegates to <see cref="FoundryChatClient.ParseAgentEndpoint(Uri)"/>
+    /// so the chat client and the agent share a single source of truth for the URL shape.
+    /// </summary>
+    internal static (string AgentName, Uri ProjectRoot) ParseAgentEndpoint(Uri agentEndpoint)
+        => FoundryChatClient.ParseAgentEndpoint(agentEndpoint);
+
     /// <summary>
     /// Parses an agent endpoint URI of shape
     /// <c>https://&lt;host&gt;/.../projects/&lt;project&gt;/agents/&lt;agentName&gt;/endpoint/protocols/openai</c>
@@ -369,90 +358,12 @@ public sealed class FoundryAgent : DelegatingAIAgent
     /// strips query string and fragment. Throws <see cref="ArgumentException"/> for inputs that
     /// do not match the expected shape.
     /// </remarks>
-    /// <exception cref="ArgumentException">
-    /// The endpoint is missing the <c>/agents/</c> segment, has an empty agent name, or has a
-    /// suffix other than <c>/endpoint/protocols/openai</c>.
-    /// </exception>
-    internal static (string AgentName, Uri ProjectRoot) ParseAgentEndpoint(Uri agentEndpoint)
-    {
-        Throw.IfNull(agentEndpoint);
-
-        const string AgentsSegment = "/agents/";
-        const string ExpectedSuffix = "/endpoint/protocols/openai";
-
-        var path = agentEndpoint.AbsolutePath.TrimEnd('/');
-        var idx = path.IndexOf(AgentsSegment, StringComparison.OrdinalIgnoreCase);
-        if (idx < 0)
-        {
-            throw new ArgumentException(
-                $"Expected an agent endpoint of shape 'https://<host>/.../projects/<project>/agents/<agentName>/endpoint/protocols/openai' but got '{agentEndpoint}'.",
-                nameof(agentEndpoint));
-        }
-
-        var afterAgents = path.Substring(idx + AgentsSegment.Length);
-        var nextSlash = afterAgents.IndexOf('/');
-        if (nextSlash <= 0)
-        {
-            throw new ArgumentException(
-                $"Agent endpoint '{agentEndpoint}' is missing the '<agentName>{ExpectedSuffix}' suffix.",
-                nameof(agentEndpoint));
-        }
-
-        var agentName = afterAgents.Substring(0, nextSlash);
-        var suffix = afterAgents.Substring(nextSlash);
-        if (!string.Equals(suffix, ExpectedSuffix, StringComparison.OrdinalIgnoreCase))
-        {
-            throw new ArgumentException(
-                $"Agent endpoint '{agentEndpoint}' has an unexpected suffix '{suffix}'. Expected '{ExpectedSuffix}'.",
-                nameof(agentEndpoint));
-        }
-
-        var rootPath = path.Substring(0, idx);
-        var projectRoot = new UriBuilder(agentEndpoint)
-        {
-            Path = rootPath,
-            Query = string.Empty,
-            Fragment = string.Empty,
-        }.Uri;
-
-        return (agentName, projectRoot);
-    }
-
     private static AIProjectClient CreateProjectClient(Uri endpoint, AuthenticationTokenProvider credential, AIProjectClientOptions? clientOptions = null)
     {
         Throw.IfNull(endpoint);
         Throw.IfNull(credential);
 
-        clientOptions ??= new AIProjectClientOptions();
-        clientOptions.AddPolicy(RequestOptionsExtensions.UserAgentPolicy, PipelinePosition.PerCall);
-        return new AIProjectClient(endpoint, credential, clientOptions);
-    }
-
-    internal static AIProjectClientOptions? CreateProjectClientOptions(ProjectOpenAIClientOptions? clientOptions)
-    {
-        if (clientOptions is null)
-        {
-            return null;
-        }
-
-        // Copy pipeline behavior the caller configured on the per-agent options bag onto the
-        // project-level options bag so the agent endpoint client honors it. UserAgentApplicationId
-        // is project-level (not derived from the agent endpoint), so it must be carried through too.
-        var projectOptions = new AIProjectClientOptions
-        {
-            Transport = clientOptions.Transport,
-            RetryPolicy = clientOptions.RetryPolicy,
-            NetworkTimeout = clientOptions.NetworkTimeout,
-            MessageLoggingPolicy = clientOptions.MessageLoggingPolicy,
-            UserAgentApplicationId = clientOptions.UserAgentApplicationId,
-        };
-
-        if (clientOptions.ClientLoggingOptions is not null)
-        {
-            projectOptions.ClientLoggingOptions = clientOptions.ClientLoggingOptions;
-        }
-
-        return projectOptions;
+        return new AIProjectClient(endpoint, credential, clientOptions ?? new AIProjectClientOptions());
     }
 
     #endregion

dotnet/src/Microsoft.Agents.AI.Foundry/FoundryAgentExtensions.cs

@@ -0,0 +1,116 @@
+// Copyright (c) Microsoft. All rights reserved.
+
+using System;
+using System.Collections.Generic;
+using System.Diagnostics.CodeAnalysis;
+using System.Threading;
+using System.Threading.Tasks;
+using Azure.AI.Extensions.OpenAI;
+using Azure.AI.Projects.Agents;
+using Microsoft.Extensions.AI;
+using Microsoft.Shared.DiagnosticIds;
+using Microsoft.Shared.Diagnostics;
+using OpenAI.Files;
+using OpenAI.VectorStores;
+
+#pragma warning disable OPENAI001
+
+namespace Microsoft.Agents.AI.Foundry;
+
+/// <summary>
+/// Foundry-specific extensions on <see cref="FoundryAgent"/>. Hosts the prompt-agent converter
+/// plus thin forwarders that surface the file and vector-store helpers from the inner
+/// <see cref="FoundryChatClient"/> at the agent level so callers do not need to drop down to
+/// <c>agent.GetService&lt;FoundryChatClient&gt;().X()</c> for common workflows.
+/// </summary>
+[Experimental(DiagnosticIds.Experiments.AIOpenAIResponses)]
+public static class FoundryAgentExtensions
+{
+    /// <summary>
+    /// Converts the supplied <see cref="FoundryAgent"/> into a <see cref="ProjectsAgentDefinition"/>
+    /// ready to publish via <c>AgentAdministrationClient.CreateAgentVersionAsync</c>.
+    /// </summary>
+    /// <remarks>
+    /// The Agent Endpoint construction mode (Mode 3) is not convertible because no local
+    /// definition exists; conversion in that case throws <see cref="InvalidOperationException"/>.
+    /// </remarks>
+    /// <param name="agent">The Foundry agent to convert.</param>
+    /// <param name="cancellationToken">A token that can cancel an internal server-side fetch when the agent was constructed from a bare <see cref="AgentReference"/>.</param>
+    /// <returns>A <see cref="ProjectsAgentDefinition"/> suitable for publishing.</returns>
+    /// <exception cref="ArgumentNullException"><paramref name="agent"/> is <see langword="null"/>.</exception>
+    /// <exception cref="InvalidOperationException">The agent's chat client is not a <see cref="FoundryChatClient"/>; the agent was constructed via the Agent Endpoint mode (Mode 3); no model id is set on the agent's <see cref="ChatOptions"/> for the Responses Agent mode (Mode 1); or the agent contains an <see cref="AITool"/> that cannot be converted to a <c>ResponseTool</c>.</exception>
+    public static Task<ProjectsAgentDefinition> ToPromptAgentAsync(this FoundryAgent agent, CancellationToken cancellationToken = default)
+    {
+        Throw.IfNull(agent);
+
+        var innerChatClient = agent.GetService<IChatClient>()
+            ?? throw new InvalidOperationException(
+                "ToPromptAgentAsync could not resolve the inner IChatClient on the FoundryAgent.");
+        var chatOptions = agent.GetService<ChatOptions>();
+        return FoundryPromptAgentConverter.ConvertAsync(innerChatClient, chatOptions, cancellationToken);
+    }
+
+    /// <summary>
+    /// Uploads a file to the project. Thin forwarder to
+    /// <see cref="FoundryChatClient.UploadFileAsync(string, FileUploadPurpose, CancellationToken)"/>
+    /// on the agent's inner <see cref="FoundryChatClient"/>.
+    /// </summary>
+    /// <param name="agent">The Foundry agent whose inner chat client owns the upload pipeline.</param>
+    /// <param name="filePath">Path to the file to upload.</param>
+    /// <param name="purpose">The upload purpose (e.g. <see cref="FileUploadPurpose.Assistants"/>).</param>
+    /// <param name="cancellationToken">A token that can cancel the upload.</param>
+    /// <exception cref="ArgumentNullException"><paramref name="agent"/> is <see langword="null"/>.</exception>
+    /// <exception cref="InvalidOperationException">The agent does not expose a <see cref="FoundryChatClient"/> via <see cref="AIAgent.GetService{TService}(object?)"/>.</exception>
+    public static Task<OpenAIFile> UploadFileAsync(this FoundryAgent agent, string filePath, FileUploadPurpose purpose, CancellationToken cancellationToken = default)
+        => RequireFoundryChatClient(agent).UploadFileAsync(filePath, purpose, cancellationToken);
+
+    /// <summary>
+    /// Deletes a previously uploaded file. Thin forwarder to
+    /// <see cref="FoundryChatClient.DeleteFileAsync(string, CancellationToken)"/>.
+    /// </summary>
+    /// <param name="agent">The Foundry agent whose inner chat client owns the file pipeline.</param>
+    /// <param name="fileId">The file id returned by <see cref="UploadFileAsync(FoundryAgent, string, FileUploadPurpose, CancellationToken)"/>.</param>
+    /// <param name="cancellationToken">A token that can cancel the delete.</param>
+    /// <exception cref="ArgumentNullException"><paramref name="agent"/> is <see langword="null"/>.</exception>
+    /// <exception cref="InvalidOperationException">The agent does not expose a <see cref="FoundryChatClient"/>.</exception>
+    public static Task<FileDeletionResult> DeleteFileAsync(this FoundryAgent agent, string fileId, CancellationToken cancellationToken = default)
+        => RequireFoundryChatClient(agent).DeleteFileAsync(fileId, cancellationToken);
+
+    /// <summary>
+    /// Uploads the supplied files, creates a vector store containing them, and waits until the
+    /// store leaves the in-progress state. Thin forwarder to
+    /// <see cref="FoundryChatClient.CreateVectorStoreAsync(string, IEnumerable{string}, TimeSpan?, TimeSpan?, CancellationToken)"/>.
+    /// </summary>
+    /// <param name="agent">The Foundry agent whose inner chat client owns the file and vector-store pipeline.</param>
+    /// <param name="name">The vector store name.</param>
+    /// <param name="filePaths">Paths to files to upload and attach to the store.</param>
+    /// <param name="expiresAfter">Optional last-active-at expiration window.</param>
+    /// <param name="pollingTimeout">Optional upper bound on the wait for the vector store to leave the in-progress state. Defaults to 5 minutes; pass <see cref="Timeout.InfiniteTimeSpan"/> to disable.</param>
+    /// <param name="cancellationToken">A token that can cancel the orchestration.</param>
+    /// <exception cref="ArgumentNullException"><paramref name="agent"/> is <see langword="null"/>.</exception>
+    /// <exception cref="InvalidOperationException">The agent does not expose a <see cref="FoundryChatClient"/>.</exception>
+    /// <exception cref="TimeoutException">The vector store did not leave the in-progress state within <paramref name="pollingTimeout"/>.</exception>
+    public static Task<VectorStore> CreateVectorStoreAsync(this FoundryAgent agent, string name, IEnumerable<string> filePaths, TimeSpan? expiresAfter = null, TimeSpan? pollingTimeout = null, CancellationToken cancellationToken = default)
+        => RequireFoundryChatClient(agent).CreateVectorStoreAsync(name, filePaths, expiresAfter, pollingTimeout, cancellationToken);
+
+    /// <summary>
+    /// Deletes a vector store. Thin forwarder to
+    /// <see cref="FoundryChatClient.DeleteVectorStoreAsync(string, CancellationToken)"/>.
+    /// </summary>
+    /// <param name="agent">The Foundry agent whose inner chat client owns the vector-store pipeline.</param>
+    /// <param name="vectorStoreId">The vector store id.</param>
+    /// <param name="cancellationToken">A token that can cancel the delete.</param>
+    /// <exception cref="ArgumentNullException"><paramref name="agent"/> is <see langword="null"/>.</exception>
+    /// <exception cref="InvalidOperationException">The agent does not expose a <see cref="FoundryChatClient"/>.</exception>
+    public static Task<VectorStoreDeletionResult> DeleteVectorStoreAsync(this FoundryAgent agent, string vectorStoreId, CancellationToken cancellationToken = default)
+        => RequireFoundryChatClient(agent).DeleteVectorStoreAsync(vectorStoreId, cancellationToken);
+
+    private static FoundryChatClient RequireFoundryChatClient(FoundryAgent agent)
+    {
+        Throw.IfNull(agent);
+        return agent.GetService<FoundryChatClient>()
+            ?? throw new InvalidOperationException(
+                "FoundryAgent does not expose a FoundryChatClient via GetService<FoundryChatClient>(). " +
+                "File and vector-store helpers require the agent's inner chat client to be a FoundryChatClient.");
+    }
+}

dotnet/src/Microsoft.Agents.AI.Foundry/FoundryChatClient.cs

@@ -0,0 +1,703 @@
+// Copyright (c) Microsoft. All rights reserved.
+
+using System;
+using System.ClientModel;
+using System.ClientModel.Primitives;
+using System.Collections.Generic;
+using System.Diagnostics.CodeAnalysis;
+using System.IO;
+using System.Runtime.CompilerServices;
+using System.Threading;
+using System.Threading.Tasks;
+using Azure.AI.Extensions.OpenAI;
+using Azure.AI.Projects;
+using Azure.AI.Projects.Agents;
+using Microsoft.Extensions.AI;
+using Microsoft.Shared.DiagnosticIds;
+using Microsoft.Shared.Diagnostics;
+using OpenAI.Files;
+using OpenAI.Responses;
+using OpenAI.VectorStores;
+
+#pragma warning disable OPENAI001
+
+namespace Microsoft.Agents.AI.Foundry;
+
+/// <summary>
+/// Foundry chat-client decorator that unifies the three Foundry chat-client construction
+/// modes (Responses Agent, Prompt Agent, Agent Endpoint) behind a single type and centralizes
+/// Foundry-specific concerns: <c>microsoft.foundry</c> telemetry tagging,
+/// <c>agent-framework-dotnet/{version}</c> User-Agent stamping, <c>x-ms-served-model</c>
+/// response-header capture, and (for Prompt Agents) per-request payload mutation that injects
+/// the agent reference and strips per-request overrides that the server owns.
+/// </summary>
+/// <remarks>
+/// <para>
+/// Replaces the previous <c>AzureAIProjectChatClient</c> and <c>AzureAIProjectResponsesChatClient</c>
+/// decorators. All Foundry entry points (the public <c>FoundryAgent</c> constructors and the
+/// <c>AIProjectClientExtensions.AsAIAgent</c> overloads) now construct a
+/// <see cref="FoundryChatClient"/> internally, so telemetry and the agent-framework User-Agent
+/// segment are uniform across paths.
+/// </para>
+/// <para>
+/// The three construction modes are:
+/// </para>
+/// <list type="bullet">
+///   <item><description><b>Responses Agent</b> (Mode 1): direct Responses API call against a project-level model id; no server-side agent definition exists. Constructed from <c>(AIProjectClient, modelId)</c>.</description></item>
+///   <item><description><b>Prompt Agent</b> (Mode 2): server-side agent definition (a <see cref="ProjectsAgentDefinition"/>, typically a <see cref="DeclarativeAgentDefinition"/>) invoked by <see cref="AgentReference"/> against the project Responses URL. Constructed from <see cref="AgentReference"/>, <see cref="ProjectsAgentVersion"/>, or <see cref="ProjectsAgentRecord"/>.</description></item>
+///   <item><description><b>Agent Endpoint</b> (Mode 3): invocation via the per-agent endpoint URL <c>…/projects/{p}/agents/{name}/endpoint/protocols/openai</c>. The agent behind the endpoint can be either a hosted (container-backed) agent or a Prompt Agent. Constructed from <c>(Uri agentEndpoint, credential)</c>.</description></item>
+/// </list>
+/// <para>
+/// Note: "Hosted Agent" refers to a container-based runtime agent (see
+/// <c>Microsoft.Agents.AI.Foundry.Hosting</c>) and is the <i>kind</i> of agent that may sit
+/// behind an Agent Endpoint. It is not synonymous with the Agent Endpoint mode itself.
+/// </para>
+/// </remarks>
+[Experimental(DiagnosticIds.Experiments.AIOpenAIResponses)]
+public sealed class FoundryChatClient : DelegatingChatClient
+{
+    private readonly ChatClientMetadata _metadata;
+    private readonly AIProjectClient? _aiProjectClient;
+    private readonly AgentReference? _agentReference;
+    private readonly ProjectsAgentVersion? _agentVersion;
+    private readonly ProjectsAgentRecord? _agentRecord;
+    private readonly ChatOptions? _baseChatOptions;
+
+    /// <summary>
+    /// Initializes a new instance for the Responses Agent mode (Mode 1): direct Responses API
+    /// call against a project-level model id; no server-side agent definition exists.
+    /// </summary>
+    /// <param name="aiProjectClient">The project client.</param>
+    /// <param name="modelId">The model deployment id.</param>
+    internal FoundryChatClient(AIProjectClient aiProjectClient, string modelId)
+        : base(Throw.IfNull(aiProjectClient)
+            .GetProjectOpenAIClient()
+            .GetProjectResponsesClientForModel(Throw.IfNullOrWhitespace(modelId))
+            .AsIChatClient())
+    {
+        this._aiProjectClient = aiProjectClient;
+        this._metadata = new ChatClientMetadata("microsoft.foundry", defaultModelId: modelId);
+        TryRegisterAgentFrameworkUserAgentPolicy(this.InnerClient);
+        TryRegisterServedModelPolicy(this.InnerClient);
+    }
+
+    /// <summary>
+    /// Initializes a new instance for the Prompt Agent mode (Mode 2): server-side agent
+    /// definition invoked by <see cref="AgentReference"/>.
+    /// </summary>
+    internal FoundryChatClient(AIProjectClient aiProjectClient, AgentReference agentReference, string? defaultModelId, ChatOptions? baseChatOptions)
+        : base(Throw.IfNull(aiProjectClient)
+            .GetProjectOpenAIClient()
+            .GetProjectResponsesClientForAgent(Throw.IfNull(agentReference))
+            .AsIChatClient())
+    {
+        this._aiProjectClient = aiProjectClient;
+        this._agentReference = agentReference;
+        this._metadata = new ChatClientMetadata("microsoft.foundry", defaultModelId: defaultModelId);
+        this._baseChatOptions = baseChatOptions;
+        this.AgentName = agentReference.Name;
+        TryRegisterAgentFrameworkUserAgentPolicy(this.InnerClient);
+        TryRegisterServedModelPolicy(this.InnerClient);
+    }
+
+    /// <summary>
+    /// Initializes a new instance for the Prompt Agent mode (Mode 2, record variant):
+    /// server-side agent definition invoked by record, resolving to the latest version.
+    /// </summary>
+    internal FoundryChatClient(AIProjectClient aiProjectClient, ProjectsAgentRecord agentRecord, ChatOptions? baseChatOptions)
+        : this(aiProjectClient, Throw.IfNull(agentRecord).GetLatestVersion(), baseChatOptions)
+    {
+        this._agentRecord = agentRecord;
+    }
+
+    /// <summary>
+    /// Initializes a new instance for the Prompt Agent mode (Mode 2, version variant):
+    /// server-side agent definition invoked by a specific version.
+    /// </summary>
+    internal FoundryChatClient(AIProjectClient aiProjectClient, ProjectsAgentVersion agentVersion, ChatOptions? baseChatOptions)
+        : this(
+              aiProjectClient,
+              CreateAgentReference(Throw.IfNull(agentVersion)),
+              (agentVersion.Definition as DeclarativeAgentDefinition)?.Model,
+              baseChatOptions)
+    {
+        this._agentVersion = agentVersion;
+    }
+
+    /// <summary>
+    /// Initializes a new instance for the Agent Endpoint mode (Mode 3): invocation via the
+    /// per-agent endpoint URL. Parses the URL into its per-agent
+    /// <see cref="ProjectOpenAIClient"/> shape internally and forwards through the resulting
+    /// responses client.
+    /// </summary>
+    /// <param name="agentEndpoint">
+    /// The agent-specific endpoint URI. Must be of the shape
+    /// <c>https://&lt;host&gt;/.../projects/&lt;project&gt;/agents/&lt;agentName&gt;/endpoint/protocols/openai</c>.
+    /// </param>
+    /// <param name="credential">The authentication credential.</param>
+    /// <param name="clientOptions">Optional per-agent client options. <c>Endpoint</c> and <c>AgentName</c> are owned by this ctor and overridden with values derived from <paramref name="agentEndpoint"/>.</param>
+    internal FoundryChatClient(Uri agentEndpoint, AuthenticationTokenProvider credential, ProjectOpenAIClientOptions? clientOptions)
+        : this(BuildAgentEndpointInner(agentEndpoint, credential, clientOptions))
+    {
+    }
+
+    /// <summary>
+    /// Initializes a new instance for the Agent Endpoint mode (Mode 3) by reusing an existing
+    /// <see cref="AIProjectClient"/>'s pipeline. Equivalent to the
+    /// <see cref="FoundryChatClient(Uri, AuthenticationTokenProvider, ProjectOpenAIClientOptions?)"/>
+    /// constructor but skips building a fresh per-agent pipeline: the project-level
+    /// <see cref="ProjectOpenAIClient"/> on <paramref name="aiProjectClient"/> is used directly.
+    /// </summary>
+    /// <param name="aiProjectClient">The project client already configured at the project root containing <paramref name="agentEndpoint"/>.</param>
+    /// <param name="agentEndpoint">The per-agent endpoint URI. Same shape constraints as the other agent-endpoint ctor.</param>
+    /// <param name="clientOptions">Optional per-agent client options applied to the per-agent <c>GetProjectResponsesClientForAgentEndpoint</c> call.</param>
+    internal FoundryChatClient(AIProjectClient aiProjectClient, Uri agentEndpoint, ProjectOpenAIClientOptions? clientOptions)
+        : this(BuildAgentEndpointInnerFromProjectClient(aiProjectClient, agentEndpoint, clientOptions))
+    {
+    }
+
+    private FoundryChatClient(AgentEndpointInner inner)
+        : base(inner.ChatClient)
+    {
+        this._aiProjectClient = inner.AIProjectClient;
+        this.AgentName = inner.AgentName;
+        this._metadata = new ChatClientMetadata("microsoft.foundry");
+        TryRegisterAgentFrameworkUserAgentPolicy(this.InnerClient);
+        TryRegisterServedModelPolicy(this.InnerClient);
+    }
+
+    /// <summary>
+    /// Gets the agent name associated with this chat client.
+    /// </summary>
+    /// <remarks>
+    /// <para>Set in two cases:</para>
+    /// <list type="bullet">
+    /// <item>
+    /// <description>
+    /// Prompt Agent mode (Mode 2): the value of <see cref="AgentReference.Name"/> supplied at
+    /// construction.
+    /// </description>
+    /// </item>
+    /// <item>
+    /// <description>
+    /// Agent Endpoint mode (Mode 3): the agent name segment parsed from the supplied agent
+    /// endpoint URI.
+    /// </description>
+    /// </item>
+    /// </list>
+    /// <para>
+    /// Returns <see langword="null"/> for the Responses Agent mode (Mode 1) where no agent name
+    /// exists.
+    /// </para>
+    /// </remarks>
+    internal string? AgentName { get; }
+
+    /// <inheritdoc/>
+    public override object? GetService(Type serviceType, object? serviceKey = null)
+    {
+        return (serviceKey is null && serviceType == typeof(ChatClientMetadata))
+            ? this._metadata
+            : (serviceKey is null && serviceType == typeof(AIProjectClient))
+            ? this._aiProjectClient
+            : (serviceKey is null && serviceType == typeof(AgentReference))
+            ? this._agentReference
+            : (serviceKey is null && serviceType == typeof(ProjectsAgentVersion))
+            ? this._agentVersion
+            : (serviceKey is null && serviceType == typeof(ProjectsAgentRecord))
+            ? this._agentRecord
+            : base.GetService(serviceType, serviceKey);
+    }
+
+    /// <inheritdoc/>
+    public override async Task<ChatResponse> GetResponseAsync(IEnumerable<ChatMessage> messages, ChatOptions? options = null, CancellationToken cancellationToken = default)
+    {
+        var effectiveOptions = this._agentReference is not null
+            ? this.GetAgentEnabledChatOptions(options)
+            : options;
+
+        var box = new StrongBox<string?>(null);
+        var previous = ServedModelScope.Current;
+        ServedModelScope.Current = box;
+
+        try
+        {
+            var response = await base.GetResponseAsync(messages, effectiveOptions, cancellationToken).ConfigureAwait(false);
+
+            if (box.Value is { } servedModel)
+            {
+                response.ModelId = servedModel;
+            }
+
+            return response;
+        }
+        finally
+        {
+            ServedModelScope.Current = previous;
+        }
+    }
+
+    /// <inheritdoc/>
+    public override async IAsyncEnumerable<ChatResponseUpdate> GetStreamingResponseAsync(IEnumerable<ChatMessage> messages, ChatOptions? options = null, [EnumeratorCancellation] CancellationToken cancellationToken = default)
+    {
+        var effectiveOptions = this._agentReference is not null
+            ? this.GetAgentEnabledChatOptions(options)
+            : options;
+
+        var box = new StrongBox<string?>(null);
+        var previous = ServedModelScope.Current;
+        ServedModelScope.Current = box;
+
+        try
+        {
+            await foreach (var chunk in base.GetStreamingResponseAsync(messages, effectiveOptions, cancellationToken).ConfigureAwait(false))
+            {
+                if (box.Value is { } servedModel)
+                {
+                    chunk.ModelId = servedModel;
+                }
+
+                yield return chunk;
+            }
+        }
+        finally
+        {
+            ServedModelScope.Current = previous;
+        }
+    }
+
+    #region File and vector-store helpers (mirrors Python's foundry_chat_client surface)
+
+    /// <summary>
+    /// Uploads a single file to the project for the supplied purpose. The upload is performed
+    /// against the project-level <see cref="AIProjectClient"/> reachable via
+    /// <see cref="GetService(Type, object?)"/>, so this method works uniformly across all three
+    /// FoundryChatClient construction modes.
+    /// </summary>
+    /// <param name="filePath">Absolute or relative path to the file to upload. The file must exist.</param>
+    /// <param name="purpose">The file upload purpose (e.g. <see cref="FileUploadPurpose.Assistants"/>).</param>
+    /// <param name="cancellationToken">A token that can cancel the upload.</param>
+    /// <returns>The created <see cref="OpenAIFile"/> as returned by the service.</returns>
+    /// <exception cref="ArgumentNullException"><paramref name="filePath"/> is <see langword="null"/>.</exception>
+    /// <exception cref="FileNotFoundException">The file at <paramref name="filePath"/> does not exist.</exception>
+    public async Task<OpenAIFile> UploadFileAsync(string filePath, FileUploadPurpose purpose, CancellationToken cancellationToken = default)
+    {
+        Throw.IfNull(filePath);
+        if (!File.Exists(filePath))
+        {
+            throw new FileNotFoundException($"File not found: '{filePath}'.", filePath);
+        }
+
+        var fileClient = this.GetOpenAIFileClient();
+        // Use the Stream overload to honor cancellation; the (string, purpose) overload has no
+        // CancellationToken parameter in the OpenAI SDK.
+        using var stream = File.OpenRead(filePath);
+        var result = await fileClient.UploadFileAsync(stream, Path.GetFileName(filePath), purpose, cancellationToken).ConfigureAwait(false);
+        return result.Value;
+    }
+
+    /// <summary>Deletes a file previously uploaded to the project.</summary>
+    /// <param name="fileId">The file id returned by <see cref="UploadFileAsync(string, FileUploadPurpose, CancellationToken)"/>.</param>
+    /// <param name="cancellationToken">A token that can cancel the delete.</param>
+    /// <returns>The deletion result.</returns>
+    /// <exception cref="ArgumentException"><paramref name="fileId"/> is <see langword="null"/> or whitespace.</exception>
+    public async Task<FileDeletionResult> DeleteFileAsync(string fileId, CancellationToken cancellationToken = default)
+    {
+        Throw.IfNullOrWhitespace(fileId);
+        var fileClient = this.GetOpenAIFileClient();
+        var result = await fileClient.DeleteFileAsync(fileId, cancellationToken).ConfigureAwait(false);
+        return result.Value;
+    }
+
+    /// <summary>
+    /// Uploads the supplied files, creates a vector store containing them, waits until the
+    /// store finishes ingesting its files (status leaves <see cref="VectorStoreStatus.InProgress"/>),
+    /// and returns the <see cref="VectorStore"/>. Mirrors Python's
+    /// <c>foundry_chat_client.create_vector_store(name, files, expires_after_days)</c>.
+    /// </summary>
+    /// <param name="name">The vector store name.</param>
+    /// <param name="filePaths">Paths to files to upload and attach to the store.</param>
+    /// <param name="expiresAfter">Optional last-active-at expiration window. When supplied, the vector store expires this many days after its last use.</param>
+    /// <param name="pollingTimeout">Optional upper bound on the wait for the vector store to leave <see cref="VectorStoreStatus.InProgress"/>. Defaults to 5 minutes when not supplied; pass <see cref="Timeout.InfiniteTimeSpan"/> to disable. Independent of <paramref name="cancellationToken"/>: cancellation always wins.</param>
+    /// <param name="cancellationToken">A token that can cancel the orchestration.</param>
+    /// <returns>The created and fully-ready <see cref="VectorStore"/>. The returned instance reflects the state observed after polling completes; it may be in <see cref="VectorStoreStatus.Completed"/> (typical), <see cref="VectorStoreStatus.Expired"/>, or any other terminal status returned by the service. Only <see cref="VectorStoreStatus.InProgress"/> is polled.</returns>
+    /// <remarks>
+    /// <para>
+    /// File-upload semantics are best-effort: when one of the per-file uploads throws, this method
+    /// makes a best-effort attempt to delete the files it has already uploaded so they do not
+    /// accumulate as orphaned resources on the project, then rethrows the original exception. The
+    /// cleanup itself does not throw — its failures are silently ignored because the caller is
+    /// already receiving a more meaningful exception from the original upload failure.
+    /// </para>
+    /// <para>
+    /// Cancellation aborts the polling loop with an <see cref="OperationCanceledException"/>; any
+    /// already-uploaded files and the partially-created vector store remain on the project and are
+    /// the caller's responsibility to clean up. The same applies when the polling timeout elapses
+    /// (a <see cref="TimeoutException"/> is thrown instead).
+    /// </para>
+    /// </remarks>
+    /// <exception cref="ArgumentException"><paramref name="name"/> is <see langword="null"/> or whitespace, or <paramref name="filePaths"/> is <see langword="null"/>.</exception>
+    /// <exception cref="TimeoutException">The vector store did not leave <see cref="VectorStoreStatus.InProgress"/> within <paramref name="pollingTimeout"/>.</exception>
+    public async Task<VectorStore> CreateVectorStoreAsync(string name, IEnumerable<string> filePaths, TimeSpan? expiresAfter = null, TimeSpan? pollingTimeout = null, CancellationToken cancellationToken = default)
+    {
+        Throw.IfNullOrWhitespace(name);
+        Throw.IfNull(filePaths);
+
+        var fileIds = new List<string>();
+        try
+        {
+            foreach (var path in filePaths)
+            {
+                cancellationToken.ThrowIfCancellationRequested();
+                var uploaded = await this.UploadFileAsync(path, FileUploadPurpose.Assistants, cancellationToken).ConfigureAwait(false);
+                fileIds.Add(uploaded.Id);
+            }
+        }
+        catch
+        {
+            // Q-B: best-effort cleanup of files already uploaded before the mid-loop failure so
+            // they do not accumulate as orphaned resources on the project. Swallow cleanup
+            // exceptions — the caller is already going to see the original upload exception, and
+            // there is nothing useful we can do with a secondary delete failure.
+            await this.BestEffortDeleteFilesAsync(fileIds).ConfigureAwait(false);
+            throw;
+        }
+
+        var options = new VectorStoreCreationOptions
+        {
+            Name = name,
+        };
+        foreach (var id in fileIds)
+        {
+            options.FileIds.Add(id);
+        }
+        if (expiresAfter is { } window)
+        {
+            options.ExpirationPolicy = new VectorStoreExpirationPolicy(VectorStoreExpirationAnchor.LastActiveAt, (int)Math.Ceiling(window.TotalDays));
+        }
+
+        var vectorStoreClient = this.GetVectorStoreClient();
+        var createResult = await vectorStoreClient.CreateVectorStoreAsync(options, cancellationToken).ConfigureAwait(false);
+        var created = createResult.Value;
+
+        // Q-A: poll until the vector store leaves the in-progress state. Without this the helper
+        // hands the caller a vector store whose file ingestion may still be running, defeating
+        // the purpose of the one-call wrapper.
+        return await WaitForVectorStoreReadyAsync(vectorStoreClient, created, pollingTimeout ?? s_defaultPollingTimeout, cancellationToken).ConfigureAwait(false);
+    }
+
+    private async Task BestEffortDeleteFilesAsync(IEnumerable<string> fileIds)
+    {
+        foreach (var id in fileIds)
+        {
+            try
+            {
+                // Pass CancellationToken.None: cleanup runs in the catch path; the caller's
+                // token may already be cancelled and we still want to do our best to free
+                // orphaned resources before propagating the original exception.
+                await this.DeleteFileAsync(id, CancellationToken.None).ConfigureAwait(false);
+            }
+            catch
+            {
+                // Silently ignore cleanup failures; see XML doc on CreateVectorStoreAsync.
+            }
+        }
+    }
+
+    /// <summary>Upper bound on <see cref="WaitForVectorStoreReadyAsync"/> when the caller does not supply one. Chosen to comfortably cover normal Foundry vector-store ingestion (seconds to a minute for modest file sets) while still surfacing a clear failure if the server is stuck.</summary>
+    private static readonly TimeSpan s_defaultPollingTimeout = TimeSpan.FromMinutes(5);
+
+    private static async Task<VectorStore> WaitForVectorStoreReadyAsync(VectorStoreClient client, VectorStore initial, TimeSpan timeout, CancellationToken cancellationToken)
+    {
+        if (initial.Status != VectorStoreStatus.InProgress)
+        {
+            return initial;
+        }
+
+        var stopwatch = System.Diagnostics.Stopwatch.StartNew();
+        var delay = TimeSpan.FromMilliseconds(250);
+        var maxDelay = TimeSpan.FromSeconds(2);
+        var current = initial;
+        while (current.Status == VectorStoreStatus.InProgress)
+        {
+            if (timeout != Timeout.InfiniteTimeSpan && stopwatch.Elapsed >= timeout)
+            {
+                throw new TimeoutException(
+                    $"Vector store '{current.Id}' did not leave the in-progress state within {timeout.TotalSeconds:0.##} seconds.");
+            }
+
+            await Task.Delay(delay, cancellationToken).ConfigureAwait(false);
+            var refreshed = await client.GetVectorStoreAsync(current.Id, cancellationToken).ConfigureAwait(false);
+            current = refreshed.Value;
+
+            if (delay < maxDelay)
+            {
+                var next = TimeSpan.FromMilliseconds(delay.TotalMilliseconds * 2);
+                delay = next < maxDelay ? next : maxDelay;
+            }
+        }
+
+        return current;
+    }
+
+    /// <summary>Deletes a vector store. The associated files (if any) are not deleted by this method; call <see cref="DeleteFileAsync(string, CancellationToken)"/> separately to clean them up.</summary>
+    /// <param name="vectorStoreId">The vector store id.</param>
+    /// <param name="cancellationToken">A token that can cancel the delete.</param>
+    /// <returns>The deletion result.</returns>
+    /// <exception cref="ArgumentException"><paramref name="vectorStoreId"/> is <see langword="null"/> or whitespace.</exception>
+    public async Task<VectorStoreDeletionResult> DeleteVectorStoreAsync(string vectorStoreId, CancellationToken cancellationToken = default)
+    {
+        Throw.IfNullOrWhitespace(vectorStoreId);
+        var vectorStoreClient = this.GetVectorStoreClient();
+        var result = await vectorStoreClient.DeleteVectorStoreAsync(vectorStoreId, cancellationToken).ConfigureAwait(false);
+        return result.Value;
+    }
+
+    private OpenAIFileClient GetOpenAIFileClient()
+    {
+        var projectClient = this._aiProjectClient
+            ?? throw new InvalidOperationException("This FoundryChatClient does not have an AIProjectClient available. File and vector-store helpers require an AIProjectClient.");
+        return projectClient.GetProjectOpenAIClient().GetOpenAIFileClient();
+    }
+
+    private VectorStoreClient GetVectorStoreClient()
+    {
+        var projectClient = this._aiProjectClient
+            ?? throw new InvalidOperationException("This FoundryChatClient does not have an AIProjectClient available. File and vector-store helpers require an AIProjectClient.");
+        return projectClient.GetProjectOpenAIClient().GetVectorStoreClient();
+    }
+
+    #endregion
+
+    /// <summary>
+    /// Parses an agent endpoint URI of shape
+    /// <c>https://&lt;host&gt;/.../projects/&lt;project&gt;/agents/&lt;agentName&gt;/endpoint/protocols/openai</c>
+    /// and returns the agent name and the derived project-root URI.
+    /// </summary>
+    /// <remarks>
+    /// Tolerates trailing slash, casing variants on <c>/agents/</c> and the suffix segment, and
+    /// strips query string and fragment. Throws <see cref="ArgumentException"/> for inputs that
+    /// do not match the expected shape.
+    /// </remarks>
+    /// <exception cref="ArgumentException">
+    /// The endpoint is missing the <c>/agents/</c> segment, has an empty agent name, or has a
+    /// suffix other than <c>/endpoint/protocols/openai</c>.
+    /// </exception>
+    internal static (string AgentName, Uri ProjectRoot) ParseAgentEndpoint(Uri agentEndpoint)
+    {
+        Throw.IfNull(agentEndpoint);
+
+        const string AgentsSegment = "/agents/";
+        const string ExpectedSuffix = "/endpoint/protocols/openai";
+
+        var path = agentEndpoint.AbsolutePath.TrimEnd('/');
+        var idx = path.IndexOf(AgentsSegment, StringComparison.OrdinalIgnoreCase);
+        if (idx < 0)
+        {
+            throw new ArgumentException(
+                $"Expected an agent endpoint of shape 'https://<host>/.../projects/<project>/agents/<agentName>/endpoint/protocols/openai' but got '{agentEndpoint}'. " +
+                "If you want to construct a FoundryAgent against a project endpoint, use the (Uri projectEndpoint, AuthenticationTokenProvider credential, string model, string instructions, ...) constructor instead.",
+                nameof(agentEndpoint));
+        }
+
+        var afterAgents = path.Substring(idx + AgentsSegment.Length);
+        var nextSlash = afterAgents.IndexOf('/');
+        if (nextSlash <= 0)
+        {
+            throw new ArgumentException(
+                $"Agent endpoint '{agentEndpoint}' is missing the '<agentName>{ExpectedSuffix}' suffix.",
+                nameof(agentEndpoint));
+        }
+
+        var agentName = afterAgents.Substring(0, nextSlash);
+        var suffix = afterAgents.Substring(nextSlash);
+        if (!string.Equals(suffix, ExpectedSuffix, StringComparison.OrdinalIgnoreCase))
+        {
+            throw new ArgumentException(
+                $"Agent endpoint '{agentEndpoint}' has an unexpected suffix '{suffix}'. Expected '{ExpectedSuffix}'.",
+                nameof(agentEndpoint));
+        }
+
+        var rootPath = path.Substring(0, idx);
+        var projectRoot = new UriBuilder(agentEndpoint)
+        {
+            Path = rootPath,
+            Query = string.Empty,
+            Fragment = string.Empty,
+        }.Uri;
+
+        return (agentName, projectRoot);
+    }
+
+    private ChatOptions GetAgentEnabledChatOptions(ChatOptions? options)
+    {
+        // Start with a clone of the base chat options defined for the agent, if any.
+        ChatOptions agentEnabledChatOptions = this._baseChatOptions?.Clone() ?? new();
+
+        // Ignore per-request all options that can't be overridden.
+        agentEnabledChatOptions.Instructions = null;
+        agentEnabledChatOptions.Tools = null;
+        agentEnabledChatOptions.Temperature = null;
+        agentEnabledChatOptions.TopP = null;
+        agentEnabledChatOptions.PresencePenalty = null;
+        agentEnabledChatOptions.ResponseFormat = null;
+
+        // Use the conversation from the request, or the one defined at the client level.
+        agentEnabledChatOptions.ConversationId = options?.ConversationId ?? this._baseChatOptions?.ConversationId;
+
+        // Preserve the original RawRepresentationFactory.
+        var originalFactory = options?.RawRepresentationFactory;
+
+        agentEnabledChatOptions.RawRepresentationFactory = (client) =>
+        {
+            if (originalFactory?.Invoke(this) is not CreateResponseOptions responseCreationOptions)
+            {
+                responseCreationOptions = new CreateResponseOptions();
+            }
+
+            responseCreationOptions.Agent = this._agentReference;
+#pragma warning disable SCME0001 // Type is for evaluation purposes only and is subject to change or removal in future updates.
+            responseCreationOptions.Patch.Remove("$.model"u8);
+#pragma warning restore SCME0001
+
+            return responseCreationOptions;
+        };
+
+        return agentEnabledChatOptions;
+    }
+
+    private static AgentReference CreateAgentReference(ProjectsAgentVersion agentVersion)
+    {
+        // If the version is null, empty, or whitespace, use "latest" as the default. This handles
+        // cases where hosted agents (like MCP agents) may not have a version assigned.
+        var version = string.IsNullOrWhiteSpace(agentVersion.Version) ? "latest" : agentVersion.Version;
+        return new AgentReference(agentVersion.Name, version);
+    }
+
+    private static AgentEndpointInner BuildAgentEndpointInner(
+        Uri agentEndpoint,
+        AuthenticationTokenProvider credential,
+        ProjectOpenAIClientOptions? clientOptions)
+    {
+        Throw.IfNull(agentEndpoint);
+        Throw.IfNull(credential);
+
+        var (agentName, projectRoot) = ParseAgentEndpoint(agentEndpoint);
+
+        var perAgentOptions = clientOptions ?? new ProjectOpenAIClientOptions();
+        perAgentOptions.Endpoint = agentEndpoint;
+        perAgentOptions.AgentName = agentName;
+
+        var authPolicy = new BearerTokenPolicy(credential, AzureAiResourceScope);
+        var perAgentClient = new ProjectOpenAIClient(authPolicy, perAgentOptions);
+
+        var chatClient = perAgentClient.GetProjectResponsesClient().AsIChatClient();
+
+        // Materialize a project-level AIProjectClient from the parsed project root so
+        // GetService<AIProjectClient>() returns non-null for all FoundryChatClient
+        // construction modes. Project-level helpers (file upload, vector store create/delete)
+        // depend on this. RBAC for those calls is at the project level; if the supplied
+        // credential lacks project-scope permissions, the SDK surfaces a clean 401/403 at
+        // call time. The four observable primitive ClientPipelineOptions properties are
+        // propagated from the caller's per-agent options bag so test-injected transports and
+        // explicit RetryPolicy / NetworkTimeout / UserAgentApplicationId reach the
+        // project-level pipeline. Pipeline policies added via AddPolicy on the caller bag are
+        // NOT propagated because ClientPipelineOptions does not publicly enumerate policies.
+        var aiProjectClientOptions = new AIProjectClientOptions();
+        if (clientOptions is not null)
+        {
+            if (clientOptions.RetryPolicy is not null)
+            {
+                aiProjectClientOptions.RetryPolicy = clientOptions.RetryPolicy;
+            }
+            if (clientOptions.NetworkTimeout is not null)
+            {
+                aiProjectClientOptions.NetworkTimeout = clientOptions.NetworkTimeout;
+            }
+            if (clientOptions.Transport is not null)
+            {
+                aiProjectClientOptions.Transport = clientOptions.Transport;
+            }
+            if (!string.IsNullOrEmpty(clientOptions.UserAgentApplicationId))
+            {
+                aiProjectClientOptions.UserAgentApplicationId = clientOptions.UserAgentApplicationId;
+            }
+        }
+        var aiProjectClient = new AIProjectClient(projectRoot, credential, aiProjectClientOptions);
+
+        return new AgentEndpointInner(chatClient, aiProjectClient, agentName);
+    }
+
+    private static AgentEndpointInner BuildAgentEndpointInnerFromProjectClient(
+        AIProjectClient aiProjectClient,
+        Uri agentEndpoint,
+        ProjectOpenAIClientOptions? clientOptions)
+    {
+        Throw.IfNull(aiProjectClient);
+        Throw.IfNull(agentEndpoint);
+
+        var (agentName, _) = ParseAgentEndpoint(agentEndpoint);
+
+        var perAgentOptions = clientOptions ?? new ProjectOpenAIClientOptions();
+        perAgentOptions.Endpoint = agentEndpoint;
+        perAgentOptions.AgentName = agentName;
+
+        var chatClient = aiProjectClient.GetProjectOpenAIClient()
+            .GetProjectResponsesClientForAgentEndpoint(agentName, options: perAgentOptions)
+            .AsIChatClient();
+
+        // Reuse the caller's AIProjectClient verbatim — no new pipeline is materialized.
+        return new AgentEndpointInner(chatClient, aiProjectClient, agentName);
+    }
+
+    /// <summary>Best-effort registration of <see cref="AgentFrameworkUserAgentPolicy"/> via the MEAI <see cref="OpenAIRequestPolicies"/> hook with at-most-once dedup per pipeline.</summary>
+    private static void TryRegisterAgentFrameworkUserAgentPolicy(IChatClient? innerClient)
+    {
+        if (innerClient?.GetService<OpenAIRequestPolicies>() is { } policies)
+        {
+            // OpenAIRequestPoliciesReflection.AddPolicyIfMissing performs a check-then-add against
+            // the private _entries collection on the OpenAIRequestPolicies instance, so the
+            // policy is registered at most once even when many FoundryChatClient instances share
+            // the same underlying chat client.
+            OpenAIRequestPoliciesReflection.AddPolicyIfMissing(
+                policies,
+                AgentFrameworkUserAgentPolicy.Instance,
+                PipelinePosition.PerCall);
+        }
+    }
+
+    /// <summary>
+    /// Best-effort registration of <see cref="ServedModelPolicy"/> via the MEAI
+    /// <see cref="OpenAIRequestPolicies"/> hook. The policy captures the
+    /// <c>x-ms-served-model</c> response header from Azure OpenAI and writes it into
+    /// <see cref="ServedModelScope"/> so the <see cref="GetResponseAsync"/> and
+    /// <see cref="GetStreamingResponseAsync"/> overrides can overwrite
+    /// <see cref="ChatResponse.ModelId"/> with the actual model snapshot.
+    /// </summary>
+    private static void TryRegisterServedModelPolicy(IChatClient? innerClient)
+    {
+        if (innerClient?.GetService<OpenAIRequestPolicies>() is { } policies)
+        {
+            OpenAIRequestPoliciesReflection.AddPolicyIfMissing(
+                policies,
+                ServedModelPolicy.Instance,
+                PipelinePosition.PerCall);
+        }
+    }
+
+    /// <summary>Default OAuth scope for the Azure AI resource. Matches the scope used by <c>Azure.AI.Extensions.OpenAI</c>'s internal authentication helper so the bearer token is accepted by the Foundry control plane.</summary>
+    private const string AzureAiResourceScope = "https://ai.azure.com/.default";
+
+    private readonly struct AgentEndpointInner
+    {
+        public AgentEndpointInner(IChatClient chatClient, AIProjectClient aiProjectClient, string agentName)
+        {
+            this.ChatClient = chatClient;
+            this.AIProjectClient = aiProjectClient;
+            this.AgentName = agentName;
+        }
+
+        public IChatClient ChatClient { get; }
+        public AIProjectClient AIProjectClient { get; }
+        public string AgentName { get; }
+    }
+}

dotnet/src/Microsoft.Agents.AI.Foundry/FoundryPromptAgentConverter.cs

@@ -0,0 +1,150 @@
+// Copyright (c) Microsoft. All rights reserved.
+
+using System;
+using System.Diagnostics.CodeAnalysis;
+using System.Threading;
+using System.Threading.Tasks;
+using Azure.AI.Extensions.OpenAI;
+using Azure.AI.Projects;
+using Azure.AI.Projects.Agents;
+using Microsoft.Extensions.AI;
+using Microsoft.Shared.DiagnosticIds;
+using Microsoft.Shared.Diagnostics;
+using OpenAI.Responses;
+
+#pragma warning disable OPENAI001
+
+namespace Microsoft.Agents.AI.Foundry;
+
+/// <summary>
+/// Shared internal implementation behind the public <c>ToPromptAgentAsync</c> extension methods
+/// on <see cref="ChatClientAgent"/> and <see cref="FoundryAgent"/>. Converts a Foundry-backed
+/// agent into a <see cref="ProjectsAgentDefinition"/> ready to publish via
+/// <see cref="AgentAdministrationClient"/>.
+/// </summary>
+/// <remarks>
+/// <para>
+/// Dispatch by <see cref="FoundryChatClient"/> construction mode (reachable via
+/// <see cref="IChatClient.GetService(Type, object?)"/>):
+/// </para>
+/// <list type="bullet">
+/// <item><description><b>Responses Agent (Mode 1)</b>: synthesize a <see cref="DeclarativeAgentDefinition"/> from the agent's <see cref="ChatOptions"/>.</description></item>
+/// <item><description><b>Prompt Agent (Mode 2, cached version)</b>: return the cached <see cref="ProjectsAgentVersion.Definition"/>.</description></item>
+/// <item><description><b>Prompt Agent (Mode 2, AgentReference-only)</b>: fetch the latest version from the service and return its definition.</description></item>
+/// <item><description><b>Agent Endpoint (Mode 3)</b>: throw — no local definition exists to convert.</description></item>
+/// </list>
+/// </remarks>
+[Experimental(DiagnosticIds.Experiments.AIOpenAIResponses)]
+internal static class FoundryPromptAgentConverter
+{
+    /// <summary>Performs the conversion for an agent whose chat client and chat options are supplied.</summary>
+    /// <param name="chatClient">The chat client extracted from the calling agent (must surface a <see cref="FoundryChatClient"/> via <see cref="IChatClient.GetService(Type, object?)"/>).</param>
+    /// <param name="chatOptions">The agent's chat options (model id, instructions, temperature, top-p, tools). Required for the Responses Agent mode; ignored for the Prompt Agent mode.</param>
+    /// <param name="cancellationToken">A token that can cancel a server-side fetch (Prompt Agent AgentReference path).</param>
+    /// <returns>A <see cref="ProjectsAgentDefinition"/> suitable for <c>AgentAdministrationClient.CreateAgentVersionAsync</c>.</returns>
+    /// <exception cref="InvalidOperationException">Thrown when the chat client is not Foundry-backed, the agent was constructed via the Agent Endpoint mode, no model id is set for the Responses Agent mode, or an unsupported <see cref="AITool"/> is encountered.</exception>
+    public static async Task<ProjectsAgentDefinition> ConvertAsync(IChatClient chatClient, ChatOptions? chatOptions, CancellationToken cancellationToken)
+    {
+        Throw.IfNull(chatClient);
+
+        var foundryChatClient = chatClient.GetService<FoundryChatClient>()
+            ?? throw new InvalidOperationException(
+                "ToPromptAgentAsync requires a FoundryChatClient-backed agent. " +
+                "The supplied agent's chat client does not expose a FoundryChatClient via GetService<FoundryChatClient>().");
+
+        // Prompt Agent (Mode 2) with a cached server-side version (constructed via ProjectsAgentVersion or ProjectsAgentRecord).
+        if (foundryChatClient.GetService<ProjectsAgentVersion>() is { } cachedVersion)
+        {
+            return cachedVersion.Definition;
+        }
+
+        // Prompt Agent (Mode 2) AgentReference-only: fetch the agent definition from the service.
+        // Honor a pinned AgentReference.Version when present (Q-C fix); fall back to the latest
+        // version only when the reference is unpinned ("", null, or "latest").
+        if (foundryChatClient.GetService<AgentReference>() is { } agentReference)
+        {
+            var aiProjectClient = foundryChatClient.GetService<AIProjectClient>()
+                ?? throw new InvalidOperationException(
+                    "Cannot fetch the agent version because the FoundryChatClient does not expose an AIProjectClient.");
+
+            if (!string.IsNullOrWhiteSpace(agentReference.Version)
+                && !string.Equals(agentReference.Version, "latest", StringComparison.OrdinalIgnoreCase))
+            {
+                var pinnedVersion = await aiProjectClient.AgentAdministrationClient
+                    .GetAgentVersionAsync(agentReference.Name, agentReference.Version, cancellationToken)
+                    .ConfigureAwait(false);
+                return pinnedVersion.Value.Definition;
+            }
+
+            var record = await aiProjectClient.AgentAdministrationClient
+                .GetAgentAsync(agentReference.Name, cancellationToken)
+                .ConfigureAwait(false);
+            return record.Value.GetLatestVersion().Definition;
+        }
+
+        // Agent Endpoint (Mode 3): AgentName is set (parsed from URL) but no AgentReference exists
+        // locally. The agent definition lives only on the server and is not retrievable through this
+        // chat client, so conversion is not supported here.
+        if (foundryChatClient.AgentName is not null)
+        {
+            throw new InvalidOperationException(
+                "ToPromptAgentAsync is not supported for agents constructed via the Agent Endpoint mode (Mode 3); " +
+                "no local definition exists to convert.");
+        }
+
+        // Responses Agent (Mode 1): synthesize from ChatOptions.
+        return SynthesizeFromChatOptions(chatOptions);
+    }
+
+    private static DeclarativeAgentDefinition SynthesizeFromChatOptions(ChatOptions? chatOptions)
+    {
+        if (chatOptions is null || string.IsNullOrWhiteSpace(chatOptions.ModelId))
+        {
+            throw new InvalidOperationException(
+                "ToPromptAgentAsync requires a model id on the agent's ChatOptions to synthesize a prompt agent definition.");
+        }
+
+        var definition = new DeclarativeAgentDefinition(chatOptions.ModelId!)
+        {
+            Instructions = chatOptions.Instructions,
+            Temperature = chatOptions.Temperature,
+            TopP = chatOptions.TopP,
+        };
+
+        if (chatOptions.Tools is { Count: > 0 } tools)
+        {
+            foreach (var tool in tools)
+            {
+                definition.Tools.Add(ConvertTool(tool));
+            }
+        }
+
+        return definition;
+    }
+
+    private static ResponseTool ConvertTool(AITool tool)
+    {
+        Throw.IfNull(tool);
+
+        if (tool is AIFunction function)
+        {
+            // strictModeEnabled is intentionally true to match the Python spec's
+            // default behavior. JsonSchema on AIFunction is a JsonElement; serialize via its
+            // string form so the payload matches what callers pass elsewhere in this codebase.
+            return ResponseTool.CreateFunctionTool(
+                function.Name,
+                BinaryData.FromString(function.JsonSchema.ToString() ?? "{}"),
+                strictModeEnabled: true,
+                function.Description);
+        }
+
+        if (tool.GetService(typeof(ResponseTool)) is ResponseTool responseTool)
+        {
+            return responseTool;
+        }
+
+        throw new InvalidOperationException(
+            $"Cannot convert AITool of type '{tool.GetType().Name}' to a ResponseTool. " +
+            "Only AIFunction and AITool instances that wrap a ResponseTool (such as those produced by FoundryAITool factories) are supported.");
+    }
+}

dotnet/src/Microsoft.Agents.AI.Foundry/RequestOptionsExtensions.cs

@@ -1,58 +0,0 @@
-// Copyright (c) Microsoft. All rights reserved.
-
-using System.ClientModel.Primitives;
-using System.Collections.Generic;
-using System.Reflection;
-using System.Threading.Tasks;
-
-namespace Microsoft.Agents.AI;
-
-internal static class RequestOptionsExtensions
-{
-    /// <summary>Gets the singleton <see cref="PipelinePolicy"/> that adds a MEAI user-agent header.</summary>
-    internal static PipelinePolicy UserAgentPolicy => MeaiUserAgentPolicy.Instance;
-
-    /// <summary>Provides a pipeline policy that adds a "MEAI/x.y.z" user-agent header.</summary>
-    private sealed class MeaiUserAgentPolicy : PipelinePolicy
-    {
-        public static MeaiUserAgentPolicy Instance { get; } = new MeaiUserAgentPolicy();
-
-        private static readonly string s_userAgentValue = CreateUserAgentValue();
-
-        public override void Process(PipelineMessage message, IReadOnlyList<PipelinePolicy> pipeline, int currentIndex)
-        {
-            AddUserAgentHeader(message);
-            ProcessNext(message, pipeline, currentIndex);
-        }
-
-        public override ValueTask ProcessAsync(PipelineMessage message, IReadOnlyList<PipelinePolicy> pipeline, int currentIndex)
-        {
-            AddUserAgentHeader(message);
-            return ProcessNextAsync(message, pipeline, currentIndex);
-        }
-
-        private static void AddUserAgentHeader(PipelineMessage message) =>
-            message.Request.Headers.Add("User-Agent", s_userAgentValue);
-
-        private static string CreateUserAgentValue()
-        {
-            const string Name = "MEAI";
-
-            if (typeof(MeaiUserAgentPolicy).Assembly.GetCustomAttribute<AssemblyInformationalVersionAttribute>()?.InformationalVersion is string version)
-            {
-                int pos = version.IndexOf('+');
-                if (pos >= 0)
-                {
-                    version = version.Substring(0, pos);
-                }
-
-                if (version.Length > 0)
-                {
-                    return $"{Name}/{version}";
-                }
-            }
-
-            return Name;
-        }
-    }
-}

dotnet/src/Microsoft.Agents.AI.Foundry/ServedModelPolicy.cs

@@ -0,0 +1,67 @@
+// Copyright (c) Microsoft. All rights reserved.
+
+using System.ClientModel.Primitives;
+using System.Collections.Generic;
+using System.Threading.Tasks;
+
+namespace Microsoft.Agents.AI.Foundry;
+
+/// <summary>
+/// Pipeline policy that captures the <c>x-ms-served-model</c> response header from Azure OpenAI
+/// and stores it in <see cref="ServedModelScope"/> for consumption by <see cref="FoundryChatClient"/>.
+/// </summary>
+/// <remarks>
+/// <para>
+/// Azure OpenAI Responses API returns the deployment alias in <c>response.model</c> but the actual
+/// model snapshot (e.g. <c>gpt-5-nano-2025-08-07</c>) in the <c>x-ms-served-model</c> response header.
+/// This policy extracts the header after the HTTP roundtrip so the <see cref="FoundryChatClient"/>
+/// can overwrite <c>ChatResponse.ModelId</c> with the true model name.
+/// </para>
+/// <para>
+/// Registered once per <c>OpenAIRequestPolicies</c> instance via the MEAI 10.5.1 extension hook.
+/// When the header is absent (non-Azure endpoints), the scope is not set and the
+/// <see cref="FoundryChatClient"/> preserves the original model name.
+/// </para>
+/// </remarks>
+internal sealed class ServedModelPolicy : PipelinePolicy
+{
+    /// <summary>The Azure OpenAI response header that carries the actual served model name.</summary>
+    internal const string ServedModelHeader = "x-ms-served-model";
+
+    public static ServedModelPolicy Instance { get; } = new ServedModelPolicy();
+
+    private ServedModelPolicy()
+    {
+    }
+
+    public override void Process(PipelineMessage message, IReadOnlyList<PipelinePolicy> pipeline, int currentIndex)
+    {
+        ProcessNext(message, pipeline, currentIndex);
+        CaptureServedModel(message);
+    }
+
+    public override async ValueTask ProcessAsync(PipelineMessage message, IReadOnlyList<PipelinePolicy> pipeline, int currentIndex)
+    {
+        await ProcessNextAsync(message, pipeline, currentIndex).ConfigureAwait(false);
+        CaptureServedModel(message);
+    }
+
+    private static void CaptureServedModel(PipelineMessage message)
+    {
+        if (message.Response is null)
+        {
+            return;
+        }
+
+        if (message.Response.Headers.TryGetValue(ServedModelHeader, out string? servedModel)
+            && !string.IsNullOrWhiteSpace(servedModel))
+        {
+            // Write into the box (reference-type mutation) so the value is visible to the
+            // FoundryChatClient that pushed the box before calling the inner client.
+            if (ServedModelScope.Current is { } box)
+            {
+                box.Value = servedModel.Trim();
+            }
+        }
+    }
+}

dotnet/src/Microsoft.Agents.AI.Foundry/ServedModelScope.cs

@@ -0,0 +1,35 @@
+// Copyright (c) Microsoft. All rights reserved.
+
+using System.Runtime.CompilerServices;
+using System.Threading;
+
+namespace Microsoft.Agents.AI.Foundry;
+
+/// <summary>
+/// AsyncLocal carrier that bridges the <c>x-ms-served-model</c> response header value from the
+/// <see cref="ServedModelPolicy"/> running inside the SCM transport pipeline up to the
+/// <see cref="FoundryChatClient"/> decorator.
+/// </summary>
+/// <remarks>
+/// <para>
+/// Because <see cref="AsyncLocal{T}"/> mutations inside a child <c>async</c> method do not propagate
+/// back to the caller (copy-on-write semantics), this scope uses <see cref="StrongBox{T}"/> as an
+/// indirection layer. The <see cref="FoundryChatClient"/> pushes a fresh box onto the scope
+/// before calling the inner client; the <see cref="ServedModelPolicy"/> writes into the box's
+/// <see cref="StrongBox{T}.Value"/> (a reference-type mutation visible to anyone holding the same box).
+/// After the inner call returns, the client reads the box's value.
+/// </para>
+/// </remarks>
+internal static class ServedModelScope
+{
+    private static readonly AsyncLocal<StrongBox<string?>?> s_current = new();
+
+    /// <summary>
+    /// Gets or sets the per-async-flow served model box.
+    /// </summary>
+    public static StrongBox<string?>? Current
+    {
+        get => s_current.Value;
+        set => s_current.Value = value;
+    }
+}

dotnet/src/Microsoft.Agents.AI.Harness/HarnessAgent.cs

@@ -4,7 +4,11 @@ using System;
 using System.Collections.Generic;
 using System.Diagnostics.CodeAnalysis;
 using System.IO;
+using System.Linq;
 using Microsoft.Agents.AI.Compaction;
+#if NET
+using Microsoft.Agents.AI.Tools.Shell;
+#endif
 using Microsoft.Extensions.AI;
 using Microsoft.Shared.DiagnosticIds;
 using Microsoft.Shared.Diagnostics;
@@ -200,6 +204,14 @@ public sealed class HarnessAgent : DelegatingAIAgent
             result.Tools.Add(new HostedWebSearchTool());
         }
 
+#if NET
+        if (options?.ShellExecutor is ShellExecutor shellExecutor)
+        {
+            result.Tools ??= [];
+            result.Tools.Add(shellExecutor.AsAIFunction());
+        }
+#endif
+
         return result;
     }
 
@@ -249,6 +261,22 @@ public sealed class HarnessAgent : DelegatingAIAgent
             providers.Add(skillsProvider);
         }
 
+        if (options?.BackgroundAgents is IEnumerable<AIAgent> backgroundAgents)
+        {
+            var materializedAgents = backgroundAgents.ToList();
+            if (materializedAgents.Count > 0)
+            {
+                providers.Add(new BackgroundAgentsProvider(materializedAgents, options.BackgroundAgentsProviderOptions));
+            }
+        }
+
+#if NET
+        if (options?.ShellExecutor is ShellExecutor shellExecutor)
+        {
+            providers.Add(new ShellEnvironmentProvider(shellExecutor, options.ShellEnvironmentProviderOptions));
+        }
+#endif
+
         if (options?.AIContextProviders is IEnumerable<AIContextProvider> userProviders)
         {
             providers.AddRange(userProviders);

dotnet/src/Microsoft.Agents.AI.Harness/HarnessAgentOptions.cs

@@ -2,6 +2,9 @@
 
 using System.Collections.Generic;
 using System.Diagnostics.CodeAnalysis;
+#if NET
+using Microsoft.Agents.AI.Tools.Shell;
+#endif
 using Microsoft.Extensions.AI;
 using Microsoft.Shared.DiagnosticIds;
 
@@ -218,4 +221,49 @@ public sealed class HarnessAgentOptions
     /// This property is ignored when <see cref="DisableOpenTelemetry"/> is <see langword="true"/>.
     /// </remarks>
     public string? OpenTelemetrySourceName { get; set; }
+
+    /// <summary>
+    /// Gets or sets the collection of background agents available for delegation via <see cref="BackgroundAgentsProvider"/>.
+    /// </summary>
+    /// <remarks>
+    /// When non-null and non-empty, a <see cref="BackgroundAgentsProvider"/> is automatically included in the
+    /// agent's context providers, enabling the agent to start, monitor, and retrieve results from background tasks.
+    /// When <see langword="null"/> or empty, no <see cref="BackgroundAgentsProvider"/> is configured.
+    /// Each agent in the collection must have a non-empty <see cref="AIAgent.Name"/> and names must be unique
+    /// (case-insensitive). If these requirements are not met, <see cref="BackgroundAgentsProvider"/> will throw
+    /// an <see cref="System.ArgumentException"/> during construction.
+    /// </remarks>
+    public IEnumerable<AIAgent>? BackgroundAgents { get; set; }
+
+    /// <summary>
+    /// Gets or sets optional configuration for the <see cref="BackgroundAgentsProvider"/>.
+    /// </summary>
+    /// <remarks>
+    /// Use this to customize instructions or agent list formatting for the background agents feature.
+    /// This property is ignored when <see cref="BackgroundAgents"/> is <see langword="null"/> or empty.
+    /// </remarks>
+    public BackgroundAgentsProviderOptions? BackgroundAgentsProviderOptions { get; set; }
+
+#if NET
+    /// <summary>
+    /// Gets or sets the shell executor used to enable shell tool and environment probing via <see cref="ShellEnvironmentProvider"/>.
+    /// </summary>
+    /// <remarks>
+    /// When non-null, a <see cref="ShellEnvironmentProvider"/> is automatically included in the agent's context
+    /// providers (injecting OS/shell/CWD information into the system prompt), and the executor's
+    /// <see cref="ShellExecutor.AsAIFunction"/> is registered as a callable tool.
+    /// When <see langword="null"/> (the default), no shell features are enabled.
+    /// </remarks>
+    public ShellExecutor? ShellExecutor { get; set; }
+
+    /// <summary>
+    /// Gets or sets optional configuration for the <see cref="ShellEnvironmentProvider"/>.
+    /// </summary>
+    /// <remarks>
+    /// Use this to customize which tools are probed, the probe timeout, shell family override,
+    /// or the instructions formatter.
+    /// This property is ignored when <see cref="ShellExecutor"/> is <see langword="null"/>.
+    /// </remarks>
+    public ShellEnvironmentProviderOptions? ShellEnvironmentProviderOptions { get; set; }
+#endif
 }

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

@@ -15,6 +15,10 @@
     <ProjectReference Include="..\Microsoft.Agents.AI\Microsoft.Agents.AI.csproj" />
   </ItemGroup>
 
+  <ItemGroup Condition="$([MSBuild]::IsTargetFrameworkCompatible('$(TargetFramework)', 'net8.0'))">
+    <ProjectReference Include="..\Microsoft.Agents.AI.Tools.Shell\Microsoft.Agents.AI.Tools.Shell.csproj" />
+  </ItemGroup>
+
   <PropertyGroup>
     <!-- NuGet Package Settings -->
     <Title>Microsoft Agent Framework Harness</Title>

dotnet/src/Microsoft.Agents.AI.Tools.Shell/DockerShellExecutor.cs

@@ -248,7 +248,7 @@ public sealed class DockerShellExecutor : ShellExecutor
     /// Build the AIFunction for this tool.
     /// </summary>
     /// <remarks>
-    /// When <paramref name="requireApproval"/> is <see langword="null"/>
+    /// When <paramref name="requireApproval"/> is <see langword="true"/>
     /// (the default), the returned function is wrapped in
     /// <see cref="ApprovalRequiredAIFunction"/>. The caller must
     /// explicitly pass <see langword="false"/> to opt out of approval
@@ -259,14 +259,12 @@ public sealed class DockerShellExecutor : ShellExecutor
     /// <param name="name">Function name surfaced to the model.</param>
     /// <param name="description">Function description for the model.</param>
     /// <param name="requireApproval">
-    /// <see langword="true"/> or <see langword="null"/> (the default)
-    /// wraps the function in <see cref="ApprovalRequiredAIFunction"/>;
+    /// <see langword="true"/> (the default) wraps the function in
+    /// <see cref="ApprovalRequiredAIFunction"/>;
     /// <see langword="false"/> opts out and returns the raw function.
     /// </param>
-    public AIFunction AsAIFunction(string name = "run_shell", string? description = null, bool? requireApproval = null)
+    public override AIFunction AsAIFunction(string name = "run_shell", string? description = null, bool requireApproval = true)
     {
-        var effectiveRequireApproval = requireApproval ?? true;
-
         description ??=
             "Execute a single shell command inside an isolated Docker container and return its " +
             "stdout, stderr, and exit code. The container has no network, no host filesystem access " +
@@ -292,7 +290,7 @@ public sealed class DockerShellExecutor : ShellExecutor
             },
             new AIFunctionFactoryOptions { Name = name, Description = description });
 
-        return effectiveRequireApproval ? new ApprovalRequiredAIFunction(fn) : fn;
+        return requireApproval ? new ApprovalRequiredAIFunction(fn) : fn;
     }
 
     /// <summary>

dotnet/src/Microsoft.Agents.AI.Tools.Shell/LocalShellExecutor.cs

@@ -325,7 +325,7 @@ public sealed class LocalShellExecutor : ShellExecutor
     /// container where the tool itself is the boundary).
     /// </param>
     /// <returns>An <see cref="AIFunction"/> wrapping <see cref="RunAsync"/>.</returns>
-    public AIFunction AsAIFunction(string name = "run_shell", string? description = null, bool requireApproval = true)
+    public override AIFunction AsAIFunction(string name = "run_shell", string? description = null, bool requireApproval = true)
     {
         if (!requireApproval && !this._acknowledgeUnsafe)
         {

dotnet/src/Microsoft.Agents.AI.Tools.Shell/ShellExecutor.cs

@@ -3,6 +3,7 @@
 using System;
 using System.Threading;
 using System.Threading.Tasks;
+using Microsoft.Extensions.AI;
 
 namespace Microsoft.Agents.AI.Tools.Shell;
 
@@ -65,6 +66,20 @@ public abstract class ShellExecutor : IAsyncDisposable
     /// <param name="cancellationToken">Cancellation token.</param>
     public abstract Task<ShellResult> RunAsync(string command, CancellationToken cancellationToken = default);
 
+    /// <summary>
+    /// Build an <see cref="AIFunction"/> bound to this executor, suitable for
+    /// registering with an agent as a callable tool.
+    /// </summary>
+    /// <param name="name">Function name visible to the model.</param>
+    /// <param name="description">Function description for the model.</param>
+    /// <param name="requireApproval">
+    /// When <see langword="true"/> (the default), wraps the function in
+    /// <see cref="ApprovalRequiredAIFunction"/> so every invocation requires
+    /// explicit user approval before executing.
+    /// </param>
+    /// <returns>An <see cref="AIFunction"/> wrapping <see cref="RunAsync"/>.</returns>
+    public abstract AIFunction AsAIFunction(string name = "run_shell", string? description = null, bool requireApproval = true);
+
     /// <inheritdoc />
     public abstract ValueTask DisposeAsync();
 }

dotnet/src/Microsoft.Agents.AI.Workflows.Declarative/Extensions/AgentProviderExtensions.cs

@@ -22,9 +22,13 @@ internal static class AgentProviderExtensions
     {
         IAsyncEnumerable<AgentResponseUpdate> agentUpdates = agentProvider.InvokeAgentAsync(agentName, null, conversationId, inputMessages, inputArguments, cancellationToken);
 
-        // Enable "autoSend" behavior if this is the workflow conversation.
+        // Determine whether the target conversation is the workflow conversation
+        // (used below to decide whether to mirror messages into the workflow conversation
+        // when an agent runs against a different conversation). The caller's autoSend
+        // value is honored as-is — when the workflow.yaml specifies autoSend: false the
+        // raw agent output must not be streamed to the caller, even when the agent is
+        // running on the workflow conversation.
         bool isWorkflowConversation = context.IsWorkflowConversation(conversationId, out string? workflowConversationId);
-        autoSend |= isWorkflowConversation;
 
         // Process the agent response updates.
         List<AgentResponseUpdate> updates = [];

dotnet/src/Microsoft.Agents.AI.Workflows.Declarative/Interpreter/DeclarativeActionExecutor.cs

@@ -71,6 +71,13 @@ internal abstract class DeclarativeActionExecutor : Executor<ActionExecutorResul
     [SendsMessage(typeof(ActionExecutorResult))]
     public override async ValueTask HandleAsync(ActionExecutorResult message, IWorkflowContext context, CancellationToken cancellationToken = default)
     {
+        // Establish the Foundry ProductContext on the current async logical context before
+        // running any code that reads PropertyPath.VariableName / NamespaceAlias. ObjectModel
+        // resolves those lazily against AsyncLocal<ProductContext>; when the workflow is
+        // hosted (AsAIAgent + AddFoundryResponses) each HTTP request runs on a fresh logical
+        // context where the build-thread setting does not flow.
+        WorkflowDiagnostics.SetFoundryProduct();
+
         if (this.Model.Disabled)
         {
             Debug.WriteLine($"DISABLED {this.GetType().Name} [{this.Id}]");

dotnet/src/Microsoft.Agents.AI.Workflows.Declarative/ObjectModel/InvokeAzureAgentExecutor.cs

@@ -192,13 +192,16 @@ internal sealed class InvokeAzureAgentExecutor(InvokeAzureAgent model, ResponseA
 
     private bool GetAutoSendValue()
     {
-        if (this.AgentOutput?.AutoSend is null)
+        // AzureAgentOutput.AutoSend is never null — it returns a literal-false default
+        // when the YAML omits the field. Use AutoSendIsDefaultValue to distinguish an
+        // explicit autoSend value from the implicit default, and treat the implicit
+        // default as autoSend = true (the historical behavior for actions that omit
+        // autoSend or have no output block at all).
+        if (this.AgentOutput is { AutoSendIsDefaultValue: false } output)
         {
-            return true;
+            return this.Evaluator.GetValue(output.AutoSend).Value;
         }
 
-        EvaluationResult<bool> autoSendResult = this.Evaluator.GetValue(this.AgentOutput.AutoSend);
-
-        return autoSendResult.Value;
+        return true;
     }
 }

dotnet/src/Microsoft.Agents.AI.Workflows.Declarative/ObjectModel/InvokeFunctionToolExecutor.cs

@@ -1,5 +1,6 @@
 // Copyright (c) Microsoft. All rights reserved.
 
+using System;
 using System.Collections.Generic;
 using System.Linq;
 using System.Text.Json;
@@ -103,6 +104,24 @@ internal sealed class InvokeFunctionToolExecutor(
         FunctionResultContent? matchingResult = functionResults
             .FirstOrDefault(r => r.CallId == this.Id);
 
+        // When the caller approved an approval-required function call but didn't execute it
+        // locally (the hosted Foundry scenario, where mcp_approval_response is converted to a
+        // ToolApprovalResponseContent only), invoke the registered AIFunction here so that the
+        // declarative workflow can capture the result and continue (e.g. for downstream
+        // SendActivity/PropertyPath consumers like {Local.Result}).
+        if (matchingResult is null)
+        {
+            ToolApprovalResponseContent? approval = response.Messages
+                .SelectMany(m => m.Contents)
+                .OfType<ToolApprovalResponseContent>()
+                .FirstOrDefault(r => r.RequestId == this.Id);
+
+            if (approval is { Approved: true })
+            {
+                matchingResult = await this.InvokeRegisteredFunctionAsync(cancellationToken).ConfigureAwait(false);
+            }
+        }
+
         if (matchingResult is not null)
         {
             // Store the result in output variable
@@ -241,6 +260,48 @@ internal sealed class InvokeFunctionToolExecutor(
         return conversationIdValue.Length == 0 ? null : conversationIdValue;
     }
 
+    private async ValueTask<FunctionResultContent?> InvokeRegisteredFunctionAsync(CancellationToken cancellationToken)
+    {
+        string functionName = this.GetFunctionName();
+        AIFunction? function = agentProvider.Functions?.FirstOrDefault(
+            f => string.Equals(f.Name, functionName, StringComparison.Ordinal));
+
+        if (function is null)
+        {
+            return new FunctionResultContent(this.Id, result: null)
+            {
+                Exception = new InvalidOperationException(
+                    $"Function '{functionName}' is not registered with the agent provider."),
+            };
+        }
+
+        Dictionary<string, object?>? arguments = this.GetArguments();
+        AIFunctionArguments? functionArguments = arguments is null ? null : new AIFunctionArguments(arguments);
+
+        object? result;
+        try
+        {
+            result = await function.InvokeAsync(functionArguments, cancellationToken).ConfigureAwait(false);
+        }
+        catch (Exception ex) when (ex is not OperationCanceledException)
+        {
+            return new FunctionResultContent(this.Id, result: null) { Exception = ex };
+        }
+
+        // Match FunctionInvokingChatClient's serialization: pass strings through as-is and
+        // JSON-serialize anything else so structured results remain consumable by downstream
+        // PropertyPath consumers such as {Local.RefundResult}. Use AIJsonUtilities so the
+        // same trim/AOT-friendly serializer chain used elsewhere in the framework is applied.
+        string serialized = result switch
+        {
+            null => string.Empty,
+            string s => s,
+            _ => JsonSerializer.Serialize(result, AIJsonUtilities.DefaultOptions.GetTypeInfo(result.GetType())),
+        };
+
+        return new FunctionResultContent(this.Id, serialized);
+    }
+
     private bool GetRequireApproval()
     {
         if (this.Model.RequireApproval is null)
@@ -253,12 +314,16 @@ internal sealed class InvokeFunctionToolExecutor(
 
     private bool GetAutoSendValue()
     {
-        if (this.Model.Output?.AutoSend is null)
+        // InvokeToolOutput.AutoSend is never null — it returns a literal-false default
+        // when the YAML omits the field. Use AutoSendIsDefaultValue to distinguish an
+        // explicit autoSend value from the implicit default, and treat the implicit
+        // default as autoSend = true (the historical behavior).
+        if (this.Model.Output is { AutoSendIsDefaultValue: false } output)
         {
-            return true;
+            return this.Evaluator.GetValue(output.AutoSend).Value;
         }
 
-        return this.Evaluator.GetValue(this.Model.Output.AutoSend).Value;
+        return true;
     }
 
     private Dictionary<string, object?>? GetArguments()

dotnet/src/Microsoft.Agents.AI.Workflows.Declarative/ObjectModel/InvokeMcpToolExecutor.cs

@@ -311,12 +311,16 @@ internal sealed class InvokeMcpToolExecutor(
 
     private bool GetAutoSendValue()
     {
-        if (this.Model.Output?.AutoSend is null)
+        // InvokeToolOutput.AutoSend is never null — it returns a literal-false default
+        // when the YAML omits the field. Use AutoSendIsDefaultValue to distinguish an
+        // explicit autoSend value from the implicit default, and treat the implicit
+        // default as autoSend = true (the historical behavior).
+        if (this.Model.Output is { AutoSendIsDefaultValue: false } output)
         {
-            return true;
+            return this.Evaluator.GetValue(output.AutoSend).Value;
         }
 
-        return this.Evaluator.GetValue(this.Model.Output.AutoSend).Value;
+        return true;
     }
 
     private string? GetConnectionName()

dotnet/src/Microsoft.Agents.AI.Workflows.Declarative/ObjectModel/SendActivityExecutor.cs

@@ -21,12 +21,21 @@ internal sealed class SendActivityExecutor(SendActivity model, WorkflowFormulaSt
 
             await context.AddEventAsync(new MessageActivityEvent(activityText.Trim()), cancellationToken).ConfigureAwait(false);
 
+            ChatMessage message = new(ChatRole.Assistant, activityText);
+
+            // Emit an AgentResponseUpdateEvent so chat protocols (e.g. AsAIAgent) receive the
+            // activity text as streaming chat content. This event is yielded by WorkflowSession
+            // unconditionally, mirroring how AgentProviderExtensions surfaces autoSend agent
+            // updates — without it, SendActivity output is dropped whenever the host runs with
+            // includeWorkflowOutputsInResponse = false (the default).
+            AgentResponseUpdate update = new(ChatRole.Assistant, activityText) { AuthorName = this.Id };
+            await context.AddEventAsync(new AgentResponseUpdateEvent(this.Id, update), cancellationToken).ConfigureAwait(false);
+
             // Route through YieldOutputAsync so the activity participates in the workflow's
             // output-filter pipeline. The runner currently special-cases AgentResponse to
-            // produce an AgentResponseEvent identical to the one we'd build by hand, so this
-            // is behavior-preserving today and forward-compatible if filtering is ever
-            // applied to agent responses.
-            AgentResponse response = new([new ChatMessage(ChatRole.Assistant, activityText)]);
+            // produce an AgentResponseEvent identical to the one we'd build by hand, which
+            // is the gated summary surfaced only when includeWorkflowOutputsInResponse = true.
+            AgentResponse response = new([message]);
             await context.YieldOutputAsync(response, cancellationToken).ConfigureAwait(false);
         }
 

dotnet/tests/Foundry.IntegrationTests/FoundryAgentExtensionsTests.cs

@@ -0,0 +1,229 @@
+// Copyright (c) Microsoft. All rights reserved.
+
+using System;
+using System.IO;
+using System.Threading.Tasks;
+using AgentConformance.IntegrationTests.Support;
+using Azure.AI.Projects;
+using Azure.AI.Projects.Agents;
+using Microsoft.Agents.AI;
+using Microsoft.Agents.AI.Foundry;
+using OpenAI.Files;
+using OpenAI.Responses;
+using OpenAI.VectorStores;
+using Shared.IntegrationTests;
+
+namespace Foundry.IntegrationTests;
+
+/// <summary>
+/// Integration tests for the file and vector-store forwarder extensions on
+/// <see cref="FoundryAgent"/> declared in <see cref="FoundryAgentExtensions"/>. End-to-end
+/// counterparts of the unit tests in
+/// <c>FoundryAgentExtensionsTests</c> that exercise the live Foundry project pipeline.
+/// </summary>
+/// <remarks>
+/// Mirrors <see cref="FoundryVersionedAgentCreateTests.CreateAgent_CreatesAgentWithVectorStoresAsync(string)"/>
+/// in shape (file upload → vector store creation → FileSearchTool answer → cleanup), but routes
+/// every helper call through the new <see cref="FoundryAgent"/> extensions instead of the raw
+/// <c>projectOpenAIClient.GetProjectFilesClient()</c> / <c>GetProjectVectorStoresClient()</c>
+/// path. Skipped by default for the same reasons as the existing vector-store IT (cost and
+/// runtime); flip Skip to run manually after seeding the right Foundry project.
+/// </remarks>
+public class FoundryAgentExtensionsTests
+{
+    private readonly AIProjectClient _client = new(
+        new Uri(TestConfiguration.GetRequiredValue(TestSettings.AzureAIProjectEndpoint)),
+        TestAzureCliCredentials.CreateAzureCliCredential());
+
+    [Fact(Skip = "For manual testing only")]
+    public async Task UploadFileAsync_ViaAgentExtension_UploadsToProjectAsync()
+    {
+        // Arrange — non-versioned Responses Agent (Mode 1) so we do not have to provision a server-side agent.
+        var agent = this._client.AsAIAgent(
+            model: TestConfiguration.GetRequiredValue(TestSettings.AzureAIModelDeploymentName),
+            instructions: "Be helpful.");
+        var foundryAgent = this.WrapAsFoundryAgent(agent);
+
+        var filePath = Path.GetTempFileName() + ".txt";
+        File.WriteAllText(filePath, "agent-extensions integration test payload");
+
+        OpenAIFile? uploaded = null;
+        try
+        {
+            // Act.
+            uploaded = await foundryAgent.UploadFileAsync(filePath, FileUploadPurpose.Assistants);
+
+            // Assert.
+            Assert.NotNull(uploaded);
+            Assert.False(string.IsNullOrEmpty(uploaded.Id));
+            Assert.Equal(Path.GetFileName(filePath), uploaded.Filename);
+        }
+        finally
+        {
+            if (uploaded is not null)
+            {
+                await foundryAgent.DeleteFileAsync(uploaded.Id);
+            }
+
+            File.Delete(filePath);
+        }
+    }
+
+    [Fact(Skip = "For manual testing only")]
+    public async Task DeleteFileAsync_ViaAgentExtension_RemovesUploadedFileAsync()
+    {
+        var agent = this._client.AsAIAgent(
+            model: TestConfiguration.GetRequiredValue(TestSettings.AzureAIModelDeploymentName),
+            instructions: "Be helpful.");
+        var foundryAgent = this.WrapAsFoundryAgent(agent);
+
+        var filePath = Path.GetTempFileName() + ".txt";
+        File.WriteAllText(filePath, "delete-me payload");
+
+        try
+        {
+            var uploaded = await foundryAgent.UploadFileAsync(filePath, FileUploadPurpose.Assistants);
+
+            // Act.
+            var result = await foundryAgent.DeleteFileAsync(uploaded.Id);
+
+            // Assert.
+            Assert.NotNull(result);
+            Assert.Equal(uploaded.Id, result.FileId);
+            Assert.True(result.Deleted);
+        }
+        finally
+        {
+            File.Delete(filePath);
+        }
+    }
+
+    [Fact(Skip = "For manual testing only")]
+    public async Task CreateVectorStoreAsync_ViaAgentExtension_BuildsStoreAndAnswersFileSearchQuestionAsync()
+    {
+        // Mirrors CreateAgent_CreatesAgentWithVectorStoresAsync but the upload-then-create-store
+        // sequence routes through the FoundryAgent.CreateVectorStoreAsync extension (single call
+        // that uploads, creates the store, and polls until ready). The resulting vector store id
+        // is then wired to a versioned agent's FileSearch tool and queried for a known value.
+        string AgentName = FoundryVersionedAgentFixture.GenerateUniqueAgentName("VectorStoreExtAgent");
+        const string AgentInstructions = """
+            You are a helpful agent that can help fetch data from files you know about.
+            Use the File Search Tool to look up codes for words.
+            Do not answer a question unless you can find the answer using the File Search Tool.
+            """;
+
+        // Non-versioned helper agent that owns the upload pipeline.
+        var helperAgent = this._client.AsAIAgent(
+            model: TestConfiguration.GetRequiredValue(TestSettings.AzureAIModelDeploymentName),
+            instructions: "Be helpful.");
+        var helperFoundryAgent = this.WrapAsFoundryAgent(helperAgent);
+
+        var searchFilePath = Path.GetTempFileName() + "wordcodelookup.txt";
+        File.WriteAllText(searchFilePath, "The word 'apple' uses the code 442345, while the word 'banana' uses the code 673457.");
+
+        VectorStore? vectorStore = null;
+        FoundryAgent? versionedAgent = null;
+        try
+        {
+            // Act — single agent-level helper call uploads, creates, and waits until ready.
+            vectorStore = await helperFoundryAgent.CreateVectorStoreAsync(
+                "WordCodeLookup_ExtensionVectorStore",
+                new[] { searchFilePath });
+
+            Assert.NotNull(vectorStore);
+            Assert.False(string.IsNullOrEmpty(vectorStore.Id));
+            Assert.NotEqual(VectorStoreStatus.InProgress, vectorStore.Status);
+
+            // Wire the store id into a versioned agent's FileSearch tool to prove it is actually usable.
+            var definition = new DeclarativeAgentDefinition(TestConfiguration.GetRequiredValue(TestSettings.AzureAIModelDeploymentName))
+            {
+                Instructions = AgentInstructions,
+                Tools = { ResponseTool.CreateFileSearchTool(vectorStoreIds: [vectorStore.Id]) },
+            };
+
+            var agentVersion = await this._client.AgentAdministrationClient.CreateAgentVersionAsync(
+                AgentName,
+                new ProjectsAgentVersionCreationOptions(definition));
+
+            versionedAgent = this._client.AsAIAgent(agentVersion);
+
+            // Assert.
+            var result = await versionedAgent.RunAsync("Can you give me the documented code for 'banana'?");
+            Assert.Contains("673457", result.ToString());
+        }
+        finally
+        {
+            if (versionedAgent is not null)
+            {
+                await this._client.AgentAdministrationClient.DeleteAgentAsync(versionedAgent.Name);
+            }
+
+            // Cleanup the vector store via the new extension too.
+            if (vectorStore is not null)
+            {
+                await helperFoundryAgent.DeleteVectorStoreAsync(vectorStore.Id);
+            }
+
+            File.Delete(searchFilePath);
+        }
+    }
+
+    [Fact(Skip = "For manual testing only")]
+    public async Task DeleteVectorStoreAsync_ViaAgentExtension_RemovesStoreAsync()
+    {
+        var agent = this._client.AsAIAgent(
+            model: TestConfiguration.GetRequiredValue(TestSettings.AzureAIModelDeploymentName),
+            instructions: "Be helpful.");
+        var foundryAgent = this.WrapAsFoundryAgent(agent);
+
+        var filePath = Path.GetTempFileName() + ".txt";
+        File.WriteAllText(filePath, "delete-store payload");
+
+        VectorStore? vectorStore = null;
+        try
+        {
+            vectorStore = await foundryAgent.CreateVectorStoreAsync(
+                "DeleteVectorStore_ExtensionTest",
+                new[] { filePath });
+
+            // Act.
+            var result = await foundryAgent.DeleteVectorStoreAsync(vectorStore.Id);
+
+            // Assert.
+            Assert.NotNull(result);
+            Assert.Equal(vectorStore.Id, result.VectorStoreId);
+            Assert.True(result.Deleted);
+            vectorStore = null;
+        }
+        finally
+        {
+            if (vectorStore is not null)
+            {
+                await foundryAgent.DeleteVectorStoreAsync(vectorStore.Id);
+            }
+
+            File.Delete(filePath);
+        }
+    }
+
+    /// <summary>
+    /// Resolves the underlying <see cref="FoundryAgent"/> from an <see cref="AIAgent"/> handle
+    /// returned by <c>AIProjectClient.AsAIAgent(model, instructions)</c>. The Mode 1 overload
+    /// returns a <see cref="ChatClientAgent"/>; the extension forwarders we test live on
+    /// <see cref="FoundryAgent"/>, so callers wanting them through this entry point need to
+    /// reach for the FoundryAgent constructor instead. This helper makes the test setup
+    /// consistent across the four IT scenarios.
+    /// </summary>
+    private FoundryAgent WrapAsFoundryAgent(AIAgent agent)
+    {
+        // The Mode 1 AsAIAgent overload returns ChatClientAgent rather than FoundryAgent; use
+        // the FoundryAgent projectEndpoint+model+instructions ctor to get the same underlying
+        // FoundryChatClient surfaced through a FoundryAgent typed handle.
+        _ = agent;
+        return new FoundryAgent(
+            projectEndpoint: new Uri(TestConfiguration.GetRequiredValue(TestSettings.AzureAIProjectEndpoint)),
+            credential: TestAzureCliCredentials.CreateAzureCliCredential(),
+            model: TestConfiguration.GetRequiredValue(TestSettings.AzureAIModelDeploymentName),
+            instructions: "Be helpful.");
+    }
+}

dotnet/tests/Foundry.IntegrationTests/FoundryVersionedAgentStructuredOutputRunTests.cs

@@ -11,7 +11,7 @@ namespace Foundry.IntegrationTests;
 public class FoundryVersionedAgentStructuredOutputRunTests() : StructuredOutputRunTests<FoundryVersionedAgentStructuredOutputFixture<CityInfo>>(() => new FoundryVersionedAgentStructuredOutputFixture<CityInfo>())
 {
     private const string NotSupported = "Versioned Foundry agents do not support specifying structured output type at invocation time.";
-    private const string ResponseFormatNotSupported = "AzureAIProjectChatClient clears ResponseFormat for versioned agents; structured output must be defined in the server-side agent definition.";
+    private const string ResponseFormatNotSupported = "FoundryChatClient clears ResponseFormat for versioned agents; structured output must be defined in the server-side agent definition.";
 
     /// <summary>
     /// Verifies that response format provided at agent initialization is used when invoking RunAsync.
@@ -41,7 +41,7 @@ public class FoundryVersionedAgentStructuredOutputRunTests() : StructuredOutputR
     /// </summary>
     /// <remarks>
     /// Versioned Foundry agents do not support specifying the structured output type at invocation time yet.
-    /// The type T provided to RunAsync&lt;T&gt; is ignored by AzureAIProjectChatClient and is only used
+    /// The type T provided to RunAsync&lt;T&gt; is ignored by FoundryChatClient and is only used
     /// for deserializing the agent response by AgentResponse&lt;T&gt;.Result.
     /// </remarks>
     [RetryFact(Constants.RetryCount, Constants.RetryDelay, Skip = ResponseFormatNotSupported)]

dotnet/tests/Foundry.IntegrationTests/ResponsesAgentServedModelTests.cs

@@ -0,0 +1,85 @@
+// Copyright (c) Microsoft. All rights reserved.
+
+using System;
+using System.Text.RegularExpressions;
+using System.Threading.Tasks;
+using AgentConformance.IntegrationTests.Support;
+using Azure.AI.Projects;
+using Microsoft.Agents.AI;
+using Microsoft.Extensions.AI;
+using Shared.IntegrationTests;
+
+namespace Foundry.IntegrationTests;
+
+/// <summary>
+/// Integration tests validating that the <c>x-ms-served-model</c> response header
+/// returned by the Azure OpenAI Responses API is surfaced on <see cref="ChatResponse.ModelId"/>.
+/// </summary>
+public class ResponsesAgentServedModelTests
+{
+    // Matches a dated served-model snapshot, e.g. "gpt-5-nano-2025-08-07".
+    private static readonly Regex s_snapshotRegex = new(@"-\d{4}-\d{2}-\d{2}$", RegexOptions.Compiled);
+
+    private static Uri Endpoint => new(TestConfiguration.GetRequiredValue(TestSettings.AzureAIProjectEndpoint));
+
+    private static string DeploymentName => TestConfiguration.GetRequiredValue(TestSettings.AzureAIModelDeploymentName);
+
+    private readonly AIProjectClient _client = new(Endpoint, TestAzureCliCredentials.CreateAzureCliCredential());
+
+    [Fact]
+    public async Task GetResponseAsync_ReturnsServedModelSnapshotOnModelIdAsync()
+    {
+        // Arrange
+        ChatClientAgent agent = this._client.AsAIAgent(
+            model: DeploymentName,
+            instructions: "You are a helpful assistant. Reply with a single short word.",
+            name: "ServedModelTest");
+
+        IChatClient chatClient = agent.ChatClient;
+
+        // Act
+        ChatResponse response = await chatClient.GetResponseAsync(
+            [new ChatMessage(ChatRole.User, "Say hi.")],
+            new ChatOptions { ModelId = DeploymentName });
+
+        // Assert
+        AssertServedModel(response.ModelId);
+    }
+
+    [Fact]
+    public async Task RunAsync_AgentResponseRawRepresentationCarriesServedModelAsync()
+    {
+        // Arrange
+        ChatClientAgent agent = this._client.AsAIAgent(
+            model: DeploymentName,
+            instructions: "You are a helpful assistant. Reply with a single short word.",
+            name: "ServedModelTestRun");
+
+        // Act
+        AgentResponse agentResponse = await agent.RunAsync("Say hi.");
+
+        // Assert
+        ChatResponse? chatResponse = agentResponse.RawRepresentation as ChatResponse;
+        Assert.NotNull(chatResponse);
+        AssertServedModel(chatResponse!.ModelId);
+    }
+
+    private static void AssertServedModel(string? modelId)
+    {
+        Assert.False(string.IsNullOrWhiteSpace(modelId), "ChatResponse.ModelId must be populated.");
+
+        // Primary invariant: the served-model value must look like a dated snapshot
+        // (e.g. "gpt-5-nano-2025-08-07"). This is what the x-ms-served-model header carries.
+        // Only when the configured deployment name itself already matches the snapshot pattern
+        // do we fall back to permitting equality with the deployment alias.
+        bool aliasIsSnapshot = s_snapshotRegex.IsMatch(DeploymentName);
+
+        if (aliasIsSnapshot)
+        {
+            return;
+        }
+
+        Assert.Matches(s_snapshotRegex, modelId!);
+        Assert.NotEqual(DeploymentName, modelId);
+    }
+}

dotnet/tests/Microsoft.Agents.AI.Foundry.Hosting.UnitTests/HostedOutboundUserAgentTests.cs

@@ -64,15 +64,29 @@ public sealed class HostedOutboundUserAgentTests : IAsyncDisposable
         var inboundBody = await inboundResponse.Content.ReadAsStringAsync();
 
         // Assert: at least one OUTBOUND request reached the fake transport, AND it carries the
-        // foundry-hosting/agent-framework-dotnet/{version} supplement on its User-Agent.
-        // (We don't care about the inbound response shape — only that the agent's call to MEAI
-        // triggered an outbound request whose UA reaches the sandbox boundary correctly.)
+        // combined hosted segment foundry-hosting/agent-framework-dotnet/{version} on its
+        // User-Agent. This matches Python's contract
+        // (foundry-hosting/agent-framework-python/{version}, see
+        // python/packages/core/agent_framework/_telemetry.py): a single combined segment when
+        // hosted, never two separate ones. The bare agent-framework-dotnet/{version} segment
+        // (from AgentFrameworkUserAgentPolicy in FoundryChatClient) must be upgraded in place
+        // by HostedAgentUserAgentPolicy — never appear duplicated.
         Assert.True(this._outboundHandler!.Requests.Count > 0,
             $"Expected at least one outbound request. Inbound status: {(int)inboundResponse.StatusCode}, body: {inboundBody}");
         var outbound = this._outboundHandler.Requests[0];
         Assert.StartsWith(TestEndpoint, outbound.Uri);
         Assert.Contains("MEAI/", outbound.UserAgent);
-        Assert.Contains("foundry-hosting/agent-framework-dotnet", outbound.UserAgent);
+        Assert.Contains("foundry-hosting/agent-framework-dotnet/", outbound.UserAgent);
+
+        // The bare agent-framework-dotnet/{v} segment must NOT appear separately when the
+        // combined form is present — Python emits a single combined value when the hosted
+        // prefix is registered, and .NET preserves that contract via the in-place upgrade in
+        // HostedAgentUserAgentPolicy.
+        var combinedIdx = outbound.UserAgent!.IndexOf("foundry-hosting/agent-framework-dotnet/", StringComparison.Ordinal);
+        var beforeCombined = outbound.UserAgent.Substring(0, combinedIdx);
+        var afterCombined = outbound.UserAgent.Substring(combinedIdx + "foundry-hosting/agent-framework-dotnet/".Length);
+        Assert.DoesNotContain("agent-framework-dotnet/", beforeCombined);
+        Assert.DoesNotContain("agent-framework-dotnet/", afterCombined);
     }
 
     private async Task StartHostedServerAsync()
@@ -197,6 +211,179 @@ public sealed class HostedOutboundUserAgentTests : IAsyncDisposable
         return array?.Length ?? -1;
     }
 
+    // -----------------------------------------------------------------------
+    // Direct unit tests for HostedAgentUserAgentPolicy's in-place upgrade behavior.
+    // These run the policy on a synthetic ClientPipeline (no hosting infrastructure)
+    // so the upgrade logic itself can be asserted in isolation.
+    // -----------------------------------------------------------------------
+
+    [Fact]
+    public async Task HostedAgentUserAgentPolicy_UpgradesBareAgentFrameworkSegment_InPlaceAsync()
+    {
+        // Arrange: an upstream per-call policy stamps the bare agent-framework-dotnet/{version}
+        // segment (matching what AgentFrameworkUserAgentPolicy would write in non-hosted code).
+        // Then HostedAgentUserAgentPolicy runs and must REPLACE that segment with the combined
+        // foundry-hosting/agent-framework-dotnet/{version} form, not append a duplicate.
+        using var handler = new InspectingHandler();
+#pragma warning disable CA5399
+        using var httpClient = new HttpClient(handler);
+#pragma warning restore CA5399
+
+        var pipeline = ClientPipeline.Create(
+            new ClientPipelineOptions { Transport = new HttpClientPipelineTransport(httpClient) },
+            perCallPolicies: [new SetUserAgentPolicy("agent-framework-dotnet/9.9.9"), HostedAgentUserAgentPolicy.Instance],
+            perTryPolicies: default,
+            beforeTransportPolicies: default);
+
+        // Act
+        var message = pipeline.CreateMessage();
+        message.Request.Method = "POST";
+        message.Request.Uri = new Uri("https://example.test/anything");
+        await pipeline.SendAsync(message);
+
+        // Assert: combined form is present; bare form is gone (no duplicate agent-framework segment).
+        Assert.NotNull(handler.LastUserAgent);
+        Assert.Contains("foundry-hosting/agent-framework-dotnet/", handler.LastUserAgent);
+        var ua = handler.LastUserAgent!;
+        var firstAgentFramework = ua.IndexOf("agent-framework-dotnet/", StringComparison.Ordinal);
+        Assert.True(firstAgentFramework >= 0, "Expected agent-framework-dotnet segment.");
+        var secondAgentFramework = ua.IndexOf("agent-framework-dotnet/", firstAgentFramework + 1, StringComparison.Ordinal);
+        Assert.Equal(-1, secondAgentFramework);
+    }
+
+    [Fact]
+    public async Task HostedAgentUserAgentPolicy_AppendsCombined_WhenNoBareSegmentPresentAsync()
+    {
+        // Arrange: nothing upstream stamps the bare segment. Hosted policy should append the
+        // full combined segment to whatever User-Agent is on the wire.
+        using var handler = new InspectingHandler();
+#pragma warning disable CA5399
+        using var httpClient = new HttpClient(handler);
+#pragma warning restore CA5399
+
+        var pipeline = ClientPipeline.Create(
+            new ClientPipelineOptions { Transport = new HttpClientPipelineTransport(httpClient) },
+            perCallPolicies: [HostedAgentUserAgentPolicy.Instance],
+            perTryPolicies: default,
+            beforeTransportPolicies: default);
+
+        // Act
+        var message = pipeline.CreateMessage();
+        message.Request.Method = "POST";
+        message.Request.Uri = new Uri("https://example.test/anything");
+        await pipeline.SendAsync(message);
+
+        // Assert
+        Assert.NotNull(handler.LastUserAgent);
+        Assert.Contains("foundry-hosting/agent-framework-dotnet/", handler.LastUserAgent);
+    }
+
+    [Fact]
+    public async Task HostedAgentUserAgentPolicy_IsIdempotent_WhenCombinedSegmentAlreadyPresentAsync()
+    {
+        // Arrange: upstream pre-populates the combined segment (simulating a retry or duplicate
+        // registration). Hosted policy must not re-append.
+        using var handler = new InspectingHandler();
+#pragma warning disable CA5399
+        using var httpClient = new HttpClient(handler);
+#pragma warning restore CA5399
+
+        var pipeline = ClientPipeline.Create(
+            new ClientPipelineOptions { Transport = new HttpClientPipelineTransport(httpClient) },
+            perCallPolicies: [new SetUserAgentPolicy("foundry-hosting/agent-framework-dotnet/9.9.9"), HostedAgentUserAgentPolicy.Instance],
+            perTryPolicies: default,
+            beforeTransportPolicies: default);
+
+        // Act
+        var message = pipeline.CreateMessage();
+        message.Request.Method = "POST";
+        message.Request.Uri = new Uri("https://example.test/anything");
+        await pipeline.SendAsync(message);
+
+        // Assert: exactly one occurrence of "foundry-hosting/agent-framework-dotnet/" segment.
+        Assert.NotNull(handler.LastUserAgent);
+        var first = handler.LastUserAgent!.IndexOf("foundry-hosting/agent-framework-dotnet/", StringComparison.Ordinal);
+        Assert.True(first >= 0);
+        var second = handler.LastUserAgent.IndexOf("foundry-hosting/agent-framework-dotnet/", first + 1, StringComparison.Ordinal);
+        Assert.Equal(-1, second);
+    }
+
+    [Fact]
+    public async Task HostedAgentUserAgentPolicy_ReplacesDifferentVersionCombinedSegment_InPlaceAsync()
+    {
+        // Q-D regression: when the User-Agent already carries the COMBINED hosted form with a
+        // different version (e.g. an older registration or caller-supplied baseline), the policy
+        // must replace the entire combined span — not just the bare suffix — so we never emit
+        // the malformed `foundry-hosting/foundry-hosting/agent-framework-dotnet/...` shape.
+        using var handler = new InspectingHandler();
+#pragma warning disable CA5399
+        using var httpClient = new HttpClient(handler);
+#pragma warning restore CA5399
+
+        var pipeline = ClientPipeline.Create(
+            new ClientPipelineOptions { Transport = new HttpClientPipelineTransport(httpClient) },
+            perCallPolicies: [new SetUserAgentPolicy("foundry-hosting/agent-framework-dotnet/0.0.1 MEAI/10.5.1"), HostedAgentUserAgentPolicy.Instance],
+            perTryPolicies: default,
+            beforeTransportPolicies: default);
+
+        // Act
+        var message = pipeline.CreateMessage();
+        message.Request.Method = "POST";
+        message.Request.Uri = new Uri("https://example.test/anything");
+        await pipeline.SendAsync(message);
+
+        // Assert: no doubled foundry-hosting/ prefix.
+        Assert.NotNull(handler.LastUserAgent);
+        Assert.DoesNotContain("foundry-hosting/foundry-hosting/", handler.LastUserAgent, StringComparison.Ordinal);
+
+        // The combined segment must appear exactly once, and the trailing MEAI segment must be
+        // preserved in place (i.e. the policy only rewrote the combined span, not anything after it).
+        var firstCombined = handler.LastUserAgent!.IndexOf("foundry-hosting/agent-framework-dotnet/", StringComparison.Ordinal);
+        Assert.True(firstCombined >= 0);
+        var secondCombined = handler.LastUserAgent.IndexOf("foundry-hosting/agent-framework-dotnet/", firstCombined + 1, StringComparison.Ordinal);
+        Assert.Equal(-1, secondCombined);
+        Assert.Contains(" MEAI/10.5.1", handler.LastUserAgent, StringComparison.Ordinal);
+
+        // And the version that survives must be the runtime supplement value's version, not 0.0.1.
+        Assert.DoesNotContain("foundry-hosting/agent-framework-dotnet/0.0.1", handler.LastUserAgent, StringComparison.Ordinal);
+    }
+
+    private sealed class InspectingHandler : HttpClientHandler
+    {
+        public string? LastUserAgent { get; private set; }
+
+        protected override Task<HttpResponseMessage> SendAsync(HttpRequestMessage request, CancellationToken cancellationToken)
+        {
+            this.LastUserAgent = request.Headers.TryGetValues("User-Agent", out var values)
+                ? string.Join(",", values)
+                : null;
+
+            return Task.FromResult(new HttpResponseMessage(HttpStatusCode.OK)
+            {
+                Content = new StringContent("{}", Encoding.UTF8, "application/json"),
+                RequestMessage = request,
+            });
+        }
+    }
+
+    private sealed class SetUserAgentPolicy : PipelinePolicy
+    {
+        private readonly string _value;
+        public SetUserAgentPolicy(string value) => this._value = value;
+
+        public override void Process(PipelineMessage message, IReadOnlyList<PipelinePolicy> pipeline, int currentIndex)
+        {
+            message.Request.Headers.Set("User-Agent", this._value);
+            ProcessNext(message, pipeline, currentIndex);
+        }
+
+        public override ValueTask ProcessAsync(PipelineMessage message, IReadOnlyList<PipelinePolicy> pipeline, int currentIndex)
+        {
+            message.Request.Headers.Set("User-Agent", this._value);
+            return ProcessNextAsync(message, pipeline, currentIndex);
+        }
+    }
+
     private sealed class NoopHandler : HttpMessageHandler
     {
         protected override Task<HttpResponseMessage> SendAsync(HttpRequestMessage request, CancellationToken cancellationToken)

dotnet/tests/Microsoft.Agents.AI.Foundry.UnitTests/AIProjectClientExtensionsTests.cs

@@ -23,9 +23,9 @@ namespace Microsoft.Agents.AI.Foundry.UnitTests;
 
 #pragma warning disable CS0618
 /// <summary>
-/// Unit tests for the <see cref="AzureAIProjectChatClientExtensions"/> class.
+/// Unit tests for the <see cref="AIProjectClientExtensions"/> class.
 /// </summary>
-public sealed class AzureAIProjectChatClientExtensionsTests
+public sealed class AIProjectClientExtensionsTests
 {
     #region AsAIAgent(AIProjectClient, model, instructions) Tests
 
@@ -71,7 +71,11 @@ public sealed class AzureAIProjectChatClientExtensionsTests
         Assert.Equal("test-agent", agent.Name);
         Assert.Equal("A test agent", agent.Description);
         Assert.NotNull(agent.GetService<IChatClient>());
-        Assert.Null(agent.GetService<AIProjectClient>());
+        // After the FoundryChatClient consolidation the inner chat-client now exposes the
+        // AIProjectClient via GetService — Foundry callers can walk to the project client from
+        // the agent without holding their own reference. (Previously this path returned null
+        // because AsAIAgent(model, instructions) skipped the decorator entirely.)
+        Assert.NotNull(agent.GetService<AIProjectClient>());
     }
 
     /// <summary>
@@ -123,7 +127,10 @@ public sealed class AzureAIProjectChatClientExtensionsTests
         Assert.NotNull(agent);
         Assert.Equal("options-agent", agent.Name);
         Assert.Equal("Agent from options", agent.Description);
-        Assert.Null(agent.GetService<AIProjectClient>());
+        // After the FoundryChatClient consolidation the inner chat-client now exposes the
+        // AIProjectClient via GetService — see twin assertion in
+        // AsAIAgent_Rapi_WithModelAndInstructions_CreatesChatClientAgent for the rationale.
+        Assert.NotNull(agent.GetService<AIProjectClient>());
     }
 
     /// <summary>
@@ -185,6 +192,106 @@ public sealed class AzureAIProjectChatClientExtensionsTests
         Assert.True(userAgentFound, "MEAI user-agent header was not found in any request");
     }
 
+    /// <summary>
+    /// Verify that the non-versioned AsAIAgent overload now wraps with FoundryChatClient
+    /// (regression-prevention for the previously-untagged extension path).
+    /// </summary>
+    [Fact]
+    public void AsAIAgent_Rapi_WithModelAndInstructions_ExposesFoundryChatClientAndProviderName()
+    {
+        // Arrange
+        AIProjectClient client = this.CreateTestAgentClient();
+
+        // Act
+        ChatClientAgent agent = client.AsAIAgent("gpt-4o-mini", "You are helpful.");
+
+        // Assert: FoundryChatClient is internal-sealed and reachable via GetService<IChatClient>().
+        var chatClient = agent.GetService<IChatClient>();
+        Assert.NotNull(chatClient);
+
+        // Provider tag is "microsoft.foundry" (previously this path had no Foundry tag at all).
+        var metadata = chatClient!.GetService<ChatClientMetadata>();
+        Assert.NotNull(metadata);
+        Assert.Equal("microsoft.foundry", metadata!.ProviderName);
+        Assert.Equal("gpt-4o-mini", metadata.DefaultModelId);
+
+        // Reaching the FoundryChatClient by type (via InternalsVisibleTo).
+        Assert.NotNull(agent.GetService<FoundryChatClient>());
+    }
+
+    /// <summary>
+    /// Verify that the options-based non-versioned AsAIAgent overload now wraps with FoundryChatClient.
+    /// </summary>
+    [Fact]
+    public void AsAIAgent_Rapi_WithOptions_ExposesFoundryChatClientAndProviderName()
+    {
+        // Arrange
+        AIProjectClient client = this.CreateTestAgentClient();
+        ChatClientAgentOptions options = new()
+        {
+            Name = "options-agent",
+            ChatOptions = new ChatOptions { ModelId = "gpt-4o-mini", Instructions = "x" },
+        };
+
+        // Act
+        ChatClientAgent agent = client.AsAIAgent(options);
+
+        // Assert
+        var chatClient = agent.GetService<IChatClient>();
+        Assert.NotNull(chatClient);
+        var metadata = chatClient!.GetService<ChatClientMetadata>();
+        Assert.NotNull(metadata);
+        Assert.Equal("microsoft.foundry", metadata!.ProviderName);
+        Assert.NotNull(agent.GetService<FoundryChatClient>());
+    }
+
+    /// <summary>
+    /// Verify that the non-versioned AsAIAgent overload stamps the
+    /// agent-framework-dotnet/{version} segment on outbound requests via the new
+    /// AgentFrameworkUserAgentPolicy registered by FoundryChatClient.
+    /// </summary>
+    [Fact]
+    public async Task AsAIAgent_Rapi_WithModelAndInstructions_StampsAgentFrameworkUserAgentSegmentAsync()
+    {
+        bool afSeen = false;
+        using HttpHandlerAssert httpHandler = new(request =>
+        {
+            if (request.Headers.TryGetValues("User-Agent", out IEnumerable<string>? values))
+            {
+                foreach (string value in values)
+                {
+                    if (value.Contains("agent-framework-dotnet/"))
+                    {
+                        afSeen = true;
+                    }
+                }
+            }
+
+            return new HttpResponseMessage(HttpStatusCode.OK)
+            {
+                Content = new StringContent(TestDataUtil.GetOpenAIDefaultResponseJson(), Encoding.UTF8, "application/json")
+            };
+        });
+
+#pragma warning disable CA5399
+        using HttpClient httpClient = new(httpHandler);
+#pragma warning restore CA5399
+
+        AIProjectClient aiProjectClient = new(
+            new Uri("https://test.openai.azure.com/"),
+            new FakeAuthenticationTokenProvider(),
+            new() { Transport = new HttpClientPipelineTransport(httpClient) });
+
+        ChatClientAgent agent = aiProjectClient.AsAIAgent("gpt-4o-mini", "You are helpful.");
+
+        // Act
+        AgentSession session = await agent.CreateSessionAsync();
+        await agent.RunAsync("Hello", session);
+
+        // Assert
+        Assert.True(afSeen, "Expected agent-framework-dotnet/{version} segment on outbound requests from AsAIAgent(model, instructions).");
+    }
+
     #endregion
 
     #region AsAIAgent(AIProjectClient, ProjectsAgentRecord) Tests

dotnet/tests/Microsoft.Agents.AI.Foundry.UnitTests/AgentFrameworkUserAgentPolicyTests.cs

@@ -0,0 +1,199 @@
+// Copyright (c) Microsoft. All rights reserved.
+
+using System;
+using System.ClientModel.Primitives;
+using System.Collections.Generic;
+using System.Net;
+using System.Net.Http;
+using System.Reflection;
+using System.Text;
+using System.Threading;
+using System.Threading.Tasks;
+
+namespace Microsoft.Agents.AI.Foundry.UnitTests;
+
+/// <summary>
+/// Verifies the framework-wide <see cref="AgentFrameworkUserAgentPolicy"/>. The policy stamps
+/// <c>agent-framework-dotnet/{version}</c> onto the outgoing <c>User-Agent</c> header of every
+/// request made through a Foundry chat client and is registered automatically by
+/// <c>FoundryChatClient</c> via the MEAI <c>OpenAIRequestPolicies</c> hook.
+/// </summary>
+public sealed class AgentFrameworkUserAgentPolicyTests
+{
+    [Fact]
+    public async Task AgentFrameworkUserAgentPolicy_AddsAgentFrameworkSegment_ToOutgoingRequestAsync()
+    {
+        // Arrange
+        using var handler = new RecordingHandler();
+#pragma warning disable CA5399
+        using var httpClient = new HttpClient(handler);
+#pragma warning restore CA5399
+        var pipeline = ClientPipeline.Create(
+            new ClientPipelineOptions { Transport = new HttpClientPipelineTransport(httpClient) },
+            perCallPolicies: [AgentFrameworkUserAgentPolicy.Instance],
+            perTryPolicies: default,
+            beforeTransportPolicies: default);
+
+        // Act
+        var message = pipeline.CreateMessage();
+        message.Request.Method = "POST";
+        message.Request.Uri = new Uri("https://example.test/anything");
+        await pipeline.SendAsync(message);
+
+        // Assert
+        Assert.Equal(1, handler.Count);
+        Assert.NotNull(handler.LastUserAgent);
+        Assert.Contains("agent-framework-dotnet/", handler.LastUserAgent);
+    }
+
+    [Fact]
+    public async Task AgentFrameworkUserAgentPolicy_DoesNotStampMeaiSegmentAsync()
+    {
+        // Arrange: the AF policy must only contribute the agent-framework-dotnet segment.
+        // The MEAI/{version} segment is contributed by the MEAI-shipped policy at a different
+        // layer; this policy must not duplicate or replace it.
+        using var handler = new RecordingHandler();
+#pragma warning disable CA5399
+        using var httpClient = new HttpClient(handler);
+#pragma warning restore CA5399
+        var pipeline = ClientPipeline.Create(
+            new ClientPipelineOptions { Transport = new HttpClientPipelineTransport(httpClient) },
+            perCallPolicies: [AgentFrameworkUserAgentPolicy.Instance],
+            perTryPolicies: default,
+            beforeTransportPolicies: default);
+
+        // Act
+        var message = pipeline.CreateMessage();
+        message.Request.Method = "POST";
+        message.Request.Uri = new Uri("https://example.test/anything");
+        await pipeline.SendAsync(message);
+
+        // Assert
+        Assert.NotNull(handler.LastUserAgent);
+        Assert.DoesNotContain("MEAI/", handler.LastUserAgent);
+        Assert.DoesNotContain("foundry-hosting/", handler.LastUserAgent);
+    }
+
+    [Fact]
+    public async Task AgentFrameworkUserAgentPolicy_PreservesExistingUserAgent_WhenAppendingAsync()
+    {
+        // Arrange: a per-call policy upstream that pre-populates the User-Agent header. The AF
+        // policy must read the existing value and append (not overwrite) the agent-framework
+        // segment so both stay reachable on the wire. (The exact separator the HTTP transport
+        // emits between multi-value User-Agent entries is comma per RFC 7230; this test does
+        // not assert on the separator character because that is a transport detail.)
+        using var handler = new RecordingHandler();
+#pragma warning disable CA5399
+        using var httpClient = new HttpClient(handler);
+#pragma warning restore CA5399
+        var pipeline = ClientPipeline.Create(
+            new ClientPipelineOptions { Transport = new HttpClientPipelineTransport(httpClient) },
+            perCallPolicies: [new SeedUserAgentPolicy("existing-app/1.0"), AgentFrameworkUserAgentPolicy.Instance],
+            perTryPolicies: default,
+            beforeTransportPolicies: default);
+
+        // Act
+        var message = pipeline.CreateMessage();
+        message.Request.Method = "POST";
+        message.Request.Uri = new Uri("https://example.test/anything");
+        await pipeline.SendAsync(message);
+
+        // Assert: both segments survive to the wire.
+        Assert.NotNull(handler.LastUserAgent);
+        Assert.Contains("existing-app/1.0", handler.LastUserAgent);
+        Assert.Contains("agent-framework-dotnet/", handler.LastUserAgent);
+    }
+
+    [Fact]
+    public async Task AgentFrameworkUserAgentPolicy_IsIdempotent_DoesNotDoubleStampAsync()
+    {
+        // Arrange: register the same policy twice on the same pipeline. The second application
+        // must detect the segment is already present and not append it again. Guards against
+        // double-stamping on retries or duplicate registration.
+        using var handler = new RecordingHandler();
+#pragma warning disable CA5399
+        using var httpClient = new HttpClient(handler);
+#pragma warning restore CA5399
+        var pipeline = ClientPipeline.Create(
+            new ClientPipelineOptions { Transport = new HttpClientPipelineTransport(httpClient) },
+            perCallPolicies: [AgentFrameworkUserAgentPolicy.Instance, AgentFrameworkUserAgentPolicy.Instance],
+            perTryPolicies: default,
+            beforeTransportPolicies: default);
+
+        // Act
+        var message = pipeline.CreateMessage();
+        message.Request.Method = "POST";
+        message.Request.Uri = new Uri("https://example.test/anything");
+        await pipeline.SendAsync(message);
+
+        // Assert: exactly one occurrence of "agent-framework-dotnet/".
+        Assert.NotNull(handler.LastUserAgent);
+        var ua = handler.LastUserAgent!;
+        var first = ua.IndexOf("agent-framework-dotnet/", StringComparison.Ordinal);
+        Assert.True(first >= 0, "Expected at least one agent-framework-dotnet segment.");
+        var second = ua.IndexOf("agent-framework-dotnet/", first + 1, StringComparison.Ordinal);
+        Assert.Equal(-1, second);
+    }
+
+    [Fact]
+    public void AgentFrameworkUserAgentPolicy_ExposesSingletonInstance()
+    {
+        // Two reads of the static property must return the same instance. The policy is stateless
+        // and shared; allocating a fresh instance per registration site would bloat memory and
+        // defeat the dedup logic in OpenAIRequestPoliciesReflection.AddPolicyIfMissing.
+        var first = AgentFrameworkUserAgentPolicy.Instance;
+        var second = AgentFrameworkUserAgentPolicy.Instance;
+        Assert.Same(first, second);
+    }
+
+    [Fact]
+    public void AgentFrameworkUserAgentPolicy_ValueIncludesAFFoundryAssemblyVersion_ReflectionGuard()
+    {
+        // The policy emits "agent-framework-dotnet/{Microsoft.Agents.AI.Foundry assembly InformationalVersion}".
+        // If the assembly metadata stops being readable, the policy falls back to "agent-framework-dotnet"
+        // without a version, which is a measurable telemetry regression.
+        var attr = typeof(AgentFrameworkUserAgentPolicy).Assembly
+            .GetCustomAttribute<AssemblyInformationalVersionAttribute>();
+        Assert.NotNull(attr);
+        Assert.False(string.IsNullOrEmpty(attr!.InformationalVersion));
+    }
+
+    private sealed class RecordingHandler : HttpClientHandler
+    {
+        public int Count { get; private set; }
+        public string? LastUserAgent { get; private set; }
+
+        protected override Task<HttpResponseMessage> SendAsync(HttpRequestMessage request, CancellationToken cancellationToken)
+        {
+            this.Count++;
+            this.LastUserAgent = request.Headers.TryGetValues("User-Agent", out var values)
+                ? string.Join(",", values)
+                : null;
+
+            var resp = new HttpResponseMessage(HttpStatusCode.OK)
+            {
+                Content = new StringContent("{}", Encoding.UTF8, "application/json"),
+                RequestMessage = request,
+            };
+            return Task.FromResult(resp);
+        }
+    }
+
+    private sealed class SeedUserAgentPolicy : PipelinePolicy
+    {
+        private readonly string _value;
+        public SeedUserAgentPolicy(string value) => this._value = value;
+
+        public override void Process(PipelineMessage message, IReadOnlyList<PipelinePolicy> pipeline, int currentIndex)
+        {
+            message.Request.Headers.Set("User-Agent", this._value);
+            ProcessNext(message, pipeline, currentIndex);
+        }
+
+        public override ValueTask ProcessAsync(PipelineMessage message, IReadOnlyList<PipelinePolicy> pipeline, int currentIndex)
+        {
+            message.Request.Headers.Set("User-Agent", this._value);
+            return ProcessNextAsync(message, pipeline, currentIndex);
+        }
+    }
+}

dotnet/tests/Microsoft.Agents.AI.Foundry.UnitTests/AzureAIProjectChatClientTests.cs

@@ -1,209 +0,0 @@
-// Copyright (c) Microsoft. All rights reserved.
-
-using System;
-using System.ClientModel.Primitives;
-using System.Net;
-using System.Net.Http;
-using System.Text;
-using System.Threading.Tasks;
-using Azure.AI.Extensions.OpenAI;
-using Azure.AI.Projects;
-
-namespace Microsoft.Agents.AI.Foundry.UnitTests;
-
-#pragma warning disable CS0618
-public class AzureAIProjectChatClientTests
-{
-    /// <summary>
-    /// Verify that after the first RunAsync, the session's ConversationId is set from the
-    /// response, and subsequent requests include that conversation ID automatically.
-    /// </summary>
-    [Fact]
-    public async Task ChatClient_UsesDefaultConversationIdAsync()
-    {
-        // Arrange
-        var responsesRequestCount = 0;
-        using var httpHandler = new HttpHandlerAssert(async (request) =>
-        {
-            if (request.Method == HttpMethod.Post && request.RequestUri!.PathAndQuery.Contains("/responses"))
-            {
-                responsesRequestCount++;
-
-                // Assert: On the second Responses API call, verify the conversation ID
-                // from the first response is automatically included in the request body.
-                if (responsesRequestCount == 2 && request.Content is not null)
-                {
-                    var requestBody = await request.Content.ReadAsStringAsync().ConfigureAwait(false);
-                    Assert.Contains("resp_0888a", requestBody);
-                }
-
-                return new HttpResponseMessage(HttpStatusCode.OK) { Content = new StringContent(TestDataUtil.GetOpenAIDefaultResponseJson(), Encoding.UTF8, "application/json") };
-            }
-
-            return new HttpResponseMessage(HttpStatusCode.OK) { Content = new StringContent(TestDataUtil.GetAgentResponseJson(), Encoding.UTF8, "application/json") };
-        });
-
-#pragma warning disable CA5399
-        using var httpClient = new HttpClient(httpHandler);
-#pragma warning restore CA5399
-
-        AIProjectClient projectClient = new(
-            new Uri("https://test.openai.azure.com/"),
-            new FakeAuthenticationTokenProvider(),
-            new AIProjectClientOptions() { Transport = new HttpClientPipelineTransport(httpClient) });
-
-        var agent = projectClient.AsAIAgent(new AgentReference("agent-name"));
-
-        // Act
-        var session = await agent.CreateSessionAsync();
-        await agent.RunAsync("Hello", session);
-        await agent.RunAsync("Follow up", session);
-
-        // Assert
-        Assert.Equal(2, responsesRequestCount);
-        var chatClientSession = Assert.IsType<ChatClientAgentSession>(session);
-        Assert.Equal("resp_0888a46cbf2b1ff3006914596e05d08195a77c3f5187b769a7", chatClientSession.ConversationId);
-    }
-
-    /// <summary>
-    /// Verify that when the chat client doesn't have a default "conv_" conversation id, the chat client still uses the conversation ID in HTTP requests.
-    /// </summary>
-    [Fact]
-    public async Task ChatClient_UsesPerRequestConversationId_WhenNoDefaultConversationIdIsProvidedAsync()
-    {
-        // Arrange
-        var requestTriggered = false;
-        using var httpHandler = new HttpHandlerAssert(async (request) =>
-        {
-            if (request.Method == HttpMethod.Post && request.RequestUri!.PathAndQuery.Contains("/responses"))
-            {
-                requestTriggered = true;
-
-                // Assert
-                if (request.Content is not null)
-                {
-                    var requestBody = await request.Content.ReadAsStringAsync().ConfigureAwait(false);
-                    Assert.Contains("conv_12345", requestBody);
-                }
-
-                return new HttpResponseMessage(HttpStatusCode.OK) { Content = new StringContent(TestDataUtil.GetOpenAIDefaultResponseJson(), Encoding.UTF8, "application/json") };
-            }
-
-            return new HttpResponseMessage(HttpStatusCode.OK) { Content = new StringContent(TestDataUtil.GetAgentResponseJson(), Encoding.UTF8, "application/json") };
-        });
-
-#pragma warning disable CA5399
-        using var httpClient = new HttpClient(httpHandler);
-#pragma warning restore CA5399
-
-        AIProjectClient projectClient = new(
-            new Uri("https://test.openai.azure.com/"),
-            new FakeAuthenticationTokenProvider(),
-            new AIProjectClientOptions() { Transport = new HttpClientPipelineTransport(httpClient) });
-
-        var agent = projectClient.AsAIAgent(new AgentReference("agent-name"));
-
-        // Act
-        var session = await agent.CreateSessionAsync();
-        await agent.RunAsync("Hello", session, options: new ChatClientAgentRunOptions() { ChatOptions = new() { ConversationId = "conv_12345" } });
-
-        Assert.True(requestTriggered);
-        var chatClientSession = Assert.IsType<ChatClientAgentSession>(session);
-        Assert.Equal("conv_12345", chatClientSession.ConversationId);
-    }
-
-    /// <summary>
-    /// Verify that even when the chat client has a default conversation id, the chat client will prioritize the per-request conversation id provided in HTTP requests.
-    /// </summary>
-    [Fact]
-    public async Task ChatClient_UsesPerRequestConversationId_EvenWhenDefaultConversationIdIsProvidedAsync()
-    {
-        // Arrange
-        var requestTriggered = false;
-        using var httpHandler = new HttpHandlerAssert(async (request) =>
-        {
-            if (request.Method == HttpMethod.Post && request.RequestUri!.PathAndQuery.Contains("/responses"))
-            {
-                requestTriggered = true;
-
-                // Assert
-                if (request.Content is not null)
-                {
-                    var requestBody = await request.Content.ReadAsStringAsync().ConfigureAwait(false);
-                    Assert.Contains("conv_12345", requestBody);
-                }
-
-                return new HttpResponseMessage(HttpStatusCode.OK) { Content = new StringContent(TestDataUtil.GetOpenAIDefaultResponseJson(), Encoding.UTF8, "application/json") };
-            }
-
-            return new HttpResponseMessage(HttpStatusCode.OK) { Content = new StringContent(TestDataUtil.GetAgentResponseJson(), Encoding.UTF8, "application/json") };
-        });
-
-#pragma warning disable CA5399
-        using var httpClient = new HttpClient(httpHandler);
-#pragma warning restore CA5399
-
-        AIProjectClient projectClient = new(
-            new Uri("https://test.openai.azure.com/"),
-            new FakeAuthenticationTokenProvider(),
-            new AIProjectClientOptions() { Transport = new HttpClientPipelineTransport(httpClient) });
-
-        var agent = projectClient.AsAIAgent(new AgentReference("agent-name"));
-
-        // Act
-        var session = await agent.CreateSessionAsync();
-        await agent.RunAsync("Hello", session, options: new ChatClientAgentRunOptions() { ChatOptions = new() { ConversationId = "conv_12345" } });
-
-        Assert.True(requestTriggered);
-        var chatClientSession = Assert.IsType<ChatClientAgentSession>(session);
-        Assert.Equal("conv_12345", chatClientSession.ConversationId);
-    }
-
-    /// <summary>
-    /// Verify that when the chat client is provided without a "conv_" prefixed conversation ID, the chat client uses the previous conversation ID in HTTP requests.
-    /// </summary>
-    [Fact]
-    public async Task ChatClient_UsesPreviousResponseId_WhenConversationIsNotPrefixedAsConvAsync()
-    {
-        // Arrange
-        var requestTriggered = false;
-        using var httpHandler = new HttpHandlerAssert(async (request) =>
-        {
-            if (request.Method == HttpMethod.Post && request.RequestUri!.PathAndQuery.Contains("/responses"))
-            {
-                requestTriggered = true;
-
-                // Assert
-                if (request.Content is not null)
-                {
-                    var requestBody = await request.Content.ReadAsStringAsync().ConfigureAwait(false);
-                    Assert.Contains("resp_0888a", requestBody);
-                }
-
-                return new HttpResponseMessage(HttpStatusCode.OK) { Content = new StringContent(TestDataUtil.GetOpenAIDefaultResponseJson(), Encoding.UTF8, "application/json") };
-            }
-
-            return new HttpResponseMessage(HttpStatusCode.OK) { Content = new StringContent(TestDataUtil.GetAgentResponseJson(), Encoding.UTF8, "application/json") };
-        });
-
-#pragma warning disable CA5399
-        using var httpClient = new HttpClient(httpHandler);
-#pragma warning restore CA5399
-
-        AIProjectClient projectClient = new(
-            new Uri("https://test.openai.azure.com/"),
-            new FakeAuthenticationTokenProvider(),
-            new AIProjectClientOptions() { Transport = new HttpClientPipelineTransport(httpClient) });
-
-        var agent = projectClient.AsAIAgent(new AgentReference("agent-name"));
-
-        // Act
-        var session = await agent.CreateSessionAsync();
-        await agent.RunAsync("Hello", session, options: new ChatClientAgentRunOptions() { ChatOptions = new() { ConversationId = "resp_0888a" } });
-
-        Assert.True(requestTriggered);
-        var chatClientSession = Assert.IsType<ChatClientAgentSession>(session);
-        Assert.Equal("resp_0888a46cbf2b1ff3006914596e05d08195a77c3f5187b769a7", chatClientSession.ConversationId);
-    }
-}
-#pragma warning restore CS0618

dotnet/tests/Microsoft.Agents.AI.Foundry.UnitTests/FoundryAgentExtensionsTests.cs

@@ -0,0 +1,200 @@
+// Copyright (c) Microsoft. All rights reserved.
+
+using System;
+using System.ClientModel.Primitives;
+using System.Net;
+using System.Net.Http;
+using System.Text;
+using System.Threading.Tasks;
+using Azure.AI.Projects;
+using OpenAI.Files;
+
+#pragma warning disable OPENAI001, CS0618
+
+namespace Microsoft.Agents.AI.Foundry.UnitTests;
+
+/// <summary>
+/// Unit tests for the file and vector-store forwarder extensions on <see cref="FoundryAgent"/>
+/// declared in <see cref="FoundryAgentExtensions"/>. The forwarders are thin shims over the
+/// inner <see cref="FoundryChatClient"/>, so coverage focuses on (a) request shape (the agent
+/// path reaches the same wire as a direct chat-client call), (b) null/missing-FoundryChatClient
+/// handling, and (c) returns the same payload the chat client would.
+/// </summary>
+public sealed class FoundryAgentExtensionsTests
+{
+    private static readonly Uri s_testProjectEndpoint = new("https://test.openai.azure.com/");
+
+    [Fact]
+    public async Task UploadFileAsync_Forwards_ToInnerFoundryChatClient_Async()
+    {
+        // Arrange — agent built via the Responses Agent (Mode 1) projectEndpoint+model+instructions
+        // ctor wires a FoundryChatClient inside that the extension can resolve via GetService.
+        var sawPostToFiles = false;
+        using var handler = new HttpHandlerAssert(req =>
+        {
+            if (req.Method == HttpMethod.Post && req.RequestUri!.AbsolutePath.Contains("/files", StringComparison.Ordinal))
+            {
+                sawPostToFiles = true;
+                return new HttpResponseMessage(HttpStatusCode.OK)
+                {
+                    Content = new StringContent(FakeFileJson("file_via_agent"), Encoding.UTF8, "application/json"),
+                };
+            }
+            return new HttpResponseMessage(HttpStatusCode.OK) { Content = new StringContent("{}", Encoding.UTF8, "application/json") };
+        });
+#pragma warning disable CA5399
+        using var httpClient = new HttpClient(handler);
+#pragma warning restore CA5399
+
+        var agent = new FoundryAgent(
+            projectEndpoint: s_testProjectEndpoint,
+            credential: new FakeAuthenticationTokenProvider(),
+            model: "gpt-4o-mini",
+            instructions: "Be helpful.",
+            clientOptions: new AIProjectClientOptions { Transport = new HttpClientPipelineTransport(httpClient) });
+
+        var path = System.IO.Path.Combine(System.IO.Path.GetTempPath(), $"fae-{Guid.NewGuid():N}.txt");
+        System.IO.File.WriteAllText(path, "hello");
+
+        try
+        {
+            // Act — call the forwarder on the agent.
+            var result = await agent.UploadFileAsync(path, FileUploadPurpose.Assistants);
+
+            // Assert
+            Assert.True(sawPostToFiles, "POST to /files must reach the wire through the agent forwarder.");
+            Assert.Equal("file_via_agent", result.Id);
+        }
+        finally
+        {
+            System.IO.File.Delete(path);
+        }
+    }
+
+    [Fact]
+    public async Task DeleteFileAsync_Forwards_ToInnerFoundryChatClient_Async()
+    {
+        var sawDelete = false;
+        using var handler = new HttpHandlerAssert(req =>
+        {
+            if (req.Method == HttpMethod.Delete && req.RequestUri!.AbsolutePath.Contains("/files/", StringComparison.Ordinal))
+            {
+                sawDelete = true;
+                return new HttpResponseMessage(HttpStatusCode.OK)
+                {
+                    Content = new StringContent("{\"id\":\"file_abc\",\"object\":\"file\",\"deleted\":true}", Encoding.UTF8, "application/json"),
+                };
+            }
+            return new HttpResponseMessage(HttpStatusCode.OK) { Content = new StringContent("{}", Encoding.UTF8, "application/json") };
+        });
+#pragma warning disable CA5399
+        using var httpClient = new HttpClient(handler);
+#pragma warning restore CA5399
+
+        var agent = new FoundryAgent(
+            projectEndpoint: s_testProjectEndpoint,
+            credential: new FakeAuthenticationTokenProvider(),
+            model: "gpt-4o-mini",
+            instructions: "Be helpful.",
+            clientOptions: new AIProjectClientOptions { Transport = new HttpClientPipelineTransport(httpClient) });
+
+        var result = await agent.DeleteFileAsync("file_abc");
+
+        Assert.True(sawDelete);
+        Assert.NotNull(result);
+    }
+
+    [Fact]
+    public async Task CreateVectorStoreAsync_Forwards_ToInnerFoundryChatClient_Async()
+    {
+        var sawVectorStorePost = false;
+        using var handler = new HttpHandlerAssert(req =>
+        {
+            if (req.Method == HttpMethod.Post && req.RequestUri!.AbsolutePath.Contains("/vector_stores", StringComparison.Ordinal))
+            {
+                sawVectorStorePost = true;
+                return new HttpResponseMessage(HttpStatusCode.OK)
+                {
+                    Content = new StringContent(FakeVectorStoreJson("vs_via_agent", "kb"), Encoding.UTF8, "application/json"),
+                };
+            }
+            return new HttpResponseMessage(HttpStatusCode.OK) { Content = new StringContent("{}", Encoding.UTF8, "application/json") };
+        });
+#pragma warning disable CA5399
+        using var httpClient = new HttpClient(handler);
+#pragma warning restore CA5399
+
+        var agent = new FoundryAgent(
+            projectEndpoint: s_testProjectEndpoint,
+            credential: new FakeAuthenticationTokenProvider(),
+            model: "gpt-4o-mini",
+            instructions: "Be helpful.",
+            clientOptions: new AIProjectClientOptions { Transport = new HttpClientPipelineTransport(httpClient) });
+
+        var store = await agent.CreateVectorStoreAsync("kb", Array.Empty<string>());
+
+        Assert.True(sawVectorStorePost);
+        Assert.Equal("vs_via_agent", store.Id);
+    }
+
+    [Fact]
+    public async Task DeleteVectorStoreAsync_Forwards_ToInnerFoundryChatClient_Async()
+    {
+        var sawDelete = false;
+        using var handler = new HttpHandlerAssert(req =>
+        {
+            if (req.Method == HttpMethod.Delete && req.RequestUri!.AbsolutePath.Contains("/vector_stores/", StringComparison.Ordinal))
+            {
+                sawDelete = true;
+                return new HttpResponseMessage(HttpStatusCode.OK)
+                {
+                    Content = new StringContent("{\"id\":\"vs_abc\",\"object\":\"vector_store.deleted\",\"deleted\":true}", Encoding.UTF8, "application/json"),
+                };
+            }
+            return new HttpResponseMessage(HttpStatusCode.OK) { Content = new StringContent("{}", Encoding.UTF8, "application/json") };
+        });
+#pragma warning disable CA5399
+        using var httpClient = new HttpClient(handler);
+#pragma warning restore CA5399
+
+        var agent = new FoundryAgent(
+            projectEndpoint: s_testProjectEndpoint,
+            credential: new FakeAuthenticationTokenProvider(),
+            model: "gpt-4o-mini",
+            instructions: "Be helpful.",
+            clientOptions: new AIProjectClientOptions { Transport = new HttpClientPipelineTransport(httpClient) });
+
+        await agent.DeleteVectorStoreAsync("vs_abc");
+
+        Assert.True(sawDelete);
+    }
+
+    [Fact]
+    public async Task UploadFileAsync_NullAgent_ThrowsArgumentNullExceptionAsync()
+        => await Assert.ThrowsAsync<ArgumentNullException>(() =>
+            FoundryAgentExtensions.UploadFileAsync(null!, "x", FileUploadPurpose.Assistants));
+
+    [Fact]
+    public async Task DeleteFileAsync_NullAgent_ThrowsArgumentNullExceptionAsync()
+        => await Assert.ThrowsAsync<ArgumentNullException>(() =>
+            FoundryAgentExtensions.DeleteFileAsync(null!, "file_abc"));
+
+    [Fact]
+    public async Task CreateVectorStoreAsync_NullAgent_ThrowsArgumentNullExceptionAsync()
+        => await Assert.ThrowsAsync<ArgumentNullException>(() =>
+            FoundryAgentExtensions.CreateVectorStoreAsync(null!, "kb", Array.Empty<string>()));
+
+    [Fact]
+    public async Task DeleteVectorStoreAsync_NullAgent_ThrowsArgumentNullExceptionAsync()
+        => await Assert.ThrowsAsync<ArgumentNullException>(() =>
+            FoundryAgentExtensions.DeleteVectorStoreAsync(null!, "vs_abc"));
+
+    // ----- Helpers -----
+
+    private static string FakeFileJson(string id)
+        => $"{{\"id\":\"{id}\",\"object\":\"file\",\"bytes\":11,\"created_at\":1700000000,\"filename\":\"x.txt\",\"purpose\":\"assistants\",\"status\":\"processed\"}}";
+
+    private static string FakeVectorStoreJson(string id, string name)
+        => $"{{\"id\":\"{id}\",\"object\":\"vector_store\",\"created_at\":1700000000,\"name\":\"{name}\",\"usage_bytes\":0,\"file_counts\":{{\"in_progress\":0,\"completed\":0,\"failed\":0,\"cancelled\":0,\"total\":0}},\"status\":\"completed\",\"last_active_at\":1700000000}}";
+}
+#pragma warning restore CS0618

dotnet/tests/Microsoft.Agents.AI.Foundry.UnitTests/FoundryAgentTests.cs

@@ -2,7 +2,6 @@
 
 using System;
 using System.ClientModel.Primitives;
-using System.Collections.Generic;
 using System.Net;
 using System.Net.Http;
 using System.Text;
@@ -352,18 +351,24 @@ public class FoundryAgentTests
     }
 
     [Fact]
-    public async Task Constructor_UserAgentHeaderAddedToRequestsAsync()
+    public async Task Constructor_AgentFrameworkUserAgentHeaderAddedToRequestsAsync()
     {
-        bool userAgentFound = false;
+        // After the FoundryChatClient consolidation, every outbound request from a
+        // FoundryAgent-built chat client carries the new agent-framework-dotnet/{version}
+        // segment (stamped by AgentFrameworkUserAgentPolicy registered via the MEAI
+        // OpenAIRequestPolicies hook). The local MEAI/{version} stamp was removed because
+        // MEAI 10.5.1 stamps that itself; this test only verifies the framework-wide segment
+        // that the Foundry package now guarantees.
+        bool agentFrameworkUserAgentFound = false;
         using HttpHandlerAssert httpHandler = new(request =>
         {
-            if (request.Headers.TryGetValues("User-Agent", out IEnumerable<string>? values))
+            if (request.Headers.TryGetValues("User-Agent", out System.Collections.Generic.IEnumerable<string>? values))
             {
                 foreach (string value in values)
                 {
-                    if (value.StartsWith("MEAI/", StringComparison.OrdinalIgnoreCase))
+                    if (value.Contains("agent-framework-dotnet/"))
                     {
-                        userAgentFound = true;
+                        agentFrameworkUserAgentFound = true;
                     }
                 }
             }
@@ -396,7 +401,7 @@ public class FoundryAgentTests
         AgentSession session = await agent.CreateSessionAsync();
         await agent.RunAsync("Hello", session);
 
-        Assert.True(userAgentFound, "Expected MEAI user-agent header to be present in requests.");
+        Assert.True(agentFrameworkUserAgentFound, "Expected agent-framework-dotnet user-agent segment to be present on outbound requests.");
     }
 
     #endregion
@@ -434,6 +439,9 @@ public class FoundryAgentTests
     [Fact]
     public void AgentEndpointConstructor_GetServiceProjectOpenAIClient_ReturnsNull()
     {
+        // Behavior change: FoundryAgent no longer caches a ProjectOpenAIClient. Callers
+        // retrieve it from the AIProjectClient themselves
+        // (agent.GetService<AIProjectClient>()!.GetProjectOpenAIClient()).
         FoundryAgent agent = new(s_testAgentEndpoint, new FakeAuthenticationTokenProvider());
 
         Assert.Null(agent.GetService<ProjectOpenAIClient>());
@@ -442,6 +450,10 @@ public class FoundryAgentTests
     [Fact]
     public void AgentEndpointConstructor_GetServiceAIProjectClient_ReturnsNonNull()
     {
+        // Behavior change: after Plan #2's Agent Endpoint mode (Mode 3) AIProjectClient materialization, the
+        // agent-endpoint constructor now derives a project-level AIProjectClient from the
+        // parsed project root URL and surfaces it via GetService. Previously this returned
+        // null because no AIProjectClient was constructed for hosted-agent-endpoint agents.
         FoundryAgent agent = new(s_testAgentEndpoint, new FakeAuthenticationTokenProvider());
 
         Assert.NotNull(agent.GetService<AIProjectClient>());
@@ -450,6 +462,7 @@ public class FoundryAgentTests
     [Fact]
     public void ProjectEndpointConstructor_GetServiceProjectOpenAIClient_ReturnsNull()
     {
+        // See AgentEndpointConstructor_GetServiceProjectOpenAIClient_ReturnsNull for rationale.
         FoundryAgent agent = new(
             s_testEndpoint,
             new FakeAuthenticationTokenProvider(),
@@ -611,6 +624,57 @@ public class FoundryAgentTests
         Assert.True(meaiSeen, "Expected MEAI/x.y.z to appear in the User-Agent header on the agent-endpoint pipeline.");
     }
 
+    [Fact]
+    public void AgentEndpointConstructor_ExposesFoundryProviderName_OnChatClientMetadata()
+    {
+        // Behavior change: after the FoundryChatClient consolidation, the agent-endpoint path
+        // now wraps with FoundryChatClient in the Agent Endpoint mode (Mode 3) and stamps the microsoft.foundry provider
+        // name. Previously this path used a bare AsIChatClient() with no Foundry-specific
+        // decorator, so the provider name defaulted to whatever MEAI surfaces. This guards the
+        // new behavior.
+        FoundryAgent agent = new(s_testAgentEndpoint, new FakeAuthenticationTokenProvider());
+
+        var metadata = agent.GetService<ChatClientMetadata>();
+        Assert.NotNull(metadata);
+        Assert.Equal("microsoft.foundry", metadata!.ProviderName);
+    }
+
+    [Fact]
+    public async Task AgentEndpointConstructor_StampsAgentFrameworkUserAgentSegmentAsync()
+    {
+        // Behavior change: after the FoundryChatClient consolidation, every outbound request
+        // from the agent-endpoint constructor carries the agent-framework-dotnet/{version}
+        // segment via AgentFrameworkUserAgentPolicy. Previously this path had no
+        // agent-framework branding at all.
+        bool afSeen = false;
+        using HttpHandlerAssert handler = new(req =>
+        {
+            if (req.Headers.TryGetValues("User-Agent", out var values))
+            {
+                foreach (string v in values)
+                {
+                    if (v.Contains("agent-framework-dotnet/"))
+                    {
+                        afSeen = true;
+                    }
+                }
+            }
+            return new HttpResponseMessage(HttpStatusCode.OK)
+            {
+                Content = new StringContent(TestDataUtil.GetOpenAIDefaultResponseJson(), Encoding.UTF8, "application/json"),
+            };
+        });
+#pragma warning disable CA5399
+        using HttpClient http = new(handler);
+#pragma warning restore CA5399
+        ProjectOpenAIClientOptions opts = new() { Transport = new HttpClientPipelineTransport(http) };
+
+        FoundryAgent agent = new(s_testAgentEndpoint, new FakeAuthenticationTokenProvider(), clientOptions: opts);
+        await agent.RunAsync("Hello");
+
+        Assert.True(afSeen, "Expected agent-framework-dotnet/{version} segment on the agent-endpoint outbound User-Agent.");
+    }
+
     [Fact]
     public async Task AgentEndpointConstructor_PassesThroughCallerPolicyOnPerAgentPipelineAsync()
     {
@@ -666,82 +730,22 @@ public class FoundryAgentTests
     }
 
     [Fact]
-    public void AgentEndpointConstructor_PreservesUserAgentApplicationId()
+    public void AgentEndpointConstructor_PropagatesUserAgentApplicationId_ToProjectLevelClient()
     {
+        // The MEAI policy adds its own User-Agent header so we cannot reliably observe the OpenAI SDK's
+        // application-id stamp in the outbound request. Verify the value is propagated onto the
+        // caller's options bag and that the materialized AIProjectClient is reachable so
+        // downstream conversation/file/vector-store operations can pick the application id up.
         ProjectOpenAIClientOptions opts = new() { UserAgentApplicationId = "my-app-id" };
 
         FoundryAgent agent = new(s_testAgentEndpoint, new FakeAuthenticationTokenProvider(), clientOptions: opts);
 
+        AIProjectClient? aiProjectClient = agent.GetService<AIProjectClient>();
+        Assert.NotNull(aiProjectClient);
         // Caller's UserAgentApplicationId is preserved on the per-agent options bag verbatim.
-        Assert.NotNull(agent);
         Assert.Equal("my-app-id", opts.UserAgentApplicationId);
     }
 
-    [Fact]
-    public void CreateProjectClientOptions_NullCallerOptions_ReturnsNull()
-    {
-        Assert.Null(FoundryAgent.CreateProjectClientOptions(null));
-    }
-
-    [Fact]
-    public void CreateProjectClientOptions_CarriesPipelineSettingsAndUserAgent()
-    {
-        // Arrange
-        var transport = new FakePipelineTransport();
-        var retryPolicy = new FakeRetryPolicy();
-        var messageLoggingPolicy = new FakeMessageLoggingPolicy();
-        var clientLoggingOptions = new ClientLoggingOptions { EnableLogging = false };
-        var networkTimeout = TimeSpan.FromSeconds(42);
-
-        ProjectOpenAIClientOptions callerOptions = new()
-        {
-            UserAgentApplicationId = "my-app-id",
-            Transport = transport,
-            RetryPolicy = retryPolicy,
-            MessageLoggingPolicy = messageLoggingPolicy,
-            ClientLoggingOptions = clientLoggingOptions,
-            NetworkTimeout = networkTimeout,
-        };
-
-        // Act
-        AIProjectClientOptions? projectOptions = FoundryAgent.CreateProjectClientOptions(callerOptions);
-
-        // Assert: every settable pipeline behavior the caller configured is forwarded
-        // onto the project-level options bag, not silently dropped.
-        Assert.NotNull(projectOptions);
-        Assert.Equal("my-app-id", projectOptions!.UserAgentApplicationId);
-        Assert.Same(transport, projectOptions.Transport);
-        Assert.Same(retryPolicy, projectOptions.RetryPolicy);
-        Assert.Same(messageLoggingPolicy, projectOptions.MessageLoggingPolicy);
-        Assert.Same(clientLoggingOptions, projectOptions.ClientLoggingOptions);
-        Assert.Equal(networkTimeout, projectOptions.NetworkTimeout);
-    }
-
-    private sealed class FakeRetryPolicy : PipelinePolicy
-    {
-        public override void Process(PipelineMessage message, IReadOnlyList<PipelinePolicy> pipeline, int currentIndex)
-            => ProcessNext(message, pipeline, currentIndex);
-
-        public override ValueTask ProcessAsync(PipelineMessage message, IReadOnlyList<PipelinePolicy> pipeline, int currentIndex)
-            => ProcessNextAsync(message, pipeline, currentIndex);
-    }
-
-    private sealed class FakeMessageLoggingPolicy : PipelinePolicy
-    {
-        public override void Process(PipelineMessage message, IReadOnlyList<PipelinePolicy> pipeline, int currentIndex)
-            => ProcessNext(message, pipeline, currentIndex);
-
-        public override ValueTask ProcessAsync(PipelineMessage message, IReadOnlyList<PipelinePolicy> pipeline, int currentIndex)
-            => ProcessNextAsync(message, pipeline, currentIndex);
-    }
-
-    private sealed class FakePipelineTransport : PipelineTransport
-    {
-        protected override PipelineMessage CreateMessageCore() => throw new NotSupportedException();
-        protected override void ProcessCore(PipelineMessage message) => throw new NotSupportedException();
-        protected override ValueTask ProcessCoreAsync(PipelineMessage message) => throw new NotSupportedException();
-    }
-
     #endregion
 
     #region ParseAgentEndpoint tests
@@ -824,13 +828,13 @@ public class FoundryAgentTests
         private readonly string _value;
         public HeaderStampPolicy(string name, string value) { this._name = name; this._value = value; }
 
-        public override void Process(PipelineMessage message, IReadOnlyList<PipelinePolicy> pipeline, int currentIndex)
+        public override void Process(PipelineMessage message, System.Collections.Generic.IReadOnlyList<PipelinePolicy> pipeline, int currentIndex)
         {
             message.Request.Headers.Set(this._name, this._value);
             ProcessNext(message, pipeline, currentIndex);
         }
 
-        public override ValueTask ProcessAsync(PipelineMessage message, IReadOnlyList<PipelinePolicy> pipeline, int currentIndex)
+        public override ValueTask ProcessAsync(PipelineMessage message, System.Collections.Generic.IReadOnlyList<PipelinePolicy> pipeline, int currentIndex)
         {
             message.Request.Headers.Set(this._name, this._value);
             return ProcessNextAsync(message, pipeline, currentIndex);

dotnet/tests/Microsoft.Agents.AI.Foundry.UnitTests/FoundryChatClientTests.cs

@@ -0,0 +1,616 @@
+// Copyright (c) Microsoft. All rights reserved.
+
+using System;
+using System.ClientModel.Primitives;
+using System.Net;
+using System.Net.Http;
+using System.Reflection;
+using System.Text;
+using System.Threading.Tasks;
+using Azure.AI.Extensions.OpenAI;
+using Azure.AI.Projects;
+using Azure.AI.Projects.Agents;
+using Microsoft.Extensions.AI;
+
+#pragma warning disable OPENAI001, CS0618
+
+namespace Microsoft.Agents.AI.Foundry.UnitTests;
+
+/// <summary>
+/// Unit tests for the internal <see cref="FoundryChatClient"/>. Covers the three construction
+/// modes (Responses Agent, Prompt Agent, Agent Endpoint), the GetService
+/// returns per mode, the metadata-tagging contract, the agent-framework user-agent registration,
+/// the Agent Endpoint mode (Mode 3) URL parsing happy and error paths, and end-to-end behavior through the public
+/// <c>AsAIAgent(AgentReference)</c> extension that constructs a FoundryChatClient internally.
+/// </summary>
+public sealed class FoundryChatClientTests
+{
+    #region the Responses Agent mode (Mode 1): Responses Agent (AIProjectClient + modelId)
+
+    [Fact]
+    public void Mode1_ResponsesAgent_StampsFoundryProviderName()
+    {
+        // Arrange
+        var projectClient = CreateProjectClient();
+
+        // Act
+        var chatClient = new FoundryChatClient(projectClient, "gpt-4o-mini");
+
+        // Assert
+        var metadata = chatClient.GetService<ChatClientMetadata>();
+        Assert.NotNull(metadata);
+        Assert.Equal("microsoft.foundry", metadata!.ProviderName);
+        Assert.Equal("gpt-4o-mini", metadata.DefaultModelId);
+    }
+
+    [Fact]
+    public void Mode1_ResponsesAgent_ExposesAIProjectClient_ViaGetService()
+    {
+        // Arrange
+        var projectClient = CreateProjectClient();
+
+        // Act
+        var chatClient = new FoundryChatClient(projectClient, "gpt-4o-mini");
+
+        // Assert
+        Assert.Same(projectClient, chatClient.GetService<AIProjectClient>());
+        // ProjectOpenAIClient is intentionally NOT exposed via GetService — callers retrieve
+        // it from the AIProjectClient themselves (aiProjectClient.GetProjectOpenAIClient()).
+        Assert.Null(chatClient.GetService<ProjectOpenAIClient>());
+    }
+
+    [Fact]
+    public void Mode1_ResponsesAgent_ReturnsNullForAgentSpecificServices()
+    {
+        // Arrange
+        var projectClient = CreateProjectClient();
+
+        // Act
+        var chatClient = new FoundryChatClient(projectClient, "gpt-4o-mini");
+
+        // Assert
+        Assert.Null(chatClient.GetService<AgentReference>());
+        Assert.Null(chatClient.GetService<ProjectsAgentVersion>());
+        Assert.Null(chatClient.GetService<ProjectsAgentRecord>());
+        // No agent name exists in the Responses Agent mode (Mode 1) — only the Prompt Agent mode (Mode 2) (from AgentReference.Name) and the Agent Endpoint mode (Mode 3)
+        // (parsed from URL) populate FoundryChatClient.AgentName.
+        Assert.Null(chatClient.AgentName);
+    }
+
+    [Fact]
+    public void Mode1_ResponsesAgent_ThrowsOnNullProjectClient()
+        => Assert.Throws<ArgumentNullException>(() => new FoundryChatClient(aiProjectClient: null!, "gpt-4o-mini"));
+
+    [Fact]
+    public void Mode1_ResponsesAgent_ThrowsOnEmptyModelId()
+        => Assert.Throws<ArgumentException>(() => new FoundryChatClient(CreateProjectClient(), modelId: ""));
+
+    #endregion
+
+    #region the Prompt Agent mode (Mode 2): Prompt Agent (direct unit tests)
+
+    [Fact]
+    public void Mode2_PromptAgent_StampsFoundryProviderNameAndDefaultModelId()
+    {
+        // Arrange
+        var projectClient = CreateProjectClient();
+        var agentRef = new AgentReference("agent-name", "1");
+
+        // Act
+        var chatClient = new FoundryChatClient(projectClient, agentRef, defaultModelId: "gpt-4o", baseChatOptions: null);
+
+        // Assert
+        var metadata = chatClient.GetService<ChatClientMetadata>();
+        Assert.NotNull(metadata);
+        Assert.Equal("microsoft.foundry", metadata!.ProviderName);
+        Assert.Equal("gpt-4o", metadata.DefaultModelId);
+    }
+
+    [Fact]
+    public void Mode2_PromptAgent_ExposesAgentReference_ViaGetService()
+    {
+        // Arrange
+        var projectClient = CreateProjectClient();
+        var agentRef = new AgentReference("agent-name", "1");
+
+        // Act
+        var chatClient = new FoundryChatClient(projectClient, agentRef, defaultModelId: null, baseChatOptions: null);
+
+        // Assert
+        Assert.Same(agentRef, chatClient.GetService<AgentReference>());
+        Assert.Same(projectClient, chatClient.GetService<AIProjectClient>());
+        // ProjectOpenAIClient is intentionally NOT exposed via GetService — see comment in
+        // Mode1_ResponsesAgent_ExposesAIProjectClient_ViaGetService.
+        Assert.Null(chatClient.GetService<ProjectOpenAIClient>());
+        // Version/Record were not provided via this ctor.
+        Assert.Null(chatClient.GetService<ProjectsAgentVersion>());
+        Assert.Null(chatClient.GetService<ProjectsAgentRecord>());
+    }
+
+    [Fact]
+    public void Mode2_PromptAgent_PopulatesAgentNameFromAgentReference()
+    {
+        // Arrange
+        var projectClient = CreateProjectClient();
+        var agentRef = new AgentReference("my-server-side-agent", "1");
+
+        // Act
+        var chatClient = new FoundryChatClient(projectClient, agentRef, defaultModelId: null, baseChatOptions: null);
+
+        // Assert: AgentName is general-purpose across the Prompt Agent (Mode 2) and Agent Endpoint (Mode 3) modes. In the Prompt Agent mode (Mode 2) it mirrors
+        // AgentReference.Name so callers have a uniform handle regardless of construction mode.
+        Assert.Equal("my-server-side-agent", chatClient.AgentName);
+    }
+
+    [Fact]
+    public void Mode2_PromptAgent_AllowsNullDefaultModelIdAndBaseChatOptions()
+    {
+        // Arrange
+        var projectClient = CreateProjectClient();
+        var agentRef = new AgentReference("agent-name", "1");
+
+        // Act + Assert: must not throw; defaultModelId and baseChatOptions are optional.
+        var chatClient = new FoundryChatClient(projectClient, agentRef, defaultModelId: null, baseChatOptions: null);
+        Assert.NotNull(chatClient);
+    }
+
+    [Fact]
+    public void Mode2_PromptAgent_ThrowsOnNullAgentReference()
+        => Assert.Throws<ArgumentNullException>(() =>
+            new FoundryChatClient(CreateProjectClient(), agentReference: null!, defaultModelId: null, baseChatOptions: null));
+
+    #endregion
+
+    #region the Prompt Agent mode (Mode 2): Prompt Agent end-to-end round-trip via AsAIAgent(AgentReference) extension
+
+    // The end-to-end tests below exercise the same FoundryChatClient mode-2 behaviors above,
+    // but through the public AsAIAgent(AgentReference) extension that constructs a FoundryChatClient
+    // internally. They focus on the conversation-id handling that only manifests through the
+    // ChatClientAgentSession surface, which requires a fully assembled agent rather than a bare
+    // chat client.
+
+    /// <summary>
+    /// Verify that after the first RunAsync, the session's ConversationId is set from the
+    /// response, and subsequent requests include that conversation ID automatically.
+    /// </summary>
+    [Fact]
+    public async Task EndToEnd_AgentReference_UsesDefaultConversationIdAsync()
+    {
+        // Arrange
+        var responsesRequestCount = 0;
+        using var httpHandler = new HttpHandlerAssert(async (request) =>
+        {
+            if (request.Method == HttpMethod.Post && request.RequestUri!.PathAndQuery.Contains("/responses"))
+            {
+                responsesRequestCount++;
+
+                // Assert: On the second Responses API call, verify the conversation ID
+                // from the first response is automatically included in the request body.
+                if (responsesRequestCount == 2 && request.Content is not null)
+                {
+                    var requestBody = await request.Content.ReadAsStringAsync().ConfigureAwait(false);
+                    Assert.Contains("resp_0888a", requestBody);
+                }
+
+                return new HttpResponseMessage(HttpStatusCode.OK) { Content = new StringContent(TestDataUtil.GetOpenAIDefaultResponseJson(), Encoding.UTF8, "application/json") };
+            }
+
+            return new HttpResponseMessage(HttpStatusCode.OK) { Content = new StringContent(TestDataUtil.GetAgentResponseJson(), Encoding.UTF8, "application/json") };
+        });
+
+#pragma warning disable CA5399
+        using var httpClient = new HttpClient(httpHandler);
+#pragma warning restore CA5399
+
+        AIProjectClient projectClient = new(
+            new Uri("https://test.openai.azure.com/"),
+            new FakeAuthenticationTokenProvider(),
+            new AIProjectClientOptions() { Transport = new HttpClientPipelineTransport(httpClient) });
+
+        var agent = projectClient.AsAIAgent(new AgentReference("agent-name"));
+
+        // Act
+        var session = await agent.CreateSessionAsync();
+        await agent.RunAsync("Hello", session);
+        await agent.RunAsync("Follow up", session);
+
+        // Assert
+        Assert.Equal(2, responsesRequestCount);
+        var chatClientSession = Assert.IsType<ChatClientAgentSession>(session);
+        Assert.Equal("resp_0888a46cbf2b1ff3006914596e05d08195a77c3f5187b769a7", chatClientSession.ConversationId);
+    }
+
+    /// <summary>
+    /// Verify that when the chat client doesn't have a default "conv_" conversation id, the chat client still uses the conversation ID in HTTP requests.
+    /// </summary>
+    [Fact]
+    public async Task EndToEnd_AgentReference_UsesPerRequestConversationId_WhenNoDefaultConversationIdIsProvidedAsync()
+    {
+        // Arrange
+        var requestTriggered = false;
+        using var httpHandler = new HttpHandlerAssert(async (request) =>
+        {
+            if (request.Method == HttpMethod.Post && request.RequestUri!.PathAndQuery.Contains("/responses"))
+            {
+                requestTriggered = true;
+
+                // Assert
+                if (request.Content is not null)
+                {
+                    var requestBody = await request.Content.ReadAsStringAsync().ConfigureAwait(false);
+                    Assert.Contains("conv_12345", requestBody);
+                }
+
+                return new HttpResponseMessage(HttpStatusCode.OK) { Content = new StringContent(TestDataUtil.GetOpenAIDefaultResponseJson(), Encoding.UTF8, "application/json") };
+            }
+
+            return new HttpResponseMessage(HttpStatusCode.OK) { Content = new StringContent(TestDataUtil.GetAgentResponseJson(), Encoding.UTF8, "application/json") };
+        });
+
+#pragma warning disable CA5399
+        using var httpClient = new HttpClient(httpHandler);
+#pragma warning restore CA5399
+
+        AIProjectClient projectClient = new(
+            new Uri("https://test.openai.azure.com/"),
+            new FakeAuthenticationTokenProvider(),
+            new AIProjectClientOptions() { Transport = new HttpClientPipelineTransport(httpClient) });
+
+        var agent = projectClient.AsAIAgent(new AgentReference("agent-name"));
+
+        // Act
+        var session = await agent.CreateSessionAsync();
+        await agent.RunAsync("Hello", session, options: new ChatClientAgentRunOptions() { ChatOptions = new() { ConversationId = "conv_12345" } });
+
+        Assert.True(requestTriggered);
+        var chatClientSession = Assert.IsType<ChatClientAgentSession>(session);
+        Assert.Equal("conv_12345", chatClientSession.ConversationId);
+    }
+
+    /// <summary>
+    /// Verify that even when the chat client has a default conversation id, the chat client will prioritize the per-request conversation id provided in HTTP requests.
+    /// </summary>
+    [Fact]
+    public async Task EndToEnd_AgentReference_UsesPerRequestConversationId_EvenWhenDefaultConversationIdIsProvidedAsync()
+    {
+        // Arrange
+        var requestTriggered = false;
+        using var httpHandler = new HttpHandlerAssert(async (request) =>
+        {
+            if (request.Method == HttpMethod.Post && request.RequestUri!.PathAndQuery.Contains("/responses"))
+            {
+                requestTriggered = true;
+
+                // Assert
+                if (request.Content is not null)
+                {
+                    var requestBody = await request.Content.ReadAsStringAsync().ConfigureAwait(false);
+                    Assert.Contains("conv_12345", requestBody);
+                }
+
+                return new HttpResponseMessage(HttpStatusCode.OK) { Content = new StringContent(TestDataUtil.GetOpenAIDefaultResponseJson(), Encoding.UTF8, "application/json") };
+            }
+
+            return new HttpResponseMessage(HttpStatusCode.OK) { Content = new StringContent(TestDataUtil.GetAgentResponseJson(), Encoding.UTF8, "application/json") };
+        });
+
+#pragma warning disable CA5399
+        using var httpClient = new HttpClient(httpHandler);
+#pragma warning restore CA5399
+
+        AIProjectClient projectClient = new(
+            new Uri("https://test.openai.azure.com/"),
+            new FakeAuthenticationTokenProvider(),
+            new AIProjectClientOptions() { Transport = new HttpClientPipelineTransport(httpClient) });
+
+        var agent = projectClient.AsAIAgent(new AgentReference("agent-name"));
+
+        // Act
+        var session = await agent.CreateSessionAsync();
+        await agent.RunAsync("Hello", session, options: new ChatClientAgentRunOptions() { ChatOptions = new() { ConversationId = "conv_12345" } });
+
+        Assert.True(requestTriggered);
+        var chatClientSession = Assert.IsType<ChatClientAgentSession>(session);
+        Assert.Equal("conv_12345", chatClientSession.ConversationId);
+    }
+
+    /// <summary>
+    /// Verify that when the chat client is provided without a "conv_" prefixed conversation ID, the chat client uses the previous conversation ID in HTTP requests.
+    /// </summary>
+    [Fact]
+    public async Task EndToEnd_AgentReference_UsesPreviousResponseId_WhenConversationIsNotPrefixedAsConvAsync()
+    {
+        // Arrange
+        var requestTriggered = false;
+        using var httpHandler = new HttpHandlerAssert(async (request) =>
+        {
+            if (request.Method == HttpMethod.Post && request.RequestUri!.PathAndQuery.Contains("/responses"))
+            {
+                requestTriggered = true;
+
+                // Assert
+                if (request.Content is not null)
+                {
+                    var requestBody = await request.Content.ReadAsStringAsync().ConfigureAwait(false);
+                    Assert.Contains("resp_0888a", requestBody);
+                }
+
+                return new HttpResponseMessage(HttpStatusCode.OK) { Content = new StringContent(TestDataUtil.GetOpenAIDefaultResponseJson(), Encoding.UTF8, "application/json") };
+            }
+
+            return new HttpResponseMessage(HttpStatusCode.OK) { Content = new StringContent(TestDataUtil.GetAgentResponseJson(), Encoding.UTF8, "application/json") };
+        });
+
+#pragma warning disable CA5399
+        using var httpClient = new HttpClient(httpHandler);
+#pragma warning restore CA5399
+
+        AIProjectClient projectClient = new(
+            new Uri("https://test.openai.azure.com/"),
+            new FakeAuthenticationTokenProvider(),
+            new AIProjectClientOptions() { Transport = new HttpClientPipelineTransport(httpClient) });
+
+        var agent = projectClient.AsAIAgent(new AgentReference("agent-name"));
+
+        // Act
+        var session = await agent.CreateSessionAsync();
+        await agent.RunAsync("Hello", session, options: new ChatClientAgentRunOptions() { ChatOptions = new() { ConversationId = "resp_0888a" } });
+
+        Assert.True(requestTriggered);
+        var chatClientSession = Assert.IsType<ChatClientAgentSession>(session);
+        Assert.Equal("resp_0888a46cbf2b1ff3006914596e05d08195a77c3f5187b769a7", chatClientSession.ConversationId);
+    }
+
+    #endregion
+
+    #region the Agent Endpoint mode (Mode 3): Agent Endpoint
+
+    [Fact]
+    public void Mode3_AgentEndpoint_ParsesAgentNameFromUrl()
+    {
+        // Arrange + Act
+        var chatClient = new FoundryChatClient(
+            agentEndpoint: new Uri("https://example.com/api/projects/myproj/agents/myagent/endpoint/protocols/openai"),
+            credential: new FakeAuthenticationTokenProvider(),
+            clientOptions: null);
+
+        // Assert
+        Assert.Equal("myagent", chatClient.AgentName);
+    }
+
+    [Fact]
+    public void Mode3_AgentEndpoint_StampsFoundryProviderName()
+    {
+        // Act
+        var chatClient = new FoundryChatClient(
+            agentEndpoint: new Uri("https://example.com/api/projects/myproj/agents/myagent/endpoint/protocols/openai"),
+            credential: new FakeAuthenticationTokenProvider(),
+            clientOptions: null);
+
+        // Assert
+        var metadata = chatClient.GetService<ChatClientMetadata>();
+        Assert.NotNull(metadata);
+        Assert.Equal("microsoft.foundry", metadata!.ProviderName);
+        // No model id is knowable from the URL alone.
+        Assert.Null(metadata.DefaultModelId);
+    }
+
+    [Fact]
+    public void Mode3_AgentEndpoint_ExposesProjectOpenAIClientAndAIProjectClient()
+    {
+        // Act
+        var chatClient = new FoundryChatClient(
+            agentEndpoint: new Uri("https://example.com/api/projects/myproj/agents/myagent/endpoint/protocols/openai"),
+            credential: new FakeAuthenticationTokenProvider(),
+            clientOptions: null);
+
+        // Assert
+        // ProjectOpenAIClient is intentionally NOT exposed via GetService — callers retrieve
+        // it from the AIProjectClient themselves (aiProjectClient.GetProjectOpenAIClient()).
+        Assert.Null(chatClient.GetService<ProjectOpenAIClient>());
+        // After the materialization change, the Agent Endpoint mode (Mode 3) also exposes a working AIProjectClient
+        // built from the parsed project root. This makes the helper surface symmetric across
+        // all three construction modes.
+        Assert.NotNull(chatClient.GetService<AIProjectClient>());
+        Assert.Null(chatClient.GetService<AgentReference>());
+        Assert.Null(chatClient.GetService<ProjectsAgentVersion>());
+        Assert.Null(chatClient.GetService<ProjectsAgentRecord>());
+    }
+
+    [Fact]
+    public void Mode3_AgentEndpoint_MaterializedAIProjectClient_TargetsParsedProjectRoot()
+    {
+        // The Agent Endpoint mode (Mode 3) ctor must derive the project root from the agent endpoint URL and
+        // construct the AIProjectClient against that root, NOT the agent endpoint itself.
+        var agentEndpoint = new Uri("https://example.com/api/projects/myproj/agents/myagent/endpoint/protocols/openai");
+        var chatClient = new FoundryChatClient(
+            agentEndpoint: agentEndpoint,
+            credential: new FakeAuthenticationTokenProvider(),
+            clientOptions: null);
+
+        var aiProjectClient = chatClient.GetService<AIProjectClient>();
+        Assert.NotNull(aiProjectClient);
+        // AIProjectClient does not expose its endpoint publicly, so we rely on reflection on
+        // the well-known private field. If the SDK field shape changes this guard fails loudly.
+        var field = typeof(AIProjectClient).GetField("_endpoint", BindingFlags.Instance | BindingFlags.NonPublic);
+        Assert.NotNull(field);
+        var actualEndpoint = (Uri)field!.GetValue(aiProjectClient!)!;
+        Assert.Equal("https://example.com/api/projects/myproj", actualEndpoint.AbsoluteUri.TrimEnd('/'));
+    }
+
+    [Fact]
+    public void Mode3_AgentEndpoint_MaterializedAIProjectClient_IsReusedAcrossGetServiceCalls()
+    {
+        // Repeated GetService<AIProjectClient>() calls must return the same instance — the
+        // materialized client is cached in the existing _aiProjectClient field, not built on
+        // demand each call.
+        var chatClient = new FoundryChatClient(
+            agentEndpoint: new Uri("https://example.com/api/projects/myproj/agents/myagent/endpoint/protocols/openai"),
+            credential: new FakeAuthenticationTokenProvider(),
+            clientOptions: null);
+
+        var first = chatClient.GetService<AIProjectClient>();
+        var second = chatClient.GetService<AIProjectClient>();
+        Assert.NotNull(first);
+        Assert.Same(first, second);
+    }
+
+    [Fact]
+    public void Mode1_ResponsesAgent_AIProjectClient_IsTheSuppliedInstance()
+    {
+        // Regression check: the Responses Agent mode (Mode 1) must continue to expose the AIProjectClient the caller
+        // supplied via the constructor, NOT a freshly-materialized one.
+        var supplied = CreateProjectClient();
+        var chatClient = new FoundryChatClient(supplied, "gpt-4o-mini");
+        Assert.Same(supplied, chatClient.GetService<AIProjectClient>());
+    }
+
+    [Fact]
+    public void Mode2_PromptAgent_AIProjectClient_IsTheSuppliedInstance()
+    {
+        // Regression check: the Prompt Agent mode (Mode 2) must continue to expose the AIProjectClient the caller
+        // supplied via the constructor.
+        var supplied = CreateProjectClient();
+        var agentRef = new AgentReference("agent-name", "1");
+        var chatClient = new FoundryChatClient(supplied, agentRef, defaultModelId: null, baseChatOptions: null);
+        Assert.Same(supplied, chatClient.GetService<AIProjectClient>());
+    }
+
+    [Fact]
+    public void Mode3_AgentEndpoint_ThrowsOnNullEndpoint()
+        => Assert.Throws<ArgumentNullException>(() =>
+            new FoundryChatClient(agentEndpoint: null!, credential: new FakeAuthenticationTokenProvider(), clientOptions: null));
+
+    [Fact]
+    public void Mode3_AgentEndpoint_ThrowsOnNullCredential()
+        => Assert.Throws<ArgumentNullException>(() =>
+            new FoundryChatClient(
+                agentEndpoint: new Uri("https://example.com/api/projects/myproj/agents/myagent/endpoint/protocols/openai"),
+                credential: null!,
+                clientOptions: null));
+
+    #endregion
+
+    #region ParseAgentEndpoint URL parsing
+
+    [Fact]
+    public void ParseAgentEndpoint_HappyPath_ReturnsAgentNameAndProjectRoot()
+    {
+        // Act
+        var (agentName, projectRoot) = FoundryChatClient.ParseAgentEndpoint(
+            new Uri("https://example.com/api/projects/myproj/agents/myagent/endpoint/protocols/openai"));
+
+        // Assert
+        Assert.Equal("myagent", agentName);
+        Assert.Equal("https://example.com/api/projects/myproj", projectRoot.AbsoluteUri.TrimEnd('/'));
+    }
+
+    [Fact]
+    public void ParseAgentEndpoint_TolerantOfTrailingSlash()
+    {
+        // Act
+        var (agentName, _) = FoundryChatClient.ParseAgentEndpoint(
+            new Uri("https://example.com/api/projects/myproj/agents/myagent/endpoint/protocols/openai/"));
+
+        // Assert
+        Assert.Equal("myagent", agentName);
+    }
+
+    [Fact]
+    public void ParseAgentEndpoint_TolerantOfCaseDifferencesOnAgentsSegment()
+    {
+        // Act
+        var (agentName, _) = FoundryChatClient.ParseAgentEndpoint(
+            new Uri("https://example.com/api/projects/myproj/AGENTS/myagent/endpoint/protocols/openai"));
+
+        // Assert
+        Assert.Equal("myagent", agentName);
+    }
+
+    [Fact]
+    public void ParseAgentEndpoint_StripsQueryAndFragment()
+    {
+        // Act
+        var (_, projectRoot) = FoundryChatClient.ParseAgentEndpoint(
+            new Uri("https://example.com/api/projects/myproj/agents/myagent/endpoint/protocols/openai?api-version=v1#frag"));
+
+        // Assert
+        Assert.Equal(string.Empty, projectRoot.Query);
+        Assert.Equal(string.Empty, projectRoot.Fragment);
+    }
+
+    [Fact]
+    public void ParseAgentEndpoint_ThrowsOnMissingAgentsSegment()
+        => Assert.Throws<ArgumentException>(() =>
+            FoundryChatClient.ParseAgentEndpoint(new Uri("https://example.com/api/projects/myproj/anyseg/myagent/endpoint/protocols/openai")));
+
+    [Fact]
+    public void ParseAgentEndpoint_ThrowsOnWrongSuffix()
+        => Assert.Throws<ArgumentException>(() =>
+            FoundryChatClient.ParseAgentEndpoint(new Uri("https://example.com/api/projects/myproj/agents/myagent/wrong/suffix")));
+
+    [Fact]
+    public void ParseAgentEndpoint_ThrowsOnNullUri()
+        => Assert.Throws<ArgumentNullException>(() => FoundryChatClient.ParseAgentEndpoint(null!));
+
+    #endregion
+
+    #region AgentFrameworkUserAgentPolicy + ServedModelPolicy registration + dedup
+
+    [Fact]
+    public void Register_AgentFrameworkUserAgentPolicy_OnUnderlyingOpenAIRequestPolicies()
+    {
+        // Arrange + Act: constructing a FoundryChatClient should register the
+        // AgentFrameworkUserAgentPolicy and ServedModelPolicy on the inner chat client's OpenAIRequestPolicies.
+        var chatClient = new FoundryChatClient(CreateProjectClient(), "gpt-4o-mini");
+
+        // Assert: the inner chat client (MEAI's OpenAIResponsesChatClient) exposes
+        // OpenAIRequestPolicies via GetService, and both policies are present in its entries.
+        var policies = chatClient.GetService<OpenAIRequestPolicies>();
+        Assert.NotNull(policies);
+        Assert.Equal(2, EntriesCount(policies!));
+    }
+
+    [Fact]
+    public void Register_AgentFrameworkUserAgentPolicy_IsDedupedAcrossMultipleClients_OnSharedInner()
+    {
+        // Arrange: construct via the ProjectsAgentVersion mode-2 variant, which chains via
+        // :this(...) into the AgentReference ctor. If the policy registration code were
+        // inadvertently called twice along the chain, we would see more than 2 entries.
+        var projectClient = CreateProjectClient();
+        var agentVersion = ModelReaderWriter.Read<ProjectsAgentVersion>(
+            BinaryData.FromString(TestDataUtil.GetAgentVersionResponseJson()))!;
+
+        // Act
+        var chatClient = new FoundryChatClient(projectClient, agentVersion, baseChatOptions: null);
+
+        // Assert: even though the version variant funnels through the AgentReference ctor
+        // via :this(...), each policy is registered exactly once on the inner pipeline.
+        var policies = chatClient.GetService<OpenAIRequestPolicies>();
+        Assert.NotNull(policies);
+        Assert.Equal(2, EntriesCount(policies!));
+        Assert.Same(agentVersion, chatClient.GetService<ProjectsAgentVersion>());
+        Assert.NotNull(chatClient.GetService<AgentReference>());
+    }
+
+    #endregion
+
+    #region Helpers
+
+    private static AIProjectClient CreateProjectClient()
+        => new(
+            new Uri("https://test.openai.azure.com/"),
+            new FakeAuthenticationTokenProvider(),
+            new AIProjectClientOptions { Transport = new HttpClientPipelineTransport(new HttpClient()) });
+
+    private static int EntriesCount(OpenAIRequestPolicies policies)
+    {
+        var field = typeof(OpenAIRequestPolicies).GetField("_entries", BindingFlags.Instance | BindingFlags.NonPublic);
+        Assert.NotNull(field);
+        var arr = (Array)field!.GetValue(policies)!;
+        return arr.Length;
+    }
+
+    #endregion
+}
+#pragma warning restore CS0618

dotnet/tests/Microsoft.Agents.AI.Foundry.UnitTests/FoundryChatClientVectorStoreTests.cs

@@ -0,0 +1,660 @@
+// Copyright (c) Microsoft. All rights reserved.
+
+using System;
+using System.ClientModel.Primitives;
+using System.Collections.Generic;
+using System.IO;
+using System.Net;
+using System.Net.Http;
+using System.Text;
+using System.Threading;
+using System.Threading.Tasks;
+using Azure.AI.Extensions.OpenAI;
+using Azure.AI.Projects;
+using OpenAI.Files;
+
+#pragma warning disable OPENAI001, CS0618
+
+namespace Microsoft.Agents.AI.Foundry.UnitTests;
+
+/// <summary>
+/// Unit tests for the file and vector-store helper methods on <see cref="FoundryChatClient"/>.
+/// Covers all four methods across the three FoundryChatClient construction modes plus argument
+/// validation, cancellation, and request-body shape on the wire.
+/// </summary>
+public sealed class FoundryChatClientVectorStoreTests
+{
+    // ----- Construction helpers shared by every test in this file -----
+
+    private static (FoundryChatClient ChatClient, RequestRecorder Recorder) CreateMode1(string modelId = "gpt-4o-mini", string? responseBody = null)
+    {
+        var recorder = new RequestRecorder(responseBody);
+#pragma warning disable CA5399
+        var httpClient = new HttpClient(recorder);
+#pragma warning restore CA5399
+        var projectClient = new AIProjectClient(
+            new Uri("https://test.openai.azure.com/"),
+            new FakeAuthenticationTokenProvider(),
+            new AIProjectClientOptions { Transport = new HttpClientPipelineTransport(httpClient) });
+        return (new FoundryChatClient(projectClient, modelId), recorder);
+    }
+
+    private static (FoundryChatClient ChatClient, RequestRecorder Recorder) CreateMode2(string? responseBody = null)
+    {
+        var recorder = new RequestRecorder(responseBody);
+#pragma warning disable CA5399
+        var httpClient = new HttpClient(recorder);
+#pragma warning restore CA5399
+        var projectClient = new AIProjectClient(
+            new Uri("https://test.openai.azure.com/"),
+            new FakeAuthenticationTokenProvider(),
+            new AIProjectClientOptions { Transport = new HttpClientPipelineTransport(httpClient) });
+        var agentRef = new AgentReference("agent-name", "1");
+        return (new FoundryChatClient(projectClient, agentRef, defaultModelId: "gpt-4o", baseChatOptions: null), recorder);
+    }
+
+    private static string MakeTempFile(string contents = "hello world")
+    {
+        var path = Path.Combine(Path.GetTempPath(), $"fcc-test-{Guid.NewGuid():N}.txt");
+        File.WriteAllText(path, contents);
+        return path;
+    }
+
+    // ----- UploadFileAsync -----
+
+    [Fact]
+    public async Task UploadFileAsync_Mode1_UploadsViaProjectOpenAIClientAsync()
+    {
+        var (chatClient, recorder) = CreateMode1(responseBody: FakeFileJson("file_abc"));
+        var path = MakeTempFile();
+        try
+        {
+            var result = await chatClient.UploadFileAsync(path, FileUploadPurpose.Assistants);
+
+            Assert.Equal("file_abc", result.Id);
+            Assert.NotEmpty(recorder.Requests);
+            Assert.EndsWith("/files", recorder.Requests[0].PathAndQuery.TrimEnd('/').Split('?')[0]);
+        }
+        finally { File.Delete(path); }
+    }
+
+    [Fact]
+    public async Task UploadFileAsync_Mode2_UploadsViaProjectOpenAIClientAsync()
+    {
+        var (chatClient, recorder) = CreateMode2(responseBody: FakeFileJson("file_xyz"));
+        var path = MakeTempFile();
+        try
+        {
+            var result = await chatClient.UploadFileAsync(path, FileUploadPurpose.Assistants);
+            Assert.Equal("file_xyz", result.Id);
+            Assert.Contains(recorder.Requests, r => r.PathAndQuery.Contains("/files"));
+        }
+        finally { File.Delete(path); }
+    }
+
+    [Fact]
+    public async Task UploadFileAsync_Mode3_UploadsViaMaterializedProjectClientAsync()
+    {
+        // Q-E: Mode 3 (Agent Endpoint) now honors caller-supplied transports via
+        // ProjectOpenAIClientOptions.Transport, so we can use a fake transport here instead of
+        // depending on DNS/network availability against example.com.
+        var sawUpload = false;
+        using var handler = new HttpHandlerAssert(req =>
+        {
+            if (req.Method == HttpMethod.Post && req.RequestUri!.AbsolutePath.Contains("/files", StringComparison.Ordinal))
+            {
+                sawUpload = true;
+                return MakeJsonResponse(FakeFileJson("file_mode3"));
+            }
+            return MakeJsonResponse("{}");
+        });
+#pragma warning disable CA5399
+        using var httpClient = new HttpClient(handler);
+#pragma warning restore CA5399
+        var chatClient = new FoundryChatClient(
+            agentEndpoint: new Uri("https://example.com/api/projects/myproj/agents/myagent/endpoint/protocols/openai"),
+            credential: new FakeAuthenticationTokenProvider(),
+            clientOptions: new ProjectOpenAIClientOptions { Transport = new HttpClientPipelineTransport(httpClient) });
+
+        var path = MakeTempFile();
+        try
+        {
+            var result = await chatClient.UploadFileAsync(path, FileUploadPurpose.Assistants, CancellationToken.None);
+            Assert.True(sawUpload);
+            Assert.Equal("file_mode3", result.Id);
+        }
+        finally { File.Delete(path); }
+    }
+
+    [Fact]
+    public async Task UploadFileAsync_NullFilePath_ThrowsArgumentNullExceptionAsync()
+    {
+        var (chatClient, _) = CreateMode1();
+        await Assert.ThrowsAsync<ArgumentNullException>(() =>
+            chatClient.UploadFileAsync(null!, FileUploadPurpose.Assistants));
+    }
+
+    [Fact]
+    public async Task UploadFileAsync_FileNotFound_ThrowsFileNotFoundExceptionAsync()
+    {
+        var (chatClient, _) = CreateMode1();
+        var missing = Path.Combine(Path.GetTempPath(), $"does-not-exist-{Guid.NewGuid():N}.txt");
+        await Assert.ThrowsAsync<FileNotFoundException>(() =>
+            chatClient.UploadFileAsync(missing, FileUploadPurpose.Assistants));
+    }
+
+    [Fact]
+    public async Task UploadFileAsync_HonorsCancellationAsync()
+    {
+        // Cancellation propagation through the OpenAI SDK pipeline surfaces different exception
+        // types depending on the framework target (OperationCanceledException on net10.0,
+        // ObjectDisposedException at the transport layer on net472). Asserting on the exact
+        // exception class is brittle; assert only that the call throws when the token is
+        // pre-cancelled.
+        var (chatClient, _) = CreateMode1(responseBody: FakeFileJson("file_abc"));
+        var path = MakeTempFile();
+        try
+        {
+            using var cts = new CancellationTokenSource();
+            cts.Cancel();
+            await Assert.ThrowsAnyAsync<Exception>(() =>
+                chatClient.UploadFileAsync(path, FileUploadPurpose.Assistants, cts.Token));
+        }
+        finally { File.Delete(path); }
+    }
+
+    // ----- DeleteFileAsync -----
+
+    [Fact]
+    public async Task DeleteFileAsync_Mode1_CallsDeleteOnFileClientAsync()
+    {
+        var (chatClient, recorder) = CreateMode1(responseBody: FakeFileDeletedJson("file_abc"));
+        await chatClient.DeleteFileAsync("file_abc");
+        Assert.Contains(recorder.Requests, r => r.Method == "DELETE" && r.PathAndQuery.Contains("/files/file_abc"));
+    }
+
+    [Fact]
+    public async Task DeleteFileAsync_Mode2_CallsDeleteOnFileClientAsync()
+    {
+        var (chatClient, recorder) = CreateMode2(responseBody: FakeFileDeletedJson("file_xyz"));
+        await chatClient.DeleteFileAsync("file_xyz");
+        Assert.Contains(recorder.Requests, r => r.Method == "DELETE" && r.PathAndQuery.Contains("/files/file_xyz"));
+    }
+
+    [Fact]
+    public async Task DeleteFileAsync_NullId_ThrowsArgumentExceptionAsync()
+    {
+        var (chatClient, _) = CreateMode1();
+        await Assert.ThrowsAnyAsync<ArgumentException>(() => chatClient.DeleteFileAsync(null!));
+    }
+
+    [Fact]
+    public async Task DeleteFileAsync_EmptyId_ThrowsArgumentExceptionAsync()
+    {
+        var (chatClient, _) = CreateMode1();
+        await Assert.ThrowsAnyAsync<ArgumentException>(() => chatClient.DeleteFileAsync(""));
+    }
+
+    [Fact]
+    public async Task DeleteFileAsync_HonorsCancellationAsync()
+    {
+        // Verify the cancellation token reaches the HTTP pipeline by having the handler
+        // throw OperationCanceledException when the token is cancelled before the request.
+        // This is more robust than asserting on the exact exception the SDK surfaces, which
+        // depends on internal pipeline plumbing.
+        var observedToken = CancellationToken.None;
+        using var handler = new HttpHandlerAssert(async req =>
+        {
+            // We don't have direct access to the SDK's CancellationToken here; instead, sleep
+            // briefly to give the caller's pre-cancellation a chance to be picked up by the
+            // transport. If cancellation reached the pipeline, the await on this handler call
+            // would surface OperationCanceledException; if not, the response is returned.
+            await Task.Delay(50).ConfigureAwait(false);
+            return new HttpResponseMessage(HttpStatusCode.OK)
+            {
+                Content = new StringContent(FakeFileDeletedJson("file_abc"), Encoding.UTF8, "application/json"),
+            };
+        });
+#pragma warning disable CA5399
+        using var httpClient = new HttpClient(handler);
+#pragma warning restore CA5399
+        var projectClient = new AIProjectClient(
+            new Uri("https://test.openai.azure.com/"),
+            new FakeAuthenticationTokenProvider(),
+            new AIProjectClientOptions { Transport = new HttpClientPipelineTransport(httpClient) });
+        var chatClient = new FoundryChatClient(projectClient, "gpt-4o-mini");
+
+        using var cts = new CancellationTokenSource();
+        cts.Cancel();
+        // Any throw is acceptable evidence that cancellation was honored. The SDK's exact
+        // exception surface for pre-cancelled tokens is an implementation detail of
+        // System.ClientModel's pipeline and may differ between versions.
+        await Assert.ThrowsAnyAsync<Exception>(() => chatClient.DeleteFileAsync("file_abc", cts.Token));
+    }
+
+    // ----- CreateVectorStoreAsync -----
+
+    [Fact]
+    public async Task CreateVectorStoreAsync_UploadsThenCreates_WithFileIds_ReturnsVectorStoreAsync()
+    {
+        // Each file POST returns a distinct file id; the recorder dispatches on URL to differentiate.
+        var fileCount = 0;
+        using var handler = new HttpHandlerAssert(async req =>
+        {
+            var body = req.Content is null ? "" : await req.Content.ReadAsStringAsync().ConfigureAwait(false);
+            if (req.RequestUri!.AbsolutePath.Contains("/files") && req.Method == HttpMethod.Post)
+            {
+                fileCount++;
+                return MakeJsonResponse(FakeFileJson($"file_{fileCount}"));
+            }
+            if (req.RequestUri.AbsolutePath.Contains("/vector_stores") && req.Method == HttpMethod.Post)
+            {
+                Assert.Contains("file_1", body);
+                Assert.Contains("file_2", body);
+                Assert.Contains("knowledge-base", body);
+                return MakeJsonResponse(FakeVectorStoreJson("vs_abc", name: "knowledge-base"));
+            }
+            return MakeJsonResponse("{}");
+        });
+
+#pragma warning disable CA5399
+        using var httpClient = new HttpClient(handler);
+#pragma warning restore CA5399
+        var projectClient = new AIProjectClient(
+            new Uri("https://test.openai.azure.com/"),
+            new FakeAuthenticationTokenProvider(),
+            new AIProjectClientOptions { Transport = new HttpClientPipelineTransport(httpClient) });
+        var chatClient = new FoundryChatClient(projectClient, "gpt-4o-mini");
+
+        var pathA = MakeTempFile("alpha");
+        var pathB = MakeTempFile("beta");
+        try
+        {
+            var store = await chatClient.CreateVectorStoreAsync("knowledge-base", new[] { pathA, pathB });
+            Assert.Equal("vs_abc", store.Id);
+            Assert.Equal(2, fileCount);
+        }
+        finally { File.Delete(pathA); File.Delete(pathB); }
+    }
+
+    [Fact]
+    public async Task CreateVectorStoreAsync_WithExpiresAfter_SerializesLastActiveAtAnchorAsync()
+    {
+        string? vectorStoreBody = null;
+        using var handler = new HttpHandlerAssert(async req =>
+        {
+            if (req.RequestUri!.AbsolutePath.Contains("/vector_stores") && req.Method == HttpMethod.Post)
+            {
+                vectorStoreBody = req.Content is null ? "" : await req.Content.ReadAsStringAsync().ConfigureAwait(false);
+                return MakeJsonResponse(FakeVectorStoreJson("vs_abc", name: "x"));
+            }
+            return MakeJsonResponse("{}");
+        });
+
+#pragma warning disable CA5399
+        using var httpClient = new HttpClient(handler);
+#pragma warning restore CA5399
+        var projectClient = new AIProjectClient(
+            new Uri("https://test.openai.azure.com/"),
+            new FakeAuthenticationTokenProvider(),
+            new AIProjectClientOptions { Transport = new HttpClientPipelineTransport(httpClient) });
+        var chatClient = new FoundryChatClient(projectClient, "gpt-4o-mini");
+
+        await chatClient.CreateVectorStoreAsync("x", Array.Empty<string>(), expiresAfter: TimeSpan.FromDays(7));
+
+        Assert.NotNull(vectorStoreBody);
+        Assert.Contains("\"expires_after\"", vectorStoreBody);
+        Assert.Contains("\"last_active_at\"", vectorStoreBody);
+        Assert.Contains("\"days\":7", vectorStoreBody);
+    }
+
+    [Fact]
+    public async Task CreateVectorStoreAsync_WithNullExpiresAfter_OmitsExpirationPolicyAsync()
+    {
+        string? vectorStoreBody = null;
+        using var handler = new HttpHandlerAssert(async req =>
+        {
+            if (req.RequestUri!.AbsolutePath.Contains("/vector_stores") && req.Method == HttpMethod.Post)
+            {
+                vectorStoreBody = req.Content is null ? "" : await req.Content.ReadAsStringAsync().ConfigureAwait(false);
+                return MakeJsonResponse(FakeVectorStoreJson("vs_abc", name: "x"));
+            }
+            return MakeJsonResponse("{}");
+        });
+
+#pragma warning disable CA5399
+        using var httpClient = new HttpClient(handler);
+#pragma warning restore CA5399
+        var projectClient = new AIProjectClient(
+            new Uri("https://test.openai.azure.com/"),
+            new FakeAuthenticationTokenProvider(),
+            new AIProjectClientOptions { Transport = new HttpClientPipelineTransport(httpClient) });
+        var chatClient = new FoundryChatClient(projectClient, "gpt-4o-mini");
+
+        await chatClient.CreateVectorStoreAsync("x", Array.Empty<string>(), expiresAfter: null);
+
+        Assert.NotNull(vectorStoreBody);
+        Assert.DoesNotContain("\"expires_after\"", vectorStoreBody);
+    }
+
+    [Fact]
+    public async Task CreateVectorStoreAsync_EmptyFilesList_CreatesEmptyStoreAsync()
+    {
+        var (chatClient, _) = CreateMode1(responseBody: FakeVectorStoreJson("vs_empty", name: "x"));
+        var store = await chatClient.CreateVectorStoreAsync("x", Array.Empty<string>());
+        Assert.Equal("vs_empty", store.Id);
+    }
+
+    [Fact]
+    public async Task CreateVectorStoreAsync_NullName_ThrowsArgumentExceptionAsync()
+    {
+        var (chatClient, _) = CreateMode1();
+        await Assert.ThrowsAnyAsync<ArgumentException>(() =>
+            chatClient.CreateVectorStoreAsync(null!, Array.Empty<string>()));
+    }
+
+    [Fact]
+    public async Task CreateVectorStoreAsync_NullFilePaths_ThrowsArgumentNullExceptionAsync()
+    {
+        var (chatClient, _) = CreateMode1();
+        await Assert.ThrowsAsync<ArgumentNullException>(() =>
+            chatClient.CreateVectorStoreAsync("x", filePaths: null!));
+    }
+
+    [Fact]
+    public async Task CreateVectorStoreAsync_HonorsCancellationAsync()
+    {
+        // Same rationale as UploadFileAsync_HonorsCancellationAsync — assert only that any
+        // exception is thrown on a pre-cancelled token.
+        var (chatClient, _) = CreateMode1(responseBody: FakeVectorStoreJson("vs_x", "x"));
+        using var cts = new CancellationTokenSource();
+        cts.Cancel();
+        await Assert.ThrowsAnyAsync<Exception>(() =>
+            chatClient.CreateVectorStoreAsync("x", Array.Empty<string>(), expiresAfter: null, cancellationToken: cts.Token));
+    }
+
+    [Fact]
+    public async Task CreateVectorStoreAsync_PollsUntilStoreLeavesInProgress_Async()
+    {
+        // Q-A regression: when the create response returns status=in_progress, the helper must
+        // poll GET /vector_stores/{id} until status changes before returning. Otherwise the
+        // caller receives a half-built store.
+        var pollCount = 0;
+        using var handler = new HttpHandlerAssert(req =>
+        {
+            if (req.RequestUri!.AbsolutePath.Contains("/vector_stores") && req.Method == HttpMethod.Post)
+            {
+                // First response: status=in_progress.
+                return Task.FromResult(MakeJsonResponse(FakeVectorStoreJsonWithStatus("vs_abc", name: "x", status: "in_progress")));
+            }
+            if (req.RequestUri.AbsolutePath.Contains("/vector_stores/vs_abc") && req.Method == HttpMethod.Get)
+            {
+                pollCount++;
+                // Stay in_progress for two polls, then complete on the third.
+                var status = pollCount < 3 ? "in_progress" : "completed";
+                return Task.FromResult(MakeJsonResponse(FakeVectorStoreJsonWithStatus("vs_abc", name: "x", status: status)));
+            }
+            return Task.FromResult(MakeJsonResponse("{}"));
+        });
+
+#pragma warning disable CA5399
+        using var httpClient = new HttpClient(handler);
+#pragma warning restore CA5399
+        var projectClient = new AIProjectClient(
+            new Uri("https://test.openai.azure.com/"),
+            new FakeAuthenticationTokenProvider(),
+            new AIProjectClientOptions { Transport = new HttpClientPipelineTransport(httpClient) });
+        var chatClient = new FoundryChatClient(projectClient, "gpt-4o-mini");
+
+        var store = await chatClient.CreateVectorStoreAsync("x", Array.Empty<string>());
+
+        Assert.NotEqual(OpenAI.VectorStores.VectorStoreStatus.InProgress, store.Status);
+        Assert.True(pollCount >= 3, $"Expected at least 3 GET polls before status leaves in_progress; saw {pollCount}.");
+    }
+
+    [Fact]
+    public async Task CreateVectorStoreAsync_PollingTimeout_ThrowsTimeoutExceptionAsync()
+    {
+        // Sergey #2: caller-supplied (or default) polling timeout must surface as TimeoutException
+        // when the vector store never leaves InProgress. Mock keeps the store stuck and we pass
+        // a tiny timeout; cancellation token stays unused so the only path that ends the loop
+        // is the timeout check.
+        using var handler = new HttpHandlerAssert(req =>
+        {
+            if (req.RequestUri!.AbsolutePath.Contains("/vector_stores", StringComparison.Ordinal))
+            {
+                return Task.FromResult(MakeJsonResponse(FakeVectorStoreJsonWithStatus("vs_stuck", name: "x", status: "in_progress")));
+            }
+            return Task.FromResult(MakeJsonResponse("{}"));
+        });
+#pragma warning disable CA5399
+        using var httpClient = new HttpClient(handler);
+#pragma warning restore CA5399
+        var projectClient = new AIProjectClient(
+            new Uri("https://test.openai.azure.com/"),
+            new FakeAuthenticationTokenProvider(),
+            new AIProjectClientOptions { Transport = new HttpClientPipelineTransport(httpClient) });
+        var chatClient = new FoundryChatClient(projectClient, "gpt-4o-mini");
+
+        var ex = await Assert.ThrowsAsync<TimeoutException>(() =>
+            chatClient.CreateVectorStoreAsync("x", Array.Empty<string>(), expiresAfter: null, pollingTimeout: TimeSpan.FromMilliseconds(500)));
+        Assert.Contains("vs_stuck", ex.Message, StringComparison.Ordinal);
+        Assert.Contains("in-progress", ex.Message, StringComparison.Ordinal);
+    }
+
+    [Fact]
+    public async Task CreateVectorStoreAsync_MidUploadFailure_DeletesAlreadyUploadedFilesAsync()
+    {
+        // Q-B regression: when the upload loop throws partway through (e.g. file 3 of 5 is
+        // missing or the network fails), the helper must DELETE the already-uploaded files so
+        // they do not accumulate as orphaned resources. The exception must still propagate.
+        var uploadCount = 0;
+        var deleted = new List<string>();
+        using var handler = new HttpHandlerAssert(req =>
+        {
+            // DELETE first so we don't match the upload-collection /files path against this.
+            if (req.Method == HttpMethod.Delete)
+            {
+                var segments = req.RequestUri!.AbsolutePath.Split('/');
+                var fileId = segments[segments.Length - 1];
+                deleted.Add(fileId);
+                return MakeJsonResponse(FakeFileDeletedJson(fileId));
+            }
+            if (req.Method == HttpMethod.Post && req.RequestUri!.AbsolutePath.Contains("/files", StringComparison.Ordinal))
+            {
+                uploadCount++;
+                if (uploadCount == 3)
+                {
+                    // 400 is non-retriable; the SDK retry policy ignores it. 5xx would trigger
+                    // retries and confuse the assertion on upload count.
+                    return new HttpResponseMessage(HttpStatusCode.BadRequest)
+                    {
+                        Content = new StringContent("{\"error\":{\"code\":\"BadRequest\",\"message\":\"upload-failed-on-3\"}}", Encoding.UTF8, "application/json"),
+                    };
+                }
+                return MakeJsonResponse(FakeFileJson($"file_{uploadCount}"));
+            }
+            return MakeJsonResponse("{}");
+        });
+
+#pragma warning disable CA5399
+        using var httpClient = new HttpClient(handler);
+#pragma warning restore CA5399
+        var projectClient = new AIProjectClient(
+            new Uri("https://test.openai.azure.com/"),
+            new FakeAuthenticationTokenProvider(),
+            new AIProjectClientOptions { Transport = new HttpClientPipelineTransport(httpClient) });
+        var chatClient = new FoundryChatClient(projectClient, "gpt-4o-mini");
+
+        var paths = new[] { MakeTempFile("a"), MakeTempFile("b"), MakeTempFile("c"), MakeTempFile("d"), MakeTempFile("e") };
+        try
+        {
+            await Assert.ThrowsAnyAsync<Exception>(() => chatClient.CreateVectorStoreAsync("knowledge-base", paths));
+
+            // Three upload attempts: two succeeded, the third threw.
+            Assert.Equal(3, uploadCount);
+            // The two successful uploads must have been deleted as part of best-effort cleanup.
+            Assert.Equal(2, deleted.Count);
+            Assert.Contains("file_1", deleted);
+            Assert.Contains("file_2", deleted);
+        }
+        finally
+        {
+            foreach (var p in paths)
+            {
+                File.Delete(p);
+            }
+        }
+    }
+
+    [Fact]
+    public async Task CreateVectorStoreAsync_MidUploadFailure_CleanupSwallowsDeleteErrorsAsync()
+    {
+        // Q-B follow-on: if a cleanup DELETE itself fails, the helper must still propagate the
+        // original upload exception — not the cleanup exception. The caller cares about the
+        // upload failure; cleanup is best-effort.
+        var uploadCount = 0;
+        using var handler = new HttpHandlerAssert(req =>
+        {
+            if (req.Method == HttpMethod.Delete)
+            {
+                return new HttpResponseMessage(HttpStatusCode.BadRequest)
+                {
+                    Content = new StringContent("{\"error\":{\"code\":\"DeleteFailed\",\"message\":\"cleanup-failed\"}}", Encoding.UTF8, "application/json"),
+                };
+            }
+            if (req.Method == HttpMethod.Post && req.RequestUri!.AbsolutePath.Contains("/files", StringComparison.Ordinal))
+            {
+                uploadCount++;
+                if (uploadCount == 2)
+                {
+                    return new HttpResponseMessage(HttpStatusCode.BadRequest)
+                    {
+                        Content = new StringContent("{\"error\":{\"code\":\"BadRequest\",\"message\":\"upload-failed\"}}", Encoding.UTF8, "application/json"),
+                    };
+                }
+                return MakeJsonResponse(FakeFileJson($"file_{uploadCount}"));
+            }
+            return MakeJsonResponse("{}");
+        });
+
+#pragma warning disable CA5399
+        using var httpClient = new HttpClient(handler);
+#pragma warning restore CA5399
+        var projectClient = new AIProjectClient(
+            new Uri("https://test.openai.azure.com/"),
+            new FakeAuthenticationTokenProvider(),
+            new AIProjectClientOptions { Transport = new HttpClientPipelineTransport(httpClient) });
+        var chatClient = new FoundryChatClient(projectClient, "gpt-4o-mini");
+
+        var paths = new[] { MakeTempFile("a"), MakeTempFile("b") };
+        try
+        {
+            var ex = await Assert.ThrowsAnyAsync<Exception>(() => chatClient.CreateVectorStoreAsync("kb", paths));
+
+            // The original upload-failure message must surface, not the cleanup-failure message.
+            Assert.DoesNotContain("cleanup-failed", ex.Message ?? "", StringComparison.Ordinal);
+        }
+        finally
+        {
+            foreach (var p in paths)
+            {
+                File.Delete(p);
+            }
+        }
+    }
+
+    // ----- DeleteVectorStoreAsync -----
+
+    [Fact]
+    public async Task DeleteVectorStoreAsync_Mode1_CallsDeleteAsync()
+    {
+        var (chatClient, recorder) = CreateMode1(responseBody: FakeVectorStoreDeletedJson("vs_abc"));
+        await chatClient.DeleteVectorStoreAsync("vs_abc");
+        Assert.Contains(recorder.Requests, r => r.Method == "DELETE" && r.PathAndQuery.Contains("/vector_stores/vs_abc"));
+    }
+
+    [Fact]
+    public async Task DeleteVectorStoreAsync_Mode2_CallsDeleteAsync()
+    {
+        var (chatClient, recorder) = CreateMode2(responseBody: FakeVectorStoreDeletedJson("vs_xyz"));
+        await chatClient.DeleteVectorStoreAsync("vs_xyz");
+        Assert.Contains(recorder.Requests, r => r.Method == "DELETE" && r.PathAndQuery.Contains("/vector_stores/vs_xyz"));
+    }
+
+    [Fact]
+    public async Task DeleteVectorStoreAsync_NullId_ThrowsArgumentExceptionAsync()
+    {
+        var (chatClient, _) = CreateMode1();
+        await Assert.ThrowsAnyAsync<ArgumentException>(() => chatClient.DeleteVectorStoreAsync(null!));
+    }
+
+    [Fact]
+    public async Task DeleteVectorStoreAsync_HonorsCancellationAsync()
+    {
+        // Same approach as DeleteFileAsync_HonorsCancellationAsync — assert that the call
+        // throws when the token is pre-cancelled, without asserting on the exact exception
+        // surfaced by the SDK pipeline.
+        var (chatClient, _) = CreateMode1(responseBody: FakeVectorStoreDeletedJson("vs_abc"));
+        using var cts = new CancellationTokenSource();
+        cts.Cancel();
+        await Assert.ThrowsAnyAsync<Exception>(() => chatClient.DeleteVectorStoreAsync("vs_abc", cts.Token));
+    }
+
+    // ----- Fixtures and helpers -----
+
+    private static HttpResponseMessage MakeJsonResponse(string json)
+        => new(HttpStatusCode.OK)
+        {
+            Content = new StringContent(json, Encoding.UTF8, "application/json"),
+        };
+
+    private static string FakeFileJson(string id)
+        => $"{{\"id\":\"{id}\",\"object\":\"file\",\"bytes\":11,\"created_at\":1700000000,\"filename\":\"x.txt\",\"purpose\":\"assistants\",\"status\":\"processed\"}}";
+
+    private static string FakeFileDeletedJson(string id)
+        => $"{{\"id\":\"{id}\",\"object\":\"file\",\"deleted\":true}}";
+
+    private static string FakeVectorStoreJson(string id, string name)
+        => FakeVectorStoreJsonWithStatus(id, name, status: "completed");
+
+    private static string FakeVectorStoreJsonWithStatus(string id, string name, string status)
+        => $"{{\"id\":\"{id}\",\"object\":\"vector_store\",\"created_at\":1700000000,\"name\":\"{name}\",\"usage_bytes\":0,\"file_counts\":{{\"in_progress\":0,\"completed\":0,\"failed\":0,\"cancelled\":0,\"total\":0}},\"status\":\"{status}\",\"last_active_at\":1700000000}}";
+
+    private static string FakeVectorStoreDeletedJson(string id)
+        => $"{{\"id\":\"{id}\",\"object\":\"vector_store.deleted\",\"deleted\":true}}";
+
+    private sealed class RequestRecorder : HttpClientHandler
+    {
+        private readonly string _responseBody;
+        public List<RecordedRequest> Requests { get; } = [];
+
+        public RequestRecorder(string? responseBody)
+        {
+            this._responseBody = responseBody ?? "{}";
+        }
+
+        protected override async Task<HttpResponseMessage> SendAsync(HttpRequestMessage request, CancellationToken cancellationToken)
+        {
+            this.Requests.Add(new RecordedRequest
+            {
+                Method = request.Method.Method,
+                PathAndQuery = request.RequestUri?.PathAndQuery ?? "",
+#if NET
+                Body = request.Content is null ? "" : await request.Content.ReadAsStringAsync(cancellationToken).ConfigureAwait(false),
+#else
+                Body = request.Content is null ? "" : await request.Content.ReadAsStringAsync().ConfigureAwait(false),
+#endif
+            });
+            return MakeJsonResponse(this._responseBody);
+        }
+    }
+
+    private sealed class RecordedRequest
+    {
+        public string Method { get; set; } = "";
+        public string PathAndQuery { get; set; } = "";
+        public string Body { get; set; } = "";
+    }
+}
+#pragma warning restore CS0618

dotnet/tests/Microsoft.Agents.AI.Foundry.UnitTests/FoundryPromptAgentConverterTests.cs

@@ -0,0 +1,433 @@
+// Copyright (c) Microsoft. All rights reserved.
+
+using System;
+using System.ClientModel.Primitives;
+using System.Net;
+using System.Net.Http;
+using System.Text;
+using System.Threading;
+using System.Threading.Tasks;
+using Azure.AI.Extensions.OpenAI;
+using Azure.AI.Projects;
+using Azure.AI.Projects.Agents;
+using Microsoft.Extensions.AI;
+using OpenAI.Responses;
+
+#pragma warning disable OPENAI001, CS0618
+
+namespace Microsoft.Agents.AI.Foundry.UnitTests;
+
+/// <summary>
+/// Unit tests for the public <c>ToPromptAgentAsync</c> extension methods on
+/// <see cref="ChatClientAgent"/> and <see cref="FoundryAgent"/>. Both entry points dispatch
+/// to the same internal converter, so each behavior is asserted through both surfaces.
+/// </summary>
+public sealed class FoundryPromptAgentConverterTests
+{
+    // ----- Failure modes (assert through ChatClientAgent and FoundryAgent extensions) -----
+
+    [Fact]
+    public async Task ToPromptAgentAsync_ChatClientAgent_NonFoundryChatClient_ThrowsInvalidOperationExceptionAsync()
+    {
+        var agent = new ChatClientAgent(new NoOpChatClient());
+        var ex = await Assert.ThrowsAsync<InvalidOperationException>(() => agent.ToPromptAgentAsync());
+        Assert.Contains("FoundryChatClient", ex.Message);
+    }
+
+    [Fact]
+    public async Task ToPromptAgentAsync_FoundryAgent_FoundryChatClientInMode3_ThrowsInvalidOperationExceptionAsync()
+    {
+        var foundryAgent = new FoundryAgent(
+            agentEndpoint: new Uri("https://example.com/api/projects/myproj/agents/myagent/endpoint/protocols/openai"),
+            credential: new FakeAuthenticationTokenProvider());
+        var ex = await Assert.ThrowsAsync<InvalidOperationException>(() => foundryAgent.ToPromptAgentAsync());
+        Assert.Contains("Agent Endpoint mode (Mode 3)", ex.Message);
+    }
+
+    [Fact]
+    public async Task ToPromptAgentAsync_ChatClientAgent_Mode1_MissingModelId_ThrowsInvalidOperationExceptionAsync()
+    {
+        var projectClient = CreateProjectClient();
+        // Construct a FoundryChatClient via the Responses Agent mode (Mode 1) then wrap in a ChatClientAgent whose
+        // ChatOptions has no ModelId — synthesis must throw.
+        var fcc = new FoundryChatClient(projectClient, "gpt-4o-mini");
+        var agent = new ChatClientAgent(fcc, new ChatClientAgentOptions { ChatOptions = new ChatOptions() });
+        var ex = await Assert.ThrowsAsync<InvalidOperationException>(() => agent.ToPromptAgentAsync());
+        Assert.Contains("model id", ex.Message, StringComparison.OrdinalIgnoreCase);
+    }
+
+    [Fact]
+    public async Task ToPromptAgentAsync_ChatClientAgent_Mode1_UnsupportedAITool_ThrowsInvalidOperationExceptionNamingTypeAsync()
+    {
+        var projectClient = CreateProjectClient();
+        var fcc = new FoundryChatClient(projectClient, "gpt-4o-mini");
+        var agent = new ChatClientAgent(fcc, new ChatClientAgentOptions
+        {
+            ChatOptions = new ChatOptions
+            {
+                ModelId = "gpt-4o-mini",
+                Tools = new System.Collections.Generic.List<AITool> { new UnsupportedTool() },
+            },
+        });
+        var ex = await Assert.ThrowsAsync<InvalidOperationException>(() => agent.ToPromptAgentAsync());
+        Assert.Contains(nameof(UnsupportedTool), ex.Message);
+    }
+
+    [Fact]
+    public async Task ToPromptAgentAsync_FoundryAgent_HonorsCancellationAsync()
+    {
+        // Cancellation should bubble up from the AgentReference fetch path. Construct a
+        // FoundryAgent via AsAIAgent(AgentReference) and pass a pre-cancelled token.
+        var (foundryAgent, _) = CreateMode2_PromptAgentOnly("agent-name");
+        using var cts = new CancellationTokenSource();
+        cts.Cancel();
+        await Assert.ThrowsAnyAsync<Exception>(() => foundryAgent.ToPromptAgentAsync(cts.Token));
+    }
+
+    // ----- the Responses Agent mode (Mode 1) (RAPI) synthesis paths -----
+
+    [Fact]
+    public async Task ToPromptAgentAsync_ChatClientAgent_Mode1_RoundTripsModelInstructionsTemperatureTopPAsync()
+    {
+        var projectClient = CreateProjectClient();
+        var fcc = new FoundryChatClient(projectClient, "gpt-4o-mini");
+        var agent = new ChatClientAgent(fcc, new ChatClientAgentOptions
+        {
+            ChatOptions = new ChatOptions
+            {
+                ModelId = "gpt-4o-mini",
+                Instructions = "Be helpful.",
+                Temperature = 0.5f,
+                TopP = 0.9f,
+            },
+        });
+
+        var def = await agent.ToPromptAgentAsync();
+        var declarative = Assert.IsType<DeclarativeAgentDefinition>(def);
+        Assert.Equal("gpt-4o-mini", declarative.Model);
+        Assert.Equal("Be helpful.", declarative.Instructions);
+        Assert.Equal(0.5f, declarative.Temperature);
+        Assert.Equal(0.9f, declarative.TopP);
+        Assert.Empty(declarative.Tools);
+    }
+
+    [Fact]
+    public async Task ToPromptAgentAsync_ChatClientAgent_Mode1_NoTools_ReturnsDefinitionWithEmptyToolsAsync()
+    {
+        var projectClient = CreateProjectClient();
+        var fcc = new FoundryChatClient(projectClient, "gpt-4o-mini");
+        var agent = new ChatClientAgent(fcc, new ChatClientAgentOptions
+        {
+            ChatOptions = new ChatOptions { ModelId = "gpt-4o-mini" },
+        });
+        var def = await agent.ToPromptAgentAsync();
+        var declarative = Assert.IsType<DeclarativeAgentDefinition>(def);
+        Assert.Empty(declarative.Tools);
+    }
+
+    [Fact]
+    public async Task ToPromptAgentAsync_ChatClientAgent_Mode1_AIFunctionTool_ConvertsToFunctionToolAsync()
+    {
+        var projectClient = CreateProjectClient();
+        var fcc = new FoundryChatClient(projectClient, "gpt-4o-mini");
+        var function = AIFunctionFactory.Create(() => "ok", "my_function", "A documented function.");
+        var agent = new ChatClientAgent(fcc, new ChatClientAgentOptions
+        {
+            ChatOptions = new ChatOptions
+            {
+                ModelId = "gpt-4o-mini",
+                Tools = new System.Collections.Generic.List<AITool> { function },
+            },
+        });
+
+        var def = await agent.ToPromptAgentAsync();
+        var declarative = Assert.IsType<DeclarativeAgentDefinition>(def);
+        var fnTool = Assert.Single(declarative.Tools);
+        var ft = Assert.IsType<FunctionTool>(fnTool);
+        Assert.Equal("my_function", ft.FunctionName);
+        Assert.Equal("A documented function.", ft.FunctionDescription);
+    }
+
+    [Fact]
+    public async Task ToPromptAgentAsync_ChatClientAgent_Mode1_FoundryAITool_UnwrapsUnderlyingResponseToolAsync()
+    {
+        var projectClient = CreateProjectClient();
+        var fcc = new FoundryChatClient(projectClient, "gpt-4o-mini");
+        var agent = new ChatClientAgent(fcc, new ChatClientAgentOptions
+        {
+            ChatOptions = new ChatOptions
+            {
+                ModelId = "gpt-4o-mini",
+                Tools = new System.Collections.Generic.List<AITool> { FoundryAITool.CreateWebSearchTool() },
+            },
+        });
+
+        var def = await agent.ToPromptAgentAsync();
+        var declarative = Assert.IsType<DeclarativeAgentDefinition>(def);
+        var tool = Assert.Single(declarative.Tools);
+        // The unwrapped instance must be the concrete WebSearchTool from the OpenAI SDK.
+        Assert.IsType<WebSearchTool>(tool);
+    }
+
+    [Fact]
+    public async Task ToPromptAgentAsync_ChatClientAgent_Mode1_MultipleToolsMixed_ConvertsAllInOrderAsync()
+    {
+        var projectClient = CreateProjectClient();
+        var fcc = new FoundryChatClient(projectClient, "gpt-4o-mini");
+        var function = AIFunctionFactory.Create(() => "ok", "fn", "");
+        var agent = new ChatClientAgent(fcc, new ChatClientAgentOptions
+        {
+            ChatOptions = new ChatOptions
+            {
+                ModelId = "gpt-4o-mini",
+                Tools = new System.Collections.Generic.List<AITool> { function, FoundryAITool.CreateWebSearchTool() },
+            },
+        });
+
+        var def = await agent.ToPromptAgentAsync();
+        var declarative = Assert.IsType<DeclarativeAgentDefinition>(def);
+        Assert.Equal(2, declarative.Tools.Count);
+        Assert.IsType<FunctionTool>(declarative.Tools[0]);
+        Assert.IsType<WebSearchTool>(declarative.Tools[1]);
+    }
+
+    [Fact]
+    public async Task ToPromptAgentAsync_FoundryAgent_Mode1_ResultIsDeclarativeAgentDefinitionAsync()
+    {
+        // FoundryAgent constructed via the projectEndpoint+model+instructions ctor (Responses Agent mode, the Responses Agent mode (Mode 1)).
+        var foundryAgent = new FoundryAgent(
+            projectEndpoint: new Uri("https://test.openai.azure.com/"),
+            credential: new FakeAuthenticationTokenProvider(),
+            model: "gpt-4o-mini",
+            instructions: "You are helpful.");
+
+        var def = await foundryAgent.ToPromptAgentAsync();
+        var declarative = Assert.IsType<DeclarativeAgentDefinition>(def);
+        Assert.Equal("gpt-4o-mini", declarative.Model);
+        Assert.Equal("You are helpful.", declarative.Instructions);
+    }
+
+    // ----- the Prompt Agent mode (Mode 2) paths -----
+
+    [Fact]
+    public async Task ToPromptAgentAsync_FoundryAgent_Mode2_AgentVersion_ReturnsCachedDefinitionAsync()
+    {
+        // Construct via ProjectsAgentVersion → the Definition reference must come back unchanged.
+        var version = ModelReaderWriter.Read<ProjectsAgentVersion>(BinaryData.FromString(TestDataUtil.GetAgentVersionResponseJson()))!;
+        var projectClient = CreateProjectClient();
+        var foundryAgent = projectClient.AsAIAgent(version);
+
+        var def = await foundryAgent.ToPromptAgentAsync();
+        Assert.Same(version.Definition, def);
+    }
+
+    [Fact]
+    public async Task ToPromptAgentAsync_FoundryAgent_Mode2_AgentRecord_ReturnsLatestVersionDefinitionAsync()
+    {
+        var record = ModelReaderWriter.Read<ProjectsAgentRecord>(BinaryData.FromString(TestDataUtil.GetAgentResponseJson()))!;
+        var projectClient = CreateProjectClient();
+        var foundryAgent = projectClient.AsAIAgent(record);
+
+        var def = await foundryAgent.ToPromptAgentAsync();
+        Assert.Same(record.GetLatestVersion().Definition, def);
+    }
+
+    [Fact]
+    public async Task ToPromptAgentAsync_FoundryAgent_Mode2_PromptAgentOnly_FetchesLatestVersionAsync()
+    {
+        // The handler returns a known agent JSON. The converter must hit GET /agents/{name}
+        // and return that record's latest version definition.
+        var fetched = false;
+        using var handler = new HttpHandlerAssert(req =>
+        {
+            if (req.Method == HttpMethod.Get && req.RequestUri!.AbsolutePath.Contains("/agents/agent-name"))
+            {
+                fetched = true;
+                return new HttpResponseMessage(HttpStatusCode.OK)
+                {
+                    Content = new StringContent(TestDataUtil.GetAgentResponseJson(agentName: "agent-name"), Encoding.UTF8, "application/json"),
+                };
+            }
+            return new HttpResponseMessage(HttpStatusCode.OK) { Content = new StringContent("{}", Encoding.UTF8, "application/json") };
+        });
+#pragma warning disable CA5399
+        using var httpClient = new HttpClient(handler);
+#pragma warning restore CA5399
+        var projectClient = new AIProjectClient(
+            new Uri("https://test.openai.azure.com/"),
+            new FakeAuthenticationTokenProvider(),
+            new AIProjectClientOptions { Transport = new HttpClientPipelineTransport(httpClient) });
+        var foundryAgent = projectClient.AsAIAgent(new AgentReference("agent-name"));
+
+        var def = await foundryAgent.ToPromptAgentAsync();
+        Assert.True(fetched);
+        Assert.NotNull(def);
+    }
+
+    [Fact]
+    public async Task ToPromptAgentAsync_FoundryAgent_Mode2_PromptAgentOnly_PinnedVersion_FetchesPinnedVersionAsync()
+    {
+        // Q-C regression: when AgentReference.Version is set, the converter must call
+        // GET /agents/{name}/versions/{version} and return that pinned version's definition,
+        // NOT GET /agents/{name} -> GetLatestVersion() which would silently substitute the
+        // server's latest. We probe both paths from the same handler and assert exactly one was hit.
+        var fetchedLatest = false;
+        var fetchedPinned = false;
+        using var handler = new HttpHandlerAssert(req =>
+        {
+            // Pinned-version path: …/agents/{name}/versions/{version}
+            if (req.Method == HttpMethod.Get && req.RequestUri!.AbsolutePath.Contains("/agents/agent-name/versions/2", StringComparison.Ordinal))
+            {
+                fetchedPinned = true;
+                var pinnedDef = new DeclarativeAgentDefinition("gpt-pinned") { Instructions = "Pinned-version instructions." };
+                return new HttpResponseMessage(HttpStatusCode.OK)
+                {
+                    Content = new StringContent(TestDataUtil.GetAgentVersionResponseJson(agentName: "agent-name", agentDefinition: pinnedDef), Encoding.UTF8, "application/json"),
+                };
+            }
+            // Latest-version path: …/agents/{name}
+            if (req.Method == HttpMethod.Get && req.RequestUri!.AbsolutePath.EndsWith("/agents/agent-name", StringComparison.Ordinal))
+            {
+                fetchedLatest = true;
+                var latestDef = new DeclarativeAgentDefinition("gpt-latest") { Instructions = "Latest-version instructions." };
+                return new HttpResponseMessage(HttpStatusCode.OK)
+                {
+                    Content = new StringContent(TestDataUtil.GetAgentResponseJson(agentName: "agent-name", agentDefinition: latestDef), Encoding.UTF8, "application/json"),
+                };
+            }
+            return new HttpResponseMessage(HttpStatusCode.OK) { Content = new StringContent("{}", Encoding.UTF8, "application/json") };
+        });
+#pragma warning disable CA5399
+        using var httpClient = new HttpClient(handler);
+#pragma warning restore CA5399
+        var projectClient = new AIProjectClient(
+            new Uri("https://test.openai.azure.com/"),
+            new FakeAuthenticationTokenProvider(),
+            new AIProjectClientOptions { Transport = new HttpClientPipelineTransport(httpClient) });
+        var foundryAgent = projectClient.AsAIAgent(new AgentReference("agent-name", "2"));
+
+        var def = await foundryAgent.ToPromptAgentAsync();
+
+        Assert.True(fetchedPinned, "Pinned-version endpoint (.../agents/agent-name/versions/2) must be called when AgentReference.Version is set.");
+        Assert.False(fetchedLatest, "Latest-version endpoint (.../agents/agent-name) must NOT be called when AgentReference.Version is set.");
+        var declarative = Assert.IsType<DeclarativeAgentDefinition>(def);
+        Assert.Equal("gpt-pinned", declarative.Model);
+        Assert.Equal("Pinned-version instructions.", declarative.Instructions);
+    }
+
+    [Fact]
+    public async Task ToPromptAgentAsync_FoundryAgent_Mode2_PromptAgentOnly_UnpinnedVersionKeyword_FetchesLatestAsync()
+    {
+        // Q-C boundary: AgentReference.Version == "latest" must fall back to the GET /agents/{name}
+        // path (the latest-version path), NOT GET /agents/{name}/versions/latest.
+        var fetchedLatest = false;
+        using var handler = new HttpHandlerAssert(req =>
+        {
+            if (req.Method == HttpMethod.Get && req.RequestUri!.AbsolutePath.EndsWith("/agents/agent-name", StringComparison.Ordinal))
+            {
+                fetchedLatest = true;
+                return new HttpResponseMessage(HttpStatusCode.OK)
+                {
+                    Content = new StringContent(TestDataUtil.GetAgentResponseJson(agentName: "agent-name"), Encoding.UTF8, "application/json"),
+                };
+            }
+            return new HttpResponseMessage(HttpStatusCode.OK) { Content = new StringContent("{}", Encoding.UTF8, "application/json") };
+        });
+#pragma warning disable CA5399
+        using var httpClient = new HttpClient(handler);
+#pragma warning restore CA5399
+        var projectClient = new AIProjectClient(
+            new Uri("https://test.openai.azure.com/"),
+            new FakeAuthenticationTokenProvider(),
+            new AIProjectClientOptions { Transport = new HttpClientPipelineTransport(httpClient) });
+        var foundryAgent = projectClient.AsAIAgent(new AgentReference("agent-name", "latest"));
+
+        var def = await foundryAgent.ToPromptAgentAsync();
+
+        Assert.True(fetchedLatest);
+        Assert.NotNull(def);
+    }
+
+    [Fact]
+    public async Task ToPromptAgentAsync_FoundryAgent_Mode2_PromptAgentOnly_ServerReturnsError_PropagatesExceptionAsync()
+    {
+        using var handler = new HttpHandlerAssert(req =>
+            new HttpResponseMessage(HttpStatusCode.NotFound) { Content = new StringContent("{\"error\":{\"code\":\"NotFound\"}}", Encoding.UTF8, "application/json") });
+#pragma warning disable CA5399
+        using var httpClient = new HttpClient(handler);
+#pragma warning restore CA5399
+        var projectClient = new AIProjectClient(
+            new Uri("https://test.openai.azure.com/"),
+            new FakeAuthenticationTokenProvider(),
+            new AIProjectClientOptions { Transport = new HttpClientPipelineTransport(httpClient) });
+        var foundryAgent = projectClient.AsAIAgent(new AgentReference("missing-agent"));
+
+        await Assert.ThrowsAnyAsync<Exception>(() => foundryAgent.ToPromptAgentAsync());
+    }
+
+    // ----- Python-parity guard: both extensions produce equivalent definitions -----
+
+    [Fact]
+    public async Task BothExtensions_ProduceEquivalentDefinitions_ForEquivalentInputsAsync()
+    {
+        // Build two agents that are semantically equivalent: one as a plain ChatClientAgent
+        // via AsAIAgent(model, instructions), and one as a FoundryAgent via the projectEndpoint
+        // ctor. Both flow through the same converter; assert key fields match.
+        var projectClient = CreateProjectClient();
+        ChatClientAgent ccaAgent = projectClient.AsAIAgent("gpt-4o-mini", "Be helpful.");
+        var foundryAgent = new FoundryAgent(
+            projectEndpoint: new Uri("https://test.openai.azure.com/"),
+            credential: new FakeAuthenticationTokenProvider(),
+            model: "gpt-4o-mini",
+            instructions: "Be helpful.");
+
+        var ccaDef = await ccaAgent.ToPromptAgentAsync();
+        var faDef = await foundryAgent.ToPromptAgentAsync();
+
+        var a = Assert.IsType<DeclarativeAgentDefinition>(ccaDef);
+        var b = Assert.IsType<DeclarativeAgentDefinition>(faDef);
+        Assert.Equal(a.Model, b.Model);
+        Assert.Equal(a.Instructions, b.Instructions);
+        Assert.Equal(a.Tools.Count, b.Tools.Count);
+    }
+
+    // ----- Helpers -----
+
+    private static AIProjectClient CreateProjectClient()
+        => new(
+            new Uri("https://test.openai.azure.com/"),
+            new FakeAuthenticationTokenProvider(),
+            new AIProjectClientOptions { Transport = new HttpClientPipelineTransport(new HttpClient()) });
+
+    private static (FoundryAgent FoundryAgent, AIProjectClient ProjectClient) CreateMode2_PromptAgentOnly(string agentName)
+    {
+        var projectClient = CreateProjectClient();
+        var foundryAgent = projectClient.AsAIAgent(new AgentReference(agentName));
+        return (foundryAgent, projectClient);
+    }
+
+    private sealed class NoOpChatClient : IChatClient
+    {
+        public Task<ChatResponse> GetResponseAsync(System.Collections.Generic.IEnumerable<ChatMessage> messages, ChatOptions? options = null, CancellationToken cancellationToken = default)
+            => Task.FromResult(new ChatResponse());
+
+        public System.Collections.Generic.IAsyncEnumerable<ChatResponseUpdate> GetStreamingResponseAsync(System.Collections.Generic.IEnumerable<ChatMessage> messages, ChatOptions? options = null, CancellationToken cancellationToken = default)
+            => EmptyAsyncEnumerableAsync();
+
+        private static async System.Collections.Generic.IAsyncEnumerable<ChatResponseUpdate> EmptyAsyncEnumerableAsync()
+        {
+            await Task.CompletedTask.ConfigureAwait(false);
+            yield break;
+        }
+
+        public object? GetService(Type serviceType, object? serviceKey = null) => null;
+
+        public void Dispose() { }
+    }
+
+    private sealed class UnsupportedTool : AITool
+    {
+        public override string Name => "unsupported";
+    }
+}
+#pragma warning restore CS0618

dotnet/tests/Microsoft.Agents.AI.Foundry.UnitTests/MeaiAutoUserAgentVerificationTests.cs

@@ -0,0 +1,90 @@
+// Copyright (c) Microsoft. All rights reserved.
+
+using System;
+using System.ClientModel;
+using System.ClientModel.Primitives;
+using System.Net;
+using System.Net.Http;
+using System.Text;
+using System.Threading;
+using System.Threading.Tasks;
+using Microsoft.Extensions.AI;
+using OpenAI;
+using OpenAI.Responses;
+
+#pragma warning disable OPENAI001
+
+namespace Microsoft.Agents.AI.Foundry.UnitTests;
+
+/// <summary>
+/// One-shot verification (kept in tree to detect regressions) that MEAI 10.5.1 stamps its own
+/// <c>MEAI/{version}</c> User-Agent segment automatically when an <see cref="ResponsesClient"/>
+/// is wrapped via <c>AsIChatClient()</c>. If this test starts failing, the FoundryChatClient
+/// implementation must re-register the MEAI policy explicitly via OpenAIRequestPolicies because
+/// the local Foundry copy was deleted under the assumption that MEAI provides it built-in.
+/// </summary>
+public sealed class MeaiAutoUserAgentVerificationTests
+{
+    [Fact]
+    public async Task MeaiOpenAIResponsesClient_StampsMeaiSegmentAutomatically_WithoutLocalPolicyAsync()
+    {
+        // Arrange: bare OpenAI ResponseClient over a fake HTTP transport, wrapped via MEAI's
+        // AsIChatClient() with no custom OpenAIRequestPolicies registration. If MEAI auto-stamps
+        // its own MEAI/{version} segment, it will appear here.
+        using var handler = new RecordingHandler();
+#pragma warning disable CA5399
+        using var httpClient = new HttpClient(handler);
+#pragma warning restore CA5399
+
+        var options = new OpenAIClientOptions
+        {
+            Transport = new HttpClientPipelineTransport(httpClient),
+            Endpoint = new Uri("https://example.test/v1"),
+        };
+
+        var responseClient = new ResponsesClient(new ApiKeyCredential("test-key"), options);
+        var chatClient = responseClient.AsIChatClient("gpt-4o-mini");
+
+        // Act: send a request through MEAI's chat client. The fake transport will throw on
+        // response parsing, but we only care about the outbound headers, which are captured
+        // before the response is parsed.
+        try
+        {
+            await chatClient.GetResponseAsync("hi", cancellationToken: CancellationToken.None);
+        }
+        catch
+        {
+            // Expected: the fake response body is not parseable as a Responses API payload.
+        }
+
+        // Assert: at least one outbound request reached the transport, and its User-Agent
+        // contains either "MEAI/" (auto-stamped by MEAI) or no MEAI segment (verification
+        // signal — see test summary).
+        Assert.True(handler.Count > 0, "Expected at least one outbound request from MEAI wrapper.");
+        Assert.NotNull(handler.LastUserAgent);
+        // INTENT: assert that MEAI auto-stamps. If the assertion fails, see the FoundryChatClient
+        // implementation note about needing to register the MEAI policy explicitly.
+        Assert.Contains("MEAI/", handler.LastUserAgent);
+    }
+
+    private sealed class RecordingHandler : HttpClientHandler
+    {
+        public int Count { get; private set; }
+        public string? LastUserAgent { get; private set; }
+
+        protected override Task<HttpResponseMessage> SendAsync(HttpRequestMessage request, CancellationToken cancellationToken)
+        {
+            this.Count++;
+            this.LastUserAgent = request.Headers.TryGetValues("User-Agent", out var values)
+                ? string.Join(",", values)
+                : null;
+
+            var resp = new HttpResponseMessage(HttpStatusCode.OK)
+            {
+                Content = new StringContent("{}", Encoding.UTF8, "application/json"),
+                RequestMessage = request,
+            };
+            return Task.FromResult(resp);
+        }
+    }
+}

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

@@ -14,11 +14,14 @@
     <ProjectReference Include="..\..\src\Microsoft.Agents.AI.Foundry\Microsoft.Agents.AI.Foundry.csproj" />
   </ItemGroup>
 
-  <!-- FoundryEval tests require net8.0+ (MEAI.Evaluation does not support legacy TFMs) -->
+  <!-- Tests requiring net8.0+ (MEAI.Evaluation and some SCM pipeline APIs do not support legacy TFMs) -->
   <ItemGroup Condition="!$([MSBuild]::IsTargetFrameworkCompatible('$(TargetFramework)', 'net8.0'))">
     <Compile Remove="FoundryEvalConverterTests.cs" />
     <Compile Remove="FoundryEvalsTests.cs" />
     <Compile Remove="ClientHeadersExtensionsTests.cs" />
+    <Compile Remove="ServedModelTestHelpers.cs" />
+    <Compile Remove="ServedModelScopeTests.cs" />
+    <Compile Remove="ServedModelPolicyTests.cs" />
   </ItemGroup>
 
   <ItemGroup>

dotnet/tests/Microsoft.Agents.AI.Foundry.UnitTests/RequestOptionsExtensionsTests.cs

@@ -1,115 +0,0 @@
-// Copyright (c) Microsoft. All rights reserved.
-
-using System.ClientModel.Primitives;
-using System.Net;
-using System.Net.Http;
-using System.Reflection;
-using System.Text;
-using System.Threading;
-using System.Threading.Tasks;
-
-namespace Microsoft.Agents.AI.Foundry.UnitTests;
-
-/// <summary>
-/// Verifies the per-call <c>MeaiUserAgentPolicy</c> exposed via
-/// <see cref="RequestOptionsExtensions.UserAgentPolicy"/>. The policy is reachable through the
-/// public <see cref="FoundryAgent"/> constructors (which add it to the internally-built
-/// <see cref="Azure.AI.Projects.AIProjectClient"/>'s pipeline), so its behavior is part of the
-/// public API surface.
-/// </summary>
-public sealed class RequestOptionsExtensionsTests
-{
-    [Fact]
-    public async Task MeaiUserAgentPolicy_AddsMeaiSegment_ToOutgoingRequestAsync()
-    {
-        // Arrange
-        using var handler = new RecordingHandler();
-#pragma warning disable CA5399
-        using var httpClient = new HttpClient(handler);
-#pragma warning restore CA5399
-        var pipeline = ClientPipeline.Create(
-            new ClientPipelineOptions { Transport = new HttpClientPipelineTransport(httpClient) },
-            perCallPolicies: [RequestOptionsExtensions.UserAgentPolicy],
-            perTryPolicies: default,
-            beforeTransportPolicies: default);
-
-        // Act
-        var message = pipeline.CreateMessage();
-        message.Request.Method = "POST";
-        message.Request.Uri = new System.Uri("https://example.test/anything");
-        await pipeline.SendAsync(message);
-
-        // Assert
-        Assert.Equal(1, handler.Count);
-        Assert.NotNull(handler.LastUserAgent);
-        Assert.Contains("MEAI/", handler.LastUserAgent);
-    }
-
-    [Fact]
-    public async Task MeaiUserAgentPolicy_DoesNotAddFoundryHostingSegmentAsync()
-    {
-        // Arrange
-        using var handler = new RecordingHandler();
-#pragma warning disable CA5399
-        using var httpClient = new HttpClient(handler);
-#pragma warning restore CA5399
-        var pipeline = ClientPipeline.Create(
-            new ClientPipelineOptions { Transport = new HttpClientPipelineTransport(httpClient) },
-            perCallPolicies: [RequestOptionsExtensions.UserAgentPolicy],
-            perTryPolicies: default,
-            beforeTransportPolicies: default);
-
-        // Act
-        var message = pipeline.CreateMessage();
-        message.Request.Method = "POST";
-        message.Request.Uri = new System.Uri("https://example.test/anything");
-        await pipeline.SendAsync(message);
-
-        // Assert: the policy is MEAI-only; the foundry-hosting supplement is added elsewhere
-        // (by the polyfill UserAgentResponsesClient → HostedAgentUserAgentPolicy).
-        Assert.NotNull(handler.LastUserAgent);
-        Assert.DoesNotContain("foundry-hosting/agent-framework-dotnet", handler.LastUserAgent);
-    }
-
-    [Fact]
-    public void UserAgentPolicy_ExposesSingletonInstance()
-    {
-        // Two reads of the static property must return the same instance — the policy is stateless and shared.
-        var first = RequestOptionsExtensions.UserAgentPolicy;
-        var second = RequestOptionsExtensions.UserAgentPolicy;
-        Assert.Same(first, second);
-    }
-
-    [Fact]
-    public void MeaiUserAgentPolicy_ValueIncludesAFFoundryAssemblyVersion_ReflectionGuard()
-    {
-        // The policy emits "MEAI/{Microsoft.Agents.AI.Foundry assembly InformationalVersion}".
-        // If the assembly metadata stops being readable, the policy falls back to "MEAI" without a version,
-        // which is a measurable telemetry regression.
-        var attr = typeof(RequestOptionsExtensions).Assembly
-            .GetCustomAttribute<AssemblyInformationalVersionAttribute>();
-        Assert.NotNull(attr);
-        Assert.False(string.IsNullOrEmpty(attr!.InformationalVersion));
-    }
-
-    private sealed class RecordingHandler : HttpClientHandler
-    {
-        public int Count { get; private set; }
-        public string? LastUserAgent { get; private set; }
-
-        protected override Task<HttpResponseMessage> SendAsync(HttpRequestMessage request, CancellationToken cancellationToken)
-        {
-            this.Count++;
-            this.LastUserAgent = request.Headers.TryGetValues("User-Agent", out var values)
-                ? string.Join(",", values)
-                : null;
-
-            var resp = new HttpResponseMessage(HttpStatusCode.OK)
-            {
-                Content = new StringContent("{}", Encoding.UTF8, "application/json"),
-                RequestMessage = request,
-            };
-            return Task.FromResult(resp);
-        }
-    }
-}

dotnet/tests/Microsoft.Agents.AI.Foundry.UnitTests/ServedModelPolicyTests.cs

@@ -0,0 +1,84 @@
+// Copyright (c) Microsoft. All rights reserved.
+
+using System.Threading.Tasks;
+using Microsoft.Extensions.AI;
+
+#pragma warning disable OPENAI001, MEAI001, MAAI001, SCME0001
+
+namespace Microsoft.Agents.AI.Foundry.UnitTests;
+
+/// <summary>
+/// Unit tests for <see cref="ServedModelPolicy"/>: the SCM pipeline policy that reads the
+/// <c>x-ms-served-model</c> response header and writes it into the active
+/// <see cref="ServedModelScope"/> box.
+/// </summary>
+/// <remarks>
+/// Tests drive the policy through a real OpenAI ResponsesClient SCM pipeline against a mock
+/// HTTP handler so the policy executes in its production configuration.
+/// </remarks>
+public sealed class ServedModelPolicyTests
+{
+    [Fact]
+    public void Instance_IsSingleton()
+    {
+        Assert.Same(ServedModelPolicy.Instance, ServedModelPolicy.Instance);
+    }
+
+    [Fact]
+    public async Task ProcessAsync_HeaderPresent_SetsModelIdOnResponseAsync()
+    {
+        // Arrange
+        using var handler = new ServedModelTestHelpers.ServedModelHandler(ServedModelTestHelpers.MinimalResponseJson(), servedModel: "gpt-5-nano-2025-08-07");
+        IChatClient chatClient = ServedModelTestHelpers.CreateChatClientWithPolicy(handler);
+
+        // Act
+        var response = await chatClient.GetResponseAsync("hi");
+
+        // Assert
+        Assert.Equal("gpt-5-nano-2025-08-07", response.ModelId);
+    }
+
+    [Fact]
+    public async Task ProcessAsync_HeaderAbsent_PreservesModelIdFromBodyAsync()
+    {
+        // Arrange
+        using var handler = new ServedModelTestHelpers.ServedModelHandler(ServedModelTestHelpers.MinimalResponseJson(), servedModel: null);
+        IChatClient chatClient = ServedModelTestHelpers.CreateChatClientWithPolicy(handler);
+
+        // Act
+        var response = await chatClient.GetResponseAsync("hi");
+
+        // Assert: ModelId is the deployment alias from the JSON body ("fake").
+        Assert.Equal("fake", response.ModelId);
+    }
+
+    [Theory]
+    [InlineData("")]
+    [InlineData("   ")]
+    public async Task ProcessAsync_EmptyOrWhitespaceHeader_PreservesModelIdFromBodyAsync(string headerValue)
+    {
+        // Arrange
+        using var handler = new ServedModelTestHelpers.ServedModelHandler(ServedModelTestHelpers.MinimalResponseJson(), servedModel: headerValue);
+        IChatClient chatClient = ServedModelTestHelpers.CreateChatClientWithPolicy(handler);
+
+        // Act
+        var response = await chatClient.GetResponseAsync("hi");
+
+        // Assert: empty/whitespace header is rejected by the policy, ModelId stays as "fake".
+        Assert.Equal("fake", response.ModelId);
+    }
+
+    [Fact]
+    public async Task ProcessAsync_HeaderWithSurroundingWhitespace_TrimsValueAsync()
+    {
+        // Arrange
+        using var handler = new ServedModelTestHelpers.ServedModelHandler(ServedModelTestHelpers.MinimalResponseJson(), servedModel: "  gpt-5-nano-2025-08-07  ");
+        IChatClient chatClient = ServedModelTestHelpers.CreateChatClientWithPolicy(handler);
+
+        // Act
+        var response = await chatClient.GetResponseAsync("hi");
+
+        // Assert
+        Assert.Equal("gpt-5-nano-2025-08-07", response.ModelId);
+    }
+}

dotnet/tests/Microsoft.Agents.AI.Foundry.UnitTests/ServedModelScopeTests.cs

@@ -0,0 +1,40 @@
+// Copyright (c) Microsoft. All rights reserved.
+
+using System.Runtime.CompilerServices;
+
+namespace Microsoft.Agents.AI.Foundry.UnitTests;
+
+/// <summary>
+/// Unit tests for <see cref="ServedModelScope"/>: the AsyncLocal carrier that bridges the
+/// served-model value from the SCM pipeline policy up to the delegating chat client.
+/// </summary>
+public sealed class ServedModelScopeTests
+{
+    [Fact]
+    public void Current_DefaultIsNull()
+    {
+        Assert.Null(ServedModelScope.Current);
+    }
+
+    [Fact]
+    public void Current_SetAndGet_ReturnsBox()
+    {
+        // Arrange
+        var previous = ServedModelScope.Current;
+
+        try
+        {
+            // Act
+            var box = new StrongBox<string?>("gpt-5-nano-2025-08-07");
+            ServedModelScope.Current = box;
+
+            // Assert
+            Assert.Same(box, ServedModelScope.Current);
+            Assert.Equal("gpt-5-nano-2025-08-07", ServedModelScope.Current!.Value);
+        }
+        finally
+        {
+            ServedModelScope.Current = previous;
+        }
+    }
+}

dotnet/tests/Microsoft.Agents.AI.Foundry.UnitTests/ServedModelTestHelpers.cs

@@ -0,0 +1,80 @@
+// Copyright (c) Microsoft. All rights reserved.
+
+using System;
+using System.ClientModel.Primitives;
+using System.Net;
+using System.Net.Http;
+using System.Text;
+using System.Threading;
+using System.Threading.Tasks;
+using Azure.AI.Projects;
+using Microsoft.Extensions.AI;
+
+#pragma warning disable OPENAI001, MEAI001, MAAI001, SCME0001
+
+namespace Microsoft.Agents.AI.Foundry.UnitTests;
+
+/// <summary>
+/// Shared helpers and fake clients used by the served-model test suite
+/// (<see cref="ServedModelScopeTests"/>, <see cref="ServedModelPolicyTests"/>).
+/// </summary>
+internal static class ServedModelTestHelpers
+{
+    public static string MinimalResponseJson() => """
+        {
+          "id":"resp_1","object":"response","created_at":1700000000,"status":"completed",
+          "model":"fake","output":[],"usage":{"input_tokens":1,"output_tokens":1,"total_tokens":2}
+        }
+        """;
+
+    /// <summary>
+    /// Creates a <see cref="FoundryChatClient"/> backed by a real OpenAI Responses pipeline
+    /// routed through the supplied <paramref name="handler"/>. The <see cref="ServedModelPolicy"/>
+    /// is registered automatically by the <see cref="FoundryChatClient"/> constructor.
+    /// </summary>
+    public static IChatClient CreateChatClientWithPolicy(HttpMessageHandler handler)
+    {
+#pragma warning disable CA5399
+        var http = new HttpClient(handler);
+#pragma warning restore CA5399
+
+        var projectClient = new AIProjectClient(
+            new Uri("https://test.openai.azure.com/"),
+            new FakeAuthenticationTokenProvider(),
+            new AIProjectClientOptions { Transport = new HttpClientPipelineTransport(http) });
+
+        return new FoundryChatClient(projectClient, "fake");
+    }
+
+    /// <summary>
+    /// An <see cref="HttpClientHandler"/> that returns a fixed response body and optionally
+    /// includes the <c>x-ms-served-model</c> response header.
+    /// </summary>
+    public sealed class ServedModelHandler : HttpClientHandler
+    {
+        private readonly string _body;
+        private readonly string? _servedModel;
+
+        public ServedModelHandler(string body, string? servedModel)
+        {
+            this._body = body;
+            this._servedModel = servedModel;
+        }
+
+        protected override Task<HttpResponseMessage> SendAsync(HttpRequestMessage request, CancellationToken cancellationToken)
+        {
+            var resp = new HttpResponseMessage(HttpStatusCode.OK)
+            {
+                Content = new StringContent(this._body, Encoding.UTF8, "application/json"),
+                RequestMessage = request,
+            };
+
+            if (this._servedModel is not null)
+            {
+                resp.Headers.Add("x-ms-served-model", this._servedModel);
+            }
+
+            return Task.FromResult(resp);
+        }
+    }
+}

dotnet/tests/Microsoft.Agents.AI.Harness.UnitTests/HarnessAgentOptionsTests.cs

@@ -1,6 +1,9 @@
 // Copyright (c) Microsoft. All rights reserved.
 
 using Moq;
+#if NET
+using Microsoft.Agents.AI.Tools.Shell;
+#endif
 
 namespace Microsoft.Agents.AI.UnitTests;
 
@@ -37,6 +40,12 @@ public class HarnessAgentOptionsTests
         Assert.Null(options.FileAccessStore);
         Assert.Null(options.AgentModeProviderOptions);
         Assert.Null(options.AgentSkillsSource);
+        Assert.Null(options.BackgroundAgents);
+        Assert.Null(options.BackgroundAgentsProviderOptions);
+#if NET
+        Assert.Null(options.ShellExecutor);
+        Assert.Null(options.ShellEnvironmentProviderOptions);
+#endif
     }
 
     /// <summary>
@@ -52,6 +61,12 @@ public class HarnessAgentOptionsTests
         var fileAccessStore = new Mock<AgentFileStore>().Object;
         var agentModeOptions = new AgentModeProviderOptions();
         var skillsSource = new Mock<AgentSkillsSource>().Object;
+        var backgroundAgents = new AIAgent[] { new Mock<AIAgent>().Object };
+        var backgroundAgentsOptions = new BackgroundAgentsProviderOptions();
+#if NET
+        var shellExecutor = new Mock<ShellExecutor>().Object;
+        var shellEnvOptions = new ShellEnvironmentProviderOptions();
+#endif
 
         // Act
         var options = new HarnessAgentOptions
@@ -77,6 +92,12 @@ public class HarnessAgentOptionsTests
             AgentSkillsSource = skillsSource,
             DisableOpenTelemetry = true,
             OpenTelemetrySourceName = "custom-source",
+            BackgroundAgents = backgroundAgents,
+            BackgroundAgentsProviderOptions = backgroundAgentsOptions,
+#if NET
+            ShellExecutor = shellExecutor,
+            ShellEnvironmentProviderOptions = shellEnvOptions,
+#endif
         };
 
         // Assert
@@ -103,5 +124,11 @@ public class HarnessAgentOptionsTests
         Assert.Same(skillsSource, options.AgentSkillsSource);
         Assert.True(options.DisableOpenTelemetry);
         Assert.Equal("custom-source", options.OpenTelemetrySourceName);
+        Assert.Same(backgroundAgents, options.BackgroundAgents);
+        Assert.Same(backgroundAgentsOptions, options.BackgroundAgentsProviderOptions);
+#if NET
+        Assert.Same(shellExecutor, options.ShellExecutor);
+        Assert.Same(shellEnvOptions, options.ShellEnvironmentProviderOptions);
+#endif
     }
 }

dotnet/tests/Microsoft.Agents.AI.Harness.UnitTests/HarnessAgentTests.cs

@@ -5,6 +5,9 @@ using System.Collections.Generic;
 using System.Linq;
 using System.Threading;
 using System.Threading.Tasks;
+#if NET
+using Microsoft.Agents.AI.Tools.Shell;
+#endif
 using Microsoft.Extensions.AI;
 using Moq;
 
@@ -1197,4 +1200,264 @@ public class HarnessAgentTests
     }
 
     #endregion
+
+    #region Feature: BackgroundAgentsProvider
+
+    /// <summary>
+    /// Verify that BackgroundAgentsProvider is included when BackgroundAgents are specified.
+    /// </summary>
+    [Fact]
+    public void BackgroundAgentsProvider_IncludedWhenAgentsSpecified()
+    {
+        // Arrange
+        var chatClient = new Mock<IChatClient>().Object;
+        var bgAgentMock = new Mock<AIAgent>();
+        bgAgentMock.Setup(a => a.Name).Returns("TestBackgroundAgent");
+        var options = CreateAllDisabledOptions();
+        options.BackgroundAgents = [bgAgentMock.Object];
+
+        // Act
+        var agent = new HarnessAgent(chatClient, TestMaxContextWindowTokens, TestMaxOutputTokens, options);
+        var innerAgent = agent.GetService<ChatClientAgent>();
+
+        // Assert
+        Assert.NotNull(innerAgent?.AIContextProviders);
+        Assert.Contains(innerAgent!.AIContextProviders!, p => p is BackgroundAgentsProvider);
+    }
+
+    /// <summary>
+    /// Verify that BackgroundAgentsProvider is not included when BackgroundAgents is null.
+    /// </summary>
+    [Fact]
+    public void BackgroundAgentsProvider_ExcludedWhenAgentsNull()
+    {
+        // Arrange
+        var chatClient = new Mock<IChatClient>().Object;
+        var options = CreateAllDisabledOptions();
+        options.BackgroundAgents = null;
+
+        // Act
+        var agent = new HarnessAgent(chatClient, TestMaxContextWindowTokens, TestMaxOutputTokens, options);
+        var innerAgent = agent.GetService<ChatClientAgent>();
+
+        // Assert
+        Assert.NotNull(innerAgent);
+        if (innerAgent!.AIContextProviders != null)
+        {
+            Assert.DoesNotContain(innerAgent.AIContextProviders, p => p is BackgroundAgentsProvider);
+        }
+    }
+
+    /// <summary>
+    /// Verify that BackgroundAgentsProvider is not included when BackgroundAgents is an empty collection.
+    /// </summary>
+    [Fact]
+    public void BackgroundAgentsProvider_ExcludedWhenAgentsEmpty()
+    {
+        // Arrange
+        var chatClient = new Mock<IChatClient>().Object;
+        var options = CreateAllDisabledOptions();
+        options.BackgroundAgents = Array.Empty<AIAgent>();
+
+        // Act
+        var agent = new HarnessAgent(chatClient, TestMaxContextWindowTokens, TestMaxOutputTokens, options);
+        var innerAgent = agent.GetService<ChatClientAgent>();
+
+        // Assert
+        Assert.NotNull(innerAgent);
+        if (innerAgent!.AIContextProviders != null)
+        {
+            Assert.DoesNotContain(innerAgent.AIContextProviders, p => p is BackgroundAgentsProvider);
+        }
+    }
+
+    /// <summary>
+    /// Verify that BackgroundAgentsProviderOptions is passed through when specified.
+    /// </summary>
+    [Fact]
+    public async Task BackgroundAgentsProvider_UsesProvidedOptionsAsync()
+    {
+        // Arrange
+        var chatClient = new Mock<IChatClient>().Object;
+        var bgAgentMock = new Mock<AIAgent>();
+        bgAgentMock.Setup(a => a.Name).Returns("TestBackgroundAgent");
+        bgAgentMock.Setup(a => a.Description).Returns("A test background agent");
+        var providerOptions = new BackgroundAgentsProviderOptions
+        {
+            Instructions = "Custom instructions with {background_agents} list.",
+        };
+        var options = CreateAllDisabledOptions();
+        options.BackgroundAgents = [bgAgentMock.Object];
+        options.BackgroundAgentsProviderOptions = providerOptions;
+
+        // Act
+        var agent = new HarnessAgent(chatClient, TestMaxContextWindowTokens, TestMaxOutputTokens, options);
+        var innerAgent = agent.GetService<ChatClientAgent>();
+        var bgProvider = innerAgent!.AIContextProviders!.OfType<BackgroundAgentsProvider>().Single();
+
+#pragma warning disable MAAI001
+        var invokingContext = new AIContextProvider.InvokingContext(
+            new Mock<AIAgent>().Object,
+            new Mock<AgentSession>().Object,
+            new AIContext());
+#pragma warning restore MAAI001
+
+        AIContext result = await bgProvider.InvokingAsync(invokingContext);
+
+        // Assert — custom instructions template is used and agent info is included
+        Assert.NotNull(result.Instructions);
+        Assert.Contains("Custom instructions with", result.Instructions);
+        Assert.Contains("TestBackgroundAgent", result.Instructions);
+    }
+
+    /// <summary>
+    /// Verify that multiple background agents are all passed to the provider.
+    /// </summary>
+    [Fact]
+    public async Task BackgroundAgentsProvider_IncludesMultipleAgentsAsync()
+    {
+        // Arrange
+        var chatClient = new Mock<IChatClient>().Object;
+        var agent1Mock = new Mock<AIAgent>();
+        agent1Mock.Setup(a => a.Name).Returns("Agent1");
+        agent1Mock.Setup(a => a.Description).Returns("First agent");
+        var agent2Mock = new Mock<AIAgent>();
+        agent2Mock.Setup(a => a.Name).Returns("Agent2");
+        agent2Mock.Setup(a => a.Description).Returns("Second agent");
+        var options = CreateAllDisabledOptions();
+        options.BackgroundAgents = [agent1Mock.Object, agent2Mock.Object];
+
+        // Act
+        var agent = new HarnessAgent(chatClient, TestMaxContextWindowTokens, TestMaxOutputTokens, options);
+        var innerAgent = agent.GetService<ChatClientAgent>();
+        var bgProvider = innerAgent!.AIContextProviders!.OfType<BackgroundAgentsProvider>().Single();
+
+#pragma warning disable MAAI001
+        var invokingContext = new AIContextProvider.InvokingContext(
+            new Mock<AIAgent>().Object,
+            new Mock<AgentSession>().Object,
+            new AIContext());
+#pragma warning restore MAAI001
+
+        AIContext result = await bgProvider.InvokingAsync(invokingContext);
+
+        // Assert — both agents appear in the provider's instructions
+        Assert.NotNull(result.Instructions);
+        Assert.Contains("Agent1", result.Instructions);
+        Assert.Contains("First agent", result.Instructions);
+        Assert.Contains("Agent2", result.Instructions);
+        Assert.Contains("Second agent", result.Instructions);
+    }
+
+    #endregion
+
+#if NET
+    #region Feature: ShellEnvironmentProvider
+
+    /// <summary>
+    /// Verify that ShellEnvironmentProvider is included when ShellExecutor is provided.
+    /// </summary>
+    [Fact]
+    public void ShellEnvironmentProvider_IncludedWhenExecutorProvided()
+    {
+        // Arrange
+        var chatClient = new Mock<IChatClient>().Object;
+        var executorMock = new Mock<ShellExecutor>();
+        executorMock.Setup(e => e.AsAIFunction(It.IsAny<string>(), It.IsAny<string?>(), It.IsAny<bool>()))
+            .Returns(AIFunctionFactory.Create(() => "test", "run_shell"));
+        var options = CreateAllDisabledOptions();
+        options.ShellExecutor = executorMock.Object;
+
+        // Act
+        var agent = new HarnessAgent(chatClient, TestMaxContextWindowTokens, TestMaxOutputTokens, options);
+        var innerAgent = agent.GetService<ChatClientAgent>();
+
+        // Assert
+        Assert.NotNull(innerAgent?.AIContextProviders);
+        Assert.Contains(innerAgent!.AIContextProviders!, p => p is ShellEnvironmentProvider);
+    }
+
+    /// <summary>
+    /// Verify that ShellEnvironmentProvider is not included when ShellExecutor is null.
+    /// </summary>
+    [Fact]
+    public void ShellEnvironmentProvider_ExcludedWhenExecutorNull()
+    {
+        // Arrange
+        var chatClient = new Mock<IChatClient>().Object;
+        var options = CreateAllDisabledOptions();
+        options.ShellExecutor = null;
+
+        // Act
+        var agent = new HarnessAgent(chatClient, TestMaxContextWindowTokens, TestMaxOutputTokens, options);
+        var innerAgent = agent.GetService<ChatClientAgent>();
+
+        // Assert
+        Assert.NotNull(innerAgent);
+        Assert.NotNull(innerAgent!.AIContextProviders);
+        Assert.DoesNotContain(innerAgent.AIContextProviders!, p => p is ShellEnvironmentProvider);
+    }
+
+    /// <summary>
+    /// Verify that the shell tool AIFunction is added to ChatOptions.Tools when ShellExecutor is provided.
+    /// </summary>
+    [Fact]
+    public async Task ShellExecutor_ToolAddedToChatOptionsAsync()
+    {
+        // Arrange
+        ChatOptions? capturedOptions = null;
+        var chatClientMock = new Mock<IChatClient>();
+        chatClientMock
+            .Setup(c => c.GetResponseAsync(It.IsAny<IEnumerable<ChatMessage>>(), It.IsAny<ChatOptions>(), It.IsAny<CancellationToken>()))
+            .Callback<IEnumerable<ChatMessage>, ChatOptions?, CancellationToken>((_, opts, _) => capturedOptions = opts)
+            .ReturnsAsync(new ChatResponse(new ChatMessage(ChatRole.Assistant, "done")));
+
+        var executorMock = new Mock<ShellExecutor>();
+        executorMock.Setup(e => e.AsAIFunction(It.IsAny<string>(), It.IsAny<string?>(), It.IsAny<bool>()))
+            .Returns(AIFunctionFactory.Create(() => "shell output", "run_shell"));
+
+        var options = CreateAllDisabledOptions();
+        options.DisableWebSearch = true;
+        options.ShellExecutor = executorMock.Object;
+
+        // Act
+        var agent = new HarnessAgent(chatClientMock.Object, TestMaxContextWindowTokens, TestMaxOutputTokens, options);
+        var session = await agent.CreateSessionAsync();
+        await agent.RunAsync([new ChatMessage(ChatRole.User, "Hi")], session);
+
+        // Assert — the shell tool should be present
+        Assert.NotNull(capturedOptions?.Tools);
+        Assert.Contains(capturedOptions!.Tools!, t => t is AIFunction f && f.Name == "run_shell");
+    }
+
+    /// <summary>
+    /// Verify that ShellEnvironmentProvider is present when ShellEnvironmentProviderOptions is also specified.
+    /// </summary>
+    [Fact]
+    public void ShellEnvironmentProvider_PresentWhenOptionsProvided()
+    {
+        // Arrange
+        var chatClient = new Mock<IChatClient>().Object;
+        var executorMock = new Mock<ShellExecutor>();
+        executorMock.Setup(e => e.AsAIFunction(It.IsAny<string>(), It.IsAny<string?>(), It.IsAny<bool>()))
+            .Returns(AIFunctionFactory.Create(() => "test", "run_shell"));
+        var envOptions = new ShellEnvironmentProviderOptions
+        {
+            ProbeTools = ["git", "python"],
+        };
+        var options = CreateAllDisabledOptions();
+        options.ShellExecutor = executorMock.Object;
+        options.ShellEnvironmentProviderOptions = envOptions;
+
+        // Act
+        var agent = new HarnessAgent(chatClient, TestMaxContextWindowTokens, TestMaxOutputTokens, options);
+        var innerAgent = agent.GetService<ChatClientAgent>();
+
+        // Assert — provider should exist (options wiring is validated by the provider's behavior)
+        Assert.NotNull(innerAgent?.AIContextProviders);
+        Assert.Contains(innerAgent!.AIContextProviders!, p => p is ShellEnvironmentProvider);
+    }
+
+    #endregion
+#endif
 }

dotnet/tests/Microsoft.Agents.AI.Tools.Shell.UnitTests/ShellEnvironmentProviderTests.cs

@@ -6,6 +6,7 @@ using System.Reflection;
 using System.Runtime.InteropServices;
 using System.Threading;
 using System.Threading.Tasks;
+using Microsoft.Extensions.AI;
 
 namespace Microsoft.Agents.AI.Tools.Shell.UnitTests;
 
@@ -226,6 +227,8 @@ public sealed class ShellEnvironmentProviderTests
         public override Task InitializeAsync(CancellationToken cancellationToken = default) => Task.CompletedTask;
         public override Task<ShellResult> RunAsync(string command, CancellationToken cancellationToken = default) =>
             Task.FromResult(this.Responses.Dequeue());
+        public override AIFunction AsAIFunction(string name = "run_shell", string? description = null, bool requireApproval = true) =>
+            throw new NotSupportedException();
         public override ValueTask DisposeAsync() => default;
     }
 
@@ -280,6 +283,8 @@ public sealed class ShellEnvironmentProviderTests
         public override Task InitializeAsync(CancellationToken cancellationToken = default) => Task.CompletedTask;
         public override Task<ShellResult> RunAsync(string command, CancellationToken cancellationToken = default) =>
             Task.FromResult(this._factory(cancellationToken));
+        public override AIFunction AsAIFunction(string name = "run_shell", string? description = null, bool requireApproval = true) =>
+            throw new NotSupportedException();
         public override ValueTask DisposeAsync() => default;
     }
 
@@ -372,6 +377,8 @@ public sealed class ShellEnvironmentProviderTests
             this.RunCount++;
             return Task.FromResult(this.NextResult);
         }
+        public override AIFunction AsAIFunction(string name = "run_shell", string? description = null, bool requireApproval = true) =>
+            throw new NotSupportedException();
         public override ValueTask DisposeAsync() => default;
     }
 }

dotnet/tests/Microsoft.Agents.AI.Workflows.Declarative.UnitTests/Extensions/AgentProviderExtensionsTest.cs

@@ -0,0 +1,139 @@
+// Copyright (c) Microsoft. All rights reserved.
+
+using System.Collections.Generic;
+using System.Linq;
+using System.Threading;
+using System.Threading.Tasks;
+using Microsoft.Agents.AI.Workflows.Declarative.Extensions;
+using Microsoft.Agents.AI.Workflows.Declarative.Kit;
+using Microsoft.Agents.AI.Workflows.Declarative.PowerFx;
+using Microsoft.Agents.AI.Workflows.Declarative.UnitTests.ObjectModel;
+using Microsoft.Agents.ObjectModel;
+using Microsoft.Extensions.AI;
+using Microsoft.PowerFx.Types;
+using Moq;
+
+namespace Microsoft.Agents.AI.Workflows.Declarative.UnitTests.Extensions;
+
+/// <summary>
+/// Tests for <see cref="AgentProviderExtensions.InvokeAgentAsync"/>.
+/// </summary>
+public sealed class AgentProviderExtensionsTest(ITestOutputHelper output) : WorkflowActionExecutorTest(output)
+{
+    private const string WorkflowConversationId = "workflow-conv-id";
+    private const string AgentName = "test-agent";
+
+    [Fact]
+    public Task AutoSendFalseOnWorkflowConversationSuppressesResponseEventsAsync() =>
+        this.RunAsync(autoSend: false, conversationId: WorkflowConversationId, expectResponseEvents: false);
+
+    [Fact]
+    public Task AutoSendTrueOnWorkflowConversationEmitsResponseEventsAsync() =>
+        this.RunAsync(autoSend: true, conversationId: WorkflowConversationId, expectResponseEvents: true);
+
+    [Fact]
+    public Task AutoSendFalseOnExternalConversationSuppressesResponseEventsAsync() =>
+        this.RunAsync(autoSend: false, conversationId: "other-conv-id", expectResponseEvents: false);
+
+    [Fact]
+    public Task AutoSendTrueOnExternalConversationEmitsResponseEventsAndCopiesMessagesAsync() =>
+        this.RunAsync(
+            autoSend: true,
+            conversationId: "other-conv-id",
+            expectResponseEvents: true,
+            expectCrossConversationCopy: true);
+
+    private async Task RunAsync(
+        bool autoSend,
+        string conversationId,
+        bool expectResponseEvents,
+        bool expectCrossConversationCopy = false)
+    {
+        // Arrange: seed the workflow conversation id so IsWorkflowConversation can recognize it.
+        this.State.Set(
+            SystemScope.Names.ConversationId,
+            FormulaValue.New(WorkflowConversationId),
+            VariableScopeNames.System);
+
+        MockAgentProvider mockProvider = new();
+        AgentResponseUpdate[] updates =
+        [
+            new(ChatRole.Assistant, "hello "),
+            new(ChatRole.Assistant, "world"),
+        ];
+        mockProvider
+            .Setup(p => p.InvokeAgentAsync(
+                AgentName,
+                It.IsAny<string?>(),
+                It.IsAny<string?>(),
+                It.IsAny<IEnumerable<ChatMessage>?>(),
+                It.IsAny<IDictionary<string, object?>?>(),
+                It.IsAny<CancellationToken>()))
+            .Returns(ToAsyncEnumerableAsync(updates));
+
+        List<(string ConversationId, ChatMessage Message)> copiedMessages = [];
+        mockProvider
+            .Setup(p => p.CreateMessageAsync(
+                It.IsAny<string>(),
+                It.IsAny<ChatMessage>(),
+                It.IsAny<CancellationToken>()))
+            .Returns<string, ChatMessage, CancellationToken>(
+                (convId, msg, _) =>
+                {
+                    copiedMessages.Add((convId, msg));
+                    return Task.FromResult(msg);
+                });
+
+        string actionId = this.CreateActionId().Value;
+
+        // Act
+        WorkflowEvent[] events =
+            await this.ExecuteAsync(
+                actionId,
+                async (IWorkflowContext context, ActionExecutorResult _, CancellationToken cancellationToken) =>
+                {
+                    await mockProvider.Object.InvokeAgentAsync(
+                        actionId,
+                        context,
+                        AgentName,
+                        conversationId,
+                        autoSend,
+                        cancellationToken: cancellationToken).ConfigureAwait(false);
+                });
+
+        // Assert
+        int updateEventCount = events.OfType<AgentResponseUpdateEvent>().Count();
+        int responseEventCount = events.OfType<AgentResponseEvent>().Count();
+
+        if (expectResponseEvents)
+        {
+            Assert.Equal(updates.Length, updateEventCount);
+            Assert.Equal(1, responseEventCount);
+        }
+        else
+        {
+            Assert.Equal(0, updateEventCount);
+            Assert.Equal(0, responseEventCount);
+        }
+
+        if (expectCrossConversationCopy)
+        {
+            Assert.NotEmpty(copiedMessages);
+            Assert.All(copiedMessages, c => Assert.Equal(WorkflowConversationId, c.ConversationId));
+        }
+        else
+        {
+            Assert.Empty(copiedMessages);
+        }
+    }
+
+    private static async IAsyncEnumerable<AgentResponseUpdate> ToAsyncEnumerableAsync(IEnumerable<AgentResponseUpdate> updates)
+    {
+        foreach (AgentResponseUpdate update in updates)
+        {
+            yield return update;
+        }
+
+        await Task.CompletedTask;
+    }
+}

python/CHANGELOG.md

@@ -7,6 +7,22 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ## [Unreleased]
 
+## [1.6.0] - 2026-05-21
+
+### Added
+- **agent-framework-core**: Shell tool with support for local and Docker execution ([#5664](https://github.com/microsoft/agent-framework/pull/5664))
+- **agent-framework-monty**: New Monty-backed CodeAct provider package ([#5915](https://github.com/microsoft/agent-framework/pull/5915))
+- **agent-framework-foundry**: Add experimental hosted tool factories on `FoundryChatClient` ([#5958](https://github.com/microsoft/agent-framework/pull/5958))
+- **agent-framework-foundry**: Include tool definitions for Foundry agent evals ([#5974](https://github.com/microsoft/agent-framework/pull/5974))
+- **agent-framework-a2a**: Use non-streaming transport and `return_immediately` for background ops ([#5963](https://github.com/microsoft/agent-framework/pull/5963))
+
+### Changed
+- **agent-framework-core**, **agent-framework-foundry**: [BREAKING] Enable instrumentation by default ([#5865](https://github.com/microsoft/agent-framework/pull/5865))
+- **agent-framework-foundry**: Show more authentication methods in Foundry Toolbox MCP ([#5719](https://github.com/microsoft/agent-framework/pull/5719))
+
+### Fixed
+- **agent-framework-core**: Skip MCP prompt loading when unsupported ([#5370](https://github.com/microsoft/agent-framework/pull/5370))
+
 ## [1.5.0] - 2026-05-19
 
 ### Added
@@ -1088,7 +1104,8 @@ Release candidate for **agent-framework-core** and **agent-framework-azure-ai**
 
 For more information, see the [announcement blog post](https://devblogs.microsoft.com/foundry/introducing-microsoft-agent-framework-the-open-source-engine-for-agentic-ai-apps/).
 
-[Unreleased]: https://github.com/microsoft/agent-framework/compare/python-1.5.0...HEAD
+[Unreleased]: https://github.com/microsoft/agent-framework/compare/python-1.6.0...HEAD
+[1.6.0]: https://github.com/microsoft/agent-framework/compare/python-1.5.0...python-1.6.0
 [1.5.0]: https://github.com/microsoft/agent-framework/compare/python-1.4.0...python-1.5.0
 [1.4.0]: https://github.com/microsoft/agent-framework/compare/python-1.3.0...python-1.4.0
 [1.3.0]: https://github.com/microsoft/agent-framework/compare/python-1.2.2...python-1.3.0

python/packages/a2a/agent_framework_a2a/_agent.py

@@ -129,6 +129,7 @@ class A2AAgent(AgentTelemetryLayer, BaseAgent):
         self._timeout_config = self._create_timeout_config(timeout)
         if client is not None:
             self.client = client
+            self._non_streaming_client: Client | None = None
             self._close_http_client = True
             return
         if agent_card is None:
@@ -144,17 +145,30 @@ class A2AAgent(AgentTelemetryLayer, BaseAgent):
             self._http_client = http_client  # Store for cleanup
             self._close_http_client = True
 
-        # Create A2A client using factory
-        config = ClientConfig(
+        interceptors = [auth_interceptor] if auth_interceptor is not None else None
+
+        # Create streaming client (SSE transport for stream=True)
+        streaming_config = ClientConfig(
             httpx_client=http_client,
+            streaming=True,
             supported_protocol_bindings=["JSONRPC"],
         )
-        factory = ClientFactory(config)
-        interceptors = [auth_interceptor] if auth_interceptor is not None else None
+        # Create non-streaming client (single request/response for stream=False)
+        non_streaming_config = ClientConfig(
+            httpx_client=http_client,
+            streaming=False,
+            supported_protocol_bindings=["JSONRPC"],
+        )
+        streaming_factory = ClientFactory(streaming_config)
+        non_streaming_factory = ClientFactory(non_streaming_config)
 
         # Attempt transport negotiation with the provided agent card
         try:
-            self.client = factory.create(agent_card, interceptors=interceptors)  # type: ignore
+            self.client = streaming_factory.create(agent_card, interceptors=interceptors)  # type: ignore
+            self._non_streaming_client = non_streaming_factory.create(
+                agent_card,
+                interceptors=interceptors,  # type: ignore
+            )
         except Exception as transport_error:
             # Transport negotiation failed - fall back to minimal agent card with JSONRPC
             fallback_url = agent_card.supported_interfaces[0].url if agent_card.supported_interfaces else url
@@ -166,7 +180,11 @@ class A2AAgent(AgentTelemetryLayer, BaseAgent):
                 ) from transport_error
             fallback_card = minimal_agent_card(fallback_url, ["JSONRPC"])
             try:
-                self.client = factory.create(fallback_card, interceptors=interceptors)  # type: ignore
+                self.client = streaming_factory.create(fallback_card, interceptors=interceptors)  # type: ignore
+                self._non_streaming_client = non_streaming_factory.create(
+                    fallback_card,
+                    interceptors=interceptors,  # type: ignore
+                )
             except Exception as fallback_error:
                 raise RuntimeError(
                     f"A2A transport negotiation failed. "
@@ -282,6 +300,13 @@ class A2AAgent(AgentTelemetryLayer, BaseAgent):
         del function_invocation_kwargs, client_kwargs, kwargs
         normalized_messages = normalize_messages(messages)
 
+        # Use non-streaming transport for non-streaming calls when available.
+        # This sends a single HTTP request/response instead of opening an SSE
+        # connection, matching the protocol's intent for synchronous operations.
+        active_client = (
+            self._non_streaming_client if (not stream and self._non_streaming_client is not None) else self.client
+        )
+
         if continuation_token is not None:
             a2a_stream: AsyncIterable[A2AStreamItem] = self.client.subscribe(
                 SubscribeToTaskRequest(id=continuation_token["task_id"])
@@ -293,7 +318,11 @@ class A2AAgent(AgentTelemetryLayer, BaseAgent):
                 normalized_messages[-1],
                 context_id=session.service_session_id if session else None,
             )
-            a2a_stream = self.client.send_message(SendMessageRequest(message=a2a_message))
+            request = SendMessageRequest(message=a2a_message)
+            if background and not stream:
+                # return_immediately only applies to non-streaming (message/send)
+                request.configuration.return_immediately = True
+            a2a_stream = active_client.send_message(request)
 
         provider_session = session
         if provider_session is None and self.context_providers:

python/packages/a2a/pyproject.toml

@@ -4,7 +4,7 @@ description = "A2A integration for Microsoft Agent Framework."
 authors = [{ name = "Microsoft", email = "af-support@microsoft.com"}]
 readme = "README.md"
 requires-python = ">=3.10"
-version = "1.0.0b260519"
+version = "1.0.0b260521"
 license-files = ["LICENSE"]
 urls.homepage = "https://aka.ms/agent-framework"
 urls.source = "https://github.com/microsoft/agent-framework/tree/main/python"
@@ -23,7 +23,7 @@ classifiers = [
   "Typing :: Typed",
 ]
 dependencies = [
-    "agent-framework-core>=1.5.0,<2",
+    "agent-framework-core>=1.6.0,<2",
     "a2a-sdk>=1.0.0,<2",
 ]
 

python/packages/a2a/tests/test_a2a_agent.py

@@ -44,6 +44,7 @@ class MockA2AClient:
         self.subscribe_responses: list[StreamResponse] = []
         self.get_task_response: Task | None = None
         self.last_message: Any = None
+        self.last_request: Any = None
 
     def add_message_response(self, message_id: str, text: str, role: str = "agent") -> None:
         """Add a mock Message response."""
@@ -91,6 +92,7 @@ class MockA2AClient:
 
     async def send_message(self, request: Any) -> AsyncIterator[StreamResponse]:
         """Mock send_message method that yields responses."""
+        self.last_request = request
         self.last_message = getattr(request, "message", request)
         self.call_count += 1
 
@@ -745,6 +747,96 @@ async def test_working_task_no_token_without_background(a2a_agent: A2AAgent, moc
     assert response.continuation_token is None
 
 
+async def test_background_sets_return_immediately_on_request(
+    a2a_agent: A2AAgent, mock_a2a_client: MockA2AClient
+) -> None:
+    """Test that background=True sets return_immediately=True on SendMessageRequest configuration."""
+    mock_a2a_client.add_in_progress_task_response("task-bg", state=TaskState.TASK_STATE_WORKING)
+
+    await a2a_agent.run("Background task", background=True)
+
+    assert mock_a2a_client.last_request.configuration.return_immediately is True
+
+
+async def test_foreground_does_not_set_return_immediately(
+    a2a_agent: A2AAgent, mock_a2a_client: MockA2AClient
+) -> None:
+    """Test that background=False (default) does not set configuration on SendMessageRequest."""
+    mock_a2a_client.add_task_response("task-fg2", [{"id": "art-1", "content": "Done"}])
+
+    await a2a_agent.run("Foreground task")
+
+    assert mock_a2a_client.last_request.HasField("configuration") is False
+
+
+async def test_streaming_background_does_not_set_return_immediately(
+    a2a_agent: A2AAgent, mock_a2a_client: MockA2AClient
+) -> None:
+    """Test that background=True with stream=True does not set return_immediately.
+
+    Per A2A spec, return_immediately only applies to non-streaming (message/send).
+    """
+    mock_a2a_client.add_task_response("task-sb", [{"id": "art-1", "content": "Streaming bg"}])
+
+    updates: list[AgentResponseUpdate] = []
+    async for update in a2a_agent.run("Stream background", stream=True, background=True):
+        updates.append(update)
+
+    assert mock_a2a_client.last_request.HasField("configuration") is False
+
+
+async def test_non_streaming_run_uses_non_streaming_client() -> None:
+    """Test that stream=False uses the non-streaming client when available."""
+    streaming_client = MockA2AClient()
+    non_streaming_client = MockA2AClient()
+    non_streaming_client.add_task_response("task-ns", [{"id": "art-1", "content": "Non-streaming result"}])
+
+    agent = A2AAgent(name="Test Agent", id="test-ns", client=streaming_client, http_client=None)
+    agent._non_streaming_client = non_streaming_client  # type: ignore[assignment]
+
+    response = await agent.run("Hello")
+
+    # Non-streaming client should have been called
+    assert non_streaming_client.call_count == 1
+    assert streaming_client.call_count == 0
+    assert response.messages[0].text == "Non-streaming result"
+    assert non_streaming_client.last_request.HasField("configuration") is False
+
+
+async def test_streaming_run_uses_streaming_client() -> None:
+    """Test that stream=True always uses the streaming client."""
+    streaming_client = MockA2AClient()
+    non_streaming_client = MockA2AClient()
+    streaming_client.add_task_response("task-s", [{"id": "art-1", "content": "Streaming result"}])
+
+    agent = A2AAgent(name="Test Agent", id="test-s", client=streaming_client, http_client=None)
+    agent._non_streaming_client = non_streaming_client  # type: ignore[assignment]
+
+    updates: list[AgentResponseUpdate] = []
+    async for update in agent.run("Hello", stream=True):
+        updates.append(update)
+
+    # Streaming client should have been called
+    assert streaming_client.call_count == 1
+    assert non_streaming_client.call_count == 0
+    assert updates[0].contents[0].text == "Streaming result"
+
+
+async def test_non_streaming_client_fallback_when_not_available(
+    a2a_agent: A2AAgent, mock_a2a_client: MockA2AClient
+) -> None:
+    """Test that stream=False falls back to streaming client when non-streaming client is unavailable."""
+    mock_a2a_client.add_task_response("task-fb", [{"id": "art-1", "content": "Fallback result"}])
+
+    # a2a_agent is created with client= param so _non_streaming_client is None
+    assert a2a_agent._non_streaming_client is None
+
+    response = await a2a_agent.run("Hello")
+
+    assert mock_a2a_client.call_count == 1
+    assert response.messages[0].text == "Fallback result"
+
+
 async def test_completed_task_has_no_continuation_token(a2a_agent: A2AAgent, mock_a2a_client: MockA2AClient) -> None:
     """Test that a completed task does not set a continuation token."""
     mock_a2a_client.add_task_response("task-done", [{"id": "art-1", "content": "Result"}])

python/packages/ag-ui/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "agent-framework-ag-ui"
-version = "1.0.0rc2"
+version = "1.0.0rc3"
 description = "AG-UI protocol integration for Agent Framework"
 readme = "README.md"
 license-files = ["LICENSE"]
@@ -22,7 +22,7 @@ classifiers = [
   "Typing :: Typed",
 ]
 dependencies = [
-    "agent-framework-core>=1.5.0,<2",
+    "agent-framework-core>=1.6.0,<2",
     "ag-ui-protocol>=0.1.16,<0.2",
     "fastapi>=0.115.0,<0.133.1",
     "uvicorn[standard]>=0.30.0,<1"

python/packages/anthropic/pyproject.toml

@@ -4,7 +4,7 @@ description = "Anthropic integration for Microsoft Agent Framework."
 authors = [{ name = "Microsoft", email = "af-support@microsoft.com"}]
 readme = "README.md"
 requires-python = ">=3.10"
-version = "1.0.0b260519"
+version = "1.0.0b260521"
 license-files = ["LICENSE"]
 urls.homepage = "https://aka.ms/agent-framework"
 urls.source = "https://github.com/microsoft/agent-framework/tree/main/python"
@@ -23,7 +23,7 @@ classifiers = [
   "Typing :: Typed",
 ]
 dependencies = [
-    "agent-framework-core>=1.5.0,<2",
+    "agent-framework-core>=1.6.0,<2",
     "anthropic>=0.80.0,<0.80.1",
 ]
 

python/packages/azure-ai-search/pyproject.toml

@@ -4,7 +4,7 @@ description = "Azure AI Search integration for Microsoft Agent Framework."
 authors = [{ name = "Microsoft", email = "af-support@microsoft.com"}]
 readme = "README.md"
 requires-python = ">=3.10"
-version = "1.0.0b260519"
+version = "1.0.0b260521"
 license-files = ["LICENSE"]
 urls.homepage = "https://aka.ms/agent-framework"
 urls.source = "https://github.com/microsoft/agent-framework/tree/main/python"
@@ -23,7 +23,7 @@ classifiers = [
   "Typing :: Typed",
 ]
 dependencies = [
-    "agent-framework-core>=1.5.0,<2",
+    "agent-framework-core>=1.6.0,<2",
     "azure-search-documents>=11.7.0b2,<11.7.0b3",
 ]
 

python/packages/azure-contentunderstanding/pyproject.toml

@@ -4,7 +4,7 @@ description = "Azure Content Understanding integration for Microsoft Agent Frame
 authors = [{ name = "Microsoft", email = "af-support@microsoft.com" }]
 readme = "README.md"
 requires-python = ">=3.10"
-version = "1.0.0a260519"
+version = "1.0.0a260521"
 license-files = ["LICENSE"]
 urls.homepage = "https://aka.ms/agent-framework"
 urls.source = "https://github.com/microsoft/agent-framework/tree/main/python"
@@ -23,8 +23,8 @@ classifiers = [
   "Typing :: Typed",
 ]
 dependencies = [
-    "agent-framework-core>=1.5.0,<2",
-    "agent-framework-foundry>=1.5.0,<2",
+    "agent-framework-core>=1.6.0,<2",
+    "agent-framework-foundry>=1.6.0,<2",
     "azure-ai-contentunderstanding>=1.0.1,<1.1",
     "aiohttp>=3.9,<4",
     "filetype>=1.2,<2",

python/packages/azure-cosmos/pyproject.toml

@@ -4,7 +4,7 @@ description = "Azure Cosmos DB history provider integration for Microsoft Agent
 authors = [{ name = "Microsoft", email = "af-support@microsoft.com"}]
 readme = "README.md"
 requires-python = ">=3.10"
-version = "1.0.0b260519"
+version = "1.0.0b260521"
 license-files = ["LICENSE"]
 urls.homepage = "https://aka.ms/agent-framework"
 urls.source = "https://github.com/microsoft/agent-framework/tree/main/python"
@@ -23,7 +23,7 @@ classifiers = [
   "Typing :: Typed",
 ]
 dependencies = [
-    "agent-framework-core>=1.5.0,<2",
+    "agent-framework-core>=1.6.0,<2",
     "azure-cosmos>=4.3.0,<5",
 ]
 

python/packages/azurefunctions/pyproject.toml

@@ -4,7 +4,7 @@ description = "Azure Functions integration for Microsoft Agent Framework."
 authors = [{ name = "Microsoft", email = "af-support@microsoft.com"}]
 readme = "README.md"
 requires-python = ">=3.10"
-version = "1.0.0b260519"
+version = "1.0.0b260521"
 license-files = ["LICENSE"]
 urls.homepage = "https://aka.ms/agent-framework"
 urls.source = "https://github.com/microsoft/agent-framework/tree/main/python"
@@ -22,8 +22,8 @@ classifiers = [
   "Typing :: Typed",
 ]
 dependencies = [
-    "agent-framework-core>=1.5.0,<2",
-    "agent-framework-durabletask>=1.0.0b260519,<2",
+    "agent-framework-core>=1.6.0,<2",
+    "agent-framework-durabletask>=1.0.0b260521,<2",
     "azure-functions>=1.24.0,<2",
     "azure-functions-durable>=1.3.1,<2",
 ]

python/packages/bedrock/pyproject.toml

@@ -4,7 +4,7 @@ description = "Amazon Bedrock integration for Microsoft Agent Framework."
 authors = [{ name = "Microsoft", email = "af-support@microsoft.com"}]
 readme = "README.md"
 requires-python = ">=3.10"
-version = "1.0.0b260519"
+version = "1.0.0b260521"
 license-files = ["LICENSE"]
 urls.homepage = "https://aka.ms/agent-framework"
 urls.source = "https://github.com/microsoft/agent-framework/tree/main/python"
@@ -23,7 +23,7 @@ classifiers = [
   "Typing :: Typed",
 ]
 dependencies = [
-    "agent-framework-core>=1.5.0,<2",
+    "agent-framework-core>=1.6.0,<2",
     "boto3>=1.35.0,<2.0.0",
     "botocore>=1.35.0,<2.0.0",
 ]

python/packages/chatkit/pyproject.toml

@@ -4,7 +4,7 @@ description = "OpenAI ChatKit integration for Microsoft Agent Framework."
 authors = [{ name = "Microsoft", email = "af-support@microsoft.com"}]
 readme = "README.md"
 requires-python = ">=3.10"
-version = "1.0.0b260519"
+version = "1.0.0b260521"
 license-files = ["LICENSE"]
 urls.homepage = "https://aka.ms/agent-framework"
 urls.source = "https://github.com/microsoft/agent-framework/tree/main/python"
@@ -22,7 +22,7 @@ classifiers = [
   "Typing :: Typed",
 ]
 dependencies = [
-    "agent-framework-core>=1.5.0,<2",
+    "agent-framework-core>=1.6.0,<2",
     "openai-chatkit>=1.4.1,<2.0.0",
 ]
 

python/packages/claude/pyproject.toml

@@ -4,7 +4,7 @@ description = "Claude Agent SDK integration for Microsoft Agent Framework."
 authors = [{ name = "Microsoft", email = "af-support@microsoft.com"}]
 readme = "README.md"
 requires-python = ">=3.10"
-version = "1.0.0b260519"
+version = "1.0.0b260521"
 license-files = ["LICENSE"]
 urls.homepage = "https://aka.ms/agent-framework"
 urls.source = "https://github.com/microsoft/agent-framework/tree/main/python"
@@ -23,7 +23,7 @@ classifiers = [
   "Typing :: Typed",
 ]
 dependencies = [
-    "agent-framework-core>=1.5.0,<2",
+    "agent-framework-core>=1.6.0,<2",
     "claude-agent-sdk>=0.1.36,<0.1.49",
 ]
 

python/packages/copilotstudio/pyproject.toml

@@ -4,7 +4,7 @@ description = "Copilot Studio integration for Microsoft Agent Framework."
 authors = [{ name = "Microsoft", email = "af-support@microsoft.com"}]
 readme = "README.md"
 requires-python = ">=3.10"
-version = "1.0.0b260519"
+version = "1.0.0b260521"
 license-files = ["LICENSE"]
 urls.homepage = "https://aka.ms/agent-framework"
 urls.source = "https://github.com/microsoft/agent-framework/tree/main/python"
@@ -23,7 +23,7 @@ classifiers = [
   "Typing :: Typed",
 ]
 dependencies = [
-    "agent-framework-core>=1.5.0,<2",
+    "agent-framework-core>=1.6.0,<2",
     "microsoft-agents-copilotstudio-client>=0.3.1,<0.3.2",
 ]
 

python/packages/core/agent_framework/_feature_stage.py

@@ -49,6 +49,8 @@ class ExperimentalFeature(str, Enum):
     EVALS = "EVALS"
     FILE_HISTORY = "FILE_HISTORY"
     FIDES = "FIDES"
+    FOUNDRY_TOOLS = "FOUNDRY_TOOLS"
+    FOUNDRY_PREVIEW_TOOLS = "FOUNDRY_PREVIEW_TOOLS"
     FUNCTIONAL_WORKFLOWS = "FUNCTIONAL_WORKFLOWS"
     HARNESS = "HARNESS"
     SKILLS = "SKILLS"

python/packages/core/agent_framework/observability.py

@@ -2153,15 +2153,14 @@ def _capture_messages(
     finish_reason: FinishReason | None = None,
 ) -> None:
     """Log messages with extra information."""
-    from ._types import normalize_messages, prepend_instructions_to_messages
+    from ._types import normalize_messages
 
-    prepped = prepend_instructions_to_messages(normalize_messages(messages), system_instructions)
+    normalized_messages = normalize_messages(messages)
     otel_messages: list[dict[str, Any]] = []
-    for index, message in enumerate(prepped):
+    for index, message in enumerate(normalized_messages):
         # Reuse the otel message representation for logging instead of calling to_dict()
         # to avoid expensive Pydantic serialization overhead
         otel_message = _to_otel_message(message)
-        otel_messages.append(otel_message)
         logger.info(
             otel_message,
             extra={
@@ -2170,6 +2169,7 @@ def _capture_messages(
                 MessageListTimestampFilter.INDEX_KEY: index,
             },
         )
+        otel_messages.append(otel_message)
     if finish_reason:
         otel_messages[-1]["finish_reason"] = FINISH_REASON_MAP[finish_reason]
     span.set_attribute(

python/packages/core/pyproject.toml

@@ -4,7 +4,7 @@ description = "Microsoft Agent Framework for building AI Agents with Python. Thi
 authors = [{ name = "Microsoft", email = "af-support@microsoft.com"}]
 readme = "README.md"
 requires-python = ">=3.10"
-version = "1.5.0"
+version = "1.6.0"
 license-files = ["LICENSE"]
 urls.homepage = "https://aka.ms/agent-framework"
 urls.source = "https://github.com/microsoft/agent-framework/tree/main/python"

python/packages/core/tests/core/test_observability.py

@@ -290,9 +290,9 @@ async def test_chat_client_observability_with_instructions(
     assert len(system_instructions) == 1
     assert system_instructions[0]["content"] == "You are a helpful assistant."
 
-    # Verify input_messages contains system message
+    # Verify input_messages excludes system instructions
     input_messages = json.loads(span.attributes[OtelAttr.INPUT_MESSAGES])
-    assert any(msg.get("role") == "system" for msg in input_messages)
+    assert [msg.get("role") for msg in input_messages] == ["user"]
 
 
 @pytest.mark.parametrize("enable_sensitive_data", [True], indirect=True)
@@ -324,6 +324,40 @@ async def test_chat_client_streaming_observability_with_instructions(
     assert len(system_instructions) == 1
     assert system_instructions[0]["content"] == "You are a helpful assistant."
 
+    input_messages = json.loads(span.attributes[OtelAttr.INPUT_MESSAGES])
+    assert [msg.get("role") for msg in input_messages] == ["user"]
+
+
+@pytest.mark.parametrize("enable_sensitive_data", [True], indirect=True)
+async def test_chat_client_observability_with_system_message_and_instructions(
+    mock_chat_client, span_exporter: InMemorySpanExporter, enable_sensitive_data
+):
+    """Test input chat-history system messages stay in input_messages when instructions are separate."""
+    import json
+
+    client = mock_chat_client()
+
+    messages = [
+        Message(role="system", contents=["Original system message"]),
+        Message(role="user", contents=["Test message"]),
+    ]
+    options = {"model": "Test", "instructions": "Framework system instruction"}
+    span_exporter.clear()
+    response = await client.get_response(messages=messages, options=options)
+
+    assert response is not None
+    spans = span_exporter.get_finished_spans()
+    assert len(spans) == 1
+    span = spans[0]
+
+    system_instructions = json.loads(span.attributes[OtelAttr.SYSTEM_INSTRUCTIONS])
+    assert system_instructions == [{"type": "text", "content": "Framework system instruction"}]
+
+    input_messages = json.loads(span.attributes[OtelAttr.INPUT_MESSAGES])
+    assert [msg.get("role") for msg in input_messages] == ["system", "user"]
+    assert input_messages[0]["parts"][0]["content"] == "Original system message"
+    assert input_messages[1]["parts"][0]["content"] == "Test message"
+
 
 @pytest.mark.parametrize("enable_sensitive_data", [True], indirect=True)
 async def test_chat_client_observability_without_instructions(
@@ -2981,6 +3015,81 @@ async def test_system_instructions_preserves_non_ascii_characters(span_exporter:
     system_instructions = json.loads(system_instructions_json)
     assert system_instructions[0]["content"] == chinese_text
 
+    input_messages = json.loads(span.attributes[OtelAttr.INPUT_MESSAGES])
+    assert [msg.get("role") for msg in input_messages] == ["user"]
+
+
+def test_capture_messages_keeps_framework_instructions_out_of_logs_and_span_messages(
+    span_exporter: InMemorySpanExporter,
+):
+    """Test separate framework instructions do not appear in chat-history logs or span messages."""
+    import json
+
+    from opentelemetry import trace
+
+    tracer = trace.get_tracer("test")
+    span_exporter.clear()
+
+    with (
+        patch("agent_framework.observability.logger.info") as mock_logger_info,
+        tracer.start_as_current_span("test_span") as span,
+    ):
+        _capture_messages(
+            span=span,
+            provider_name="test_provider",
+            messages=[Message(role="user", contents=["Test"])],
+            system_instructions="Framework system instruction",
+        )
+
+    spans = span_exporter.get_finished_spans()
+    assert len(spans) == 1
+    input_messages = json.loads(spans[0].attributes[OtelAttr.INPUT_MESSAGES])
+    assert [msg.get("role") for msg in input_messages] == ["user"]
+
+    assert mock_logger_info.call_count == 1, f"Expected 1 log call, got {mock_logger_info.call_count}"
+    (first_call,) = mock_logger_info.call_args_list
+    assert first_call.args
+    logged_message = first_call.args[0]
+    assert logged_message["role"] == "user"
+    assert logged_message["parts"][0]["content"] == "Test"
+
+
+def test_capture_messages_logs_only_chat_history_when_framework_instructions_are_separate(
+    span_exporter: InMemorySpanExporter,
+):
+    """Test chat-history logging preserves original system messages without prepending framework instructions."""
+    import json
+
+    from opentelemetry import trace
+
+    tracer = trace.get_tracer("test")
+    span_exporter.clear()
+
+    with (
+        patch("agent_framework.observability.logger.info") as mock_logger_info,
+        tracer.start_as_current_span("test_span") as span,
+    ):
+        _capture_messages(
+            span=span,
+            provider_name="test_provider",
+            messages=[
+                Message(role="system", contents=["Original system message"]),
+                Message(role="user", contents=["Test"]),
+            ],
+            system_instructions="Framework system instruction",
+        )
+
+    spans = span_exporter.get_finished_spans()
+    assert len(spans) == 1
+    input_messages = json.loads(spans[0].attributes[OtelAttr.INPUT_MESSAGES])
+    assert [msg.get("role") for msg in input_messages] == ["system", "user"]
+
+    assert mock_logger_info.call_count == 2, f"Expected 2 log calls, got {mock_logger_info.call_count}"
+    logged_messages = [call.args[0] for call in mock_logger_info.call_args_list]
+    assert [msg["role"] for msg in logged_messages] == ["system", "user"]
+    assert logged_messages[0]["parts"][0]["content"] == "Original system message"
+    assert logged_messages[1]["parts"][0]["content"] == "Test"
+
 
 @pytest.mark.parametrize("enable_sensitive_data", [True], indirect=True)
 async def test_tool_arguments_preserves_non_ascii_characters(span_exporter: InMemorySpanExporter):
@@ -3104,6 +3213,40 @@ async def test_agent_instructions_from_default_options(
     assert len(system_instructions) == 1
     assert system_instructions[0]["content"] == "Default system instructions."
 
+    input_messages = json.loads(span.attributes[OtelAttr.INPUT_MESSAGES])
+    assert [msg.get("role") for msg in input_messages] == ["user"]
+
+
+@pytest.mark.parametrize("enable_sensitive_data", [True], indirect=True)
+async def test_agent_instructions_preserve_system_messages_in_history(
+    mock_chat_agent, span_exporter: InMemorySpanExporter, enable_sensitive_data
+):
+    """Test agent spans keep chat-history system messages separate from framework instructions."""
+    import json
+
+    agent = mock_chat_agent()
+    agent.default_options = {"model": "TestModel", "instructions": "Default system instructions."}
+
+    messages = [
+        Message(role="system", contents=["Original system message"]),
+        Message(role="user", contents=["Test message"]),
+    ]
+    span_exporter.clear()
+    response = await agent.run(messages)
+
+    assert response is not None
+    spans = span_exporter.get_finished_spans()
+    assert len(spans) == 1
+    span = spans[0]
+
+    system_instructions = json.loads(span.attributes[OtelAttr.SYSTEM_INSTRUCTIONS])
+    assert system_instructions == [{"type": "text", "content": "Default system instructions."}]
+
+    input_messages = json.loads(span.attributes[OtelAttr.INPUT_MESSAGES])
+    assert [msg.get("role") for msg in input_messages] == ["system", "user"]
+    assert input_messages[0]["parts"][0]["content"] == "Original system message"
+    assert input_messages[1]["parts"][0]["content"] == "Test message"
+
 
 @pytest.mark.parametrize("enable_sensitive_data", [True], indirect=True)
 async def test_agent_instructions_from_options_override(

python/packages/declarative/pyproject.toml

@@ -4,7 +4,7 @@ description = "Declarative specification support for Microsoft Agent Framework."
 authors = [{ name = "Microsoft", email = "af-support@microsoft.com"}]
 readme = "README.md"
 requires-python = ">=3.10"
-version = "1.0.0b260519"
+version = "1.0.0b260521"
 license-files = ["LICENSE"]
 urls.homepage = "https://aka.ms/agent-framework"
 urls.source = "https://github.com/microsoft/agent-framework/tree/main/python"
@@ -22,7 +22,7 @@ classifiers = [
   "Typing :: Typed",
 ]
 dependencies = [
-    "agent-framework-core>=1.5.0,<2",
+    "agent-framework-core>=1.6.0,<2",
     "httpx>=0.27,<1",
     "powerfx>=0.0.32,<0.0.35; python_version < '3.14'",
     "pyyaml>=6.0,<7.0",

python/packages/devui/pyproject.toml

@@ -4,7 +4,7 @@ description = "Debug UI for Microsoft Agent Framework with OpenAI-compatible API
 authors = [{ name = "Microsoft", email = "af-support@microsoft.com"}]
 readme = "README.md"
 requires-python = ">=3.10"
-version = "1.0.0b260519"
+version = "1.0.0b260521"
 license-files = ["LICENSE"]
 urls.homepage = "https://github.com/microsoft/agent-framework"
 urls.source = "https://github.com/microsoft/agent-framework/tree/main/python"
@@ -23,7 +23,7 @@ classifiers = [
   "Typing :: Typed",
 ]
  dependencies = [
-     "agent-framework-core>=1.5.0,<2",
+     "agent-framework-core>=1.6.0,<2",
      "openai>=1.99.0,<3",
      "opentelemetry-sdk>=1.39.0,<2",
      "fastapi>=0.115.0,<0.133.1",

python/packages/durabletask/pyproject.toml

@@ -4,7 +4,7 @@ description = "Durable Task integration for Microsoft Agent Framework."
 authors = [{ name = "Microsoft", email = "af-support@microsoft.com"}]
 readme = "README.md"
 requires-python = ">=3.10"
-version = "1.0.0b260519"
+version = "1.0.0b260521"
 license-files = ["LICENSE"]
 urls.homepage = "https://aka.ms/agent-framework"
 urls.source = "https://github.com/microsoft/agent-framework/tree/main/python"
@@ -22,7 +22,7 @@ classifiers = [
   "Typing :: Typed",
 ]
 dependencies = [
-    "agent-framework-core>=1.5.0,<2",
+    "agent-framework-core>=1.6.0,<2",
     "durabletask>=1.4.0,!=1.4.1,!=1.4.2,!=1.4.3,<2",
     "durabletask-azuremanaged>=1.4.0,<2",
     "python-dateutil>=2.8.0,<3",

python/packages/foundry/README.md

@@ -39,3 +39,70 @@ async with Agent(
     result = await agent.run("What tools are available?")
     print(result.text)
 ```
+
+## Hosted tool factories
+
+`FoundryChatClient` exposes static factory methods that return Foundry SDK tool
+configurations ready to pass to an `Agent`'s `tools=[...]` argument. These
+factories don't require a `FoundryChatClient` instance — you can call them
+statically and reuse the same tool configuration across agents.
+
+```python
+from agent_framework import Agent
+from agent_framework.foundry import FoundryChatClient
+
+agent = Agent(
+    client=FoundryChatClient(...),
+    instructions="...",
+    tools=[
+        FoundryChatClient.get_web_search_tool(),
+        FoundryChatClient.get_code_interpreter_tool(),
+    ],
+)
+```
+
+Generally available factories: `get_code_interpreter_tool`,
+`get_file_search_tool`, `get_web_search_tool`,
+`get_image_generation_tool`, `get_mcp_tool`.
+
+> **Choosing a web grounding tool.** `get_web_search_tool` is the recommended
+> default — it requires no separate Bing resource and works with Azure OpenAI
+> models out of the box. Reach for `get_bing_grounding_tool` (experimental,
+> see below) when you need finer Bing parameters (`count`, `freshness`,
+> `market`, `set_lang`), are grounding non-OpenAI Foundry models, or are
+> migrating from Grounding with Bing Search on the classic platform — it
+> requires a Grounding with Bing Search Azure resource that you manage.
+> `get_bing_custom_search_tool` (also experimental) is for grounding
+> restricted to a curated list of domains via a Bing Custom Search instance.
+> See the
+> [web grounding overview](https://learn.microsoft.com/azure/foundry/agents/how-to/tools/web-overview)
+> for the full comparison.
+
+> **Experimental — `ExperimentalFeature.FOUNDRY_TOOLS`.** The following
+> factories wrap GA Foundry tool SDK classes but are new wrappers in
+> `agent-framework-foundry` and may change before the wrappers themselves
+> reach GA. Calls emit an `ExperimentalWarning` the first time the
+> `FOUNDRY_TOOLS` feature is exercised in a process (then deduplicated).
+
+| Factory | Foundry SDK tool |
+|---------|-----------------|
+| `get_azure_ai_search_tool(index_connection_id, index_name, ...)` | `AzureAISearchTool` |
+| `get_bing_grounding_tool(connection_id, ...)` | `BingGroundingTool` |
+
+> **Experimental — `ExperimentalFeature.FOUNDRY_PREVIEW_TOOLS`.** The
+> following factories wrap **preview** Foundry tool SDK types — the underlying
+> Foundry capability itself is in preview and may change or be removed before
+> reaching GA. Calls emit a separate `ExperimentalWarning` the first time the
+> `FOUNDRY_PREVIEW_TOOLS` feature is exercised in a process (then
+> deduplicated). Use `FOUNDRY_TOOLS` for "wrapper is new" and
+> `FOUNDRY_PREVIEW_TOOLS` for "underlying Foundry feature is preview".
+
+| Factory | Foundry SDK tool |
+|---------|-----------------|
+| `get_sharepoint_tool(connection_id)` | `SharepointPreviewTool` |
+| `get_fabric_tool(connection_id)` | `MicrosoftFabricPreviewTool` |
+| `get_memory_search_tool(memory_store_name, scope, ...)` | `MemorySearchPreviewTool` |
+| `get_computer_use_tool(environment, display_width, display_height)` | `ComputerUsePreviewTool` |
+| `get_browser_automation_tool(connection_id)` | `BrowserAutomationPreviewTool` |
+| `get_bing_custom_search_tool(connection_id, instance_name, ...)` | `BingCustomSearchPreviewTool` |
+| `get_a2a_tool(base_url=..., project_connection_id=..., ...)` | `A2APreviewTool` |

python/packages/foundry/agent_framework_foundry/_chat_client.py

@@ -16,14 +16,35 @@ from agent_framework import (
     load_settings,
 )
 from agent_framework._compaction import CompactionStrategy, TokenizerProtocol
+from agent_framework._feature_stage import ExperimentalFeature, experimental
 from agent_framework._telemetry import get_user_agent
 from agent_framework.observability import ChatTelemetryLayer
 from agent_framework_openai._chat_client import OpenAIChatOptions, RawOpenAIChatClient
 from azure.ai.projects.aio import AIProjectClient
 from azure.ai.projects.models import (
+    A2APreviewTool,
+    AISearchIndexResource,
     AutoCodeInterpreterToolParam,
+    AzureAISearchTool,
+    AzureAISearchToolResource,
+    BingCustomSearchConfiguration,
+    BingCustomSearchPreviewTool,
+    BingCustomSearchToolParameters,
+    BingGroundingSearchConfiguration,
+    BingGroundingSearchToolParameters,
+    BingGroundingTool,
+    BrowserAutomationPreviewTool,
+    BrowserAutomationToolConnectionParameters,
+    BrowserAutomationToolParameters,
     CodeInterpreterTool,
+    ComputerUsePreviewTool,
+    FabricDataAgentToolParameters,
     ImageGenTool,
+    MemorySearchPreviewTool,
+    MicrosoftFabricPreviewTool,
+    SharepointGroundingToolParameters,
+    SharepointPreviewTool,
+    ToolProjectConnection,
     WebSearchApproximateLocation,
     WebSearchTool,
     WebSearchToolFilters,
@@ -381,17 +402,44 @@ class RawFoundryChatClient(  # type: ignore[misc]
         custom_search_configuration: dict[str, Any] | None = None,
         **kwargs: Any,
     ) -> WebSearchTool:
-        """Create a web search tool configuration for Microsoft Foundry.
+        """Create a Web Search tool configuration for Microsoft Foundry.
+
+        **Choosing a web grounding tool.** Foundry exposes three options that all reach
+        the public web via Bing. Pick the one that matches your scenario:
+
+        * :py:meth:`get_web_search_tool` (this one, GA) — recommended starting point.
+          The Bing resource is managed by Microsoft, no extra Azure setup is required,
+          and only Azure OpenAI models are supported. Parameters are limited to
+          ``user_location`` and ``search_context_size``.
+        * :py:meth:`get_bing_grounding_tool` (preview) — use when you need finer Bing parameters (``count``,
+          ``freshness``, ``market``, ``set_lang``), want to ground non-OpenAI
+          Foundry models, or are migrating from Grounding with Bing Search on the
+          classic agents platform. You manage the Grounding with Bing Search
+          resource yourself (Contributor/Owner to create the resource, Foundry
+          Project Manager to wire the connection).
+        * :py:meth:`get_bing_custom_search_tool` (preview) — use when you need to
+          restrict grounding to a curated set of domains defined in a Bing Custom
+          Search instance.
+
+        For all three, search data flows outside the Azure compliance boundary. See
+        https://learn.microsoft.com/azure/foundry/agents/how-to/tools/web-overview for
+        the full comparison.
 
         Keyword Args:
-            user_location: Location context with keys like "city", "country", "region", "timezone".
-            search_context_size: Amount of context from search results ("low", "medium", "high").
-            allowed_domains: List of domains to restrict search results to.
-            custom_search_configuration: Custom Bing search configuration.
-            **kwargs: Additional arguments passed to the SDK WebSearchTool constructor.
+            user_location: Location context with keys like ``"city"``, ``"country"``,
+                ``"region"``, ``"timezone"``.
+            search_context_size: Amount of context from search results
+                (``"low"``, ``"medium"``, ``"high"``).
+            allowed_domains: List of domains to restrict search results to. Wrapped
+                into ``WebSearchToolFilters`` and passed as the ``filters`` field on
+                the SDK ``WebSearchTool``.
+            custom_search_configuration: Custom Bing search configuration for
+                domain-restricted scenarios.
+            **kwargs: Additional arguments passed to the SDK ``WebSearchTool``
+                constructor.
 
         Returns:
-            A WebSearchTool ready to pass to an Agent.
+            A ``WebSearchTool`` ready to pass to an Agent.
         """
         ws_kwargs: dict[str, Any] = {**kwargs}
         if search_context_size:
@@ -400,15 +448,137 @@ class RawFoundryChatClient(  # type: ignore[misc]
             ws_kwargs["filters"] = WebSearchToolFilters(allowed_domains=allowed_domains)
         if custom_search_configuration:
             ws_kwargs["custom_search_configuration"] = custom_search_configuration
-        ws_tool = WebSearchTool(**ws_kwargs)
         if user_location:
-            ws_tool.user_location = WebSearchApproximateLocation(
+            ws_kwargs["user_location"] = WebSearchApproximateLocation(
                 city=user_location.get("city"),
                 country=user_location.get("country"),
                 region=user_location.get("region"),
                 timezone=user_location.get("timezone"),
             )
-        return ws_tool
+        return WebSearchTool(**ws_kwargs)
+
+    @staticmethod
+    @experimental(feature_id=ExperimentalFeature.FOUNDRY_TOOLS)
+    def get_bing_grounding_tool(
+        *,
+        connection_id: str,
+        market: str | None = None,
+        set_lang: str | None = None,
+        count: int | None = None,
+        freshness: str | None = None,
+        **kwargs: Any,
+    ) -> BingGroundingTool:
+        """Create a Grounding with Bing Search tool configuration for Foundry.
+
+        Use this factory when :py:meth:`get_web_search_tool` is too restrictive — for
+        example when you need ``count``/``freshness``/``market``/``set_lang``
+        parameters, want to ground a non-OpenAI Foundry model, or are migrating an
+        agent that already uses Grounding with Bing Search on the classic agents
+        platform. You manage the Grounding with Bing Search Azure resource yourself
+        (Contributor or Owner to create the resource, Foundry Project Manager to
+        create the project connection). Search data flows outside the Azure
+        compliance boundary.
+
+        For domain-restricted grounding to a curated allow-list, use
+        :py:meth:`get_bing_custom_search_tool` instead. For a zero-setup default that
+        works for most agents, see :py:meth:`get_web_search_tool`. The full
+        comparison lives at
+        https://learn.microsoft.com/azure/foundry/agents/how-to/tools/web-overview.
+
+        Keyword Args:
+            connection_id: The Foundry project connection ID for the Grounding with
+                Bing Search resource.
+            market: Optional Bing market identifier (e.g. ``"en-US"``).
+            set_lang: Optional UI language code passed to the Bing API.
+            count: Optional number of search results to return.
+            freshness: Optional time-range filter for search results. See
+                https://learn.microsoft.com/bing/search-apis/bing-web-search/reference/query-parameters
+                for accepted values.
+            **kwargs: Additional arguments forwarded to the SDK
+                ``BingGroundingSearchConfiguration``.
+
+        Returns:
+            A ``BingGroundingTool`` ready to pass to an Agent.
+        """
+        config_kwargs: dict[str, Any] = {
+            **kwargs,
+            "project_connection_id": connection_id,
+        }
+        if market is not None:
+            config_kwargs["market"] = market
+        if set_lang is not None:
+            config_kwargs["set_lang"] = set_lang
+        if count is not None:
+            config_kwargs["count"] = count
+        if freshness is not None:
+            config_kwargs["freshness"] = freshness
+        return BingGroundingTool(
+            bing_grounding=BingGroundingSearchToolParameters(
+                search_configurations=[BingGroundingSearchConfiguration(**config_kwargs)],
+            ),
+        )
+
+    @staticmethod
+    @experimental(feature_id=ExperimentalFeature.FOUNDRY_PREVIEW_TOOLS)
+    def get_bing_custom_search_tool(
+        *,
+        connection_id: str,
+        instance_name: str,
+        market: str | None = None,
+        set_lang: str | None = None,
+        count: int | None = None,
+        freshness: str | None = None,
+        **kwargs: Any,
+    ) -> BingCustomSearchPreviewTool:
+        """Create a Grounding with Bing Custom Search tool configuration for Foundry.
+
+        Use this factory (preview) when you need to restrict grounding to a curated
+        list of domains. The allow/block list is defined ahead of time on a Bing
+        Custom Search resource (in the Bing portal) and referenced here by
+        ``instance_name``. Like the other Bing-backed tools, search data flows
+        outside the Azure compliance boundary, and you must create the Bing Custom
+        Search resource yourself.
+
+        For unrestricted public-web grounding with no extra Azure setup, prefer
+        :py:meth:`get_web_search_tool`. For unrestricted grounding with finer Bing
+        parameters or non-OpenAI models, prefer :py:meth:`get_bing_grounding_tool`.
+        See
+        https://learn.microsoft.com/azure/foundry/agents/how-to/tools/web-overview
+        for the full comparison.
+
+        Keyword Args:
+            connection_id: The Foundry project connection ID for the Grounding with
+                Bing Custom Search resource.
+            instance_name: The custom configuration instance name defined on the
+                Bing Custom Search resource.
+            market: Optional Bing market identifier (e.g. ``"en-US"``).
+            set_lang: Optional UI language code passed to the Bing API.
+            count: Optional number of search results to return.
+            freshness: Optional time-range filter for search results.
+            **kwargs: Additional arguments forwarded to the SDK
+                ``BingCustomSearchConfiguration``.
+
+        Returns:
+            A ``BingCustomSearchPreviewTool`` ready to pass to an Agent.
+        """
+        config_kwargs: dict[str, Any] = {
+            **kwargs,
+            "project_connection_id": connection_id,
+            "instance_name": instance_name,
+        }
+        if market is not None:
+            config_kwargs["market"] = market
+        if set_lang is not None:
+            config_kwargs["set_lang"] = set_lang
+        if count is not None:
+            config_kwargs["count"] = count
+        if freshness is not None:
+            config_kwargs["freshness"] = freshness
+        return BingCustomSearchPreviewTool(
+            bing_custom_search_preview=BingCustomSearchToolParameters(
+                search_configurations=[BingCustomSearchConfiguration(**config_kwargs)],
+            ),
+        )
 
     @staticmethod
     def get_image_generation_tool(  # type: ignore[override]
@@ -513,6 +683,219 @@ class RawFoundryChatClient(  # type: ignore[misc]
 
     # endregion
 
+    # region Experimental Foundry tool factories (preview SDK types)
+
+    @staticmethod
+    @experimental(feature_id=ExperimentalFeature.FOUNDRY_TOOLS)
+    def get_azure_ai_search_tool(
+        *,
+        index_connection_id: str,
+        index_name: str,
+        query_type: str | None = None,
+        top_k: int | None = None,
+        filter: str | None = None,
+        index_asset_id: str | None = None,
+        **kwargs: Any,
+    ) -> AzureAISearchTool:
+        """Create an Azure AI Search tool configuration for Foundry.
+
+        Keyword Args:
+            index_connection_id: The Foundry project connection ID for the Azure AI Search index.
+            index_name: The name of the index to search.
+            query_type: Optional query type (``"simple"``, ``"semantic"``, ``"vector"``,
+                ``"vector_simple_hybrid"``, or ``"vector_semantic_hybrid"``).
+            top_k: Optional number of documents to retrieve.
+            filter: Optional OData filter expression.
+            index_asset_id: Optional index asset id for the search resource.
+            **kwargs: Additional arguments forwarded to the SDK ``AISearchIndexResource``.
+
+        Returns:
+            An ``AzureAISearchTool`` ready to pass to an Agent.
+        """
+        index_kwargs: dict[str, Any] = {
+            **kwargs,
+            "project_connection_id": index_connection_id,
+            "index_name": index_name,
+        }
+        if query_type is not None:
+            index_kwargs["query_type"] = query_type
+        if top_k is not None:
+            index_kwargs["top_k"] = top_k
+        if filter is not None:
+            index_kwargs["filter"] = filter
+        if index_asset_id is not None:
+            index_kwargs["index_asset_id"] = index_asset_id
+        return AzureAISearchTool(
+            azure_ai_search=AzureAISearchToolResource(indexes=[AISearchIndexResource(**index_kwargs)]),
+        )
+
+    @staticmethod
+    @experimental(feature_id=ExperimentalFeature.FOUNDRY_PREVIEW_TOOLS)
+    def get_sharepoint_tool(
+        *,
+        connection_id: str,
+        **kwargs: Any,
+    ) -> SharepointPreviewTool:
+        """Create a SharePoint grounding tool configuration for Foundry.
+
+        Keyword Args:
+            connection_id: The Foundry project connection ID for the SharePoint resource.
+            **kwargs: Additional arguments forwarded to the SDK
+                ``SharepointGroundingToolParameters``.
+
+        Returns:
+            A ``SharepointPreviewTool`` ready to pass to an Agent.
+        """
+        return SharepointPreviewTool(
+            sharepoint_grounding_preview=SharepointGroundingToolParameters(
+                project_connections=[ToolProjectConnection(project_connection_id=connection_id)],
+                **kwargs,
+            )
+        )
+
+    @staticmethod
+    @experimental(feature_id=ExperimentalFeature.FOUNDRY_PREVIEW_TOOLS)
+    def get_fabric_tool(
+        *,
+        connection_id: str,
+        **kwargs: Any,
+    ) -> MicrosoftFabricPreviewTool:
+        """Create a Microsoft Fabric data agent tool configuration for Foundry.
+
+        Keyword Args:
+            connection_id: The Foundry project connection ID for the Fabric data agent.
+            **kwargs: Additional arguments forwarded to the SDK
+                ``FabricDataAgentToolParameters``.
+
+        Returns:
+            A ``MicrosoftFabricPreviewTool`` ready to pass to an Agent.
+        """
+        return MicrosoftFabricPreviewTool(
+            fabric_dataagent_preview=FabricDataAgentToolParameters(
+                project_connections=[ToolProjectConnection(project_connection_id=connection_id)],
+                **kwargs,
+            )
+        )
+
+    @staticmethod
+    @experimental(feature_id=ExperimentalFeature.FOUNDRY_PREVIEW_TOOLS)
+    def get_memory_search_tool(
+        *,
+        memory_store_name: str,
+        scope: str,
+        search_options: Any | None = None,
+        update_delay: int | None = None,
+        **kwargs: Any,
+    ) -> MemorySearchPreviewTool:
+        """Create a Memory Search tool configuration for Foundry.
+
+        Keyword Args:
+            memory_store_name: The name of the memory store to use.
+            scope: The namespace used to group and isolate memories (e.g. a user ID).
+                Use ``"{{$userId}}"`` to scope memories to the current signed-in user.
+            search_options: Optional ``MemorySearchOptions`` instance.
+            update_delay: Optional seconds to wait before updating memories after inactivity.
+            **kwargs: Additional arguments forwarded to the SDK ``MemorySearchPreviewTool``.
+
+        Returns:
+            A ``MemorySearchPreviewTool`` ready to pass to an Agent.
+        """
+        params: dict[str, Any] = {
+            **kwargs,
+            "memory_store_name": memory_store_name,
+            "scope": scope,
+        }
+        if search_options is not None:
+            params["search_options"] = search_options
+        if update_delay is not None:
+            params["update_delay"] = update_delay
+        return MemorySearchPreviewTool(**params)
+
+    @staticmethod
+    @experimental(feature_id=ExperimentalFeature.FOUNDRY_PREVIEW_TOOLS)
+    def get_computer_use_tool(
+        *,
+        environment: str,
+        display_width: int,
+        display_height: int,
+        **kwargs: Any,
+    ) -> ComputerUsePreviewTool:
+        """Create a Computer Use tool configuration for Foundry.
+
+        Keyword Args:
+            environment: The computer environment to control. One of ``"windows"``,
+                ``"mac"``, ``"linux"``, ``"ubuntu"``, or ``"browser"``.
+            display_width: The width of the computer display.
+            display_height: The height of the computer display.
+            **kwargs: Additional arguments forwarded to the SDK ``ComputerUsePreviewTool``.
+
+        Returns:
+            A ``ComputerUsePreviewTool`` ready to pass to an Agent.
+        """
+        return ComputerUsePreviewTool(
+            environment=environment,
+            display_width=display_width,
+            display_height=display_height,
+            **kwargs,
+        )
+
+    @staticmethod
+    @experimental(feature_id=ExperimentalFeature.FOUNDRY_PREVIEW_TOOLS)
+    def get_browser_automation_tool(
+        *,
+        connection_id: str,
+        **kwargs: Any,
+    ) -> BrowserAutomationPreviewTool:
+        """Create a Browser Automation tool configuration for Foundry.
+
+        Keyword Args:
+            connection_id: The Foundry project connection ID for the Azure Playwright resource.
+            **kwargs: Additional arguments forwarded to the SDK
+                ``BrowserAutomationToolParameters``.
+
+        Returns:
+            A ``BrowserAutomationPreviewTool`` ready to pass to an Agent.
+        """
+        return BrowserAutomationPreviewTool(
+            browser_automation_preview=BrowserAutomationToolParameters(
+                connection=BrowserAutomationToolConnectionParameters(project_connection_id=connection_id),
+                **kwargs,
+            )
+        )
+
+    @staticmethod
+    @experimental(feature_id=ExperimentalFeature.FOUNDRY_PREVIEW_TOOLS)
+    def get_a2a_tool(
+        *,
+        base_url: str | None = None,
+        agent_card_path: str | None = None,
+        project_connection_id: str | None = None,
+        **kwargs: Any,
+    ) -> A2APreviewTool:
+        """Create an Agent-to-Agent (A2A) tool configuration for Foundry.
+
+        Keyword Args:
+            base_url: Base URL of the remote A2A agent.
+            agent_card_path: Path to the agent card relative to ``base_url``.
+                Defaults to ``"/.well-known/agent-card.json"`` server-side.
+            project_connection_id: Foundry connection ID for the A2A server. Stores
+                authentication and other connection details.
+            **kwargs: Additional arguments forwarded to the SDK ``A2APreviewTool``.
+
+        Returns:
+            An ``A2APreviewTool`` ready to pass to an Agent.
+        """
+        params: dict[str, Any] = dict(kwargs)
+        if base_url is not None:
+            params["base_url"] = base_url
+        if agent_card_path is not None:
+            params["agent_card_path"] = agent_card_path
+        if project_connection_id is not None:
+            params["project_connection_id"] = project_connection_id
+        return A2APreviewTool(**params)
+
+    # endregion
+
 
 class FoundryChatClient(  # type: ignore[misc]
     FunctionInvocationLayer[FoundryChatOptionsT],

python/packages/foundry/agent_framework_foundry/_foundry_evals.py

@@ -75,6 +75,15 @@ _TOOL_EVALUATORS: set[str] = {
     "builtin.tool_call_success",
 }
 
+# Evaluators that accept tool_definitions in their data mapping when the
+# evaluated items include tools.
+_TOOL_DEFINITION_EVALUATORS: set[str] = _TOOL_EVALUATORS | {
+    "builtin.intent_resolution",
+    "builtin.task_adherence",
+    "builtin.task_completion",
+    "builtin.task_navigation_efficiency",
+}
+
 # Evaluators that require a ground_truth / expected_output field.
 _GROUND_TRUTH_EVALUATORS: set[str] = {
     "builtin.similarity",
@@ -161,6 +170,7 @@ def _build_testing_criteria(
     model: str,
     *,
     include_data_mapping: bool = False,
+    include_tool_definitions: bool = False,
 ) -> list[dict[str, Any]]:
     """Build ``testing_criteria`` for ``evals.create()``.
 
@@ -169,6 +179,8 @@ def _build_testing_criteria(
         model: Model deployment for the LLM judge.
         include_data_mapping: Whether to include field-level data mapping
             (required for the JSONL data source, not needed for response-based).
+        include_tool_definitions: Whether the mapped data items include tool
+            definitions.
     """
     criteria: list[dict[str, Any]] = []
     for name in evaluators:
@@ -203,7 +215,7 @@ def _build_testing_criteria(
                 mapping["context"] = "{{item.context}}"
             if qualified in _GROUND_TRUTH_EVALUATORS:
                 mapping["ground_truth"] = "{{item.ground_truth}}"
-            if qualified in _TOOL_EVALUATORS:
+            if include_tool_definitions and qualified in _TOOL_DEFINITION_EVALUATORS:
                 mapping["tool_definitions"] = "{{item.tool_definitions}}"
             entry["data_mapping"] = mapping
 
@@ -713,6 +725,7 @@ class FoundryEvals:
                 evaluators,
                 self._model,
                 include_data_mapping=True,
+                include_tool_definitions=has_tools,
             ),
         )
 

python/packages/foundry/pyproject.toml

@@ -4,7 +4,7 @@ description = "Microsoft Foundry integrations for Microsoft Agent Framework."
 authors = [{ name = "Microsoft", email = "af-support@microsoft.com"}]
 readme = "README.md"
 requires-python = ">=3.10"
-version = "1.5.0"
+version = "1.6.0"
 license-files = ["LICENSE"]
 urls.homepage = "https://aka.ms/agent-framework"
 urls.source = "https://github.com/microsoft/agent-framework/tree/main/python"
@@ -23,8 +23,8 @@ classifiers = [
   "Typing :: Typed",
 ]
 dependencies = [
-    "agent-framework-core>=1.5.0,<2",
-    "agent-framework-openai>=1.5.0,<2",
+    "agent-framework-core>=1.6.0,<2",
+    "agent-framework-openai>=1.6.0,<2",
     "azure-ai-inference>=1.0.0b9,<1.0.0b10",
     "azure-ai-projects>=2.1.0,<3.0",
 ]

python/packages/foundry/tests/foundry/test_foundry_chat_client.py

@@ -5,6 +5,7 @@ from __future__ import annotations
 import inspect
 import os
 import sys
+import warnings
 from functools import wraps
 from pathlib import Path
 from typing import Annotated, Any
@@ -984,6 +985,25 @@ def test_get_web_search_tool_with_location() -> None:
     assert tool_obj is not None
 
 
+def test_get_web_search_tool_allowed_domains() -> None:
+    """allowed_domains is wrapped into the SDK filters field."""
+    with warnings.catch_warnings():
+        warnings.simplefilter("error")
+        tool_obj = RawFoundryChatClient.get_web_search_tool(allowed_domains=["example.com"])
+    assert tool_obj.filters is not None
+    assert tool_obj.filters.allowed_domains == ["example.com"]
+
+
+def test_get_web_search_tool_custom_search_configuration() -> None:
+    """custom_search_configuration is forwarded to the SDK without warning."""
+    with warnings.catch_warnings():
+        warnings.simplefilter("error")
+        tool_obj = RawFoundryChatClient.get_web_search_tool(
+            custom_search_configuration={"connection_id": "c", "instance_name": "i"},
+        )
+    assert tool_obj.custom_search_configuration == {"connection_id": "c", "instance_name": "i"}
+
+
 def test_get_image_generation_tool() -> None:
     """Test image generation tool creation."""
 
@@ -1012,6 +1032,223 @@ def test_get_mcp_tool_with_connection_id() -> None:
     assert tool_obj is not None
 
 
+def _skip_if_sdk_class_missing(name: str) -> Any:
+    """Return the SDK class or skip the test if older azure-ai-projects lacks it."""
+    from azure.ai.projects import models as projects_models
+
+    cls = getattr(projects_models, name, None)
+    if cls is None:
+        pytest.skip(f"azure-ai-projects in this environment does not expose {name!r}.")
+    return cls
+
+
+@pytest.mark.filterwarnings("ignore::FutureWarning")
+def test_get_azure_ai_search_tool() -> None:
+    """Azure AI Search tool factory builds the nested resource correctly."""
+    azure_ai_search_tool_cls = _skip_if_sdk_class_missing("AzureAISearchTool")
+
+    tool_obj = FoundryChatClient.get_azure_ai_search_tool(
+        index_connection_id="conn-1",
+        index_name="my-index",
+        query_type="vector_semantic_hybrid",
+        top_k=5,
+        filter="category eq 'docs'",
+    )
+    assert isinstance(tool_obj, azure_ai_search_tool_cls)
+    indexes = tool_obj.azure_ai_search.indexes
+    assert len(indexes) == 1
+    index = indexes[0]
+    assert index.project_connection_id == "conn-1"
+    assert index.index_name == "my-index"
+    assert index.query_type == "vector_semantic_hybrid"
+    assert index.top_k == 5
+    assert index.filter == "category eq 'docs'"
+
+
+@pytest.mark.filterwarnings("ignore::FutureWarning")
+def test_get_sharepoint_tool() -> None:
+    """SharePoint tool factory wires the connection through nested params."""
+    sharepoint_tool_cls = _skip_if_sdk_class_missing("SharepointPreviewTool")
+
+    tool_obj = FoundryChatClient.get_sharepoint_tool(connection_id="sp-conn")
+    assert isinstance(tool_obj, sharepoint_tool_cls)
+    connections = tool_obj.sharepoint_grounding_preview.project_connections
+    assert connections is not None
+    assert len(connections) == 1
+    assert connections[0].project_connection_id == "sp-conn"
+
+
+@pytest.mark.filterwarnings("ignore::FutureWarning")
+def test_get_fabric_tool() -> None:
+    """Fabric tool factory wires the connection through nested params."""
+    fabric_tool_cls = _skip_if_sdk_class_missing("MicrosoftFabricPreviewTool")
+
+    tool_obj = FoundryChatClient.get_fabric_tool(connection_id="fab-conn")
+    assert isinstance(tool_obj, fabric_tool_cls)
+    connections = tool_obj.fabric_dataagent_preview.project_connections
+    assert connections is not None
+    assert len(connections) == 1
+    assert connections[0].project_connection_id == "fab-conn"
+
+
+@pytest.mark.filterwarnings("ignore::FutureWarning")
+def test_get_memory_search_tool() -> None:
+    """Memory search tool factory passes core fields through."""
+    memory_tool_cls = _skip_if_sdk_class_missing("MemorySearchPreviewTool")
+
+    tool_obj = FoundryChatClient.get_memory_search_tool(
+        memory_store_name="store-1",
+        scope="{{$userId}}",
+        update_delay=600,
+    )
+    assert isinstance(tool_obj, memory_tool_cls)
+    assert tool_obj.memory_store_name == "store-1"
+    assert tool_obj.scope == "{{$userId}}"
+    assert tool_obj.update_delay == 600
+
+
+@pytest.mark.filterwarnings("ignore::FutureWarning")
+def test_get_computer_use_tool() -> None:
+    """Computer use tool factory passes environment + display dimensions."""
+    computer_use_cls = _skip_if_sdk_class_missing("ComputerUsePreviewTool")
+
+    tool_obj = FoundryChatClient.get_computer_use_tool(
+        environment="browser",
+        display_width=1920,
+        display_height=1080,
+    )
+    assert isinstance(tool_obj, computer_use_cls)
+    assert tool_obj.environment == "browser"
+    assert tool_obj.display_width == 1920
+    assert tool_obj.display_height == 1080
+
+
+@pytest.mark.filterwarnings("ignore::FutureWarning")
+def test_get_browser_automation_tool() -> None:
+    """Browser automation tool factory wraps the connection id in the params type."""
+    browser_tool_cls = _skip_if_sdk_class_missing("BrowserAutomationPreviewTool")
+
+    tool_obj = FoundryChatClient.get_browser_automation_tool(connection_id="playwright-conn")
+    assert isinstance(tool_obj, browser_tool_cls)
+    assert tool_obj.browser_automation_preview.connection.project_connection_id == "playwright-conn"
+
+
+@pytest.mark.filterwarnings("ignore::FutureWarning")
+def test_get_bing_custom_search_tool() -> None:
+    """Bing custom search tool factory builds the nested search configuration."""
+    bing_tool_cls = _skip_if_sdk_class_missing("BingCustomSearchPreviewTool")
+
+    tool_obj = FoundryChatClient.get_bing_custom_search_tool(
+        connection_id="bing-conn",
+        instance_name="my-custom-config",
+        market="en-US",
+        count=10,
+    )
+    assert isinstance(tool_obj, bing_tool_cls)
+    configs = tool_obj.bing_custom_search_preview.search_configurations
+    assert len(configs) == 1
+    config = configs[0]
+    assert config.project_connection_id == "bing-conn"
+    assert config.instance_name == "my-custom-config"
+    assert config.market == "en-US"
+    assert config.count == 10
+
+
+@pytest.mark.filterwarnings("ignore::FutureWarning")
+def test_get_bing_grounding_tool() -> None:
+    """Bing grounding tool factory builds the nested search configuration."""
+    bing_tool_cls = _skip_if_sdk_class_missing("BingGroundingTool")
+
+    tool_obj = FoundryChatClient.get_bing_grounding_tool(
+        connection_id="bing-conn",
+        market="en-US",
+        set_lang="en",
+        count=10,
+        freshness="Day",
+    )
+    assert isinstance(tool_obj, bing_tool_cls)
+    configs = tool_obj.bing_grounding.search_configurations
+    assert len(configs) == 1
+    config = configs[0]
+    assert config.project_connection_id == "bing-conn"
+    assert config.market == "en-US"
+    assert config.set_lang == "en"
+    assert config.count == 10
+    assert config.freshness == "Day"
+
+
+@pytest.mark.filterwarnings("ignore::FutureWarning")
+def test_get_a2a_tool() -> None:
+    """A2A tool factory carries base_url, agent_card_path, and project_connection_id."""
+    a2a_tool_cls = _skip_if_sdk_class_missing("A2APreviewTool")
+
+    tool_obj = FoundryChatClient.get_a2a_tool(
+        base_url="https://agent.example.com",
+        agent_card_path="/.well-known/agent-card.json",
+        project_connection_id="a2a-conn",
+    )
+    assert isinstance(tool_obj, a2a_tool_cls)
+    assert tool_obj.base_url == "https://agent.example.com"
+    assert tool_obj.agent_card_path == "/.well-known/agent-card.json"
+    assert tool_obj.project_connection_id == "a2a-conn"
+
+
+_FOUNDRY_TOOLS_FACTORY_CASES: list[tuple[str, str, dict[str, Any]]] = [
+    ("get_azure_ai_search_tool", "AzureAISearchTool", {"index_connection_id": "c", "index_name": "i"}),
+    (
+        "get_bing_grounding_tool",
+        "BingGroundingTool",
+        {"connection_id": "c"},
+    ),
+]
+
+_FOUNDRY_PREVIEW_TOOLS_FACTORY_CASES: list[tuple[str, str, dict[str, Any]]] = [
+    ("get_sharepoint_tool", "SharepointPreviewTool", {"connection_id": "c"}),
+    ("get_fabric_tool", "MicrosoftFabricPreviewTool", {"connection_id": "c"}),
+    (
+        "get_memory_search_tool",
+        "MemorySearchPreviewTool",
+        {"memory_store_name": "s", "scope": "u"},
+    ),
+    (
+        "get_computer_use_tool",
+        "ComputerUsePreviewTool",
+        {"environment": "browser", "display_width": 1, "display_height": 1},
+    ),
+    ("get_browser_automation_tool", "BrowserAutomationPreviewTool", {"connection_id": "c"}),
+    (
+        "get_bing_custom_search_tool",
+        "BingCustomSearchPreviewTool",
+        {"connection_id": "c", "instance_name": "i"},
+    ),
+    ("get_a2a_tool", "A2APreviewTool", {"base_url": "https://a.example.com"}),
+]
+
+
+@pytest.mark.filterwarnings("ignore::FutureWarning")
+@pytest.mark.parametrize("factory_name, sdk_class_name, kwargs", _FOUNDRY_TOOLS_FACTORY_CASES)
+def test_foundry_tools_factories_are_marked(factory_name: str, sdk_class_name: str, kwargs: dict[str, Any]) -> None:
+    """Factories wrapping GA Foundry tool SDK classes carry FOUNDRY_TOOLS metadata."""
+    _skip_if_sdk_class_missing(sdk_class_name)
+    factory = getattr(FoundryChatClient, factory_name)
+    assert getattr(factory, "__feature_stage__", None) == "experimental"
+    assert getattr(factory, "__feature_id__", None) == "FOUNDRY_TOOLS"
+    assert factory(**kwargs) is not None
+
+
+@pytest.mark.filterwarnings("ignore::FutureWarning")
+@pytest.mark.parametrize("factory_name, sdk_class_name, kwargs", _FOUNDRY_PREVIEW_TOOLS_FACTORY_CASES)
+def test_foundry_preview_tools_factories_are_marked(
+    factory_name: str, sdk_class_name: str, kwargs: dict[str, Any]
+) -> None:
+    """Factories wrapping preview Foundry tool SDK classes carry FOUNDRY_PREVIEW_TOOLS metadata."""
+    _skip_if_sdk_class_missing(sdk_class_name)
+    factory = getattr(FoundryChatClient, factory_name)
+    assert getattr(factory, "__feature_stage__", None) == "experimental"
+    assert getattr(factory, "__feature_id__", None) == "FOUNDRY_PREVIEW_TOOLS"
+    assert factory(**kwargs) is not None
+
+
 def test_parse_chunk_surfaces_oauth_consent_request() -> None:
     """An oauth_consent_request output item surfaces as Content with consent_link."""
 

python/packages/foundry/tests/test_foundry_evals.py

@@ -745,7 +745,12 @@ class TestBuildTestingCriteria:
         assert "conversation" not in criteria[1]["data_mapping"]
 
     def test_tool_evaluator_includes_tool_definitions(self) -> None:
-        criteria = _build_testing_criteria(["relevance", "tool_call_accuracy"], "gpt-4o", include_data_mapping=True)
+        criteria = _build_testing_criteria(
+            ["relevance", "tool_call_accuracy"],
+            "gpt-4o",
+            include_data_mapping=True,
+            include_tool_definitions=True,
+        )
         # relevance: string query/response
         assert criteria[0]["data_mapping"]["query"] == "{{item.query}}"
         assert criteria[0]["data_mapping"]["response"] == "{{item.response}}"
@@ -762,6 +767,17 @@ class TestBuildTestingCriteria:
             assert c["data_mapping"]["query"] == "{{item.query_messages}}", f"{c['name']}"
             assert c["data_mapping"]["response"] == "{{item.response_messages}}", f"{c['name']}"
 
+    def test_agent_evaluators_include_tool_definitions_when_tools_present(self) -> None:
+        agent_evals = ["task_adherence", "intent_resolution", "task_completion", "task_navigation_efficiency"]
+        criteria = _build_testing_criteria(
+            agent_evals,
+            "gpt-4o",
+            include_data_mapping=True,
+            include_tool_definitions=True,
+        )
+        for c in criteria:
+            assert c["data_mapping"]["tool_definitions"] == "{{item.tool_definitions}}", f"{c['name']}"
+
     def test_quality_evaluators_use_strings(self) -> None:
         quality_evals = ["coherence", "relevance", "fluency"]
         criteria = _build_testing_criteria(quality_evals, "gpt-4o", include_data_mapping=True)
@@ -781,7 +797,12 @@ class TestBuildTestingCriteria:
             "tool_output_utilization",
             "tool_call_success",
         ]
-        criteria = _build_testing_criteria(tool_evals, "gpt-4o", include_data_mapping=True)
+        criteria = _build_testing_criteria(
+            tool_evals,
+            "gpt-4o",
+            include_data_mapping=True,
+            include_tool_definitions=True,
+        )
         for c in criteria:
             assert "tool_definitions" in c["data_mapping"], f"{c['name']} missing tool_definitions"
 

python/packages/foundry_hosting/pyproject.toml

@@ -4,7 +4,7 @@ description = "Foundry Hosting integration for Microsoft Agent Framework."
 authors = [{ name = "Microsoft", email = "af-support@microsoft.com"}]
 readme = "README.md"
 requires-python = ">=3.10"
-version = "1.0.0a260519"
+version = "1.0.0a260521"
 license-files = ["LICENSE"]
 urls.homepage = "https://aka.ms/agent-framework"
 urls.source = "https://github.com/microsoft/agent-framework/tree/main/python"
@@ -23,7 +23,7 @@ classifiers = [
   "Typing :: Typed",
 ]
 dependencies = [
-    "agent-framework-core>=1.5.0,<2",
+    "agent-framework-core>=1.6.0,<2",
     "azure-ai-agentserver-core>=2.0.0b3,<3",
     "azure-ai-agentserver-responses>=1.0.0b5,<2",
     "azure-ai-agentserver-invocations>=1.0.0b3,<2",

python/packages/foundry_local/pyproject.toml

@@ -4,7 +4,7 @@ description = "Foundry Local integration for Microsoft Agent Framework."
 authors = [{ name = "Microsoft", email = "af-support@microsoft.com"}]
 readme = "README.md"
 requires-python = ">=3.10"
-version = "1.0.0b260519"
+version = "1.0.0b260521"
 license-files = ["LICENSE"]
 urls.homepage = "https://aka.ms/agent-framework"
 urls.source = "https://github.com/microsoft/agent-framework/tree/main/python"
@@ -23,8 +23,8 @@ classifiers = [
   "Typing :: Typed",
 ]
 dependencies = [
-    "agent-framework-core>=1.5.0,<2",
-    "agent-framework-openai>=1.5.0,<2",
+    "agent-framework-core>=1.6.0,<2",
+    "agent-framework-openai>=1.6.0,<2",
     "foundry-local-sdk>=0.5.1,<0.5.2",
 ]
 

python/packages/gemini/pyproject.toml

@@ -4,7 +4,7 @@ description = "Google Gemini integration for Microsoft Agent Framework."
 authors = [{ name = "Microsoft", email = "af-support@microsoft.com"}]
 readme = "README.md"
 requires-python = ">=3.10"
-version = "1.0.0a260519"
+version = "1.0.0a260521"
 license-files = ["LICENSE"]
 urls.homepage = "https://aka.ms/agent-framework"
 urls.source = "https://github.com/microsoft/agent-framework/tree/main/python"
@@ -24,7 +24,7 @@ classifiers = [
   "Typing :: Typed",
 ]
 dependencies = [
-    "agent-framework-core>=1.5.0,<2.0",
+    "agent-framework-core>=1.6.0,<2.0",
     "google-genai>=1.65.0,<2.0.0",
 ]
 

python/packages/github_copilot/pyproject.toml

@@ -4,7 +4,7 @@ description = "GitHub Copilot integration for Microsoft Agent Framework."
 authors = [{ name = "Microsoft", email = "af-support@microsoft.com"}]
 readme = "README.md"
 requires-python = ">=3.10"
-version = "1.0.0b260519"
+version = "1.0.0b260521"
 license-files = ["LICENSE"]
 urls.homepage = "https://aka.ms/agent-framework"
 urls.source = "https://github.com/microsoft/agent-framework/tree/main/python"
@@ -23,7 +23,7 @@ classifiers = [
   "Typing :: Typed",
 ]
 dependencies = [
-    "agent-framework-core>=1.5.0,<2",
+    "agent-framework-core>=1.6.0,<2",
     "github-copilot-sdk>=1.0.0b2,<=1.0.0b2; python_version >= '3.11'",
 ]
 

python/packages/hyperlight/pyproject.toml

@@ -4,7 +4,7 @@ description = "Hyperlight CodeAct integrations for Microsoft Agent Framework."
 authors = [{ name = "Microsoft", email = "af-support@microsoft.com"}]
 readme = "README.md"
 requires-python = ">=3.10"
-version = "1.0.0b260519"
+version = "1.0.0b260521"
 license-files = ["LICENSE"]
 urls.homepage = "https://aka.ms/agent-framework"
 urls.source = "https://github.com/microsoft/agent-framework/tree/main/python"
@@ -22,7 +22,7 @@ classifiers = [
   "Typing :: Typed",
 ]
 dependencies = [
-    "agent-framework-core>=1.5.0,<2",
+    "agent-framework-core>=1.6.0,<2",
     "hyperlight-sandbox>=0.4.0,<0.5",
     "hyperlight-sandbox-backend-wasm>=0.4.0,<0.5 ; ((sys_platform == 'linux' and platform_machine == 'x86_64') or (sys_platform == 'win32' and platform_machine == 'AMD64')) and python_version < '3.14'",
     "hyperlight-sandbox-python-guest>=0.4.0,<0.5",

python/packages/lab/pyproject.toml

@@ -4,7 +4,7 @@ description = "Experimental modules for Microsoft Agent Framework"
 authors = [{ name = "Microsoft", email = "af-support@microsoft.com"}]
 readme = "README.md"
 requires-python = ">=3.10"
-version = "1.0.0b260519"
+version = "1.0.0b260521"
 license-files = ["LICENSE"]
 urls.homepage = "https://aka.ms/agent-framework"
 urls.source = "https://github.com/microsoft/agent-framework/tree/main/python"
@@ -22,7 +22,7 @@ classifiers = [
   "Programming Language :: Python :: 3.14",
 ]
 dependencies = [
-  "agent-framework-core>=1.5.0,<2",
+  "agent-framework-core>=1.6.0,<2",
 ]
 
 [project.optional-dependencies]

python/packages/mem0/pyproject.toml

@@ -4,7 +4,7 @@ description = "Mem0 integration for Microsoft Agent Framework."
 authors = [{ name = "Microsoft", email = "af-support@microsoft.com"}]
 readme = "README.md"
 requires-python = ">=3.10"
-version = "1.0.0b260519"
+version = "1.0.0b260521"
 license-files = ["LICENSE"]
 urls.homepage = "https://aka.ms/agent-framework"
 urls.source = "https://github.com/microsoft/agent-framework/tree/main/python"
@@ -23,7 +23,7 @@ classifiers = [
   "Typing :: Typed",
 ]
 dependencies = [
-    "agent-framework-core>=1.5.0,<2",
+    "agent-framework-core>=1.6.0,<2",
     "mem0ai>=1.0.0,<2",
 ]
 

python/packages/monty/pyproject.toml

@@ -4,7 +4,7 @@ description = "Monty CodeAct integrations for Microsoft Agent Framework."
 authors = [{ name = "Microsoft", email = "af-support@microsoft.com"}]
 readme = "README.md"
 requires-python = ">=3.10"
-version = "1.0.0a260518"
+version = "1.0.0a260521"
 license-files = ["LICENSE"]
 urls.homepage = "https://aka.ms/agent-framework"
 urls.source = "https://github.com/microsoft/agent-framework/tree/main/python"
@@ -23,7 +23,7 @@ classifiers = [
   "Typing :: Typed",
 ]
 dependencies = [
-    "agent-framework-core>=1.4.0,<2",
+    "agent-framework-core>=1.6.0,<2",
     "pydantic-monty>=0,<0.1",
 ]
 

python/packages/ollama/pyproject.toml

@@ -4,7 +4,7 @@ description = "Ollama integration for Microsoft Agent Framework."
 authors = [{ name = "Microsoft", email = "af-support@microsoft.com"}]
 readme = "README.md"
 requires-python = ">=3.10"
-version = "1.0.0b260519"
+version = "1.0.0b260521"
 license-files = ["LICENSE"]
 urls.homepage = "https://learn.microsoft.com/en-us/agent-framework/"
 urls.source = "https://github.com/microsoft/agent-framework/tree/main/python"
@@ -23,7 +23,7 @@ classifiers = [
   "Typing :: Typed",
 ]
 dependencies = [
-    "agent-framework-core>=1.5.0,<2",
+    "agent-framework-core>=1.6.0,<2",
     "ollama>=0.5.3,<0.5.4",
 ]
 

python/packages/openai/pyproject.toml

@@ -4,7 +4,7 @@ description = "OpenAI integrations for Microsoft Agent Framework."
 authors = [{ name = "Microsoft", email = "af-support@microsoft.com"}]
 readme = "README.md"
 requires-python = ">=3.10"
-version = "1.5.0"
+version = "1.6.0"
 license-files = ["LICENSE"]
 urls.homepage = "https://aka.ms/agent-framework"
 urls.source = "https://github.com/microsoft/agent-framework/tree/main/python"
@@ -23,7 +23,7 @@ classifiers = [
   "Typing :: Typed",
 ]
 dependencies = [
-    "agent-framework-core>=1.5.0,<2",
+    "agent-framework-core>=1.6.0,<2",
     "openai>=1.99.0,<3",
 ]
 

python/packages/orchestrations/pyproject.toml

@@ -4,7 +4,7 @@ description = "Orchestration patterns for Microsoft Agent Framework. Includes Se
 authors = [{ name = "Microsoft", email = "af-support@microsoft.com"}]
 readme = "README.md"
 requires-python = ">=3.10"
-version = "1.0.0rc1"
+version = "1.0.0rc2"
 license-files = ["LICENSE"]
 urls.homepage = "https://aka.ms/agent-framework"
 urls.source = "https://github.com/microsoft/agent-framework/tree/main/python"
@@ -23,7 +23,7 @@ classifiers = [
   "Typing :: Typed",
 ]
 dependencies = [
-    "agent-framework-core>=1.5.0,<2",
+    "agent-framework-core>=1.6.0,<2",
 ]
 
 [tool.uv]