导航|地址|刷新
HTTP and Server-Sent Events

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.

Docs Directory API SDKs Changelog

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

/…
Runtime

/Communication

/HTTP and Server-Sent Events

HTTP and Server-Sent Events

Last updated Jun 3, 2026|Copy as Markdown|View as Markdown|Agent setup

OverviewHandling HTTP requestsServer-Sent Events (SSE) Manual SSE SSE message format With AI SDKConnection handlingWebSockets vs SSENext steps

Agents can handle HTTP requests and stream responses using Server-Sent Events (SSE). This page covers the onRequest method and SSE patterns.

Handling HTTP requests

Define the onRequest method to handle HTTP requests to your agent:

import { Agent } from "agents";export class APIAgent extends Agent { async onRequest(request) { const url = new URL(request.url); // Route based on path if (url.pathname.endsWith("/status")) { return Response.json({ status: "ok", state: this.state }); } if (url.pathname.endsWith("/action")) { if (request.method !== "POST") { return new Response("Method not allowed", { status: 405 }); } const data = await request.json(); await this.processAction(data.action); return Response.json({ success: true }); } return new Response("Not found", { status: 404 }); } async processAction(action) { // Handle the action }}

import { Agent } from "agents";export class APIAgent extends Agent { async onRequest(request: Request): Promise<Response> { const url = new URL(request.url); // Route based on path if (url.pathname.endsWith("/status")) { return Response.json({ status: "ok", state: this.state }); } if (url.pathname.endsWith("/action")) { if (request.method !== "POST") { return new Response("Method not allowed", { status: 405 }); } const data = await request.json<{ action: string }>(); await this.processAction(data.action); return Response.json({ success: true }); } return new Response("Not found", { status: 404 }); } async processAction(action: string) { // Handle the action }}

Server-Sent Events (SSE)

SSE allows you to stream data to clients over a long-running HTTP connection. This is ideal for AI model responses that generate tokens incrementally.

Manual SSE

Create an SSE stream manually using ReadableStream:

export class StreamAgent extends Agent { async onRequest(request) { const encoder = new TextEncoder(); const stream = new ReadableStream({ async start(controller) { // Send events controller.enqueue(encoder.encode("data: Starting...\n\n")); for (let i = 1; i <= 5; i++) { await new Promise((r) => setTimeout(r, 500)); controller.enqueue(encoder.encode(`data: Step ${i} complete\n\n`)); } controller.enqueue(encoder.encode("data: Done!\n\n")); controller.close(); }, }); return new Response(stream, { headers: { "Content-Type": "text/event-stream", "Cache-Control": "no-cache", Connection: "keep-alive", }, }); }}

export class StreamAgent extends Agent { async onRequest(request: Request): Promise<Response> { const encoder = new TextEncoder(); const stream = new ReadableStream({ async start(controller) { // Send events controller.enqueue(encoder.encode("data: Starting...\n\n")); for (let i = 1; i <= 5; i++) { await new Promise((r) => setTimeout(r, 500)); controller.enqueue(encoder.encode(`data: Step ${i} complete\n\n`)); } controller.enqueue(encoder.encode("data: Done!\n\n")); controller.close(); }, }); return new Response(stream, { headers: { "Content-Type": "text/event-stream", "Cache-Control": "no-cache", Connection: "keep-alive", }, }); }}

SSE message format

SSE messages follow a specific format:
data: your message here\n\n
You can also include event types and IDs:
event: update\nid: 123\ndata: {"count": 42}\n\n

With AI SDK

The AI SDK ↗ provides built-in SSE streaming:

import { Agent } from "agents";import { streamText } from "ai";import { createWorkersAI } from "workers-ai-provider";export class ChatAgent extends Agent { async onRequest(request) { const { prompt } = await request.json(); const workersai = createWorkersAI({ binding: this.env.AI }); const result = streamText({ model: workersai("@cf/zai-org/glm-4.7-flash"), prompt: prompt, }); return result.toTextStreamResponse(); }}

import { Agent } from "agents";import { streamText } from "ai";import { createWorkersAI } from "workers-ai-provider";interface Env { AI: Ai;}export class ChatAgent extends Agent<Env> { async onRequest(request: Request): Promise<Response> { const { prompt } = await request.json<{ prompt: string }>(); const workersai = createWorkersAI({ binding: this.env.AI }); const result = streamText({ model: workersai("@cf/zai-org/glm-4.7-flash"), prompt: prompt, }); return result.toTextStreamResponse(); }}

Connection handling

SSE connections can be long-lived. Handle client disconnects gracefully:

Persist progress — Write to agent state so clients can resume

Use agent routing — Clients can reconnect to the same agent instance without session stores

No timeout limits — Cloudflare Workers have no effective limit on SSE response duration

export class ResumeAgent extends Agent { async onRequest(request) { const url = new URL(request.url); const lastEventId = request.headers.get("Last-Event-ID"); if (lastEventId) { // Client is resuming - send events after lastEventId return this.resumeStream(lastEventId); } return this.startStream(); } async startStream() { // Start new stream, saving progress to this.state } async resumeStream(fromId) { // Resume from saved state }}

export class ResumeAgent extends Agent { async onRequest(request: Request): Promise<Response> { const url = new URL(request.url); const lastEventId = request.headers.get("Last-Event-ID"); if (lastEventId) { // Client is resuming - send events after lastEventId return this.resumeStream(lastEventId); } return this.startStream(); } async startStream(): Promise<Response> { // Start new stream, saving progress to this.state } async resumeStream(fromId: string): Promise<Response> { // Resume from saved state }}

WebSockets vs SSE

Feature WebSockets SSE
Direction Bi-directional Server → Client only
Protocol ws:// / wss:// HTTP
Binary data Yes No (text only)
Reconnection Manual Automatic (browser)
Best for Interactive apps, chat Streaming responses, notifications

Recommendation: Use WebSockets for interactive applications. Use SSE for streaming AI responses or server-push notifications.

Refer to WebSockets for WebSocket documentation.

Next steps

WebSockets

Bi-directional real-time communication.

State management

Persist stream progress and agent state.

Build a chat agent

Streaming responses with AI chat.

PreviousWebSocketsNextChat SDK

Was this helpful?

YesNo

Edit pageReport issue

On this page

Overview

Handling HTTP requests

Server-Sent Events (SSE)

Manual SSE

SSE message format

With AI SDK

Connection handling

WebSockets vs SSE

Next steps

Edit pageReport issue

Getting started
PlansContact salesPartnersFind a partnerStartupsUnder attack?Domain name search

Company
AboutCareersInvestorsPressPress kitGlobal network

Public interest
Project GalileoAthenian ProjectCloudflare for CampaignsProject FairshotImpact/ESG

Compliance
Compliance resourcesTrust HubData ProtectionResponsible AITransparency reportReport abuse

Resources
App innovation reportCloudflare RadarCase studiesStatusSupportEventsBlog

Developers
DocumentationLearning centerCommunity

Solutions
SSE and SASE platformCloudflare AI CloudAI SecurityFrontend Development PlatformMulti-Tenant Platform DevelopmentWeb Security Platform

Start BuildingLog In

© 2026 Cloudflare, Inc.

Privacy policy|Report security issues|Terms of use|Trademark
|
Your privacy choices

Docs

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

Feature	WebSockets	SSE
Direction	Bi-directional	Server → Client only
Protocol	ws:// / wss://	HTTP
Binary data	Yes	No (text only)
Reconnection	Manual	Automatic (browser)
Best for	Interactive apps, chat	Streaming responses, notifications