fix

Author: elithrar

src/content/docs/agents/api-reference/http-sse.mdx

@@ -0,0 +1,73 @@
+---
+title: HTTP and Server-Sent Events
+pcx_content_type: concept
+sidebar:
+  order: 8
+
+---
+
+import { MetaInfo, Render, Type, TypeScriptExample, WranglerConfig } from "~/components";
+
+The Agents SDK allows you to handle HTTP requests and has native support for [Server-Sent Events](https://developer.mozilla.org/en-US/docs/Web/API/Server-sent_events) (SSE). This allows you build applications that can push data to clients, avoid buffering
+
+## Handling HTTP requests
+
+Agents can handle HTTP requests using the `onRequest` method, which is called whenever an HTTP request is received by the Agent instance. The method takes a `Request` object as a parameter and returns a `Response` object.
+
+
+
+<TypeScriptExample>
+
+```ts
+class MyAgent extends Agent<Env, State> {
+  // Handle HTTP requests coming to this Agent instance
+  // Returns a Response object
+  async onRequest(request: Request) {
+    return new Response("Hello from Agent!");
+  }
+
+  async callAIModel(prompt: string) {
+  	// Implement AI model call here
+  }
+}
+```
+
+</TypeScriptExample>
+
+Review the [Agents API reference](/agents/api-reference/agents-api/) to learn more about the `Agent` class and its methods.
+
+### Implementing Server-Sent Events
+
+TODO
+<TypeScriptExample>
+
+```ts
+import { Agent } from "agents-sdk";
+import { streamText } from 'ai';
+import { createOpenAI, openai } from '@ai-sdk/openai';
+
+interface Env {
+	OPENAI_API_KEY: string;
+}
+
+class MyAgent extends Agent<Env> {
+  // Handle HTTP requests coming to this Agent instance
+  // Returns a Response object
+  async onRequest(request: Request) {
+    return new Response("Hello from Agent!");
+  }
+
+  async callAIModel(prompt: string) {
+ 		const openai = createOpenAI({
+  	  // custom settings, e.g.
+  	  compatibility: 'strict', // strict mode, enable when using the OpenAI API
+  	});
+  	}
+}
+```
+
+</TypeScriptExample>
+
+## WebSockets vs. Server-Sent Events
+
+TODO

src/content/docs/agents/api-reference/using-ai-models.mdx

@@ -8,9 +8,17 @@ sidebar:
 
 import { AnchorHeading, MetaInfo, Render, Type, TypeScriptExample, WranglerConfig } from "~/components";
 
-Agents can communicate with AI models hosted on any provider, including [Workers AI](/workers-ai/), OpenAI, Anthropic, and Google's Gemini, and use the model routing features in [AI Gateway](/ai-gateway/) to route across providers, eval responses, and manage AI provider rate limits.
+Agents can communicate with AI models hosted on any provider, including:
 
-Because Agents are built on top of [Durable Objects](/durable-objects/), each Agent or chat session is associated with a stateful compute instance. Tradtional serverless architectures often present challenges for persistent connections needed in real-time applications like chat.
+* [Workers AI](/workers-ai/)
+* The [AI SDK](https://sdk.vercel.ai/docs/ai-sdk-core/overview)
+* [OpenAI](https://platform.openai.com/docs/quickstart?language=javascript)
+* [Anthropic](https://docs.anthropic.com/en/api/client-sdks#typescript
+* [Google's Gemini](https://ai.google.dev/gemini-api/docs/openai)
+
+You can also use the model routing features in [AI Gateway](/ai-gateway/) to route across providers, eval responses, and manage AI provider rate limits.
+
+Because Agents are built on top of [Durable Objects](/durable-objects/), each Agent or chat session is associated with a stateful compute instance. Traditional serverless architectures often present challenges for persistent connections needed in real-time applications like chat.
 
 A user can disconnect during a long-running response from a modern reasoning model (such as `o3-mini` or DeepSeek R1), or lose conversational context when refreshing the browser. Instead of relying on request-response patterns and managing an external database to track & store conversation state, state can be stored directly within the Agent. If a client disconnects, the Agent can write to its own distributed storage, and catch the client up as soon as it reconnects: even if it's hours or days later.
 
@@ -34,7 +42,7 @@ import { OpenAI } from "openai"
 
 export class MyAgent extends Agent<Env> {
 	async onConnect(connection: Connection, ctx: ConnectionContext) {
-		// 
+		//
 	}
 
 	async onMessage(connection: Connection, message: WSMessage) {

src/content/docs/agents/api-reference/websockets.mdx

@@ -2,7 +2,7 @@
 title: Using WebSockets
 pcx_content_type: concept
 sidebar:
-  order: 8
+  order: 10
 
 ---
 

src/content/docs/agents/getting-started/quickstart.mdx

@@ -6,33 +6,43 @@ sidebar:
 
 ---
 
-import { Render, GitHubCode, PackageManagers, TypeScriptExample, WranglerConfig } from "~/components"
+import { Render, FileTree, GitHubCode, PackageManagers, TypeScriptExample, WranglerConfig } from "~/components"
 
-This quick start tutorial will have you build a basic Agent that can generate code based on user questions. It will show you how the Agent SDK works, how to handle requests, store and sync state from within the Agent itself, and how to route to and call Agents from your Workers code.
+This quick start tutorial will have you build a basic Agent that can generate code based on user prompts.
+
+It will show you how the Agent SDK works, how to handle requests, call AI models, store and sync state from within the Agent itself, and how to route to and call Agents from your Workers code.
 
 ### Prerequisites
 
 <Render file="prereqs" product="workers" />
 
 ### Setup the Agent
 
-You can fetch the quick start project using the following command:
+You can fetch the quick start code using the following command:
 
 ```sh
 npm create cloudflare@latest agents-quick-start -- --template="cloudflare/agents-quick-start"
 ```
 
-This will create a new directory called `agents-quick-start`, ask you a few basic questions, and install the necessary dependencies.
+This will create a new directory called `agents-quick-start`, ask you a few basic questions (select yes), and install the necessary dependencies.
 
 Once complete, change into the Agent's directory:
 
 ```sh
 cd agents-quick-start
 ```
 
+Inside this directory, there are a number of files, but we only need to worry about two for now:
+
+* `src/index.ts` - contains your Agent's code
+* `wrangler.jsonc` - defines the configuration for your Worker & Agent
+
+Let's take a look at how the Agent in the quick start is defined.
 
 ### Understand the Agent class
 
+Open the `src/index.ts` file in your editor:
+
 TODO
 
 ### Run your Agent
@@ -57,7 +67,7 @@ Starting local server...
 [wrangler:inf] Ready on http://localhost:8787
 ```
 
-Your Agent is now running locally on your machine, and ready to communicate with the outside world. Leave this server running so we can talk to your Agent in the next step.
+Your Agent is now running locally on your machine, and ready to communicate with the outside world. Make sure to leave this server running so we can talk to your Agent in the next step.
 
 ### Communicate with your Agent
 
@@ -82,6 +92,7 @@ wscat --connect "ws://localhost:8787/agents/my-agent/abc123def"
 ```
 
 
+
 #### Agent routing
 
 In the `agents-quick-start` we use the `routeAgentRequest` helper to automatically handle routing to existing and creating new Agent instances on-the-fly.
@@ -108,31 +119,41 @@ export default {
 
 You can learn about more ways to call into your Agents, as well as how to add authentication in front of your Agents, by reviewing [documentation on Calling Agents](/agents/api-reference/calling-agents/).
 
-### Deploy your Agent
+### Ship to production
 
 OK, we've:
 
 1. Learned how the `Agent` class works and how to define our own Agents using the Agents SDK.
 2. Run our Agent locally and communicated with it.
 3. Reviewed how routing to an Agent works, including how Agents are created and retrieved.
 
-Let's deploy our Agent
+Let's deploy our Agent using `wrangler`, which was installed when we originally used `npm create cloudflare`:
 
-### Extend the Agent
+```sh
+npx wrangler@latest deploy
+```
 
-TODO;
+If this is your first time deploying to Cloudflare Workers, you'll be asked to login. Otherwise, you'll see output similar to the following, including a `workers.dev` URL that allows you access any public endpoints your Agent exposes:
 
-- AI SDK
+```sh output
 
+```
 
-<TypeScriptExample>
+You can then use `wscat` to talk to your Agent running in production on Cloudflare's global network:
 
-```ts
-async aiSDKChat() {
+```sh
+wscat --connect="wss://agents-quick-start.YOUR_SUBDOMAIN.workers.dev/agents/my-agent/user-id-12345
+```
 
+TODO - debug / logs / errors / tail
+
+### Extend the Agent
+
+TODO;
+
+- AI SDK
+- Adding a new tool
 
-}
-```
 
 </TypeScriptExample>
 
@@ -142,9 +163,11 @@ TODO: delete
 
 ### Next steps
 
-What's next?
+If you're looking to build a more complex Agent, you can use the Agents SDK to build a fully-functioning AI Agent with a React front-end, tool calling, and state sync that is built on the Agents SDK with the [Agents SDK starter app](/agents/getting-started/build-a-chat-agent/).
+
+Otherwise, you can:
 
-* Deploy the [Agents SDK starter app](/agents/getting-started/build-a-chat-agent/): a fully-functioning AI Agent with a React front-end, tool calling, and state sync that is built on the Agents SDK.
 * Review the [Agents API reference](/agents/api-reference/creating-agents/) and the APIs exposed by the Agents SDK.
 * Learn more [using WebSockets](/agents/api-reference/websockets/) to build interactive Agents and stream data back from your Agent.
-* [Orchestrate asynchronous workflows](/agents/api-reference/run-workflows) from your Agent by combining the `agents-sdk` and [Workflows](/workflows).
+* [Orchestrate asynchronous workflows](/agents/api-reference/run-workflows) from your Agent by combining the Agents SDK and [Workflows](/workflows).
+* How to [schedule tasks](/agents/api-reference/schedule-tasks) from within your Agent using the `this.schedule` API.