Tool Use (Function Calling) with Claude in TypeScript

import type Anthropic from "@anthropic-ai/sdk";
import { z } from "zod";
 
// Stand-in for your database. Orders belong to customers.
const ORDERS = new Map([
  ["4821", { customerId: "cus_1", status: "shipped", total: 129.0, carrier: "UPS", eta: "2026-10-09" }],
  ["4822", { customerId: "cus_1", status: "processing", total: 42.5, carrier: null, eta: null }],
  ["5900", { customerId: "cus_2", status: "delivered", total: 18.0, carrier: "USPS", eta: null }],
]);
 
export const tools: Anthropic.Tool[] = [
  {
    name: "get_order",
    description:
      "Look up one of the current customer's orders by ID. Returns status, total in USD, carrier, and estimated delivery date. Use it whenever the customer asks about a specific order.",
    input_schema: {
      type: "object",
      properties: { order_id: { type: "string", description: "Numeric order ID without the # sign, such as 4821" } },
      required: ["order_id"],
    },
  },
  {
    name: "list_orders",
    description: "List the current customer's order IDs with status. Use it when the customer does not give an order ID.",
    input_schema: { type: "object", properties: {} },
  },
];
 
const GetOrderInput = z.object({ order_id: z.string().regex(/^\d+$/) });
 
// Every tool runs with the *authenticated* customer, never an ID the model supplies.
export async function runTool(name: string, input: unknown, customerId: string): Promise<string> {
  switch (name) {
    case "get_order": {
      const parsed = GetOrderInput.safeParse(input);
      if (!parsed.success) throw new Error("order_id must contain digits only, such as 4821");
      const { order_id } = parsed.data;
      const order = ORDERS.get(order_id);
      if (!order || order.customerId !== customerId) throw new Error(`No order ${order_id} for this customer`);
      const { customerId: _owner, ...visible } = order;
      return JSON.stringify({ order_id, ...visible });
    }
    case "list_orders":
      return JSON.stringify(
        [...ORDERS].filter(([, o]) => o.customerId === customerId).map(([id, o]) => ({ order_id: id, status: o.status })),
      );
    default:
      throw new Error(`Unknown tool: ${name}`);
  }
}

import Anthropic from "@anthropic-ai/sdk";
import { tools, runTool } from "./lib/tools.ts";
 
const client = new Anthropic();
const MAX_TURNS = 8; // a hard limit, so a confused model cannot loop forever
 
export async function answer(question: string, customerId: string): Promise<string> {
  const messages: Anthropic.MessageParam[] = [{ role: "user", content: question }];
 
  for (let turn = 0; turn < MAX_TURNS; turn++) {
    const message = await client.messages.create({
      model: "claude-opus-5-5",
      max_tokens: 4096,
      system: "You are a support assistant for an online store. Use the tools to answer questions about orders.",
      tools,
      messages,
    });
 
    // Always keep the assistant turn exactly as returned, including tool_use blocks.
    messages.push({ role: "assistant", content: message.content });
 
    if (message.stop_reason !== "tool_use") {
      return message.content.flatMap((b) => (b.type === "text" ? [b.text] : [])).join("");
    }
 
    // Run every requested tool, in parallel, and return all results in one user message.
    const calls = message.content.filter((b): b is Anthropic.ToolUseBlock => b.type === "tool_use");
    const results = await Promise.all(
      calls.map(async (call): Promise<Anthropic.ToolResultBlockParam> => {
        try {
          return { type: "tool_result", tool_use_id: call.id, content: await runTool(call.name, call.input, customerId) };
        } catch (error) {
          // Errors go back to the model as results, so it can recover or explain.
          return { type: "tool_result", tool_use_id: call.id, content: String(error), is_error: true };
        }
      }),
    );
    messages.push({ role: "user", content: results });
  }
  throw new Error(`No answer after ${MAX_TURNS} turns`);
}
 
console.log(await answer("Where is my order #4821?", "cus_1"));

import Anthropic from "@anthropic-ai/sdk";
import { betaZodTool } from "@anthropic-ai/sdk/helpers/beta/zod";
import { z } from "zod";
import { runTool } from "./lib/tools.ts";
 
const client = new Anthropic();
const customerId = "cus_1"; // from your session in a real app
 
const getOrder = betaZodTool({
  name: "get_order",
  description: "Look up one of the current customer's orders by ID. Returns status, total in USD, carrier, and estimated delivery date.",
  inputSchema: z.object({ order_id: z.string().describe("Numeric order ID without the # sign") }),
  run: ({ order_id }) => runTool("get_order", { order_id }, customerId),
});
 
const listOrders = betaZodTool({
  name: "list_orders",
  description: "List the current customer's order IDs with status. Use it when the customer does not give an order ID.",
  inputSchema: z.object({}),
  run: () => runTool("list_orders", {}, customerId),
});
 
const finalMessage = await client.beta.messages.toolRunner({
  model: "claude-opus-5-5",
  max_tokens: 4096,
  max_iterations: 8,
  system: "You are a support assistant for an online store. Use the tools to answer questions about orders.",
  tools: [getOrder, listOrders],
  messages: [{ role: "user", content: "Compare my two most recent orders." }],
});
 
console.log(finalMessage.content.flatMap((b) => (b.type === "text" ? [b.text] : [])).join(""));