Using tools

For the complete documentation index, see llms.txt. Markdown versions of documentation pages are available by appending .md to the page URL.

When generating model responses or building agents, you can extend capabilities using built‑in tools, function calling, Programmatic Tool Calling, tool search, and remote MCP servers. These enable the model to search the web, retrieve from your files, load deferred tool definitions at runtime, call your own functions, compose tool calls in JavaScript, or access third‑party services. Only gpt-5.4 and later models support tool_search.

Web search

Include web search results for the model response

import OpenAI from "openai";
const client = new OpenAI();

const response = await client.responses.create({
  model: "gpt-5.6",
  tools: [{ type: "web_search" }],
  input: "What was a positive news story from today?",
});

console.log(response.output_text);

from openai import OpenAI

client = OpenAI()

response = client.responses.create(
    model="gpt-5.6",
    tools=[{"type": "web_search"}],
    input="What was a positive news story from today?",
)

print(response.output_text)

curl "https://api.openai.com/v1/responses" \
    -H "Content-Type: application/json" \
    -H "Authorization: Bearer $OPENAI_API_KEY" \
    -d '{
        "model": "gpt-5.6",
        "tools": [{"type": "web_search"}],
        "input": "what was a positive news story from today?"
}'

openai responses create \
  --model gpt-5.6 \
  --raw-output \
  --transform 'output.#(type=="message").content.0.text' <<'YAML'
tools:
  - type: web_search
input: What was a positive news story from today?
YAML

using OpenAI.Responses;
#pragma warning disable OPENAI001

string key = Environment.GetEnvironmentVariable("OPENAI_API_KEY")!;
ResponsesClient client = new(key);

CreateResponseOptions options = new() { Model = "gpt-5.6" };
options.Tools.Add(ResponseTool.CreateWebSearchTool());
options.InputItems.Add(
    ResponseItem.CreateUserMessageItem("What was a positive news story from today?")
);

ResponseResult response = await client.CreateResponseAsync(options);

Console.WriteLine(response.GetOutputText());

require "openai"

openai = OpenAI::Client.new

response = openai.responses.create(
  model: "gpt-5.6",
  tools: [{type: "web_search"}],
  input: "What was a positive news story from today?"
)

puts(response.output_text)

File search

Search your files in a response

from openai import OpenAI

client = OpenAI()

response = client.responses.create(
    model="gpt-5.6",
    input="What is deep research by OpenAI?",
    tools=[{"type": "file_search", "vector_store_ids": ["<vector_store_id>"]}],
)
print(response)

import OpenAI from "openai";
const openai = new OpenAI();

const response = await openai.responses.create({
  model: "gpt-5.6",
  input: "What is deep research by OpenAI?",
  tools: [
    {
      type: "file_search",
      vector_store_ids: ["<vector_store_id>"],
    },
  ],
});
console.log(response);

using OpenAI.Responses;
#pragma warning disable OPENAI001

string key = Environment.GetEnvironmentVariable("OPENAI_API_KEY")!;
ResponsesClient client = new(key);

CreateResponseOptions options = new() { Model = "gpt-5.6" };
options.Tools.Add(
    ResponseTool.CreateFileSearchTool(["<vector_store_id>"])
);
options.InputItems.Add(
    ResponseItem.CreateUserMessageItem("What is deep research by OpenAI?")
);

ResponseResult response = await client.CreateResponseAsync(options);

Console.WriteLine(response.GetOutputText());

require "openai"

openai = OpenAI::Client.new

response = openai.responses.create(
  model: "gpt-5.6",
  input: "What is deep research by OpenAI?",
  tools: [
    {
      type: "file_search",
      vector_store_ids: ["<vector_store_id>"]
    }
  ]
)

puts(response)

Tool search

Load deferred tools at runtime

from openai import OpenAI

client = OpenAI()

crm_namespace = {
    "type": "namespace",
    "name": "crm",
    "description": "CRM tools for customer lookup and order management.",
    "tools": [
        {
            "type": "function",
            "name": "get_customer_profile",
            "description": "Fetch a customer profile by customer ID.",
            "parameters": {
                "type": "object",
                "properties": {
                    "customer_id": {"type": "string"},
                },
                "required": ["customer_id"],
                "additionalProperties": False,
            },
        },
        {
            "type": "function",
            "name": "list_open_orders",
            "description": "List open orders for a customer ID.",
            # highlight-start:subtle
            "defer_loading": True,
            # highlight-end
            "parameters": {
                "type": "object",
                "properties": {
                    "customer_id": {"type": "string"},
                },
                "required": ["customer_id"],
                "additionalProperties": False,
            },
        },
    ],
}

response = client.responses.create(
    model="gpt-5.6",
    input="List open orders for customer CUST-12345.",
    tools=[
        crm_namespace,
        # highlight-start:subtle
        {"type": "tool_search"},
        # highlight-end
    ],
    parallel_tool_calls=False,
)

print(response.output)

import OpenAI from "openai";

const client = new OpenAI();

/** @type {OpenAI.Responses.NamespaceTool} */
const crmNamespace = {
  type: "namespace",
  name: "crm",
  description: "CRM tools for customer lookup and order management.",
  tools: [
    {
      type: "function",
      name: "get_customer_profile",
      description: "Fetch a customer profile by customer ID.",
      parameters: {
        type: "object",
        properties: {
          customer_id: { type: "string" },
        },
        required: ["customer_id"],
        additionalProperties: false,
      },
    },
    {
      type: "function",
      name: "list_open_orders",
      description: "List open orders for a customer ID.",
      // highlight-start:subtle
      defer_loading: true,
      // highlight-end
      parameters: {
        type: "object",
        properties: {
          customer_id: { type: "string" },
        },
        required: ["customer_id"],
        additionalProperties: false,
      },
    },
  ],
};

const response = await client.responses.create({
  model: "gpt-5.6",
  input: "List open orders for customer CUST-12345.",
  // highlight-start:subtle
  tools: [crmNamespace, { type: "tool_search" }],
  // highlight-end
  parallel_tool_calls: false,
});

console.log(response.output);

Function calling

Call your own function

import OpenAI from "openai";
const client = new OpenAI();

/** @type {OpenAI.Responses.Tool[]} */
const tools = [
  {
    type: "function",
    name: "get_weather",
    description: "Get current temperature for a given location.",
    parameters: {
      type: "object",
      properties: {
        location: {
          type: "string",
          description: "City and country e.g. Bogotá, Colombia",
        },
      },
      required: ["location"],
      additionalProperties: false,
    },
    strict: true,
  },
];

const response = await client.responses.create({
  model: "gpt-5.6",
  input: [
    { role: "user", content: "What is the weather like in Paris today?" },
  ],
  tools,
});

console.log(response.output[0]);

from openai import OpenAI

client = OpenAI()

tools = [
    {
        "type": "function",
        "name": "get_weather",
        "description": "Get current temperature for a given location.",
        "parameters": {
            "type": "object",
            "properties": {
                "location": {
                    "type": "string",
                    "description": "City and country e.g. Bogotá, Colombia",
                }
            },
            "required": ["location"],
            "additionalProperties": False,
        },
        "strict": True,
    },
]

response = client.responses.create(
    model="gpt-5.6",
    input=[
        {"role": "user", "content": "What is the weather like in Paris today?"},
    ],
    tools=tools,
)

print(response.output[0].to_json())

using System.Text.Json;
using System.Text.Json.Serialization.Metadata;
using OpenAI.Responses;
#pragma warning disable CA1869
#pragma warning disable OPENAI001

string key = Environment.GetEnvironmentVariable("OPENAI_API_KEY")!;
ResponsesClient client = new(key);

CreateResponseOptions options = new() { Model = "gpt-5.6" };
options.Tools.Add(
    ResponseTool.CreateFunctionTool(
        functionName: "get_weather",
        functionDescription: "Get current temperature for a given location.",
        functionParameters: BinaryData.FromString(
            """
            {
                "type": "object",
                "properties": {
                    "location": {
                        "type": "string",
                        "description": "City and country e.g. Bogotá, Colombia"
                    }
                },
                "required": ["location"],
                "additionalProperties": false
            }
            """
        ),
        strictModeEnabled: true
    )
);
options.InputItems.Add(
    ResponseItem.CreateUserMessageItem("What is the weather like in Paris today?")
);

ResponseResult response = client.CreateResponse(options);
Console.WriteLine(
    JsonSerializer.Serialize(
        response.OutputItems[0],
        new JsonSerializerOptions
        {
            TypeInfoResolver = new DefaultJsonTypeInfoResolver(),
        }
    )
);

curl -X POST https://api.openai.com/v1/responses \
  -H "Authorization: Bearer $OPENAI_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "gpt-5.6",
    "input": [
      {"role": "user", "content": "What is the weather like in Paris today?"}
    ],
    "tools": [
      {
        "type": "function",
        "name": "get_weather",
        "description": "Get current temperature for a given location.",
        "parameters": {
          "type": "object",
          "properties": {
            "location": {
              "type": "string",
              "description": "City and country e.g. Bogotá, Colombia"
            }
          },
          "required": ["location"],
          "additionalProperties": false
        },
        "strict": true
      }
    ]
  }'

require "openai"

openai = OpenAI::Client.new

tools = [
  {
    type: "function",
    name: "get_weather",
    description: "Get current temperature for a given location.",
    parameters: {
      type: "object",
      properties: {
        location: {
          type: "string",
          description: "City and country e.g. Bogotá, Colombia"
        }
      },
      required: ["location"],
      additionalProperties: false
    },
    strict: true
  }
]

response = openai.responses.create(
  model: "gpt-5.6",
  input: [
    {role: "user", content: "What is the weather like in Paris today?"}
  ],
  tools: tools
)

puts(response.output.first.to_json)

Remote MCP

Call a remote MCP server

curl https://api.openai.com/v1/responses \ 
-H "Content-Type: application/json" \ 
-H "Authorization: Bearer $OPENAI_API_KEY" \ 
-d '{
  "model": "gpt-5.6",
    "tools": [
      {
        "type": "mcp",
        "server_label": "dmcp",
        "server_description": "A Dungeons and Dragons MCP server to assist with dice rolling.",
        "server_url": "https://dmcp-server.deno.dev/mcp",
        "require_approval": "never"
      }
    ],
    "input": "Roll 2d4+1"
  }'

import OpenAI from "openai";
const client = new OpenAI();

const resp = await client.responses.create({
  model: "gpt-5.6",
  tools: [
    {
      type: "mcp",
      server_label: "dmcp",
      server_description:
        "A Dungeons and Dragons MCP server to assist with dice rolling.",
      server_url: "https://dmcp-server.deno.dev/mcp",
      require_approval: "never",
    },
  ],
  input: "Roll 2d4+1",
});

console.log(resp.output_text);

from openai import OpenAI

client = OpenAI()

resp = client.responses.create(
    model="gpt-5.6",
    tools=[
        {
            "type": "mcp",
            "server_label": "dmcp",
            "server_description": "A Dungeons and Dragons MCP server to assist with dice rolling.",
            "server_url": "https://dmcp-server.deno.dev/mcp",
            "require_approval": "never",
        },
    ],
    input="Roll 2d4+1",
)

print(resp.output_text)

using OpenAI.Responses;
#pragma warning disable OPENAI001

string key = Environment.GetEnvironmentVariable("OPENAI_API_KEY")!;
ResponsesClient client = new(key);

CreateResponseOptions options = new() { Model = "gpt-5.6" };
options.Tools.Add(
    ResponseTool.CreateMcpTool(
        serverLabel: "dmcp",
        serverUri: new Uri("https://dmcp-server.deno.dev/mcp"),
        toolCallApprovalPolicy: GlobalMcpToolCallApprovalPolicy.NeverRequireApproval
    )
);
options.InputItems.Add(ResponseItem.CreateUserMessageItem("Roll 2d4+1"));

ResponseResult response = await client.CreateResponseAsync(options);

Console.WriteLine(response.GetOutputText());

require "openai"

openai = OpenAI::Client.new

response = openai.responses.create(
  model: "gpt-5.6",
  tools: [
    {
      type: "mcp",
      server_label: "dmcp",
      server_description: "A Dungeons and Dragons MCP server to assist with dice rolling.",
      server_url: "https://dmcp-server.deno.dev/mcp",
      require_approval: "never"
    }
  ],
  input: "Roll 2d4+1"
)

puts(response.output_text)

Available tools

Here's an overview of the tools available in the OpenAI platform—select one of them for further guidance on usage.

[Function calling

  Call custom code to give the model access to additional data and
capabilities.](https://developers.openai.com/api/docs/guides/function-calling)

[Web search

  Include data from the Internet in model response generation.](https://developers.openai.com/api/docs/guides/tools-web-search)

[Remote MCP servers

  Give the model access to new capabilities via Model Context Protocol (MCP)
servers.](https://developers.openai.com/api/docs/guides/tools-connectors-mcp)

[Skills

  Upload and reuse versioned skill bundles in hosted shell environments.](https://developers.openai.com/api/docs/guides/tools-skills)

[Shell

  Run shell commands in hosted containers or in your own local runtime.](https://developers.openai.com/api/docs/guides/tools-shell)

[Computer use

  Create agentic workflows that enable a model to control a computer
interface.](https://developers.openai.com/api/docs/guides/tools-computer-use)

[Image generation

  Generate or edit images using GPT Image.](https://developers.openai.com/api/docs/guides/tools-image-generation)

[File search

  Search the contents of uploaded files for context when generating a
response.](https://developers.openai.com/api/docs/guides/tools-file-search)

[Tool search

  Dynamically load relevant tools into the model’s context to optimize token
usage.](https://developers.openai.com/api/docs/guides/tools-tool-search)

[Programmatic Tool Calling

  Let models compose and run JavaScript that orchestrates tool calls.](https://developers.openai.com/api/docs/guides/tools-programmatic-tool-calling)

Usage in the API

When making a request to generate a model response, you usually enable tool access by specifying configurations in the tools parameter. Each tool has its own unique configuration requirements—see the Available tools section for detailed instructions.

Based on the provided prompt, the model automatically decides whether to use a configured tool. For instance, if your prompt requests information beyond the model's training cutoff date and web search is enabled, the model will typically invoke the web search tool to retrieve relevant, up-to-date information.

Some advanced workflows can also load more tool definitions during the interaction. For example, tool search can defer function definitions until the model decides they're needed.

You can explicitly control or guide this behavior by setting the tool_choice parameter in the API request.

Usage in the Agents SDK

In the Agents SDK, the tool semantics stay the same, but the wiring moves into the agent definition and workflow design rather than a single Responses API request.

Attach hosted tools, function tools, or hosted MCP tools directly on the agent when one specialist should call them itself.
Expose a specialist as a tool when a manager should stay in control of the user-facing reply.
Keep shell, apply patch, and computer-use harnesses in your runtime even when the SDK models the tool decision.

Wrap local logic as a function tool

import { tool } from "@openai/agents";
import { z } from "zod";

const getWeatherTool = tool({
  name: "get_weather",
  description: "Get the weather for a given city.",
  parameters: z.object({ city: z.string() }),
  async execute({ city }) {
    return `The weather in ${city} is sunny.`;
  },
});

from agents import function_tool


@function_tool
def get_weather(city: str) -> str:
    """Get the weather for a given city."""
    return f"The weather in {city} is sunny."

Expose a specialist as a tool

import { Agent } from "@openai/agents";

const summarizer = new Agent({
  name: "Summarizer",
  instructions: "Generate a concise summary of the supplied text.",
});

const mainAgent = new Agent({
  name: "Research assistant",
  tools: [
    summarizer.asTool({
      toolName: "summarize_text",
      toolDescription: "Generate a concise summary of the supplied text.",
    }),
  ],
});

from agents import Agent

summarizer = Agent(
    name="Summarizer",
    instructions="Generate a concise summary of the supplied text.",
)

main_agent = Agent(
    name="Research assistant",
    tools=[
        summarizer.as_tool(
            tool_name="summarize_text",
            tool_description="Generate a concise summary of the supplied text.",
        )
    ],
)

Use Agent definitions when you are shaping a single specialist, Orchestration and handoffs when tools affect ownership, Guardrails and human review when tools affect approvals, and Integrations and observability when the capability comes from MCP.

guides/tools.md +114 −125

1# Using tools1# Using tools

2 2

3> For the complete documentation index, see [llms.txt](/llms.txt). Markdown versions of documentation pages are available by appending `.md` to the page URL.

3When generating model responses or building agents, you can extend capabilities using built‑in tools, function calling, Programmatic Tool Calling, tool search, and remote MCP servers. These enable the model to search the web, retrieve from your files, load deferred tool definitions at runtime, call your own functions, compose tool calls in JavaScript, or access third‑party services. Only `gpt-5.4` and later models support `tool_search`.5When generating model responses or building agents, you can extend capabilities using built‑in tools, function calling, Programmatic Tool Calling, tool search, and remote MCP servers. These enable the model to search the web, retrieve from your files, load deferred tool definitions at runtime, call your own functions, compose tool calls in JavaScript, or access third‑party services. Only `gpt-5.4` and later models support `tool_search`.

4 6

5 7

6 8

~~7<div data-content-switcher-pane data-value="web-search">~~9Web search

~~8 <div class="hidden">Web search</div>~~10

9 Include web search results for the model response11 Include web search results for the model response

10 12

11```javascript13```javascript

59 61

60```csharp62```csharp

61using OpenAI.Responses;63using OpenAI.Responses;

64#pragma warning disable OPENAI001

62 65

63string key = Environment.GetEnvironmentVariable("OPENAI_API_KEY")!;66string key = Environment.GetEnvironmentVariable("OPENAI_API_KEY")!;

~~64OpenAIResponseClient client = new(model: "gpt-5.6", apiKey: key);~~67ResponsesClient client = new(key);

65 68

~~66ResponseCreationOptions options = new();~~69CreateResponseOptions options = new() { Model = "gpt-5.6" };

67options.Tools.Add(ResponseTool.CreateWebSearchTool());70options.Tools.Add(ResponseTool.CreateWebSearchTool());

71options.InputItems.Add(

72 ResponseItem.CreateUserMessageItem("What was a positive news story from today?")

73);

68 74

~~69OpenAIResponse response = (OpenAIResponse)client.CreateResponse([~~75ResponseResult response = await client.CreateResponseAsync(options);

~~70 ResponseItem.CreateUserMessageItem([~~

~~71 ResponseContentPart.CreateInputTextPart("What was a positive news story from today?"),~~

~~72 ]),~~

~~73], options);~~

74 76

75Console.WriteLine(response.GetOutputText());77Console.WriteLine(response.GetOutputText());

76```78```

89puts(response.output_text)91puts(response.output_text)

90```92```

91 93

~~92 </div>~~94

~~93 <div data-content-switcher-pane data-value="file-search" hidden>~~95

~~94 <div class="hidden">File search</div>~~96

99File search

100

95 Search your files in a response101 Search your files in a response

96 102

97```python103```python

126 132

127```csharp133```csharp

128using OpenAI.Responses;134using OpenAI.Responses;

135#pragma warning disable OPENAI001

129 136

130string key = Environment.GetEnvironmentVariable("OPENAI_API_KEY")!;137string key = Environment.GetEnvironmentVariable("OPENAI_API_KEY")!;

131OpenAIResponseClient client = new(model: "gpt-5.6", apiKey: key);138ResponsesClient client = new(key);

132 139

133ResponseCreationOptions options = new();140CreateResponseOptions options = new() { Model = "gpt-5.6" };

134options.Tools.Add(ResponseTool.CreateFileSearchTool(["<vector_store_id>"]));141options.Tools.Add(

142 ResponseTool.CreateFileSearchTool(["<vector_store_id>"])

143);

144options.InputItems.Add(

145 ResponseItem.CreateUserMessageItem("What is deep research by OpenAI?")

146);

135 147

136OpenAIResponse response = (OpenAIResponse)client.CreateResponse([148ResponseResult response = await client.CreateResponseAsync(options);

137 ResponseItem.CreateUserMessageItem([

138 ResponseContentPart.CreateInputTextPart("What is deep research by OpenAI?"),

139 ]),

140], options);

141 149

142Console.WriteLine(response.GetOutputText());150Console.WriteLine(response.GetOutputText());

143```151```

161puts(response)169puts(response)

162```170```

163 171

164 </div>172

165 <div data-content-switcher-pane data-value="tool-search" hidden>173

166 <div class="hidden">Tool search</div>174

175

176

177Tool search

178

167 Load deferred tools at runtime179 Load deferred tools at runtime

168 180

169```python181```python

278console.log(response.output);290console.log(response.output);

279```291```

280 292

281 </div>293

282 <div data-content-switcher-pane data-value="function-calling" hidden>294

283 <div class="hidden">Function calling</div>295

296

297

298Function calling

299

284 Call your own function300 Call your own function

285 301

286```javascript302```javascript

357 373

358```csharp374```csharp

359using System.Text.Json;375using System.Text.Json;

376using System.Text.Json.Serialization.Metadata;

360using OpenAI.Responses;377using OpenAI.Responses;

378#pragma warning disable CA1869

379#pragma warning disable OPENAI001

361 380

362string key = Environment.GetEnvironmentVariable("OPENAI_API_KEY")!;381string key = Environment.GetEnvironmentVariable("OPENAI_API_KEY")!;

363OpenAIResponseClient client = new(model: "gpt-5.6", apiKey: key);382ResponsesClient client = new(key);

364 383

365ResponseCreationOptions options = new();384CreateResponseOptions options = new() { Model = "gpt-5.6" };

366options.Tools.Add(ResponseTool.CreateFunctionTool(385options.Tools.Add(

386 ResponseTool.CreateFunctionTool(

367 functionName: "get_weather",387 functionName: "get_weather",

368 functionDescription: "Get current temperature for a given location.",388 functionDescription: "Get current temperature for a given location.",

369 functionParameters: BinaryData.FromObjectAsJson(new389 functionParameters: BinaryData.FromString(

370 {390 """

371 type = "object",

372 properties = new

373 {391 {

374 location = new392 "type": "object",

375 {393 "properties": {

376 type = "string",394 "location": {

377 description = "City and country e.g. Bogotá, Colombia"395 "type": "string",

396 "description": "City and country e.g. Bogotá, Colombia"

378 }397 }

379 },398 },

380 required = new[] { "location" },399 "required": ["location"],

381 additionalProperties = false400 "additionalProperties": false

382 }),401 }

402 """

403 ),

383 strictModeEnabled: true404 strictModeEnabled: true

384 )405 )

385);406);

407options.InputItems.Add(

408 ResponseItem.CreateUserMessageItem("What is the weather like in Paris today?")

409);

386 410

387OpenAIResponse response = (OpenAIResponse)client.CreateResponse([411ResponseResult response = client.CreateResponse(options);

388 ResponseItem.CreateUserMessageItem([412Console.WriteLine(

389 ResponseContentPart.CreateInputTextPart("What is the weather like in Paris today?")413 JsonSerializer.Serialize(

390 ])414 response.OutputItems[0],

391], options);415 new JsonSerializerOptions

~~392~~ 416 {

393Console.WriteLine(JsonSerializer.Serialize(response.OutputItems[0]));417 TypeInfoResolver = new DefaultJsonTypeInfoResolver(),

418 }

419 )

420);

394```421```

395 422

396```bash423```bash

460puts(response.output.first.to_json)487puts(response.output.first.to_json)

461```488```

462 489

463 </div>490

464 <div data-content-switcher-pane data-value="remote-mcp" hidden>491

465 <div class="hidden">Remote MCP</div>492

493

494

495Remote MCP

496

466 Call a remote MCP server497 Call a remote MCP server

467 498

468```bash499```bash

530 561

531```csharp562```csharp

532using OpenAI.Responses;563using OpenAI.Responses;

564#pragma warning disable OPENAI001

533 565

534string key = Environment.GetEnvironmentVariable("OPENAI_API_KEY")!;566string key = Environment.GetEnvironmentVariable("OPENAI_API_KEY")!;

535OpenAIResponseClient client = new(model: "gpt-5.6", apiKey: key);567ResponsesClient client = new(key);

536 568

537ResponseCreationOptions options = new();569CreateResponseOptions options = new() { Model = "gpt-5.6" };

538options.Tools.Add(ResponseTool.CreateMcpTool(570options.Tools.Add(

571 ResponseTool.CreateMcpTool(

539 serverLabel: "dmcp",572 serverLabel: "dmcp",

540 serverUri: new Uri("https://dmcp-server.deno.dev/mcp"),573 serverUri: new Uri("https://dmcp-server.deno.dev/mcp"),

541 toolCallApprovalPolicy: new McpToolCallApprovalPolicy(GlobalMcpToolCallApprovalPolicy.NeverRequireApproval)574 toolCallApprovalPolicy: GlobalMcpToolCallApprovalPolicy.NeverRequireApproval

542));575 )

576);

577options.InputItems.Add(ResponseItem.CreateUserMessageItem("Roll 2d4+1"));

543 578

544OpenAIResponse response = (OpenAIResponse)client.CreateResponse([579ResponseResult response = await client.CreateResponseAsync(options);

545 ResponseItem.CreateUserMessageItem([

546 ResponseContentPart.CreateInputTextPart("Roll 2d4+1")

547 ])

548], options);

549 580

550Console.WriteLine(response.GetOutputText());581Console.WriteLine(response.GetOutputText());

551```582```

572puts(response.output_text)603puts(response.output_text)

573```604```

574 605

575 </div>

~~576~~

577 606

578 607

579## Available tools608## Available tools

580 609

581Here's an overview of the tools available in the OpenAI platform—select one of them for further guidance on usage.610Here's an overview of the tools available in the OpenAI platform—select one of them for further guidance on usage.

582 611

583<a href="/api/docs/guides/function-calling">612[Function calling

~~584~~

585 613

586<span slot="icon">

587 </span>

588 Call custom code to give the model access to additional data and

589 capabilities.

590 614

591 615

592</a>616 Call custom code to give the model access to additional data and

617 capabilities.](https://developers.openai.com/api/docs/guides/function-calling)

593 618

594<a href="/api/docs/guides/tools-web-search">619[Web search

595 620

596 621

597<span slot="icon">

598 </span>

599 Include data from the Internet in model response generation.

600 622

623 Include data from the Internet in model response generation.](https://developers.openai.com/api/docs/guides/tools-web-search)

601 624

602</a>625[Remote MCP servers

603 626

604<a href="/api/docs/guides/tools-connectors-mcp">

605 627

606 628

607<span slot="icon">

608 </span>

609 Give the model access to new capabilities via Model Context Protocol (MCP)629 Give the model access to new capabilities via Model Context Protocol (MCP)

610 servers.630 servers.](https://developers.openai.com/api/docs/guides/tools-connectors-mcp)

~~611~~

~~612~~

613</a>

614 631

615<a href="/api/docs/guides/tools-skills">632[Skills

616 633

617 634

618<span slot="icon">

619 </span>

620 Upload and reuse versioned skill bundles in hosted shell environments.

621 635

636 Upload and reuse versioned skill bundles in hosted shell environments.](https://developers.openai.com/api/docs/guides/tools-skills)

622 637

623</a>638[Shell

624 639

625<a href="/api/docs/guides/tools-shell">

626 640

627 641

628<span slot="icon">642 Run shell commands in hosted containers or in your own local runtime.](https://developers.openai.com/api/docs/guides/tools-shell)

629 </span>

630 Run shell commands in hosted containers or in your own local runtime.

631 643

644[Computer use

632 645

633</a>

634 646

635<a href="/api/docs/guides/tools-computer-use">

636 647

~~637~~

638<span slot="icon">

639 </span>

640 Create agentic workflows that enable a model to control a computer648 Create agentic workflows that enable a model to control a computer

641 interface.649 interface.](https://developers.openai.com/api/docs/guides/tools-computer-use)

~~642~~

643 650

644</a>651[Image generation

645 652

646<a href="/api/docs/guides/tools-image-generation">

647 653

648 654

649<span slot="icon">655 Generate or edit images using GPT Image.](https://developers.openai.com/api/docs/guides/tools-image-generation)

650 </span>

651 Generate or edit images using GPT Image.

652 656

657[File search

653 658

654</a>

655 659

656<a href="/api/docs/guides/tools-file-search">

657 660

~~658~~

659<span slot="icon">

660 </span>

661 Search the contents of uploaded files for context when generating a661 Search the contents of uploaded files for context when generating a

662 response.662 response.](https://developers.openai.com/api/docs/guides/tools-file-search)

~~663~~

664 663

665</a>664[Tool search

666 665

667<a href="/api/docs/guides/tools-tool-search">

668 666

669 667

670<span slot="icon">

671 </span>

672 Dynamically load relevant tools into the model’s context to optimize token668 Dynamically load relevant tools into the model’s context to optimize token

673 usage.669 usage.](https://developers.openai.com/api/docs/guides/tools-tool-search)

~~674~~

~~675~~

676</a>

~~677~~

678<a href="/api/docs/guides/tools-programmatic-tool-calling">

679 670

671[Programmatic Tool Calling

680 672

681<span slot="icon">

682 </span>

683 Let models compose and run JavaScript that orchestrates tool calls.

684 673

685 674

686</a>675 Let models compose and run JavaScript that orchestrates tool calls.](https://developers.openai.com/api/docs/guides/tools-programmatic-tool-calling)

687 676

688## Usage in the API677## Usage in the API

689 678

690When making a request to generate a [model response](https://developers.openai.com/api/docs/api-reference/responses/create), you usually enable tool access by specifying configurations in the `tools` parameter. Each tool has its own unique configuration requirements—see the [Available tools](#available-tools) section for detailed instructions.679When making a request to generate a [model response](https://developers.openai.com/api/reference/resources/responses/methods/create), you usually enable tool access by specifying configurations in the `tools` parameter. Each tool has its own unique configuration requirements—see the [Available tools](#available-tools) section for detailed instructions.

691 680

692Based on the provided [prompt](https://developers.openai.com/api/docs/guides/text), the model automatically decides whether to use a configured tool. For instance, if your prompt requests information beyond the model's training cutoff date and web search is enabled, the model will typically invoke the web search tool to retrieve relevant, up-to-date information.681Based on the provided [prompt](https://developers.openai.com/api/docs/guides/text), the model automatically decides whether to use a configured tool. For instance, if your prompt requests information beyond the model's training cutoff date and web search is enabled, the model will typically invoke the web search tool to retrieve relevant, up-to-date information.

693 682

694Some advanced workflows can also load more tool definitions during the interaction. For example, [tool search](https://developers.openai.com/api/docs/guides/tools-tool-search) can defer function definitions until the model decides they're needed.683Some advanced workflows can also load more tool definitions during the interaction. For example, [tool search](https://developers.openai.com/api/docs/guides/tools-tool-search) can defer function definitions until the model decides they're needed.

695 684

696You can explicitly control or guide this behavior by setting the `tool_choice` parameter [in the API request](https://developers.openai.com/api/docs/api-reference/responses/create).685You can explicitly control or guide this behavior by setting the `tool_choice` parameter [in the API request](https://developers.openai.com/api/reference/resources/responses/methods/create).

697 686

698## Usage in the Agents SDK687## Usage in the Agents SDK

699 688