feat(sdk/cs): add Responses API client for OpenAI/OpenResponses compatibility

Add OpenAIResponsesClient to the C# SDK v2 with full CRUD support for the
Responses API served by Foundry Local's embedded web service.

New files:
- src/OpenAI/ResponsesClient.cs: HTTP-based client with SSE streaming
- src/OpenAI/ResponsesTypes.cs: Request/response DTOs, items, streaming events
- src/OpenAI/ResponsesJsonContext.cs: AOT-compatible source-generated JSON context

Modified files:
- src/IModel.cs: GetResponsesClientAsync() on IModel interface
- src/ModelVariant.cs: Implementation with web service URL validation
- src/Model.cs: Delegation to SelectedVariant
- src/FoundryLocalManager.cs: GetResponsesClient() factory method

Key design decisions:
- HTTP-based (HttpClient + SSE), not FFI, since no CoreInterop command exists
- AOT-compatible: all serialization uses source-generated JsonSerializerContext
- IDisposable: HttpClient properly disposed
- Follows existing patterns: Utils.CallWithExceptionHandling, ConfigureAwait(false)
- Factory on FoundryLocalManager + convenience on IModel
- ResponseObject.OutputText convenience property (matches OpenAI Python SDK)
- Full CRUD: Create, CreateStreaming, Get, Delete, Cancel, GetInputItems

Author: MaanavD

sdk/cs/src/FoundryLocalManager.cs

@@ -150,6 +150,24 @@ await Utils.CallWithExceptionHandling(() => EnsureEpsDownloadedImplAsync(ct),
                                              .ConfigureAwait(false);
     }
 
+    /// <summary>
+    /// Creates an OpenAI Responses API client.
+    /// The web service must be started first via <see cref="StartWebServiceAsync"/>.
+    /// </summary>
+    /// <param name="modelId">Optional default model ID for requests.</param>
+    /// <returns>An <see cref="OpenAIResponsesClient"/> instance.</returns>
+    /// <exception cref="FoundryLocalException">If the web service is not running.</exception>
+    public OpenAIResponsesClient GetResponsesClient(string? modelId = null)
+    {
+        if (Urls == null || Urls.Length == 0)
+        {
+            throw new FoundryLocalException(
+                "Web service is not running. Call StartWebServiceAsync before creating a ResponsesClient.", _logger);
+        }
+
+        return new OpenAIResponsesClient(Urls[0], modelId);
+    }
+
     private FoundryLocalManager(Configuration configuration, ILogger logger)
     {
         _config = configuration ?? throw new ArgumentNullException(nameof(configuration));

sdk/cs/src/IModel.cs

@@ -67,4 +67,14 @@ Task DownloadAsync(Action<float>? downloadProgress = null,
     /// <param name="ct">Optional cancellation token.</param>
     /// <returns>OpenAI.AudioClient</returns>
     Task<OpenAIAudioClient> GetAudioClientAsync(CancellationToken? ct = null);
+
+    /// <summary>
+    /// Get an OpenAI Responses API client.
+    /// Unlike Chat/Audio clients (which use FFI), the Responses API is HTTP-based,
+    /// so the web service must be started first via <see cref="FoundryLocalManager.StartWebServiceAsync"/>.
+    /// </summary>
+    /// <param name="ct">Optional cancellation token.</param>
+    /// <returns>OpenAI.ResponsesClient</returns>
+    Task<OpenAIResponsesClient> GetResponsesClientAsync(CancellationToken? ct = null)
+        => throw new NotImplementedException("GetResponsesClientAsync is not implemented by this IModel provider.");
 }

sdk/cs/src/Model.cs

@@ -113,6 +113,11 @@ public async Task<OpenAIAudioClient> GetAudioClientAsync(CancellationToken? ct =
         return await SelectedVariant.GetAudioClientAsync(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/ModelVariant.cs

@@ -100,6 +100,13 @@ public async Task<OpenAIAudioClient> GetAudioClientAsync(CancellationToken? ct =
                                                     .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);
@@ -190,4 +197,21 @@ private async Task<OpenAIAudioClient> GetAudioClientImplAsync(CancellationToken?
 
         return new OpenAIAudioClient(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 urls = FoundryLocalManager.Instance.Urls;
+        if (urls == null || urls.Length == 0)
+        {
+            throw new FoundryLocalException(
+                "Web service is not running. Call StartWebServiceAsync before creating a ResponsesClient.");
+        }
+
+        return new OpenAIResponsesClient(urls[0], Id);
+    }
 }