Function calling: letting the model use tools

MENU = {
    "espresso": ("Espresso", 120),
    "cappuccino": ("Cappuccino", 180),
    "cold-brew": ("Cold Brew", 220),
    "filter-coffee": ("Filter Coffee", 80),
    "masala-chai": ("Masala Chai", 90),
    "croissant": ("Butter Croissant", 150),
    "banana-bread": ("Banana Bread", 130),
    "veg-sandwich": ("Veg Grilled Sandwich", 160),
}

# A pretend orders table. In a real app this is a database query.
ORDERS = {
    42: {"status": "preparing", "pickup_time": "18:30"},
    43: {"status": "ready", "pickup_time": "18:45"},
}


def get_menu_price(item_id: str) -> dict:
    """Get the name and price in rupees of one menu item.

    Args:
        item_id: Menu item ID such as 'cappuccino', 'cold-brew' or 'masala-chai'.
    """
    if item_id not in MENU:
        return {"error": f"Unknown item. Valid IDs: {', '.join(MENU)}"}
    name, price = MENU[item_id]
    return {"item_id": item_id, "name": name, "price_rupees": price}


def get_order_status(order_id: int) -> dict:
    """Look up the status and pickup time of an existing order.

    Args:
        order_id: The numeric order ID given to the customer.
    """
    order = ORDERS.get(order_id)
    if order is None:
        return {"error": f"No order found with id {order_id}"}
    return {"order_id": order_id, **order}

from dotenv import load_dotenv
from google import genai
from google.genai import types

from tools import get_menu_price, get_order_status

load_dotenv()
MODEL = "gemini-flash-latest"  # use a current model ID
client = genai.Client()

response = client.models.generate_content(
    model=MODEL,
    contents="How much is a cold brew, and is order 42 ready yet?",
    config=types.GenerateContentConfig(
        system_instruction="You are the Brew & Bean assistant. Use the tools for prices and order status. Never guess.",
        tools=[get_menu_price, get_order_status],
    ),
)

print(response.text)

import json

from dotenv import load_dotenv
from google import genai
from google.genai import types

from tools import get_menu_price, get_order_status

load_dotenv()
MODEL = "gemini-flash-latest"  # use a current model ID
client = genai.Client()

# Only functions in this dictionary can ever be run.
TOOLS = {"get_menu_price": get_menu_price, "get_order_status": get_order_status}

declarations = [
    {
        "name": "get_menu_price",
        "description": "Get the name and price in rupees of one menu item.",
        "parameters": {
            "type": "object",
            "properties": {
                "item_id": {
                    "type": "string",
                    "description": "Menu item ID such as 'cappuccino' or 'cold-brew'.",
                }
            },
            "required": ["item_id"],
        },
    },
    {
        "name": "get_order_status",
        "description": "Look up the status and pickup time of an existing order.",
        "parameters": {
            "type": "object",
            "properties": {
                "order_id": {"type": "integer", "description": "The numeric order ID."}
            },
            "required": ["order_id"],
        },
    },
]

config = types.GenerateContentConfig(
    system_instruction="You are the Brew & Bean assistant. Use the tools for prices and order status. Never guess.",
    tools=[types.Tool(function_declarations=declarations)],
    automatic_function_calling=types.AutomaticFunctionCallingConfig(disable=True),
)

contents = [
    types.Content(
        role="user",
        parts=[types.Part(text="How much is a cold brew, and is order 42 ready yet?")],
    )
]

MAX_STEPS = 5  # never loop forever
for step in range(MAX_STEPS):
    response = client.models.generate_content(model=MODEL, contents=contents, config=config)

    if not response.function_calls:  # no tool requested: this is the final answer
        print(response.text)
        break

    # Keep the model's own turn in the history (it holds the call requests)
    contents.append(response.candidates[0].content)

    result_parts = []
    for call in response.function_calls:
        print(f"[tool] {call.name}({json.dumps(dict(call.args))})")
        fn = TOOLS.get(call.name)
        if fn is None:
            result = {"error": "Unknown tool"}
        else:
            try:
                result = fn(**call.args)
            except Exception as e:
                result = {"error": str(e)}
        result_parts.append(
            types.Part.from_function_response(name=call.name, response={"result": result})
        )

    # Send all results back in ONE user turn
    contents.append(types.Content(role="user", parts=result_parts))
else:
    print("Stopped: too many tool steps.")

Here is a Python function from my app:

[paste function]

Rewrite it as a tool for an LLM: give it a clear name, a docstring that says when to use it and what each argument means, strict type hints, and input validation. Also list 3 ways a model or a malicious user could misuse it and how to prevent each.