AI Function Calling Guide: OpenAI, Anthropic, Google

import OpenAI from "openai";

const client = new OpenAI();

const tools: OpenAI.ChatCompletionTool[] = [
  {
    type: "function",
    function: {
      name: "get_weather",
      description: "Get current weather for a location",
      parameters: {
        type: "object",
        properties: {
          location: {
            type: "string",
            description: "City and state, e.g. San Francisco, CA",
          },
          unit: {
            type: "string",
            enum: ["celsius", "fahrenheit"],
          },
        },
        required: ["location"],
        additionalProperties: false,
      },
    },
  },
];

const response = await client.chat.completions.create({
  model: "gpt-5.4",
  messages: [{ role: "user", content: "Weather in Tokyo?" }],
  tools,
  tool_choice: "auto",
});

from openai import OpenAI

client = OpenAI()

tools = [
    {
        "type": "function",
        "function": {
            "name": "get_weather",
            "description": "Get current weather for a location",
            "parameters": {
                "type": "object",
                "properties": {
                    "location": {
                        "type": "string",
                        "description": "City and state, e.g. SF, CA",
                    },
                    "unit": {
                        "type": "string",
                        "enum": ["celsius", "fahrenheit"],
                    },
                },
                "required": ["location"],
                "additionalProperties": False,
            },
        },
    }
]

response = client.chat.completions.create(
    model="gpt-5.4",
    messages=[{"role": "user", "content": "Weather in Tokyo?"}],
    tools=tools,
    tool_choice="auto",
)

import Anthropic from "@anthropic-ai/sdk";

const client = new Anthropic();

const tools: Anthropic.Tool[] = [
  {
    name: "get_weather",
    description: "Get current weather for a location",
    input_schema: {
      type: "object",
      properties: {
        location: {
          type: "string",
          description: "City and state, e.g. San Francisco, CA",
        },
        unit: {
          type: "string",
          enum: ["celsius", "fahrenheit"],
        },
      },
      required: ["location"],
    },
  },
];

const response = await client.messages.create({
  model: "claude-opus-4-6",
  max_tokens: 1024,
  tools,
  messages: [{ role: "user", content: "Weather in Tokyo?" }],
});

import anthropic

client = anthropic.Anthropic()

tools = [
    {
        "name": "get_weather",
        "description": "Get current weather for a location",
        "input_schema": {
            "type": "object",
            "properties": {
                "location": {
                    "type": "string",
                    "description": "City and state, e.g. SF, CA",
                },
                "unit": {
                    "type": "string",
                    "enum": ["celsius", "fahrenheit"],
                },
            },
            "required": ["location"],
        },
    }
]

response = client.messages.create(
    model="claude-opus-4-6",
    max_tokens=1024,
    tools=tools,
    messages=[{"role": "user", "content": "Weather in Tokyo?"}],
)

import { GoogleGenAI } from "@google/genai";

const ai = new GoogleGenAI({ apiKey: process.env.GOOGLE_AI_KEY });

const getWeatherDeclaration = {
  name: "get_weather",
  description: "Get current weather for a location",
  parameters: {
    type: "object",
    properties: {
      location: {
        type: "string",
        description: "City and state, e.g. San Francisco, CA",
      },
      unit: {
        type: "string",
        enum: ["celsius", "fahrenheit"],
      },
    },
    required: ["location"],
  },
};

const response = await ai.models.generateContent({
  model: "gemini-3.1-pro",
  contents: [{ role: "user", parts: [{ text: "Weather in Tokyo?" }] }],
  config: {
    tools: [{ functionDeclarations: [getWeatherDeclaration] }],
  },
});

from google import genai

client = genai.Client(api_key=os.environ["GOOGLE_AI_KEY"])

get_weather = {
    "name": "get_weather",
    "description": "Get current weather for a location",
    "parameters": {
        "type": "object",
        "properties": {
            "location": {
                "type": "string",
                "description": "City and state, e.g. SF, CA",
            },
            "unit": {
                "type": "string",
                "enum": ["celsius", "fahrenheit"],
            },
        },
        "required": ["location"],
    },
}

response = client.models.generate_content(
    model="gemini-3.1-pro",
    contents="Weather in Tokyo?",
    config={
        "tools": [{"function_declarations": [get_weather]}],
    },
)

// Define your function implementations
const functions: Record<string, (args: unknown) => Promise<string>> = {
  get_weather: async (args) => {
    const { location } = args as { location: string };
    // Call your actual weather API here
    return JSON.stringify({ temp: 18.2, unit: "celsius", location });
  },
};

// The tool loop: keeps calling until the model stops requesting tools
async function runToolLoop(userMessage: string) {
  const messages: OpenAI.ChatCompletionMessageParam[] = [
    { role: "user", content: userMessage },
  ];

  while (true) {
    const response = await client.chat.completions.create({
      model: "gpt-5.4",
      messages,
      tools,
    });

    const choice = response.choices[0];
    messages.push(choice.message);

    // If no tool calls, return the final text response
    if (!choice.message.tool_calls?.length) {
      return choice.message.content;
    }

    // Execute each tool call and add results
    for (const toolCall of choice.message.tool_calls) {
      const fn = functions[toolCall.function.name];
      const args = JSON.parse(toolCall.function.arguments);
      const result = await fn(args);

      messages.push({
        role: "tool",
        tool_call_id: toolCall.id,
        content: result,
      });
    }
  }
}

async function runToolLoop(userMessage: string) {
  const messages: Anthropic.MessageParam[] = [
    { role: "user", content: userMessage },
  ];

  while (true) {
    const response = await client.messages.create({
      model: "claude-opus-4-6",
      max_tokens: 4096,
      tools,
      messages,
    });

    // Add assistant response to history
    messages.push({ role: "assistant", content: response.content });

    // If model stopped naturally (not waiting for tool results)
    if (response.stop_reason !== "tool_use") {
      const textBlock = response.content.find((b) => b.type === "text");
      return textBlock?.text ?? "";
    }

    // Execute tool calls and build result blocks
    const toolResults = [];
    for (const block of response.content) {
      if (block.type === "tool_use") {
        const fn = functions[block.name];
        const result = await fn(block.input);
        toolResults.push({
          type: "tool_result" as const,
          tool_use_id: block.id,
          content: result,
        });
      }
    }

    messages.push({ role: "user", content: toolResults });
  }
}

import { z } from "zod";

// Define schemas for validation
const weatherSchema = z.object({
  location: z.string().min(1),
  unit: z.enum(["celsius", "fahrenheit"]).optional(),
});

async function executeToolCall(
  name: string,
  args: unknown
): Promise<{ result?: string; error?: string }> {
  try {
    // 1. Validate arguments against schema
    if (name === "get_weather") {
      const parsed = weatherSchema.safeParse(args);
      if (!parsed.success) {
        return {
          error: `Invalid arguments: ${parsed.error.message}`,
        };
      }
      // 2. Execute the function
      const data = await fetchWeather(parsed.data.location);
      return { result: JSON.stringify(data) };
    }
    return { error: `Unknown function: ${name}` };
  } catch (err) {
    // 3. Return execution errors to the model
    return {
      error: `Function execution failed: ${
        err instanceof Error ? err.message : "Unknown error"
      }`,
    };
  }
}