6 Commits

• .NET: Promote FoundryChatClient to public, add file/vector-store helpers and ToPromptAgentAsync converter (#5940)

  * Consolidate Foundry chat client decorators into FoundryChatClient
  
  - Replace AzureAIProjectChatClient and AzureAIProjectResponsesChatClient with a single internal sealed FoundryChatClient that covers three modes (pure responses, server-side agent reference, hosted agent endpoint).
  - Rename AzureAIProjectChatClientExtensions to AIProjectClientExtensions to reflect that it extends AIProjectClient.
  - All four AsAIAgent extension overloads and both FoundryAgent constructors now construct FoundryChatClient internally so the microsoft.foundry telemetry tag is uniform across paths.
  - Introduce AgentFrameworkUserAgentPolicy that stamps agent-framework-dotnet/{version} on outbound requests, mirroring the Python agent-framework-python/{version} contract.
  - Delete the Foundry-local MeaiUserAgentPolicy duplicate; rely on MEAI 10.5.1 to stamp MEAI/{version} automatically.
  - HostedAgentUserAgentPolicy keeps the combined foundry-hosting/agent-framework-dotnet/{version} segment (Python parity) and upgrades the bare segment in place to avoid duplication.
  - Tests reorganized: FoundryChatClientTests, AIProjectClientExtensionsTests, AgentFrameworkUserAgentPolicyTests, MeaiAutoUserAgentVerificationTests, plus in-place upgrade unit tests in HostedOutboundUserAgentTests.
  
  * Promote FoundryChatClient to public; add file/vector-store helpers and ToPromptAgentAsync converter
  
  - Promote FoundryChatClient from internal sealed to public sealed for Python parity, so .NET developers can hold and pass a FoundryChatClient directly the way Python developers do.
  - Mode 3 (hosted agent endpoint) now materializes an AIProjectClient from the parsed project root, making GetService<AIProjectClient>() non-null across all three construction modes. This eliminates the per-mode asymmetry that previously hid project-level helpers from agents constructed via an agent endpoint URL.
  - Add four new instance methods on FoundryChatClient mirroring Python's spec: UploadFileAsync, DeleteFileAsync, CreateVectorStoreAsync (bundles upload + create + wait), DeleteVectorStoreAsync. Single overload each, path-only inputs to start; additional overloads can be added later without breaking callers. All are Experimental, consistent with the rest of the Foundry package.
  - Add ToPromptAgentAsync extension methods on ChatClientAgent and FoundryAgent for the agent-to-prompt-agent converter described in the Foundry spec. Mode 1 (responses API) synthesizes a DeclarativeAgentDefinition from the agent's ChatOptions; mode 2 (server-side agent reference, version, or record) returns the cached or freshly fetched Definition; mode 3 throws InvalidOperationException because no local definition exists to convert.
  - Strict AITool to ResponseTool mapping for mode 1: AIFunction becomes CreateFunctionTool with the function's JSON schema; AITool instances that wrap a ResponseTool unwrap via GetService(typeof(ResponseTool)); anything else throws InvalidOperationException naming the offending tool type. Matches the Python spec's unsupported-tools-raise-ValueError contract.
  - New unit tests: FoundryChatClientVectorStoreTests (22 tests covering all four helpers across the three FoundryChatClient construction modes plus validation and cancellation), FoundryPromptAgentConverterTests (16 tests covering both extension entry points across mode 1 synthesis, mode 2 cached and fetched paths, all failure modes, and a Python-parity guard asserting both extensions produce equivalent definitions for equivalent inputs), plus four new tests in FoundryChatClientTests for the mode 3 AIProjectClient materialization.
  
  * Stop building duplicate ProjectOpenAIClient in FoundryAgent agent-endpoint ctor
  
  After Plan #2's mode-3 AIProjectClient materialization, the inner FoundryChatClient already exposes a project-level AIProjectClient (via GetService) that internally provides the project-level ProjectOpenAIClient via GetProjectOpenAIClient(). FoundryAgent's agent-endpoint constructor was still independently constructing a second project-level ProjectOpenAIClient via the now-redundant CreateProjectLevelOpenAIClientFromAgentEndpoint helper — two handles to the same logical resource.
  
  Refactor: the agent-endpoint constructor now reads the inner FoundryChatClient's materialized AIProjectClient via base.GetService(typeof(AIProjectClient)) and derives the project-level ProjectOpenAIClient from it. The dead helper on both FoundryAgent (private static wrapper) and FoundryChatClient (the actual implementation) is removed. The user-supplied per-agent ClientPipelineOptions primitives (Transport, RetryPolicy, NetworkTimeout, UserAgentApplicationId) are propagated into the materialized AIProjectClientOptions so test-injected transports and explicit retry / timeout / user-agent settings reach the project-level pipeline — preserving the behavior the dead helper used to provide.
  
  Updated AgentEndpointConstructor_GetServiceAIProjectClient_ReturnsNull to its now-correct counterpart AgentEndpointConstructor_GetServiceAIProjectClient_ReturnsNonNull, since after Plan #2 the agent-endpoint ctor surfaces a non-null AIProjectClient (per user direction in Plan #2 Q2).
  
  * Strip duplicated AIProjectClient/ProjectOpenAIClient state from FoundryAgent
  
  Both _aiProjectClient and _projectOpenAIClient fields on FoundryAgent were redundant:
  
  - _aiProjectClient: FoundryAgent's GetService<AIProjectClient> override returned this field, but DelegatingAIAgent.GetService → ChatClientAgent.GetService → FoundryChatClient.GetService<AIProjectClient> already returns the same instance through the delegating chain. Field + override are pure duplication.
  
  - _projectOpenAIClient: only used by FoundryAgent's own GetService<ProjectOpenAIClient> override and by CreateConversationSessionAsync. Per user direction, ProjectOpenAIClient is no longer exposed via GetService on either FoundryChatClient or FoundryAgent — callers retrieve it from the AIProjectClient themselves (aiProjectClient.GetProjectOpenAIClient()) the same way the framework does internally. This eliminates the mode-3 asymmetry where the chat client's stored ProjectOpenAIClient was per-agent (URL /agents/{name}/endpoint/protocols/openai) while the agent's was project-level.
  
  Refactor:
  - Delete both fields on FoundryAgent and the GetService override.
  - Delete the ProjectOpenAIClient branch from FoundryChatClient.GetService.
  - CreateConversationSessionAsync now resolves AIProjectClient at call time via this.GetService<AIProjectClient>() and derives the conversations client from it.
  - Update FoundryChatClient tests that asserted on GetService<ProjectOpenAIClient> to assert Null (deliberate removal).
  - Update FoundryAgent tests AgentEndpointConstructor_GetServiceProjectOpenAIClient_ReturnsNonNull and ProjectEndpointConstructor_GetServiceProjectOpenAIClient_ReturnsNonNull to ...ReturnsNull, and rewrite AgentEndpointConstructor_PropagatesUserAgentApplicationId_ToProjectLevelClient to look up AIProjectClient instead.
  
  No production code (only tests) referenced GetService<ProjectOpenAIClient>, so this is a safe surface reduction. Net: 30 insertions, 61 deletions; FoundryAgent shrinks to a pure delegator with only the two convenience methods (CreateSessionAsync, CreateConversationSessionAsync) on top of the delegating chain.
  
  * Rename FoundryChatClient.HostedAgentName to AgentName and populate it for mode 2
  
  The previous name implied a mode 3 only property tied to the hosted-agent endpoint URL. Today only hosted endpoints surface this name, but conceptually an agent name exists for every server-side agent the client talks to. Renaming to AgentName makes the property general-purpose and ready for future modes where the same chat client may target other server-side agent shapes that are not necessarily 'hosted'.
  
  Mode 2 (server-side agent reference) now mirrors AgentReference.Name into AgentName so callers have a uniform handle regardless of construction mode:
  
  * Mode 1 (pure responses): AgentName is null. There is no agent.
  * Mode 2 (AgentReference): AgentName == AgentReference.Name.
  * Mode 3 (agent endpoint URL): AgentName is parsed from the URL segment as before.
  
  Converter discriminator update: FoundryPromptAgentConverter previously used 'HostedAgentName is not null' to detect mode 3 and reject it. Now that mode 2 also populates AgentName, the mode 3 guard moves to the end of the resolution chain and uses the unambiguous 'AgentName is set AND no AgentReference exists' test. The user-visible error message and behavior are preserved.
  
  Dead-state cleanup spotted during format verify:
  
  * IDE0052 surfaced that FoundryChatClient._projectOpenAIClient is never read since the prior refactor stopped exposing ProjectOpenAIClient via GetService and rewired CreateConversationSessionAsync to resolve the AIProjectClient through the delegating chain. The field is deleted and its three ctor assignments removed.
  * HostedAgentEndpointInner.PerAgentClient only existed to plumb the per-agent ProjectOpenAIClient into that now-deleted field, so the property and its ctor parameter are removed. The local 'perAgentClient' variable inside BuildHostedAgentEndpointInner is still needed to derive the inner IChatClient, but no longer escapes the helper.
  
  Tests:
  
  * Mode1_PureResponses_ReturnsNullForAgentSpecificServices now also asserts AgentName is null.
  * New Mode2_AgentReference_PopulatesAgentNameFromAgentReference asserts the mode 2 mirror.
  * Mode3_HostedAgentEndpoint_ParsesAgentNameFromUrl renamed assertion target HostedAgentName to AgentName.
  
  Verification: 335/335 net10.0, 273/273 net472 Foundry unit; 229/229 Foundry.Hosting unit; format-verify (WSL2 + Docker mcr.microsoft.com/dotnet/sdk:10.0) clean on Microsoft.Agents.AI.Foundry.
  
  * Adopt canonical mode names: Responses Agent, Prompt Agent, Agent Endpoint
  
  Three FoundryChatClient construction modes now have one canonical noun used everywhere.
  
  * Responses Agent (Mode 1): inline ChatClientAgent, project-level Responses API, no server-side def.
  * Prompt Agent (Mode 2): server-side ProjectsAgentDefinition invoked by AgentReference.
  * Agent Endpoint (Mode 3): per-agent URL /agents/{name}/endpoint/protocols/openai. Hosted-or-not.
  
  'Hosted' stays the kind of agent (Microsoft.Agents.AI.Foundry.Hosting). Not synonym of Mode 3.
  
  Rings:
  1. XML docs + error messages use canonical names. en-GB to en-US: centralises, synthesise.
  2. HostedAgentEndpointInner -> AgentEndpointInner, BuildHostedAgentEndpointInner -> BuildAgentEndpointInner.
  3. Tests: Mode1_PureResponses_* -> Mode1_ResponsesAgent_*, Mode2_AgentReference_* -> Mode2_PromptAgent_*, Mode3_HostedAgentEndpoint_* -> Mode3_AgentEndpoint_*.
  
  Pure rename. No behavior change. 335/335 net10 + 273/273 net472 unit, format clean.
  
  * Address PR #5940 design feedback (Q-A through Q-F)
  
  Q-A: poll vector store til status leaves InProgress before return. Exp backoff 250ms-2s. Honor cancel.
  Q-B: try/catch upload loop. Mid-fail = best-effort DeleteFileAsync on already-uploaded ids. Swallow cleanup errors.
  Q-C: pinned AgentReference.Version uses GetAgentVersionAsync. Empty/whitespace/'latest' = GetLatest path.
  Q-D: HostedAgentUserAgentPolicy detects existing combined 'foundry-hosting/...' segment. No double prefix.
  Q-E: mode-3 vector-store test uses fake transport. No DNS to example.com.
  Q-F: no shim. Class always [Experimental] (since 8015e00f5, before dotnet-1.0.0). No compat contract. Callers rename to AIProjectClientExtensions.
  
  Rebase onto origin/main reconciliation: aad20c2b3 added public AsAIAgent(this AIProjectClient, Uri agentEndpoint, ...) extension that calls an internal FoundryAgent(AIProjectClient, Uri, ...) ctor. Reintroduced that ctor + a new FoundryChatClient(AIProjectClient, Uri, ProjectOpenAIClientOptions?) overload that reuses the supplied AIProjectClient's pipeline (via GetProjectResponsesClientForAgentEndpoint) instead of stamping a fresh credential.
  
  Verified: 346/346 net10 + 284/284 net472 Foundry unit, 230/230 Foundry.Hosting unit, format clean.
  
  * Add FoundryAgent helper extensions: UploadFile/DeleteFile/CreateVectorStore/DeleteVectorStore
  
  4 thin forwarders on FoundryAgent that route to the inner FoundryChatClient's helpers via agent.GetService<FoundryChatClient>().X(). Live in existing FoundryAgentExtensions.cs alongside ToPromptAgentAsync.
  
  Throws InvalidOperationException when agent does not expose a FoundryChatClient via GetService (same pattern as ToPromptAgentAsync).
  
  Unit tests: FoundryAgentExtensionsTests covers all 4 forwarders + null-agent ArgumentNullException for each. 8 new tests, 354/354 net10 + 292/292 net472.
  
  Integration tests: parallel FoundryAgentExtensionsTests under Foundry.IntegrationTests mirrors the existing CreateAgent_CreatesAgentWithVectorStoresAsync shape (upload -> create vector store -> FileSearch tool answers question -> cleanup), but routes every helper call through the new FoundryAgent extensions. 4 new IT tests, all verified pass live against the real Foundry project (12-30s each). Skipped by default like the existing vector-store IT.
  
  * Address Sergey's PR review comments
  
  #1 (FoundryAgent.cs:139): drop unused aiProjectClient param from internal FoundryAgent(AIProjectClient, ChatClientAgent) ctor. Was discarded after null-check. Inner FoundryChatClient already surfaces AIProjectClient via GetService. 3 call sites in AIProjectClientExtensions updated.
  
  #2 (FoundryChatClient.cs:376): add pollingTimeout param to CreateVectorStoreAsync. Defaults to 5 min, configurable, Timeout.InfiniteTimeSpan disables. Throws TimeoutException with vector store id and elapsed seconds when bound exceeded. CancellationToken still wins. New unit test PollingTimeout_ThrowsTimeoutExceptionAsync. FoundryAgentExtensions forwarder updated to plumb the new param.
  
  Verified: 355/355 net10 + 293/293 net472 Foundry unit, 230/230 Foundry.Hosting unit, format clean.

  Roger Barreto · 2026-05-21 10:05:58 +00:00
  a12cc3878e
• .NET: Bump Azure.AI.Projects to 2.1.0-beta.2 and add agent-endpoint AsAIAgent path (#5899)

  * .NET: Bump Azure.AI.Projects to 2.1.0-beta.2 and add agent-endpoint AsAIAgent path
  
  Bumps Azure.AI.Projects to 2.1.0-beta.2 with the matching transitive pins (Azure.Core 1.55.0, System.ClientModel 1.11.0).
  
  Foundry agent endpoint plumbing:
  * FoundryAgent now routes the agent-endpoint constructor through the new GetProjectResponsesClientForAgentEndpoint helper.
  * Adds an internal FoundryAgent ctor that takes an existing AIProjectClient plus a parsed agent endpoint so the public extension does not need to construct a second project client.
  * Adds public AIProjectClient.AsAIAgent(Uri agentEndpoint, ...) extension. This is the path consumer samples are expected to use for hosted agents because version selection happens server-side.
  * Trims the dangling "If you want to construct a FoundryAgent against a project endpoint..." sentence from ParseAgentEndpoint.
  
  Unit tests:
  * Four new tests in AzureAIProjectChatClientExtensionsTests cover the AIProjectClient.AsAIAgent(Uri agentEndpoint, ...) overload. 263/263 pass.
  
  Consumer samples (Using-Samples):
  * SimpleAgent and SessionFilesClient now read AZURE_AI_PROJECT_ENDPOINT and AZURE_AI_AGENT_NAME (both required, throw on missing), derive the agent endpoint with new Uri($"{projectEndpoint}/agents/{agentName}/endpoint/protocols/openai"), then call aiProjectClient.AsAIAgent(agentEndpoint, ...).
  * SessionFilesClient README updated.
  
  Contributor samples (responses/*):
  * New HostedContributorRouteExtensions.MapDevTemporaryLocalAgentEndpoint() wildcard route extension so localhost contributor servers accept the per-agent OpenAI endpoint shape the production Hosted runtime exposes.
  * All 11 contributor Program.cs files call MapDevTemporaryLocalAgentEndpoint() with a contributor-only warning comment.
  * Hosted-Files and Hosted-AzureSearchRag were importing Hosted_Shared_Contributor_Setup but never calling AddDevTemporaryLocalContributorSetup(). Both now call it so HostedSessionIsolationKeyProvider resolves correctly in dev.
  * Hosted-AzureSearchRag, Hosted-Files, Hosted-MemoryAgent csprojs drop stale VersionOverride="2.1.0-beta.1" pins.
  * Hosted-AzureSearchRag and Hosted-Files csprojs add ProjectReference to Hosted_Shared_Contributor_Setup.
  * Hosted-Observability/.dockerignore removed the out/ exclusion that was blocking COPY out/ . in Dockerfile.contributor.
  
  Verified:
  * Full solution-scoped build of changed projects: green.
  * Scoped CI-parity dotnet format via WSL2 + Docker (mcr.microsoft.com/dotnet/sdk:10.0) over every changed csproj: clean.
  * Foundry unit tests: 263/263.
  * Contributor docker smoke for 8 hosted samples (publish + docker build + docker run + curl POST to the wildcard route): HTTP 200 / 500 with route matched.
  * End-to-end smoke against the real Azure Foundry project with a fresh bearer token: Hosted-Files contributor container served HTTP 200, the agent invoked ListBundledFiles, and returned the expected file name.
  
  * Address PR review: forward pipeline settings; add UTs
  
  - CreateProjectClientOptions also carries RetryPolicy, NetworkTimeout, ClientLoggingOptions, MessageLoggingPolicy (was Transport+UserAgentApplicationId only).
  
  - Make CreateProjectClientOptions internal so tests can verify the copy directly.
  
  - Add AsAIAgent(Uri) UTs covering tools forwarding to inner ChatOptions and null tools handling.
  
  - Add CreateProjectClientOptions UTs covering null caller and full pipeline-settings copy.

  Roger Barreto · 2026-05-18 20:20:56 +00:00
  aad20c2b33
• .NET: Update FoundryAgent to address HostedAgents strict URL routing (#5677)

  * .NET: Foundry agent-endpoint constructor uses ProjectOpenAIClient directly to fix hosted-agent URL routing
  
  Fixes the experimental FoundryAgent(Uri agentEndpoint, AuthenticationTokenProvider, ...)
  constructor so it actually works against Foundry hosted agents.
  
  The previous implementation routed through AzureAIProjectChatClient, which
  internally called aiProjectClient.GetProjectOpenAIClient().GetProjectResponsesClientForAgent(...).
  For an agent-endpoint URL of the canonical shape
  
    https://<host>/api/projects/<project>/agents/<agentName>/endpoint/protocols/openai
  
  the chain produced
  
    POST https://<host>/api/projects/<project>/openai/v1/responses
  
  (project-level path, no /agents/ segment). The Foundry service rejects this with
  HTTP 400 "Hosted agents can only be called through the agent endpoint:
  .../agents/<agentName>/endpoint/protocols/openai/responses".
  
  The constructor also extracted the agent name via
  agentEndpoint.Segments[^1].TrimEnd('/'), which returns "openai" (the last segment),
  not the agent name.
  
  What changed
  - Public ctor signature: clientOptions parameter type changed from
    AIProjectClientOptions? to ProjectOpenAIClientOptions?. The constructor is
    fundamentally building a ProjectOpenAIClient; accepting AIProjectClientOptions
    was a leaky abstraction whose translation silently dropped any pipeline
    policies the caller added via AddPolicy(...). With the direct type, caller
    policies pass through to the per-agent traffic verbatim.
  - Per-agent client construction: `new ProjectOpenAIClient(BearerTokenPolicy, ProjectOpenAIClientOptions)`
    with Endpoint and AgentName set, then `GetProjectResponsesClient().AsIChatClient()`.
    The SDK auto-appends ?api-version=v1 when AgentName is set.
  - New private static ParseAgentEndpoint helper: single source of truth for both
    agent-name extraction and project-root derivation. Tolerates trailing slash,
    case variants on /agents/ and the suffix segment, strips query/fragment, and
    throws ArgumentException with paramName=nameof(agentEndpoint) for malformed input.
  - Project-level client (used by CreateConversationSessionAsync) is built fresh
    from the derived project root with primitive properties copied
    (RetryPolicy/NetworkTimeout/Transport/UserAgentApplicationId) plus MEAI UA.
  - New GetService<ProjectOpenAIClient>() entry alongside the existing
    GetService<AIProjectClient>() (the latter returns null in agent-endpoint mode
    since no AIProjectClient is constructed on that path).
  - Endpoint and AgentName on caller-supplied ProjectOpenAIClientOptions are
    overridden by values derived from agentEndpoint.
  
  Compatibility
  - FoundryAgent is [Experimental(OPENAI001)]. No GA surface touched. The Foundry
    project does not maintain PublicAPI.*.txt baselines so there is no shipped
    baseline to update.
  - The Microsoft.Agents.AI.Foundry csproj pins
    Azure.AI.Projects to VersionOverride 2.1.0-beta.1 (matching what the IT and
    hosting projects already use); the central pin in Directory.Packages.props
    stays at 2.0.0.
  - WireClientHeaders from PR #5652 is invoked on the agent-endpoint path so
    per-call x-client-* headers behave identically across both ctors.
  
  Tests
  - 23 new unit tests in FoundryAgentTests.cs:
    - 12 for the agent-endpoint constructor (URL routing for non-streaming and
      streaming, conversations URL shape, MEAI UA stamping, caller-policy
      passthrough on the per-agent pipeline, Endpoint/AgentName override
      semantics, GetService matrix, ProjectOpenAIClient propagation,
      UserAgentApplicationId propagation, null-arg validation, ID/Name slug)
    - 9 for ParseAgentEndpoint (standard shape, trailing slash, casing,
      sovereign-cloud host without /api/projects/ literal prefix, special chars
      in agent name, query/fragment stripping, three negative cases)
    - 2 null-arg tests for the public ctor
  - All 250 Microsoft.Agents.AI.Foundry.UnitTests pass (was 221 baseline plus
    29 from PR #5652 plus 23 new in this PR equals 273; pre-existing tests
    collapsed by the rebase merge keep the total at 250).
  - All 225 Microsoft.Agents.AI.Foundry.Hosting.UnitTests pass; no behavioral
    change to the hosting layer.
  - dotnet build clean across net8/9/10/netstandard2.0/net472 with
    TreatWarningsAsErrors=true.
  - dotnet format --verify-no-changes clean for the touched src and test projects.
  
  * .NET: Bump central Azure.AI.Projects pin to 2.1.0-beta.1 and flip Microsoft.Agents.AI.Foundry to preview
  
  Required to fix the NU1109 downgrade chain that broke CI on the agent-endpoint
  constructor rewire (#5677). Microsoft.Agents.AI.Foundry now depends on
  ProjectOpenAIClientOptions.AgentName and the (AuthenticationPolicy, options)
  constructor that only exist in Azure.AI.Projects 2.1.0-beta.1.
  
  Changes:
  * Directory.Packages.props: Azure.AI.Projects 2.0.0 -> 2.1.0-beta.1.
  * Microsoft.Agents.AI.Foundry.csproj: drop IsReleased=true so the package ships
    as preview (matches the beta SDK we now depend on). Add a comment noting the
    flip is temporary and should revert once Azure.AI.Projects ships a stable
    2.1.0.
  * Drop redundant VersionOverride="2.1.0-beta.1" from the 10 csprojs that had it
    as a workaround; the central pin now suffices.
  
  Verified:
  * dotnet build agent-framework-dotnet.slnx --warnaserror clean across all TFMs.
  * Microsoft.Agents.AI.Foundry.UnitTests 250/250 pass.
  * Microsoft.Agents.AI.Foundry.Hosting.UnitTests 211/211 pass.
  * dotnet format --verify-no-changes clean for the touched src and test projects.

  Roger Barreto · 2026-05-08 14:46:52 +00:00
  eb709d8fc9
• .NET: Bump MEAI to 10.5.1 and add Foundry per-call x-client header support (#5652)

  * Bump MEAI to 10.5.1 and add per-call x-client header support
  
  Replaces the brittle UserAgentResponsesClient subclass with a clean
  per-call x-client-* header pipeline built on the new Microsoft.Extensions.AI
  10.5.1 OpenAIRequestPolicies hook.
  
  Public surface (Microsoft.Agents.AI.Foundry, [Experimental(MAAI001)]):
  * chatOptions.WithClientHeader(name, value) and .WithClientHeaders(IEnumerable)
    validate the x-client- prefix (case-insensitive), apply all-or-nothing on
    bulk, and throw InvalidOperationException on foreign-typed slot collision
  * myAgent.AsBuilder().UseClientHeaders().Build() opts a customer-built agent
    into the pipeline; idempotent via agent.GetService<ClientHeadersAgent>()
  * Foundry-built agents (FoundryAgent.Create*) pre-wire automatically
  
  Internals:
  * ClientHeadersAgent decorator snapshots the dict at scope-push time so
    concurrent runs sharing a ChatOptions reference do not leak headers
  * ClientHeadersScope is an AsyncLocal<IReadOnlyDictionary<string,string>?>
    with LIFO push/dispose semantics
  * ClientHeadersPolicy singleton stamps headers via Headers.Set so per-call
    values overwrite any same-name header from earlier policies and so
    duplicate registration is value-stable
  * OpenAIRequestPoliciesReflection dedups against MEAI's private _entries
    field and falls back to AddPolicy on any reflection failure; a CI test
    asserts the field shape on every MEAI bump
  
  Hosting cleanup:
  * Deleted UserAgentResponsesClient and its dummy throwing pipeline
  * HostedAgentUserAgentPolicy is now registered via OpenAIRequestPolicies
    in FoundryHostingExtensions.TryApplyUserAgent
  
  Tests:
  * 19 new unit tests in ClientHeadersExtensionsTests.cs covering validation,
    AsyncLocal isolation, snapshot semantics, end-to-end wire stamping, and
    shared-chat-client dedup
  * Updated OpenTelemetryAgentTests for MEAI 10.5.1 changes to web_search
    serialization and the reduced tool definition payload when sensitive
    data capture is disabled
  
  Microsoft.Extensions.Compliance.Abstractions stays at 10.5.0 because no
  10.5.1 release exists on nuget.org.
  
  * Address PR review: pre-wire AsAIAgent path and dedup TryApplyUserAgent
  
  * FoundryAgent: extract WireClientHeaders helper and call it from the
    internal (AIProjectClient, ChatClientAgent) constructor used by
    AzureAIProjectChatClientExtensions.AsAIAgent so those Foundry-built
    agents also pre-wire the x-client header pipeline.
  * Foundry.Hosting TryApplyUserAgent: dedup HostedAgentUserAgentPolicy
    registration per OpenAIRequestPolicies instance via
    ConditionalWeakTable so per-request resolution does not grow the
    policy list unboundedly on singleton agents.
  
  * Add tests covering AsAIAgent pre-wire and TryApplyUserAgent dedup
  
  Backs the PR review fixes from a4c8f91 with regression tests:
  * ClientHeadersExtensionsTests: AsAIAgent_FoundryAgent_HasPreWiredClientHeadersAgent
    asserts the FoundryAgent built via AzureAIProjectChatClientExtensions.AsAIAgent
    contains a ClientHeadersAgent in its delegating chain (catches future
    regressions of the bypass).
  * ClientHeadersExtensionsTests: FoundryAgent_PublicConstructor_HasPreWiredClientHeadersAgent
    covers the public constructor path the same way.
  * ClientHeadersExtensionsTests: UseClientHeaders_RepeatedRegistrations_OnSameChatClient_OnlyRegistersOnce
    invokes UseClientHeaders 25 times on a shared chat client and asserts via
    reflection that OpenAIRequestPolicies._entries length is exactly 1.
  * HostedTryApplyUserAgentDedupTests: two tests asserting
    FoundryHostingExtensions.TryApplyUserAgent stays at one entry per
    OpenAIRequestPolicies instance after 50 calls on the same agent and across
    distinct agents on different chat clients.
  
  * Move tests next to their SUT
  
  Removes the dedicated HostedTryApplyUserAgentDedupTests.cs test class.
  Tests are co-located with the SUT they exercise:
  
  * FoundryAgentTests.cs gains the Constructor_PreWiresClientHeadersAgent
    and Constructor_FromAsAIAgentExtension_PreWiresClientHeadersAgent
    cases, since FoundryAgent is the SUT for the pre-wire behavior.
  * HostedOutboundUserAgentTests.cs gains the two TryApplyUserAgent dedup
    cases, since FoundryHostingExtensions.TryApplyUserAgent is the SUT
    it already covers.
  * ClientHeadersExtensionsTests.cs keeps only the
    UseClientHeaders_RepeatedRegistrations_OnSameChatClient_OnlyRegistersOnce
    case, which exercises the public ClientHeadersExtensions surface.
  
  * Remove redundant WithCancellation on inner streaming call
  
  ct is already passed to InnerAgent.RunStreamingAsync, so
  .WithCancellation(ct) on the resulting IAsyncEnumerable is a no-op.
  Caught by Sergey on PR review.
  
  * Address PR review: surface downstream MEAI experimental ID
  
  * Add AIOpenAIRequestPolicies = MEAIExperiments alias to
    DiagnosticIds.Experiments (matches the existing AIResponseContinuations,
    AIMcpServers, AIFunctionApprovals pattern).
  * Mark public ClientHeadersExtensions with [Experimental(AIOpenAIRequestPolicies)]
    instead of AgentsAIExperiments. Consumers now see the MEAI001 warning,
    surfacing the dependency on MEAI's experimental OpenAIRequestPolicies hook.
  * Mark internal OpenAIRequestPoliciesReflection with the same alias to
    suppress warnings at the source rather than via project-wide NoWarn.
  * Remove MEAI001 from Foundry csproj NoWarn (kept on Foundry.Hosting where
    pre-PR usages remain).
  * Clarify ClientHeadersScope XML doc: AsyncLocal flows values forward but
    does NOT auto-restore on method return; explicit using/Dispose is what
    gives stack-style LIFO semantics.

  Roger Barreto · 2026-05-06 14:43:08 +00:00
  b12109b7e4
• Add CreateSessionAsync(conversationId) to FoundryAgent (#5144)

  Adds a public CreateSessionAsync(string conversationId, CancellationToken)
  method to FoundryAgent that delegates to the inner ChatClientAgent,
  allowing users to create sessions with existing server-side conversation IDs.
  
  Fixes #5138

  Roger Barreto · 2026-04-07 12:56:07 +00:00
  4134c74060
• .NET: Rename Microsoft.Agents.AI.AzureAI to Microsoft.Agents.AI.Foundry and consolidate FoundryMemory (#5042)

  * Update Foundry Responses as ChatClientAgent
  
  * Migrate obsolete AzureAI integration tests to versioned agent pattern
  
  Replace obsolete CreateAIAgentAsync/GetAIAgentAsync calls with
  Agents.CreateAgentVersionAsync() + AsAIAgent(AgentVersion) in all
  AzureAI integration tests.
  
  - Rename AIProjectClient* test files to FoundryVersionedAgent*
  - Register AIFunction tools in PromptAgentDefinition.Tools for
    server-side visibility via AsOpenAIResponseTool()
  - Skip structured output tests (AzureAIProjectChatClient clears
    ResponseFormat for versioned agents)
  - Remove all [Obsolete] attributes and #pragma warning disable CS0618
  
  * Merge FoundryMemory package into AzureAI under Memory/ folder
  
  Move all FoundryMemory source, unit tests, and integration tests into
  the Microsoft.Agents.AI.AzureAI package. Change namespace from
  Microsoft.Agents.AI.FoundryMemory to Microsoft.Agents.AI.AzureAI.
  
  - Add [Experimental] to FoundryMemoryProviderOptions and Scope
  - Rename internal AIProjectClientExtensions to MemoryStoreExtensions
  - Update AzureAI .csproj with Compliance.Abstractions, Redaction
  - Remove FoundryMemory from solution and release filter
  - Update sample to reference AzureAI instead of FoundryMemory
  - Delete old Microsoft.Agents.AI.FoundryMemory project and tests
  
  * Add EnsureMemoryStoreCreatedAsync and memory existence checks to integration tests
  
  - Ensure memory store is created before testing memory operations
  - Add AZURE_AI_EMBEDDING_DEPLOYMENT_NAME config setting
  - Assert memories exist in store via SearchMemoriesAsync before cleanup
  - Verify scope isolation with direct memory store queries
  
  * Fix and rename AzureAI unit tests for RAPI vs Versioned clarity
  
  - Rename AsAIAgentAsync_* to AsAIAgent_* (drop Async from method group)
  - Add _Rapi_ prefix to non-versioned (Responses API) tests
  - Add _Versioned_ prefix to versioned agent tests where needed
  - Fix RAPI tests: assert GetService<AIProjectClient>() is null
  - Fix Versioned tests: assert IsType<FoundryAgent> and
    GetService<AIProjectClient>() returns the client instance
  - Fix UserAgent header tests: proper HTTP handler routing
  - Fix ChatClient_UsesDefaultConversationIdAsync test setup
  - All 153 unit tests pass with 0 failures
  
  * Rename Microsoft.Agents.AI.AzureAI to Microsoft.Agents.AI.Foundry
  
  Rename the project, namespace, folder, and all references from
  Microsoft.Agents.AI.AzureAI to Microsoft.Agents.AI.Foundry.
  Also rename Workflows.Declarative.AzureAI to .Foundry.
  
  - Rename src, unit test, integration test, and workflow folders
  - Update namespaces in all source and test .cs files
  - Update ProjectReferences in ~47 sample and test .csproj files
  - Update solution files (.slnx, .slnf)
  - Update sample using statements
  - Update READMEs, SKILL.md, ADRs in docs/
  - Disable package validation baseline for renamed packages
  - Fix UTF-8 BOM encoding on all affected .cs files
  - AzureAI.Persistent left completely unchanged
  
  * Fix format: remove ImplicitUsings, add explicit usings, fix BOM encoding
  
  - Remove ImplicitUsings=enable from Foundry csproj to resolve IDE0005
    on shared ReplacingRedactor.cs
  - Add explicit System usings to all source files that relied on them
  - Sort usings alphabetically per editorconfig rules
  - Fix UTF-8 BOM on 12 sample Program.cs files
  - Rename Azure AI Foundry Agents to Microsoft Foundry Agents in docs

  Roger Barreto · 2026-04-02 01:25:24 +00:00
  628bb1af48