Devlooped.Extensions.AI 2.0.3

Extensions for Microsoft.Extensions.AI

Configurable Chat Clients

Since tweaking chat options such as model identifier, reasoning effort, verbosity and other model settings is very common, this package provides the ability to drive those settings from configuration (with auto-reload support), both per-client as well as per-request. This makes local development and testing much easier and boosts the dev loop:

{
  "AI": {
    "Clients": {
      "Grok": {
        "Endpoint": "https://api.x.ai/v1",
        "ModelId": "grok-4-1-fast-non-reasoning",
        "ApiKey": "xai-asdf"
      }
    }
  }
}

var host = new HostApplicationBuilder(args);
host.Configuration.AddJsonFile("appsettings.json, optional: false, reloadOnChange: true);
host.AddChatClients();

var app = host.Build();
var grok = app.Services.GetRequiredKeyedService<IChatClient>("Grok");

Changing the appsettings.json file will automatically update the client configuration without restarting the application.

There's also a simpler Chat class for streamlined creation of chat messages, which can be used instead of creating an array of ChatMessage using ChatRole.[System|Assistant|User]:

var messages = new Chat()
{
    { "system", "You are a highly intelligent AI assistant." },
    { "user", "What is 101*3?" },
};

Tool Results

Given the following tool:

MyResult RunTool(string name, string description, string content) { ... }

You can use the ToolFactory and FindCall<MyResult> extension method to locate the function invocation, its outcome and the typed result for inspection:

AIFunction tool = ToolFactory.Create(RunTool);
var options = new ChatOptions
{
    ToolMode = ChatToolMode.RequireSpecific(tool.Name), // 👈 forces the tool to be used
    Tools = [tool]
};

var response = await client.GetResponseAsync(chat, options);
// 👇 finds the expected result of the tool call
var result = response.FindCalls<MyResult>(tool).FirstOrDefault();

if (result != null)
{
    // Successful tool call
    Console.WriteLine($"Args: '{result.Call.Arguments.Count}'");
    MyResult typed = result.Result;
}
else
{
    Console.WriteLine("Tool call not found in response.");
}

If the typed result is not found, you can also inspect the raw outcomes by finding untyped calls to the tool and checking their Outcome.Exception property:

var result = response.FindCalls(tool).FirstOrDefault();
if (result.Outcome.Exception is not null)
{
    Console.WriteLine($"Tool call failed: {result.Outcome.Exception.Message}");
}
else
{
    Console.WriteLine($"Tool call succeeded: {result.Outcome.Result}");
}

OpenAI

OpenAI-specific extensions enable more seamless usage with the MS.E.AI API:

• Setting output verbosity: similarly, output verbosity is not exposed in the base API.

These can be used as extension properties on ChatOptions whenever Devlooped.Extensions.AI.OpenAI is imported:

var options = new ChatOptions
{
    Verbosity = Verbosity.Low               // 👈 or Medium/High, extension property
};

var response = await chat.GetResponseAsync(messages, options);

Or you can opt to use the ChatOptions-derived OpenAIChatOptions class directly.

Web Search

The WebSearchTool can be used to customize the web search behavior in a typed manner, unlike the generic HostedWebSearchTool:

var options = new ChatOptions
{
    //                          👇 search in Argentina, Bariloche region
    Tools = [new WebSearchTool("AR")
    {
        AllowedDomains = ["catedralaltapatagonia.com"], // 👈 restrict domain
        Region = "Bariloche",                           // 👈 Bariloche region
        TimeZone = "America/Argentina/Buenos_Aires",    // 👈 IANA timezone
    }]
};

If advanced search settings are not needed, you can use the built-in M.E.AI HostedWebSearchTool instead, which is a more generic tool and provides the basics out of the box.

Observing Request/Response

The underlying HTTP pipeline provided by the Azure SDK allows setting up policies that can observe requests and responses. This is useful for monitoring the requests and responses sent to the AI service, regardless of the chat pipeline configuration used.

This is added to the OpenAIClientOptions (or more properly, any ClientPipelineOptions-derived options) using the Observe method:

var openai = new OpenAIClient(
    Environment.GetEnvironmentVariable("OPENAI_API_KEY")!,
    new OpenAIClientOptions().Observe(
        onRequest: request => Console.WriteLine($"Request: {request}"),
        onResponse: response => Console.WriteLine($"Response: {response}"),
    ));

You can for example trivially collect both requests and responses for payload analysis in tests as follows:

var requests = new List<JsonNode>();
var responses = new List<JsonNode>();
var openai = new OpenAIClient(
    Environment.GetEnvironmentVariable("OPENAI_API_KEY")!,
    new OpenAIClientOptions().Observe(requests.Add, responses.Add));

We also provide a shorthand factory method that creates the options and observes is in a single call:

var requests = new List<JsonNode>();
var responses = new List<JsonNode>();
var openai = new OpenAIClient(
    Environment.GetEnvironmentVariable("OPENAI_API_KEY")!,
    OpenAIClientOptions.Observable(requests.Add, responses.Add));

Open Source Maintenance Fee

To ensure the long-term sustainability of this project, users of this package who generate revenue must pay an Open Source Maintenance Fee. While the source code is freely available under the terms of the License, this package and other aspects of the project require adherence to the Maintenance Fee.

To pay the Maintenance Fee, become a Sponsor at the proper OSMF tier. A single fee covers all of Devlooped packages.

Sponsors

Learn more about GitHub Sponsors