.NET: OpenAI Responses: suppress 'model' parameter if it is used for agent

dotnet/samples/GettingStarted/Workflows/_Foundational/07_MixedWorkflowAgentsAndExecutors/Program.cs

@@ -132,7 +132,7 @@ private static async Task ExecuteWorkflowAsync(Workflow workflow, string input)
         const bool ShowAgentThinking = false;
 
         // Execute in streaming mode to see real-time progress
-        await using StreamingRun run = await InProcessExecution.StreamAsync<string>(workflow, input);
+        await using StreamingRun run = await InProcessExecution.StreamAsync(workflow, input);
 
         // Watch the workflow events
         await foreach (WorkflowEvent evt in run.WatchStreamAsync())

dotnet/samples/GettingStarted/Workflows/_Foundational/08_WriterCriticWorkflow/Program.cs

@@ -89,7 +89,7 @@ private static async Task Main()
     private static async Task ExecuteWorkflowAsync(Workflow workflow, string input)
     {
         // Execute in streaming mode to see real-time progress
-        await using StreamingRun run = await InProcessExecution.StreamAsync<string>(workflow, input);
+        await using StreamingRun run = await InProcessExecution.StreamAsync(workflow, input);
 
         // Watch the workflow events
         await foreach (WorkflowEvent evt in run.WatchStreamAsync())

dotnet/src/Microsoft.Agents.AI.Hosting.OpenAI/Responses/AIAgentResponseExecutor.cs

@@ -24,6 +24,10 @@ public AIAgentResponseExecutor(AIAgent agent)
         this._agent = agent;
     }
 
+    public ValueTask<ResponseError?> ValidateRequestAsync(
+        CreateResponse request,
+        CancellationToken cancellationToken = default) => ValueTask.FromResult<ResponseError?>(null);
+
     public async IAsyncEnumerable<StreamingResponseEvent> ExecuteAsync(
         AgentInvocationContext context,
         CreateResponse request,

dotnet/src/Microsoft.Agents.AI.Hosting.OpenAI/Responses/AgentRunResponseExtensions.cs

@@ -64,7 +64,7 @@ public static Response ToResponse(
             PromptCacheKey = request.PromptCacheKey,
             Reasoning = request.Reasoning,
             SafetyIdentifier = request.SafetyIdentifier,
-            ServiceTier = request.ServiceTier ?? "default",
+            ServiceTier = request.ServiceTier,
             Status = ResponseStatus.Completed,
             Store = request.Store ?? true,
             Temperature = request.Temperature ?? 1.0,

dotnet/src/Microsoft.Agents.AI.Hosting.OpenAI/Responses/HostedAgentResponseExecutor.cs

@@ -37,14 +37,50 @@ public HostedAgentResponseExecutor(
         this._logger = logger;
     }
 
+    /// <inheritdoc/>
+    public ValueTask<ResponseError?> ValidateRequestAsync(
+        CreateResponse request,
+        CancellationToken cancellationToken = default)
+    {
+        // Extract agent name from agent.name or model parameter
+        string? agentName = GetAgentName(request);
+
+        if (string.IsNullOrEmpty(agentName))
+        {
+            return ValueTask.FromResult<ResponseError?>(new ResponseError
+            {
+                Code = "missing_required_parameter",
+                Message = "No 'agent.name' or 'model' specified in the request."
+            });
+        }
+
+        // Validate that the agent can be resolved
+        AIAgent? agent = this._serviceProvider.GetKeyedService<AIAgent>(agentName);
+        if (agent is null)
+        {
+            this._logger.LogWarning("Failed to resolve agent with name '{AgentName}'", agentName);
+            return ValueTask.FromResult<ResponseError?>(new ResponseError
+            {
+                Code = "agent_not_found",
+                Message = $"Agent '{agentName}' not found. Ensure the agent is registered with AddAIAgent()."
+            });
+        }
+
+        return ValueTask.FromResult<ResponseError?>(null);
+    }
+
     /// <inheritdoc/>
     public async IAsyncEnumerable<StreamingResponseEvent> ExecuteAsync(
         AgentInvocationContext context,
         CreateResponse request,
         [EnumeratorCancellation] CancellationToken cancellationToken = default)
     {
-        // Validate and resolve agent synchronously to ensure validation errors are thrown immediately
-        AIAgent agent = this.ResolveAgent(request);
+        // Extract agent name and model from request (validation already done in ValidateRequestAsync)
+        string agentName = GetAgentName(request)!;
+        string? model = GetModelId(request);
+
+        // Resolve the keyed agent service (validation guarantees this succeeds)
+        AIAgent agent = this._serviceProvider.GetRequiredKeyedService<AIAgent>(agentName);
 
         // Create options with properties from the request
         var chatOptions = new ChatOptions
@@ -54,7 +90,7 @@ public async IAsyncEnumerable<StreamingResponseEvent> ExecuteAsync(
             TopP = (float?)request.TopP,
             MaxOutputTokens = request.MaxOutputTokens,
             Instructions = request.Instructions,
-            ModelId = request.Model,
+            ModelId = model,
         };
         var options = new ChatClientAgentRunOptions(chatOptions);
 
@@ -75,41 +111,24 @@ public async IAsyncEnumerable<StreamingResponseEvent> ExecuteAsync(
     }
 
     /// <summary>
-    /// Resolves an agent from the service provider based on the request.
+    /// Extracts the agent name from the request, prioritizing agent.name over model.
     /// </summary>
     /// <param name="request">The create response request.</param>
-    /// <returns>The resolved AIAgent instance.</returns>
-    /// <exception cref="InvalidOperationException">Thrown when the agent cannot be resolved.</exception>
-    private AIAgent ResolveAgent(CreateResponse request)
+    /// <returns>The agent name, or null if not specified.</returns>
+    private static string? GetAgentName(CreateResponse request)
     {
-        // Extract agent name from agent.name or model parameter
-        var agentName = request.Agent?.Name ?? request.Model;
-        if (string.IsNullOrEmpty(agentName))
-        {
-            throw new InvalidOperationException("No 'agent.name' or 'model' specified in the request.");
-        }
-
-        // Resolve the keyed agent service
-        try
-        {
-            return this._serviceProvider.GetRequiredKeyedService<AIAgent>(agentName);
-        }
-        catch (InvalidOperationException ex)
-        {
-            this._logger.LogError(ex, "Failed to resolve agent with name '{AgentName}'", agentName);
-            throw new InvalidOperationException($"Agent '{agentName}' not found. Ensure the agent is registered with AddAIAgent().", ex);
-        }
+        return request.Agent?.Name ?? request.Model;
     }
 
     /// <summary>
-    /// Validates that the agent can be resolved without actually resolving it.
-    /// This allows early validation before starting async execution.
+    /// Extracts the model ID from the request. Returns null if model is being used as agent name.
     /// </summary>
     /// <param name="request">The create response request.</param>
-    /// <exception cref="InvalidOperationException">Thrown when the agent cannot be resolved.</exception>
-    public void ValidateAgent(CreateResponse request)
+    /// <returns>The model ID to use, or null if model parameter is being used for agent identification.</returns>
+    private static string? GetModelId(CreateResponse request)
     {
-        // Use the same logic as ResolveAgent but don't return the agent
-        _ = this.ResolveAgent(request);
+        // If agent.name is specified, use model as the model ID
+        // Otherwise, model is being used for agent name, so return null
+        return request.Agent?.Name is not null ? request.Model : null;
     }
 }

dotnet/src/Microsoft.Agents.AI.Hosting.OpenAI/Responses/IResponseExecutor.cs

@@ -2,6 +2,7 @@
 
 using System.Collections.Generic;
 using System.Threading;
+using System.Threading.Tasks;
 using Microsoft.Agents.AI.Hosting.OpenAI.Responses.Models;
 
 namespace Microsoft.Agents.AI.Hosting.OpenAI.Responses;
@@ -12,6 +13,16 @@ namespace Microsoft.Agents.AI.Hosting.OpenAI.Responses;
 /// </summary>
 internal interface IResponseExecutor
 {
+    /// <summary>
+    /// Validates a create response request before execution.
+    /// </summary>
+    /// <param name="request">The create response request to validate.</param>
+    /// <param name="cancellationToken">Cancellation token.</param>
+    /// <returns>A <see cref="ResponseError"/> if validation fails, null if validation succeeds.</returns>
+    ValueTask<ResponseError?> ValidateRequestAsync(
+        CreateResponse request,
+        CancellationToken cancellationToken = default);
+
     /// <summary>
     /// Executes a response generation request and returns streaming events.
     /// </summary>

dotnet/src/Microsoft.Agents.AI.Hosting.OpenAI/Responses/IResponsesService.cs

@@ -18,6 +18,17 @@ internal interface IResponsesService
     /// Default limit for list operations.
     /// </summary>
     const int DefaultListLimit = 20;
+
+    /// <summary>
+    /// Validates a create response request before execution.
+    /// </summary>
+    /// <param name="request">The create response request to validate.</param>
+    /// <param name="cancellationToken">Cancellation token.</param>
+    /// <returns>A ResponseError if validation fails, null if validation succeeds.</returns>
+    ValueTask<ResponseError?> ValidateRequestAsync(
+        CreateResponse request,
+        CancellationToken cancellationToken = default);
+
     /// <summary>
     /// Creates a model response for the given input.
     /// </summary>

dotnet/src/Microsoft.Agents.AI.Hosting.OpenAI/Responses/InMemoryResponsesService.cs

@@ -147,18 +147,27 @@ public InMemoryResponsesService(IResponseExecutor executor, InMemoryStorageOptio
         this._conversationStorage = conversationStorage;
     }
 
-    public async Task<Response> CreateResponseAsync(
+    public async ValueTask<ResponseError?> ValidateRequestAsync(
         CreateResponse request,
         CancellationToken cancellationToken = default)
     {
-        ValidateRequest(request);
-
-        // Validate agent resolution early for HostedAgentResponseExecutor
-        if (this._executor is HostedAgentResponseExecutor hostedExecutor)
+        if (request.Conversation is not null && !string.IsNullOrEmpty(request.Conversation.Id) &&
+            !string.IsNullOrEmpty(request.PreviousResponseId))
         {
-            hostedExecutor.ValidateAgent(request);
+            return new ResponseError
+            {
+                Code = "invalid_request",
+                Message = "Mutually exclusive parameters: 'conversation' and 'previous_response_id'. Ensure you are only providing one of: 'previous_response_id' or 'conversation'."
+            };
         }
 
+        return await this._executor.ValidateRequestAsync(request, cancellationToken).ConfigureAwait(false);
+    }
+
+    public async Task<Response> CreateResponseAsync(
+        CreateResponse request,
+        CancellationToken cancellationToken = default)
+    {
         if (request.Stream == true)
         {
             throw new InvalidOperationException("Cannot create a streaming response using CreateResponseAsync. Use CreateResponseStreamingAsync instead.");
@@ -189,8 +198,6 @@ public async IAsyncEnumerable<StreamingResponseEvent> CreateResponseStreamingAsy
         CreateResponse request,
         [EnumeratorCancellation] CancellationToken cancellationToken = default)
     {
-        ValidateRequest(request);
-
         if (request.Stream == false)
         {
             throw new InvalidOperationException("Cannot create a non-streaming response using CreateResponseStreamingAsync. Use CreateResponseAsync instead.");
@@ -342,15 +349,6 @@ public Task<ListResponse<ItemResource>> ListResponseInputItemsAsync(
         });
     }
 
-    private static void ValidateRequest(CreateResponse request)
-    {
-        if (request.Conversation is not null && !string.IsNullOrEmpty(request.Conversation.Id) &&
-            !string.IsNullOrEmpty(request.PreviousResponseId))
-        {
-            throw new InvalidOperationException("Mutually exclusive parameters: 'conversation' and 'previous_response_id'. Ensure you are only providing one of: 'previous_response_id' or 'conversation'.");
-        }
-    }
-
     private ResponseState InitializeResponse(string responseId, CreateResponse request)
     {
         var metadata = request.Metadata ?? [];
@@ -371,7 +369,7 @@ private ResponseState InitializeResponse(string responseId, CreateResponse reque
             MaxOutputTokens = request.MaxOutputTokens,
             MaxToolCalls = request.MaxToolCalls,
             Metadata = metadata,
-            Model = request.Model ?? "default",
+            Model = request.Model,
             Output = [],
             ParallelToolCalls = request.ParallelToolCalls ?? true,
             PreviousResponseId = request.PreviousResponseId,

dotnet/src/Microsoft.Agents.AI.Hosting.OpenAI/Responses/ResponsesHttpHandler.cs

@@ -34,6 +34,21 @@ public async Task<IResult> CreateResponseAsync(
         [FromQuery] bool? stream,
         CancellationToken cancellationToken)
     {
+        // Validate the request first
+        ResponseError? validationError = await this._responsesService.ValidateRequestAsync(request, cancellationToken).ConfigureAwait(false);
+        if (validationError is not null)
+        {
+            return Results.BadRequest(new ErrorResponse
+            {
+                Error = new ErrorDetails
+                {
+                    Message = validationError.Message,
+                    Type = "invalid_request_error",
+                    Code = validationError.Code
+                }
+            });
+        }
+
         try
         {
             // Handle streaming vs non-streaming
@@ -55,45 +70,24 @@ public async Task<IResult> CreateResponseAsync(
                 request,
                 cancellationToken: cancellationToken).ConfigureAwait(false);
 
-            return Results.Ok(response);
-        }
-        catch (InvalidOperationException ex) when (ex.Message.Contains("Mutually exclusive"))
-        {
-            // Return OpenAI-style error for mutual exclusivity violations
-            return Results.BadRequest(new ErrorResponse
+            return response.Status switch
             {
-                Error = new ErrorDetails
-                {
-                    Message = ex.Message,
-                    Type = "invalid_request_error",
-                    Code = "mutually_exclusive_parameters"
-                }
-            });
-        }
-        catch (InvalidOperationException ex) when (ex.Message.Contains("not found") || ex.Message.Contains("does not exist"))
-        {
-            // Return OpenAI-style error for not found errors
-            return Results.NotFound(new ErrorResponse
-            {
-                Error = new ErrorDetails
-                {
-                    Message = ex.Message,
-                    Type = "invalid_request_error"
-                }
-            });
+                ResponseStatus.Failed when response.Error is { } error => Results.Problem(
+                    detail: error.Message,
+                    statusCode: StatusCodes.Status500InternalServerError,
+                    title: error.Code ?? "Internal Server Error"),
+                ResponseStatus.Failed => Results.Problem(),
+                ResponseStatus.Queued => Results.Accepted(value: response),
+                _ => Results.Ok(response)
+            };
         }
-        catch (InvalidOperationException ex) when (ex.Message.Contains("No 'agent.name' or 'model' specified"))
+        catch (Exception ex)
         {
-            // Return OpenAI-style error for missing required parameters
-            return Results.BadRequest(new ErrorResponse
-            {
-                Error = new ErrorDetails
-                {
-                    Message = ex.Message,
-                    Type = "invalid_request_error",
-                    Code = "missing_required_parameter"
-                }
-            });
+            // Return InternalServerError for unexpected exceptions
+            return Results.Problem(
+                detail: ex.Message,
+                statusCode: StatusCodes.Status500InternalServerError,
+                title: "Internal Server Error");
         }
     }
 

dotnet/tests/Microsoft.Agents.AI.Hosting.OpenAI.UnitTests/OpenAIResponsesAgentResolutionIntegrationTests.cs

@@ -235,7 +235,7 @@ public async Task CreateResponse_WithNonExistentAgent_ReturnsNotFoundAsync()
         using HttpResponseMessage httpResponse = await this._httpClient!.PostAsync(new Uri("/v1/responses", UriKind.Relative), requestContent);
 
         // Assert
-        Assert.Equal(System.Net.HttpStatusCode.NotFound, httpResponse.StatusCode);
+        Assert.Equal(System.Net.HttpStatusCode.BadRequest, httpResponse.StatusCode);
 
         string responseJson = await httpResponse.Content.ReadAsStringAsync();
         Assert.Contains("non-existent-agent", responseJson);