Tool Calling

Not yet available. Tool calling in the Responses API is on the roadmap. The page below documents the intended behavior.

Tool calling lets you expose functions to the model. When the model decides a function should run, it returns a tool call event; your code executes the function and submits the result back to continue the turn.

Defining Tools#

Include a tools array in your request. Each tool is a JSON Schema function definition:

{
  "model": "google/gemini-2.5-pro",
  "input": "What is the current balance on my account?",
  "tools": [
    {
      "type": "function",
      "name": "get_account_balance",
      "description": "Returns the caller's current credit balance in micro-DA.",
      "parameters": {
        "type": "object",
        "properties": {},
        "required": []
      }
    }
  ]
}

Handling a Tool Call#

When the model decides to invoke a tool, the response contains a function_call output item instead of (or before) the assistant's text:

{
  "id": "resp_01ABCdef...",
  "output": [
    {
      "type": "function_call",
      "id": "call_xyz",
      "name": "get_account_balance",
      "arguments": "{}"
    }
  ]
}

Your code runs the function, then submits the result by continuing the thread:

result = get_account_balance()  # your implementation

response = client.responses.create(
    model="google/gemini-2.5-pro",
    previous_response_id="resp_01ABCdef...",
    input=[
        {
            "type": "function_call_output",
            "call_id": "call_xyz",
            "output": str(result),
        }
    ],
)
print(response.output_text)

Tool Choice#

Control whether the model must call a tool, may call one, or is forbidden from calling:

Multiple Tools#

You can register as many tools as the model's context window allows. The model may call several in a single turn; handle each function_call item in the output array before submitting results.

Streaming with Tools#

Set "stream": true and handle response.function_call.delta events to receive tool call arguments incrementally — useful when argument payloads are large.