Sync documentation from cloudflare/agents PR 812

This commit syncs documentation changes from PR 812 which includes:

## New Features Documented

### Scheduling
- scheduleEvery() method for fixed-interval recurring tasks
- Overlap prevention and error resilience
- Comparison between cron and interval scheduling

### MCP Client
- Options-based addMcpServer() API (cleaner alternative to positional params)
- Transport options configuration
- Backward compatibility maintained

### Callable Methods (NEW PAGE)
- @callable decorator for WebSocket RPC
- Streaming with StreamingResponse.error() method
- Client-side RPC timeout support
- Method introspection with getCallableMethods()
- Options-based streaming API

### Custom Routing (NEW PAGE)
- basePath for custom URL routing
- Server-sent identity with onIdentity callbacks
- Identity change handling on reconnect
- Security controls with sendIdentityOnConnect
- Instance naming patterns

### State Management
- Enhanced onStateUpdate with source parameter
- Bidirectional state updates
- Vanilla JS AgentClient examples
- Best practices for avoiding loops

### WebSockets
- Connection management (getConnections, getConnection)
- Connection tags and filtering
- Per-connection state
- Hibernation behavior documentation
- Broadcasting patterns

## New Documentation Pages

- api-reference/callable-methods.mdx - Complete @callable decorator reference
- concepts/routing.mdx - Custom routing and identity management
- getting-started/quickstart.mdx - Comprehensive quickstart guide
- guides/add-to-existing-project.mdx - Integration with existing Workers

## Updated Pages

- api-reference/schedule-tasks.mdx
- api-reference/store-and-sync-state.mdx
- api-reference/websockets.mdx
- model-context-protocol/mcp-client-api.mdx

All documentation follows cloudflare-docs style guidelines with proper
component usage (TypeScriptExample, WranglerConfig, PackageManagers),
full relative links with trailing slashes, and no contractions.

Related PR: cloudflare/agents#812

Co-Authored-By: Claude Sonnet 4.5 <noreply@anthropic.com>

Author: github-actions[bot]

src/content/docs/agents/api-reference/callable-methods.mdx

@@ -9,6 +9,8 @@ import { MetaInfo, Render, Type, TypeScriptExample, WranglerConfig } from "~/com
 
 An Agent can schedule tasks to be run in the future by calling `this.schedule(when, callback, data)`, where `when` can be a delay, a `Date`, or a cron string; `callback` the function name to call, and `data` is an object of data to pass to the function.
 
+For recurring tasks at fixed intervals, use `this.scheduleEvery(intervalSeconds, callback, data)` to run a task repeatedly every N seconds.
+
 Scheduled tasks can do anything a request or message from a user can: make requests, query databases, send emails, read+write state: scheduled tasks can invoke any regular method on your Agent.
 
 :::note[Calling destroy() in scheduled tasks]
@@ -63,19 +65,22 @@ let task = await this.schedule(10, "someTask", { message: "hello" });
 // schedule a task to run at a specific date
 let task = await this.schedule(new Date("2025-01-01"), "someTask", {});
 
-// schedule a task to run every 10 minutes
+// schedule a task to run every 10 minutes (cron)
 let { id } = await this.schedule("*/10 * * * *", "someTask", { message: "hello" });
 
 // schedule a task to run every 10 minutes, but only on Mondays
 let task = await this.schedule("*/10 * * * 1", "someTask", { message: "hello" });
 
+// schedule a task to run every 30 seconds (fixed interval)
+let task = await this.scheduleEvery(30, "poll", { source: "api" });
+
 // cancel a scheduled task
 this.cancelSchedule(task.id);
 ```
 
 </TypeScriptExample>
 
-Calling `await this.schedule` returns a `Schedule`, which includes the task's randomly generated `id`. You can use this `id` to retrieve or cancel the task in the future. It also provides a `type` property that indicates the type of schedule, for example, one of `"scheduled" | "delayed" | "cron"`.
+Calling `await this.schedule` returns a `Schedule`, which includes the task's randomly generated `id`. You can use this `id` to retrieve or cancel the task in the future. It also provides a `type` property that indicates the type of schedule, for example, one of `"scheduled" | "delayed" | "cron" | "interval"`.
 
 :::note[Maximum scheduled tasks]
 
@@ -156,3 +161,92 @@ export class SchedulingAgent extends Agent {
 When `destroy()` is called from within a scheduled task, the Agent SDK defers the destruction to ensure the scheduled callback completes successfully. The Agent instance will be evicted immediately after the callback finishes executing.
 
 :::
+
+### Interval scheduling with scheduleEvery()
+
+Use `this.scheduleEvery()` to run tasks at fixed intervals. This is useful for polling, health checks, or any recurring task that needs sub-minute precision or arbitrary durations that cannot be expressed in cron syntax.
+
+<TypeScriptExample>
+
+```ts
+export class PollingAgent extends Agent {
+	async onRequest(request) {
+		// Poll an API every 30 seconds
+		await this.scheduleEvery(30, "poll", { source: "api" });
+		return new Response("Polling started");
+	}
+
+	async poll(data) {
+		// This runs every 30 seconds
+		const response = await fetch("https://api.example.com/data");
+		const result = await response.json();
+		// Process data...
+	}
+}
+```
+
+</TypeScriptExample>
+
+#### Key differences between cron and interval scheduling
+
+| Feature             | Cron (`schedule`)              | Interval (`scheduleEvery`)     |
+| ------------------- | ------------------------------ | ------------------------------ |
+| Minimum granularity | 1 minute                       | 1 second                       |
+| Arbitrary intervals | No (must fit cron pattern)     | Yes                            |
+| Fixed schedule      | Yes (for example, "every day at 8am") | No (relative to start) |
+| Overlap prevention  | No                             | Yes (built-in)                 |
+
+#### Overlap prevention
+
+If a callback takes longer than the interval, the next execution is skipped to prevent runaway resource usage. A warning is logged when this occurs.
+
+<TypeScriptExample>
+
+```ts
+export class DataSyncAgent extends Agent {
+	async syncData() {
+		// If this takes 45 seconds and interval is 30 seconds,
+		// the next sync is skipped (with a warning logged)
+		const data = await slowExternalApi();
+		await this.processData(data);
+	}
+}
+
+// Set up 30-second interval
+await this.scheduleEvery(30, "syncData", {});
+```
+
+</TypeScriptExample>
+
+#### Error resilience
+
+If the callback throws an error, the interval continues. Only that execution fails:
+
+<TypeScriptExample>
+
+```ts
+async syncData() {
+	// Even if this throws, the interval keeps running
+	const response = await fetch("https://api.example.com/data");
+	if (!response.ok) throw new Error("Sync failed");
+	// ...
+}
+```
+
+</TypeScriptExample>
+
+#### Cancelling interval schedules
+
+To stop an interval schedule, use `cancelSchedule()` with the task ID:
+
+<TypeScriptExample>
+
+```ts
+// Start interval
+const { id } = await this.scheduleEvery(30, "poll", {});
+
+// Stop interval later
+await this.cancelSchedule(id);
+```
+
+</TypeScriptExample>

src/content/docs/agents/api-reference/schedule-tasks.mdx

@@ -19,6 +19,13 @@ State within an Agent is:
 
 Agent state is stored in a SQL database that is embedded within each individual Agent instance: you can interact with it using the higher-level `this.setState` API (recommended), which allows you to sync state and trigger events on state changes, or by directly querying the database with `this.sql`.
 
+State is:
+
+* **Persistent** - Automatically saved to SQLite, survives restarts and hibernation
+* **Synchronized** - Changes broadcast to all connected WebSocket clients instantly
+* **Bidirectional** - Both server and clients can update state
+* **Type-safe** - Full TypeScript support with generics
+
 #### State API
 
 Every Agent has built-in state management capabilities. You can set and update the Agent's state directly using `this.setState`:
@@ -48,8 +55,17 @@ export class MyAgent extends Agent {
   }
 
   // Handle state updates
+  // source is "server" when this.setState() is called
+  // source is Connection when a client pushes state updates
   onStateUpdate(state, source: "server" | Connection) {
     console.log("state updated", state);
+
+    // Ignore server-initiated updates to avoid infinite loops
+    if (source === "server") return;
+
+    // A client updated state - validate and process
+    const connection = source;
+    console.log(`Client ${connection.id} updated state`);
   }
 }
 ```
@@ -127,7 +143,7 @@ Any initial state is synced to clients connecting via [the `useAgent` hook](#syn
 
 Clients can connect to an Agent and stay synchronized with its state using the React hooks provided as part of `agents/react`.
 
-A React application can call `useAgent` to connect to a named Agent over WebSockets at
+A React application can call `useAgent` to connect to a named Agent over WebSockets:
 
 <TypeScriptExample>
 
@@ -145,6 +161,7 @@ function StateInterface() {
   });
 
   const increment = () => {
+    // Client pushes state update to agent
     agent.setState({ counter: state.counter + 1 });
   };
 
@@ -159,6 +176,27 @@ function StateInterface() {
 
 </TypeScriptExample>
 
+For vanilla JavaScript applications, use `AgentClient`:
+
+<TypeScriptExample>
+
+```ts
+import { AgentClient } from "agents/client";
+
+const client = new AgentClient({
+	agent: "game-agent",
+	name: "room-123",
+	onStateUpdate: (state) => {
+		document.getElementById("score").textContent = state.score;
+	}
+});
+
+// Push state update
+client.setState({ ...client.state, score: 100 });
+```
+
+</TypeScriptExample>
+
 The state synchronization system:
 
 * Automatically syncs the Agent's state to all connected clients
@@ -169,10 +207,11 @@ The state synchronization system:
 Common use cases:
 
 * Real-time collaborative features
-* Multi-window/tab synchronization
+* Multi-window or tab synchronization
 * Live updates across multiple devices
 * Maintaining consistent UI state across clients
-* When new clients connect, they automatically receive the current state from the Agent, ensuring all clients start with the latest data.
+
+When new clients connect, they automatically receive the current state from the Agent, ensuring all clients start with the latest data.
 
 ### SQL API