Add OpenAI Responses API client to C# SDK

Implements `OpenAIResponsesClient` for the OpenAI Responses API surface in the C# SDK, mirroring the Python (#670) and JS (#671) SDKs and incorporating their resolved review feedback up front.

- New `Microsoft.AI.Foundry.Local.OpenAI.OpenAIResponsesClient` (HTTP-only, `HttpClient`-based, no FFI)

- Non-streaming + IAsyncEnumerable streaming (`Channel<T>` SSE pipeline)

- Full CRUD: `GetAsync`, `DeleteAsync`, `CancelAsync`, `GetInputItemsAsync`, `ListAsync(limit, order, after)`

- Polymorphic content parts and response items via `[JsonPolymorphic]` + source-gen context

- Streaming events for lifecycle, output, text deltas, function calls, and reasoning

- Vision helpers: `InputImageContent.FromFile/FromUrl/FromBytes`

- `FoundryLocalManager.GetResponsesClient(modelId?)` and `IModel.GetResponsesClientAsync`

Pre-applied PR review feedback from the Python and JS PRs:

- `Settings.Store` defaults to `null` (omit) instead of forcing `store=true`

- `InputImageContent.MediaType` is optional; unknown extensions omit the field so the server infers

- `InputImageContent.FromFile` throws `FileNotFoundException` on missing path

- `HttpClient.Timeout = Timeout.InfiniteTimeSpan`; callers use `CancellationToken` for deadlines (avoids 100s default cutting off SSE)

- `ListAsync` accepts `limit`, `order`, `after`; `ListResponsesResult` exposes `first_id`, `last_id`, `has_more`

- `InputImageContent.Validate()` enforces mutual exclusivity of `ImageUrl` / `ImageData` at request build time

- BMP supported in `DetectMediaType` alongside png/jpg/jpeg/gif/webp

- Uses shared `FoundryLocalException` for transport/parse errors, no dedicated `ResponsesException`

Tests: 22 unit tests (mocked HTTP) + integration tests gated on a running service. `dotnet build sdk/cs/src` clean; all Responses tests pass.

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

Author: MaanavD

sdk/cs/src/Detail/Model.cs

@@ -104,6 +104,11 @@ public async Task<OpenAIEmbeddingClient> GetEmbeddingClientAsync(CancellationTok
         return await SelectedVariant.GetEmbeddingClientAsync(ct).ConfigureAwait(false);
     }
 
+    public async Task<OpenAIResponsesClient> GetResponsesClientAsync(CancellationToken? ct = null)
+    {
+        return await SelectedVariant.GetResponsesClientAsync(ct).ConfigureAwait(false);
+    }
+
     public async Task UnloadAsync(CancellationToken? ct = null)
     {
         await SelectedVariant.UnloadAsync(ct).ConfigureAwait(false);

sdk/cs/src/Detail/ModelVariant.cs

@@ -109,6 +109,13 @@ public async Task<OpenAIEmbeddingClient> GetEmbeddingClientAsync(CancellationTok
                                                     .ConfigureAwait(false);
     }
 
+    public async Task<OpenAIResponsesClient> GetResponsesClientAsync(CancellationToken? ct = null)
+    {
+        return await Utils.CallWithExceptionHandling(() => GetResponsesClientImplAsync(ct),
+                                                     "Error getting responses client for model", _logger)
+                                                    .ConfigureAwait(false);
+    }
+
     private async Task<bool> IsLoadedImplAsync(CancellationToken? ct = null)
     {
         var loadedModels = await _modelLoadManager.ListLoadedModelsAsync(ct).ConfigureAwait(false);
@@ -210,6 +217,27 @@ private async Task<OpenAIEmbeddingClient> GetEmbeddingClientImplAsync(Cancellati
         return new OpenAIEmbeddingClient(Id);
     }
 
+    private async Task<OpenAIResponsesClient> GetResponsesClientImplAsync(CancellationToken? ct = null)
+    {
+        if (!await IsLoadedAsync(ct))
+        {
+            throw new FoundryLocalException($"Model {Id} is not loaded. Call LoadAsync first.");
+        }
+
+        var manager = FoundryLocalManager.Instance;
+        if (manager.Urls == null || manager.Urls.Length == 0)
+        {
+            await manager.StartWebServiceAsync(ct).ConfigureAwait(false);
+        }
+
+        if (manager.Urls == null || manager.Urls.Length == 0)
+        {
+            throw new FoundryLocalException("Web service is not running. Call StartWebServiceAsync first.");
+        }
+
+        return new OpenAIResponsesClient(manager.Urls[0], Id);
+    }
+
     public void SelectVariant(IModel variant)
     {
         throw new FoundryLocalException(

sdk/cs/src/FoundryLocalManager.cs

@@ -460,4 +460,23 @@ public void Dispose()
         Dispose(disposing: true);
         GC.SuppressFinalize(this);
     }
+
+    /// <summary>
+    /// Get an HTTP client for the OpenAI Responses API.
+    /// </summary>
+    /// <remarks>
+    /// The web service must be started first (see <see cref="StartWebServiceAsync"/>).
+    /// </remarks>
+    /// <param name="modelId">Optional default model id used when callers don't supply one.</param>
+    /// <returns>A new <see cref="OpenAIResponsesClient"/>.</returns>
+    /// <exception cref="FoundryLocalException">If the web service has not been started.</exception>
+    public OpenAIResponsesClient GetResponsesClient(string? modelId = null)
+    {
+        if (Urls == null || Urls.Length == 0)
+        {
+            throw new FoundryLocalException("Web service is not running. Call StartWebServiceAsync first.");
+        }
+
+        return new OpenAIResponsesClient(Urls[0], modelId);
+    }
 }

sdk/cs/src/IModel.cs

@@ -77,6 +77,13 @@ Task DownloadAsync(Action<float>? downloadProgress = null,
     /// <returns>OpenAI.EmbeddingClient</returns>
     Task<OpenAIEmbeddingClient> GetEmbeddingClientAsync(CancellationToken? ct = null);
 
+    /// <summary>
+    /// Get an HTTP client for the OpenAI Responses API.
+    /// </summary>
+    /// <param name="ct">Optional cancellation token.</param>
+    /// <returns>An <see cref="OpenAIResponsesClient"/> bound to this model.</returns>
+    Task<OpenAIResponsesClient> GetResponsesClientAsync(CancellationToken? ct = null);
+
     /// <summary>
     /// Variants of the model that are available. Variants of the model are optimized for different devices.
     /// </summary>