M01 — The Agent Loop & Tool Use

// acmeTools.mjs — the real function, shared by all three SDKs.
const FAKE_ORDERS = {
  "AC-1042": { status: "shipped", carrier: "UPS", eta: "Tuesday" },
  "AC-2088": { status: "processing", carrier: null, eta: "unknown" },
};

export function getOrderStatus(orderId) {
  const order = FAKE_ORDERS[orderId.toUpperCase()];
  if (!order) return { error: `No order found with id ${orderId}.` };
  return { order_id: orderId.toUpperCase(), ...order };
}

// agent_anthropic.mjs
import Anthropic from "@anthropic-ai/sdk";
import { getOrderStatus } from "./acmeTools.mjs";

const client = new Anthropic();
const SYSTEM = "You are Acme Support. Use tools to answer order questions accurately.";

const TOOLS = [{
  name: "get_order_status",
  description: "Look up the current status of an order by its order ID (e.g. AC-1042).",
  input_schema: {
    type: "object",
    properties: { order_id: { type: "string", description: "Order ID like AC-1042" } },
    required: ["order_id"],
  },
}];

async function runAgent(userMessage) {
  const messages = [{ role: "user", content: userMessage }];
  while (true) {
    const resp = await client.messages.create({
      model: "claude-sonnet-5", max_tokens: 1024,
      system: SYSTEM, tools: TOOLS, messages,
    });
    if (resp.stop_reason !== "tool_use") {
      return resp.content.filter(b => b.type === "text").map(b => b.text).join("");
    }
    messages.push({ role: "assistant", content: resp.content });
    const results = [];
    for (const block of resp.content) {
      if (block.type === "tool_use") {
        const out = getOrderStatus(block.input.order_id);
        results.push({ type: "tool_result", tool_use_id: block.id, content: JSON.stringify(out) });
      }
    }
    messages.push({ role: "user", content: results });
  }
}

console.log(await runAgent("Hi, where is my order AC-1042?"));

# agent_gemini.py
from google import genai
from google.genai import types
from acme_tools import get_order_status

client = genai.Client()
SYSTEM = "You are Acme Support. Use tools to answer order questions accurately."

# --- Describe the tool: Gemini uses FunctionDeclaration inside a Tool ---
order_tool = types.Tool(function_declarations=[types.FunctionDeclaration(
    name="get_order_status",
    description="Look up the current status of an order by its order ID (e.g. AC-1042).",
    parameters_json_schema={
        "type": "object",
        "properties": {"order_id": {"type": "string", "description": "Order ID like AC-1042"}},
        "required": ["order_id"],
    },
)])
config = types.GenerateContentConfig(system_instruction=SYSTEM, tools=[order_tool])

def run_agent(user_message: str) -> str:
    contents = [types.Content(role="user", parts=[types.Part(text=user_message)])]
    while True:
        resp = client.models.generate_content(
            model="gemini-2.5-flash", contents=contents, config=config,
        )
        # Step 3: no function call -> final answer
        if not resp.function_calls:
            return resp.text

        # Step 4: append the model's turn, then run each requested function
        contents.append(resp.candidates[0].content)
        parts = []
        for fc in resp.function_calls:
            out = get_order_status(**dict(fc.args))
            parts.append(types.Part.from_function_response(name=fc.name, response={"result": out}))
        contents.append(types.Content(role="tool", parts=parts))

if __name__ == "__main__":
    print(run_agent("Hi, where is my order AC-1042?"))

// agent_gemini.mjs
import { GoogleGenAI, Type } from "@google/genai";
import { getOrderStatus } from "./acmeTools.mjs";

const ai = new GoogleGenAI({});
const SYSTEM = "You are Acme Support. Use tools to answer order questions accurately.";

const orderTool = {
  functionDeclarations: [{
    name: "get_order_status",
    description: "Look up the current status of an order by its order ID (e.g. AC-1042).",
    parameters: {
      type: Type.OBJECT,
      properties: { order_id: { type: Type.STRING, description: "Order ID like AC-1042" } },
      required: ["order_id"],
    },
  }],
};
const config = { systemInstruction: SYSTEM, tools: [orderTool] };

async function runAgent(userMessage) {
  const contents = [{ role: "user", parts: [{ text: userMessage }] }];
  while (true) {
    const resp = await ai.models.generateContent({
      model: "gemini-2.5-flash", contents, config,
    });
    if (!resp.functionCalls || resp.functionCalls.length === 0) return resp.text;

    contents.push(resp.candidates[0].content);
    const parts = [];
    for (const fc of resp.functionCalls) {
      const out = getOrderStatus(fc.args.order_id);
      parts.push({ functionResponse: { name: fc.name, response: { result: out } } });
    }
    contents.push({ role: "tool", parts });
  }
}

console.log(await runAgent("Hi, where is my order AC-1042?"));

# agent_openai.py  (Responses API)
import json
from openai import OpenAI
from acme_tools import get_order_status

client = OpenAI()
SYSTEM = "You are Acme Support. Use tools to answer order questions accurately."

# --- Describe the tool: OpenAI Responses uses a FLAT function schema ---
TOOLS = [{
    "type": "function",
    "name": "get_order_status",
    "description": "Look up the current status of an order by its order ID (e.g. AC-1042).",
    "parameters": {
        "type": "object",
        "properties": {"order_id": {"type": "string", "description": "Order ID like AC-1042"}},
        "required": ["order_id"],
        "additionalProperties": False,
    },
}]

def run_agent(user_message: str) -> str:
    input_list = [{"role": "user", "content": user_message}]
    while True:
        resp = client.responses.create(
            model="gpt-5.5", instructions=SYSTEM, tools=TOOLS, input=input_list,
        )
        calls = [item for item in resp.output if item.type == "function_call"]
        # Step 3: no function call -> final answer
        if not calls:
            return resp.output_text

        # Step 4: append the model's output items, then each function_call_output
        input_list += resp.output
        for call in calls:
            args = json.loads(call.arguments)
            out = get_order_status(**args)
            input_list.append({
                "type": "function_call_output",
                "call_id": call.call_id,           # note: call_id, not id
                "output": json.dumps(out),
            })

if __name__ == "__main__":
    print(run_agent("Hi, where is my order AC-1042?"))

// agent_openai.mjs  (Responses API)
import OpenAI from "openai";
import { getOrderStatus } from "./acmeTools.mjs";

const client = new OpenAI();
const SYSTEM = "You are Acme Support. Use tools to answer order questions accurately.";

const TOOLS = [{
  type: "function",
  name: "get_order_status",
  description: "Look up the current status of an order by its order ID (e.g. AC-1042).",
  parameters: {
    type: "object",
    properties: { order_id: { type: "string", description: "Order ID like AC-1042" } },
    required: ["order_id"],
    additionalProperties: false,
  },
}];

async function runAgent(userMessage) {
  let input = [{ role: "user", content: userMessage }];
  while (true) {
    const resp = await client.responses.create({
      model: "gpt-5.5", instructions: SYSTEM, tools: TOOLS, input,
    });
    const calls = resp.output.filter(o => o.type === "function_call");
    if (calls.length === 0) return resp.output_text;

    input = input.concat(resp.output);
    for (const call of calls) {
      const args = JSON.parse(call.arguments);
      const out = getOrderStatus(args.order_id);
      input.push({ type: "function_call_output", call_id: call.call_id, output: JSON.stringify(out) });
    }
  }
}

console.log(await runAgent("Hi, where is my order AC-1042?"));