feat(ai): support chat function auto-calling

Author: mikehardy

packages/ai/__tests__/generative-model.test.ts

@@ -573,6 +573,100 @@ describe('GenerativeModel', () => {
     makeRequestStub.mockRestore();
   });
 
+  it('automatically calls functionReference from chat.sendMessage function calls', async () => {
+    const getWeather = jest.fn<(args: object) => object>().mockReturnValue({ temperature: 72 });
+    const genModel = new GenerativeModel(fakeAI, {
+      model: 'my-model',
+      tools: [
+        {
+          functionDeclarations: [
+            {
+              name: 'getWeather',
+              description: 'Gets weather for a city.',
+              functionReference: getWeather,
+            },
+          ],
+        },
+      ],
+    });
+    const makeRequestStub = jest
+      .spyOn(request, 'makeRequest')
+      .mockResolvedValueOnce(
+        responseFromJson({
+          candidates: [
+            {
+              index: 0,
+              content: {
+                role: 'model',
+                parts: [
+                  {
+                    functionCall: {
+                      name: 'getWeather',
+                      args: { city: 'London' },
+                    },
+                  },
+                ],
+              },
+            },
+          ],
+        }),
+      )
+      .mockResolvedValueOnce(
+        responseFromJson({
+          candidates: [
+            {
+              index: 0,
+              content: {
+                role: 'model',
+                parts: [{ text: 'It is 72 degrees.' }],
+              },
+            },
+          ],
+        }),
+      );
+    const chat = genModel.startChat();
+
+    const result = await chat.sendMessage('weather in London');
+    const history = await chat.getHistory();
+
+    expect(result.response.text()).toBe('It is 72 degrees.');
+    expect(getWeather).toHaveBeenCalledWith({ city: 'London' });
+    expect(makeRequestStub).toHaveBeenCalledTimes(2);
+    expect(history).toEqual([
+      {
+        role: 'user',
+        parts: [{ text: 'weather in London' }],
+      },
+      {
+        role: 'model',
+        parts: [
+          {
+            functionCall: {
+              name: 'getWeather',
+              args: { city: 'London' },
+            },
+          },
+        ],
+      },
+      {
+        role: 'function',
+        parts: [
+          {
+            functionResponse: {
+              name: 'getWeather',
+              response: { temperature: 72 },
+            },
+          },
+        ],
+      },
+      {
+        role: 'model',
+        parts: [{ text: 'It is 72 degrees.' }],
+      },
+    ]);
+    makeRequestStub.mockRestore();
+  });
+
   it('passes CodeExecutionTool through to chat.sendMessage', async function () {
     const genModel = new GenerativeModel(fakeAI, {
       model: 'my-model',

packages/ai/lib/methods/automatic-function-calling.ts

@@ -0,0 +1,128 @@
+/**
+ * @license
+ * Copyright 2026 Google LLC
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+import {
+  Content,
+  FunctionCall,
+  FunctionDeclaration,
+  FunctionResponse,
+  GenerateContentRequest,
+  GenerateContentResult,
+  SingleRequestOptions,
+  Tool,
+} from '../types';
+import { ApiSettings } from '../types/internal';
+import { generateContent } from './generate-content';
+
+const DEFAULT_MAX_SEQUENTIAL_FUNCTION_CALLS = 10;
+
+export interface AutomaticFunctionCallingResult {
+  result: GenerateContentResult;
+  addedContents: Content[];
+}
+
+export async function generateContentWithAutomaticFunctionCalling(
+  apiSettings: ApiSettings,
+  model: string,
+  params: GenerateContentRequest,
+  result: GenerateContentResult,
+  requestOptions?: SingleRequestOptions,
+): Promise<AutomaticFunctionCallingResult> {
+  let remainingFunctionCalls =
+    requestOptions?.maxSequentialFunctionCalls ?? DEFAULT_MAX_SEQUENTIAL_FUNCTION_CALLS;
+  let currentParams = params;
+  let currentResult = result;
+  const addedContents: Content[] = [];
+
+  while (remainingFunctionCalls > 0) {
+    const functionCalls = currentResult.response.functionCalls?.();
+    if (!functionCalls?.length) {
+      return { result: currentResult, addedContents };
+    }
+
+    const functionResponses = await callFunctionReferences(currentParams.tools, functionCalls);
+    if (!functionResponses) {
+      return { result: currentResult, addedContents };
+    }
+
+    const responseContent = getModelResponseContent(currentResult);
+    if (!responseContent) {
+      return { result: currentResult, addedContents };
+    }
+
+    remainingFunctionCalls -= 1;
+    const functionResponseContent: Content = {
+      role: 'function',
+      parts: functionResponses.map(functionResponse => ({ functionResponse })),
+    };
+    addedContents.push(responseContent, functionResponseContent);
+    currentParams = {
+      ...currentParams,
+      contents: [...currentParams.contents, responseContent, functionResponseContent],
+    };
+    currentResult = await generateContent(apiSettings, model, currentParams, requestOptions);
+  }
+
+  return { result: currentResult, addedContents };
+}
+
+function getModelResponseContent(result: GenerateContentResult): Content | undefined {
+  const responseContent = result.response.candidates?.[0]?.content;
+  if (!responseContent) {
+    return undefined;
+  }
+  return {
+    parts: responseContent.parts || [],
+    role: responseContent.role || 'model',
+  };
+}
+
+async function callFunctionReferences(
+  tools: Tool[] | undefined,
+  functionCalls: FunctionCall[],
+): Promise<FunctionResponse[] | undefined> {
+  const declarations = getFunctionDeclarationsWithReferences(tools);
+  if (!declarations.length) {
+    return undefined;
+  }
+
+  const functionResponses: FunctionResponse[] = [];
+  for (const functionCall of functionCalls) {
+    const declaration = declarations.find(candidate => candidate.name === functionCall.name);
+    if (!declaration?.functionReference) {
+      return undefined;
+    }
+
+    const response = (await declaration.functionReference(functionCall.args)) as object;
+    functionResponses.push({
+      id: functionCall.id,
+      name: functionCall.name,
+      response,
+    });
+  }
+  return functionResponses;
+}
+
+function getFunctionDeclarationsWithReferences(tools: Tool[] | undefined): FunctionDeclaration[] {
+  return (
+    tools?.flatMap(tool =>
+      'functionDeclarations' in tool
+        ? (tool.functionDeclarations?.filter(declaration => declaration.functionReference) ?? [])
+        : [],
+    ) ?? []
+  );
+}

packages/ai/lib/methods/chat-session.ts

@@ -36,6 +36,7 @@ import {
   templateGenerateContent,
   templateGenerateContentStream,
 } from './generate-content';
+import { generateContentWithAutomaticFunctionCalling } from './automatic-function-calling';
 import { ApiSettings } from '../types/internal';
 import { logger } from '../logger';
 import { mergeRequestOptions } from '../requests/request-options';
@@ -116,17 +117,26 @@ export class ChatSession extends ChatSessionBase<StartChatParams> {
     let finalResult = {} as GenerateContentResult;
     // Add onto the chain.
     this._sendPromise = this._sendPromise
-      .then(() =>
-        generateContent(
+      .then(async () => {
+        const requestOptions = mergeRequestOptions(this.requestOptions, singleRequestOptions);
+        const result = await generateContent(
           this._apiSettings,
           this.model,
           generateContentRequest,
-          mergeRequestOptions(this.requestOptions, singleRequestOptions),
-        ),
-      )
-      .then((result: GenerateContentResult) => {
+          requestOptions,
+        );
+        return generateContentWithAutomaticFunctionCalling(
+          this._apiSettings,
+          this.model,
+          generateContentRequest,
+          result,
+          requestOptions,
+        );
+      })
+      .then(({ result, addedContents }) => {
         if (result.response.candidates && result.response.candidates.length > 0) {
           this._history.push(newContent);
+          this._history.push(...addedContents);
           const responseContent: Content = {
             parts: result.response.candidates?.[0]?.content.parts || [],
             // Response seems to come back without a role set.