导航|地址|刷新
Tools

Skip to contentDocumentation Index
Fetch the complete documentation index at: https://developers.cloudflare.com/agents/llms.txt
Use this file to discover all available pages before exploring further.



DocsDirectoryAPISDKsChangelog

Search

Log in






Agents

/




Overview


Getting started


Quick start

Add to existing project

Testing your Agents






Concepts


What are agents?

Conversation state and memory

Tools

Calling LLMs

Using Agents with Workflows


Agentic patterns


Overview

Human-in-the-loop patterns

Long-running agents










Communication channels



Chat


Chat agents

Autonomous responses

Client SDK





Voice

Email

Slack


Webhooks


Overview

Push notifications










Tools


Sandbox

MCP

Browser

AI Search


Agentic Payments


Overview

Charge for HTTP content


x402


Overview

Charge for HTTP content

Charge for MCP tools

Pay from Agents SDK

Pay from coding tools





MPP (Machine Payments Protocol)






Code Mode


Overview

Create a durable Code Mode runtime

AI SDK integration

Use Code Mode with TanStack AI

Browser-owned tools

MCP

OpenAPI

How Code Mode works

Code Mode API reference










Harnesses


Overview


Think


Overview

Getting started

Configuration

Tools

Actions

Lifecycle hooks

Client tools

Messengers

Channels

Scheduled tasks

Workflows

Sub-agent RPC and programmatic turns

Programmatic submissions

Durable recovery










Runtime


Agents API


Lifecycle


Agent class internals

Callable methods

Store and sync state

Sessions

getCurrentAgent()






Communication


Routing

WebSockets

HTTP and Server-Sent Events

Chat SDK

Protocol messages

Readonly connections






Execution


Sub-agents

Schedule tasks

Durable execution with fibers

Queue tasks

Retries

Run Workflows

Agents as tools

Agent Skills






Operations


Configuration

Cross-domain authentication

Using AI Models

Observability










Examples


Chat agent

Slack agent

Voice agent

Browser agent

Email agent






Model Context Protocol (MCP)


Overview


APIs


MCP handler APIs

McpAgent

McpClient






Protocol


Tools

Authorization

Transport

MCP governance






Guides


Build MCP client

Build a Remote MCP server

Test a Remote MCP Server

Securing MCP servers

Connect to an MCP server

Handle OAuth with MCP servers

Migrate to MCP SDK v2

Build a single-tool Code Mode MCP server

Build a search and execute MCP server






Cloudflare


MCP server portals ↗


Cloudflare's own MCP servers


Overview

Cloudflare Community MCP Server









Code Mode MCP server patterns






Platform


Limits






Agent resources


Agent setup ↗

Cloudflare Skills ↗

Code Mode MCP Server ↗

Domain-specific MCP Servers ↗MCP

Agents llms.txt ↗

Agents llms-full.txt ↗

Cloudflare Docs llms.txt ↗

Cloudflare Docs llms-full.txt ↗













Home

/Agents

/…
Harnesses


/Think

/Tools



Tools


Last updated Jul 22, 2026|Copy as Markdown|View as Markdown|Agent setup

OverviewTool merge orderBuilt-in workspace tools R2 spilloverCustom toolsTool approvalPer-turn tool overridesMCP toolsCode execution tool Approvals (human-in-the-loop) The runtime handleBrowser toolsExtensions Static extensions LLM-driven extensions Extension context blocksCustom workspace backends




Think provides built-in workspace file tools on every turn, plus integration points for custom tools, code execution, and dynamic extensions.


Tool merge order


On every turn, Think merges tools from multiple sources. Later sources override earlier ones if names collide:

Workspace tools — read, write, edit, list, find, grep, delete, bash (built-in)

getTools() — your custom server-side tools

Extension tools — tools from loaded extensions (prefixed by extension name)

Session tools — set_context, load_context, search_context (from configureSession)

Skill tools — activate_skill, read_skill_resource, run_skill_script (from getSkills(), refer to Agent Skills)

MCP tools — from connected MCP servers when includeMcpTools is true

Client tools — from the browser (refer to Client tools)

Tools belong to the agent running the turn. For parent-child orchestration, use Agents as tools instead of passing one-off tools through chat().


Built-in workspace tools


Every Think agent gets this.workspace — a virtual filesystem backed by Durable Object SQLite. Workspace tools are automatically available to the model with no configuration.

Tool	Description
read	Read text with line numbers; pass images and PDFs to multimodal models
write	Write content to a file (creates parent directories)
edit	Apply a find-and-replace edit to an existing file (supports fuzzy matching)
list	List files and directories in a path
find	Find files matching a glob pattern
grep	Search file contents by regex or fixed string
delete	Delete a file or directory
bash	Run a sandboxed Bash script against workspace files

The bash tool is enabled by default. It mounts workspace files into a just-bash virtual filesystem, runs with network access disabled, and writes created, updated, and deleted files and empty directories back to the workspace. Use it for shell-style workflows that combine multiple file operations; use the narrower tools for simple reads, writes, and edits.

To keep tool calls bounded, the Bash tool snapshots up to 1,000 workspace files by default and skips files larger than 1 MB. Skipped files are reported in the tool result and are treated as protected during write-back so the script cannot accidentally overwrite or delete content that was not mounted. You can tune maxWorkspaceFiles, maxWorkspaceFileBytes, maxOutputBytes, timeout, and network through workspaceBash.

Disable the default Bash tool for conservative deployments:






export class MyAgent extends Think { workspaceBash = false; getModel() { /* ... */ }}

export class MyAgent extends Think<Env> { workspaceBash = false; getModel() { /* ... */ }}





R2 spillover


By default, the workspace stores everything in SQLite. For large files, override workspace to add R2 spillover:






import { Think } from "@cloudflare/think";import { Workspace } from "@cloudflare/shell";export class MyAgent extends Think { workspace = new Workspace({ sql: this.ctx.storage.sql, r2: this.env.R2, name: () => this.name, }); getModel() { /* ... */ }}

import { Think } from "@cloudflare/think";import { Workspace } from "@cloudflare/shell";export class MyAgent extends Think<Env> { override workspace = new Workspace({ sql: this.ctx.storage.sql, r2: this.env.R2, name: () => this.name, }); getModel() { /* ... */ }}




This requires an R2 bucket binding:





{ "$schema": "./node_modules/wrangler/config-schema.json", "r2_buckets": [ { "binding": "R2", "bucket_name": "agent-files" } ]}

[[r2_buckets]]binding = "R2"bucket_name = "agent-files"




Custom tools


Override getTools() to add your own tools. These are standard AI SDK tool() definitions with Zod schemas:






import { Think } from "@cloudflare/think";import { tool } from "ai";import { z } from "zod";export class MyAgent extends Think { getModel() { /* ... */ } getTools() { return { getWeather: tool({ description: "Get the current weather for a city", inputSchema: z.object({ city: z.string().describe("City name"), }), execute: async ({ city }) => { const res = await fetch( `https://api.weather.com/v1/current?q=${city}&key=${this.env.WEATHER_KEY}`, ); return res.json(); }, }), }; }}

import { Think } from "@cloudflare/think";import { tool } from "ai";import type { ToolSet } from "ai";import { z } from "zod";export class MyAgent extends Think<Env> { getModel() { /* ... */ } getTools(): ToolSet { return { getWeather: tool({ description: "Get the current weather for a city", inputSchema: z.object({ city: z.string().describe("City name"), }), execute: async ({ city }) => { const res = await fetch( `https://api.weather.com/v1/current?q=${city}&key=${this.env.WEATHER_KEY}`, ); return res.json(); }, }), }; }}




Custom tools are merged with workspace tools automatically. If a custom tool has the same name as a workspace tool, the custom tool wins.


Tool approval


Tools can require user approval before execution using the needsApproval option:
getTools(): ToolSet { return { deleteFile: tool({ description: "Delete a file from the system", inputSchema: z.object({ path: z.string() }), needsApproval: async ({ path }) => path.startsWith("/important/"), execute: async ({ path }) => { await this.workspace.rm(path); return { deleted: path }; }, }), };}
When needsApproval returns true, the tool call is sent to the client for approval. The conversation pauses until the client responds with CF_AGENT_TOOL_APPROVAL.


Note


Inside the code execution tool's sandbox, needsApproval behaves differently: it maps to the Code Mode runtime's durable pause/approve/resume flow, and a function-valued needsApproval always requires approval. Refer to Approvals (human-in-the-loop).




Per-turn tool overrides


The beforeTurn hook can restrict or add tools for a specific turn:
beforeTurn(ctx: TurnContext) { return { activeTools: ["read", "write", "getWeather"], tools: { emergencyTool: this.createEmergencyTool() }, };}
activeTools limits which tools the model can call. tools adds extra tools for this turn only (merged on top of existing tools).


MCP tools


Think inherits MCP client support from the Agent base class. By default, Think converts tools from connected MCP servers to AI SDK tools and adds them to every turn.

Set waitForMcpConnections to ensure MCP servers are connected before inference runs:






export class MyAgent extends Think { waitForMcpConnections = true; // default 10s timeout // or: waitForMcpConnections = { timeout: 5000 }; getModel() { /* ... */ }}

export class MyAgent extends Think<Env> { waitForMcpConnections = true; // default 10s timeout // or: waitForMcpConnections = { timeout: 5000 }; getModel() { /* ... */ }}




If you expose MCP tools through Code Mode or another mechanism outside Think's automatic tool set, turn off direct AI SDK tool exposure:






export class MyAgent extends Think { includeMcpTools = false; waitForMcpConnections = true; getModel() { /* ... */ }}

export class MyAgent extends Think<Env> { includeMcpTools = false; waitForMcpConnections = true; getModel() { /* ... */ }}




includeMcpTools controls only the automatic model tool merge. MCP connections still register, restore, discover, and wait. Raw catalog access, direct calls, Code Mode connectors, and explicit this.mcp.getAITools() calls continue to work.

Use this property instead of removing MCP tool names through activeTools in beforeTurn. Think converts MCP schemas before it calls beforeTurn, so activeTools cannot avoid that conversion. To configure a connector runtime, refer to Use MCP tools with Code Mode.

Add MCP servers programmatically or via @callable methods:






import { callable } from "agents";export class MyAgent extends Think { getModel() { /* ... */ } @callable() async addServer(name, url) { return await this.addMcpServer(name, url); } @callable() async removeServer(serverId) { await this.removeMcpServer(serverId); }}

import { callable } from "agents";export class MyAgent extends Think<Env> { getModel() { /* ... */ } @callable() async addServer(name: string, url: string) { return await this.addMcpServer(name, url); } @callable() async removeServer(serverId: string) { await this.removeMcpServer(serverId); }}





Code execution tool


Let the LLM write and run JavaScript in a sandboxed Worker, recorded on a durable Code Mode runtime (abort-and-replay, human approvals, audit trail, reusable snippets). Requires @cloudflare/codemode and a worker_loaders binding.
npm install @cloudflare/codemode
The one-liner infers everything from the agent — state.* from this.workspace, the executor from env.LOADER, and a live browser (cdp.*) from env.BROWSER if bound:






import { Think } from "@cloudflare/think";import { createExecuteTool } from "@cloudflare/think/tools/execute";export class MyAgent extends Think { getModel() { /* ... */ } getTools() { return { execute: createExecuteTool(this), }; }}

import { Think } from "@cloudflare/think";import { createExecuteTool } from "@cloudflare/think/tools/execute";export class MyAgent extends Think<Env> { getModel() { /* ... */ } getTools() { return { execute: createExecuteTool(this), }; }}




Setup checklist:





{ "$schema": "./node_modules/wrangler/config-schema.json", "worker_loaders": [ { "binding": "LOADER" } ], "browser": { "binding": "BROWSER" }}

[[worker_loaders]]binding = "LOADER"[browser]binding = "BROWSER" # optional — enables cdp.*








// worker entry — the runtime lives in a Durable Object facet, so the class// must be exported (the @cloudflare/codemode/vite plugin does this// automatically; the Think framework's generated entry already includes it)export { CodemodeRuntime } from "@cloudflare/codemode";

// worker entry — the runtime lives in a Durable Object facet, so the class// must be exported (the @cloudflare/codemode/vite plugin does this// automatically; the Think framework's generated entry already includes it)export { CodemodeRuntime } from "@cloudflare/codemode";




Each missing piece fails with an error naming the step.

Inside the sandbox the model sees typed namespaces plus the platform SDK:

tools.* — your AI SDK tools (object args, validated against their schemas). Only tools with an execute function are exposed — client-side tools cannot run in the sandbox.

state.* — the workspace filesystem (state.readFile({ path }), state.glob({ pattern }), state.planEdits(...), and so on).

cdp.* — the browser, when a Browser Run binding is configured. The execute tool defaults to session: { mode: "dynamic" }: sessions are per-execution unless the model promotes one with cdp.startSession().

codemode.search / codemode.describe / codemode.step / codemode.run — discovery, side-effect boundaries, and saved snippets.

Pass overrides for anything beyond the defaults — for example, custom tools.* alongside the agent-derived state:






execute: createExecuteTool(this, { tools: myDomainTools });

execute: createExecuteTool(this, { tools: myDomainTools });




Or fully explicit options (no agent inference):






import { createWorkspaceStateBackend } from "@cloudflare/shell";createExecuteTool({ ctx: this.ctx, tools: myDomainTools, state: createWorkspaceStateBackend(this.workspace), browser: this.env.BROWSER, loader: this.env.LOADER,});

import { createWorkspaceStateBackend } from "@cloudflare/shell";createExecuteTool({ ctx:
…(内容过长已截断)

------
导航页 打开网址