How to customize chat client with additional functionality

[bdenuit]

Hi, I am trying to move my direct OpenAI calls to the Responses API to an agent. The issue that I have is that I am currently using two pieces of functionality that OpenAI provides that are not part of the standard OpenAI chat agent in the Agent Framework - direct calling of an MCP server by OpenAI, and the use of prompt templates inside of OpenAI.

I ended up writing my own IChatClient that converts Agent Framework calls into direct OpenAI calls, and then translates the responses back, but I am worried I am going to forget to copy over something.

Is there another way to extend the current OpenAI chat client?
I am using C#.

Thanks,
Bruno.

[stephentoub]

direct calling of an MCP server by OpenAI

This is supported, eg you can put a HostedMcpServerTool into your tools collection.

the use of prompt templates inside of OpenAI.

Meaning you want to set some additional properties on the ResponseCreationOptioms? You can use the RawRepresentationFactory property to create the ResponseCreationOptioms you want to seed the IChatClient with. It'll use yours instead of creating one fresh, and you can populate on that instance whatever you want.

[bdenuit]

Thanks Stephen, I managed to make it work, with some modifications.

• The GetOpenAIResponseClient requires a model, but in the case of prompt templates, the model is (sometimes?) defined with the template, so you shouldn't send it explicitly to OpenAI. I am passing whatever in the constructor, and then removing the property in the ResponseCreationOptions.
• I am using an explicit HttpClient because I had to add an interceptor for the response from the OpenAI Responses API. In the current version of the .NET SDK, it expects Instructions to be a string, whereas currently OpenAI could return either a string or an array of content.

In case anyone else is interested, here is the code:

var httpClient = _httpClientFactory.CreateClient("openai-responses");
var client = new OpenAIClient(
        new ApiKeyCredential(_config.SecretKey),
        new OpenAIClientOptions
        {
            Transport = new HttpClientPipelineTransport(httpClient)
        })
    // The prompt template also contains the model, so we shouldn't explicitly send it in that case.
    // Pass in any model to make this method happy. It will be nulled out in the ConfigureOptions.
    //
    .GetOpenAIResponseClient(EnumConverter.GetName(model ?? AIModel.Gpt4oMini))
    .AsIChatClient();

if (!String.IsNullOrEmpty(promptTemplateId) || outputType != null)
{
    client = client.AsBuilder()
        .ConfigureOptions(o =>
        {
            o.RawRepresentationFactory = _ =>
            {
                var options = new ResponseCreationOptions();

                if (outputType != null)
                {
                    options.TextOptions = new ResponseTextOptions
                    {
                        TextFormat = ResponseTextFormat.CreateJsonSchemaFormat(
                            outputType.Name.Replace("[]", "_array"),
                            BinaryData.FromObjectAsJson(OpenAIOutputSchemaFactory.GetSchema(outputType)),
                            jsonSchemaIsStrict: true)
                    };
                }

                if (!String.IsNullOrEmpty(promptTemplateId))
                {
                    options.Patch.Set("$.prompt.id"u8, promptTemplateId);
                    options.Patch.Remove("$.model"u8);
                }

                return options;
            };
        })
        .Build();
}

return client;

public class OpenAIResponsesApiInterceptor : DelegatingHandler
{
    private readonly HashSet<string> _endpointsToIntercept = ["/v1/responses"];

    protected override async Task<HttpResponseMessage> SendAsync(
        HttpRequestMessage request,
        CancellationToken cancellationToken)
    {
        var response = await base.SendAsync(request, cancellationToken);

        if (ShouldIntercept(request.RequestUri))
        {
            var content = await response.Content.ReadAsStringAsync(cancellationToken);
            var modified = ConvertInstructionsArrayToString(content);
            response.Content = new StringContent(modified, Encoding.UTF8, "application/json");
        }

        return response;
    }

    private bool ShouldIntercept(Uri uri)
    {
        return _endpointsToIntercept.Any(endpoint => uri.AbsolutePath.Contains(endpoint));
    }

    private static string ConvertInstructionsArrayToString(string json)
    {
        var response = JsonUtils.ToJObject(json);
        if (response["instructions"] is not JArray { Count: > 0 } instructions)
        {
            return json;
        }

        var text = instructions.SelectToken("[?(@.role == 'system')].content[?(@.type == 'input_text')].text");
        response["instructions"] = text;

        return JsonUtils.ToString(response);
    }
}