.NET: [Bug]: Tool calls do not work without providing them in tools array

Description

When using GetAIAgentAsync without providing the tools list, the tools are being map in tool map using AsAITool, which instead of getting the real function anem and description OpenAIResponsesChatClient.ResponseToolAITool(tool), which uses Name => Tool.GetType().Name this means that the tool will always have the worng name in the map and will never be invocated. The reason I need this is beacause I am trying to resolve the function calls my self, but function invocation never reaches the FunctionInvoker as toolMap.TryGetValue is always false. The correct information remain inside AITool.Tool

The main problem is that there is no way to manually resolve the tool calls without always providing their method in tools array, so even manually handlem is not an options as middleware also does not get it

Code Sample

IChatClient GetChatClient(IChatClient chatClient)
{
    var functionClient = new FunctionInvokingChatClient(chatClient);
    functionClient.FunctionInvoker = FunctionInvoker;
    functionClient.TerminateOnUnknownCalls = false;
    return functionClient;
}

ValueTask<object?> FunctionInvoker(FunctionInvocationContext context, CancellationToken token)
{
    if (context.Function.Name == "GetWeather")
    {
        return new ValueTask<object?>(
            $"The weather in {context.Arguments.GetValueOrDefault("location")} is cloudy with a high of 15°C.");
    }

    return new ValueTask<object?>(DateTimeOffset.UtcNow);
}
var modifiedAgent =
    await aiProjectClient.GetAIAgentAsync("TestKS", clientFactory: GetChatClient);

Error Messages / Stack Traces

Error: Requested function "GetWeather" not found.

Package Versions

Azure.AI.Projects 1.2.0-beta.5; Microsoft.Agents.AI.AzureAI 1.0.0-preview.260205.1

.NET Version

.NET10.0

Additional Context

No response

Or do I understand everything wrong and ChatClientAgent does not have the possibility to call non-invocable functions? As I found that you can do it using ResponsesClient, but I want to use Project Conversation and to not have to manually add previousResponseId. The only workaround I found now is to create and agent with read methods and then later get it but use a fake method and intercept with middle ware or FunctionInvocator. To sum up, is there currently a way to manually resolve function calls in ChatClientAgent? if so how?

Skip tool validation when UseProvidedChatClientAsIs is true (microsof…

KornelijusS

Hi KornelijusS, thanks for reporting this! Here is some context on what's happening and workarounds.

Why `FunctionInvoker` is never called

When no tools are provided in the tools array, the server-side tool definitions are wrapped via responseTool.AsAITool() from Microsoft.Extensions.AI.OpenAI. This creates a ResponseToolAITool wrapper that:

Extends AITool (not AIFunctionDeclaration or AIFunction)
Has Name set to GetType().Name → "FunctionTool" instead of "GetWeather"

The FunctionInvokingChatClient (FICC) can only invoke tools that are AIFunction instances. It finds tools by checking tool is AIFunctionDeclaration && tool.Name == requestedName. Since ResponseToolAITool is just AITool, FICC skips it entirely and returns "Requested function 'GetWeather' not found". Your FunctionInvoker is never reached.

Intended design: Provide invocable `AIFunction` matching the server-side tool definitions

Declarative server-side agents with function tools are expected to have invocable function pointers provided at runtime. When calling GetAIAgentAsync, you should map each declarative function tool from the agent definition to a local AIFunction implementation and pass them in the tools array:

// Map server-side tool declarations to local invocable AIFunctions
AITool getWeatherTool = AIFunctionFactory.Create(
    (string location) => $"The weather in {location} is cloudy with a high of 15°C.",
    "GetWeather",
    "Gets weather for a location");

var agent = await aiProjectClient.GetAIAgentAsync(
    "TestKS",
    tools: [getWeatherTool]);

If you have many declarative functions and want to intercept them all with a custom handler, you can either build a local mapping from the agent's declarative definitions into invocable AIFunction instances before calling GetAIAgentAsync, or handle function calls manually via a middleware as shown below.

Alternative: Handle function calls manually via ChatClient middleware

If you want full control over function call resolution without relying on FICC at all, you can use a DelegatingChatClient middleware that intercepts FunctionCallContent in the LLM response and produces FunctionResultContent results manually.

Important: When bypassing FICC this way, you are responsible for the full function call lifecycle — detecting calls, resolving them, and sending results back to the LLM. A DelegatingChatClient middleware is the idiomatic way to do this in the MEAI pipeline.

You also need a NoOpFunctionInvokingChatClient — this extends FunctionInvokingChatClient so that GetService<FunctionInvokingChatClient>() returns it (preventing WithDefaultAgentMiddleware from adding a real FICC that would fail), but it passes all calls straight through without any function invocation logic:

// NoOp FICC: satisfies the FICC service check but does nothing
class NoOpFunctionInvokingChatClient(IChatClient innerClient)
    : FunctionInvokingChatClient(innerClient)
{
    public override Task<ChatResponse> GetResponseAsync(
        IEnumerable<ChatMessage> messages,
        ChatOptions? options = null,
        CancellationToken cancellationToken = default)
        => InnerClient.GetResponseAsync(messages, options, cancellationToken);

    public override IAsyncEnumerable<ChatResponseUpdate> GetStreamingResponseAsync(
        IEnumerable<ChatMessage> messages,
        ChatOptions? options = null,
        CancellationToken cancellationToken = default)
        => InnerClient.GetStreamingResponseAsync(messages, options, cancellationToken);
}

// Middleware that intercepts function calls and resolves them manually
class ManualToolHandlingMiddleware(IChatClient innerClient) : DelegatingChatClient(innerClient)
{
    public override async Task<ChatResponse> GetResponseAsync(
        IEnumerable<ChatMessage> messages,
        ChatOptions? options = null,
        CancellationToken cancellationToken = default)
    {
        var response = await base.GetResponseAsync(messages, options, cancellationToken);

        List<ChatMessage> toolResults = [];
        foreach (var message in response.Messages)
        {
            foreach (var content in message.Contents.OfType<FunctionCallContent>())
            {
                object result = content.Name switch
                {
                    "GetWeather" => $"The weather in {content.Arguments?["location"]} is sunny.",
                    _ => $"Unknown function: {content.Name}"
                };

                toolResults.Add(new ChatMessage(ChatRole.Tool,
                    [new FunctionResultContent(content.CallId, result)]));
            }
        }

        if (toolResults.Count > 0)
        {
            var allMessages = messages.Concat(response.Messages).Concat(toolResults);
            return await base.GetResponseAsync(allMessages, options, cancellationToken);
        }

        return response;
    }
}

// Wire it up via clientFactory
var agent = await aiProjectClient.GetAIAgentAsync(
    "TestKS",
    clientFactory: chatClient =>
    {
        var withToolHandling = new ManualToolHandlingMiddleware(chatClient);
        return new NoOpFunctionInvokingChatClient(withToolHandling);
    });

Upcoming fix

PR #4389 makes the GetAIAgentAsync(ChatClientAgentOptions) overload respect UseProvidedChatClientAsIs = true to skip tool validation. Once that fix ships, you'll no longer need the NoOpFunctionInvokingChatClient workaround — just the ManualToolHandlingMiddleware with UseProvidedChatClientAsIs = true will be sufficient.

Does either workaround unblock you. Let us know if you have questions.

Decouple tool matching from validation and add tool preservation test (…

.NET: AzureAI Package - Skip tool validation when UseProvidedChatClie…

Navigation Menu

Repository navigation

.NET: [Bug]: Tool calls do not work without providing them in tools array #3855

Description

Code Sample

Error Messages / Stack Traces

Package Versions

.NET Version

Additional Context

Why `FunctionInvoker` is never called

Intended design: Provide invocable `AIFunction` matching the server-side tool definitions

Alternative: Handle function calls manually via ChatClient middleware

Upcoming fix

Metadata

Assignees

Labels

Type

Projects

Milestone

Relationships

Development

.NET: [Bug]: Tool calls do not work without providing them in tools array #3855

Description

Description

Code Sample

Error Messages / Stack Traces

Package Versions

.NET Version

Additional Context

Activity

KornelijusS commented on Feb 11, 2026

rogerbarreto commented on Mar 2, 2026

Why FunctionInvoker is never called

Intended design: Provide invocable AIFunction matching the server-side tool definitions

Alternative: Handle function calls manually via ChatClient middleware

Upcoming fix

Metadata

Metadata

Assignees

Labels

Type

Projects

Milestone

Relationships

Development

Issue actions

Why `FunctionInvoker` is never called

Intended design: Provide invocable `AIFunction` matching the server-side tool definitions