84 | // wrangler.jsonc
85 | {
86 | "name": "app-name-goes-here", // name of the app
87 | "main": "src/index.ts", // default file
88 | "compatibility_date": "2025-02-11",
89 | "compatibility_flags": ["nodejs_compat"], // Enable Node.js compatibility
90 | "observability": {
91 | // Enable logging by default
92 | "enabled": true,
93 | }
94 | }
95 |
96 |
182 | import { DurableObject } from "cloudflare:workers";
183 |
184 | interface Env {
185 | WEBSOCKET_HIBERNATION_SERVER: DurableObject;
186 | }
187 |
188 | // Durable Object
189 | export class WebSocketHibernationServer extends DurableObject {
190 | async fetch(request) {
191 | // Creates two ends of a WebSocket connection.
192 | const webSocketPair = new WebSocketPair();
193 | const [client, server] = Object.values(webSocketPair);
194 |
195 | // Calling `acceptWebSocket()` informs the runtime that this WebSocket is to begin terminating
196 | // request within the Durable Object. It has the effect of "accepting" the connection,
197 | // and allowing the WebSocket to send and receive messages.
198 | // Unlike `ws.accept()`, `state.acceptWebSocket(ws)` informs the Workers Runtime that the WebSocket
199 | // is "hibernatable", so the runtime does not need to pin this Durable Object to memory while
200 | // the connection is open. During periods of inactivity, the Durable Object can be evicted
201 | // from memory, but the WebSocket connection will remain open. If at some later point the
202 | // WebSocket receives a message, the runtime will recreate the Durable Object
203 | // (run the `constructor`) and deliver the message to the appropriate handler.
204 | this.ctx.acceptWebSocket(server);
205 |
206 | return new Response(null, {
207 | status: 101,
208 | webSocket: client,
209 | });
210 |
211 | },
212 |
213 | async webSocketMessage(ws: WebSocket, message: string | ArrayBuffer): void | Promise {
214 | // Upon receiving a message from the client, reply with the same message,
215 | // but will prefix the message with "[Durable Object]: " and return the
216 | // total number of connections.
217 | ws.send(
218 | `[Durable Object] message: ${message}, connections: ${this.ctx.getWebSockets().length}`,
219 | );
220 | },
221 |
222 | async webSocketClose(ws: WebSocket, code: number, reason: string, wasClean: boolean) void | Promise {
223 | // If the client closes the connection, the runtime will invoke the webSocketClose() handler.
224 | ws.close(code, "Durable Object is closing WebSocket");
225 | },
226 |
227 | async webSocketError(ws: WebSocket, error: unknown): void | Promise {
228 | console.error("WebSocket error:", error);
229 | ws.close(1011, "WebSocket error");
230 | }
231 |
232 | }
233 |
234 |
235 |
236 |
273 | import { DurableObject } from "cloudflare:workers";
274 |
275 | interface Env {
276 | ALARM_EXAMPLE: DurableObject;
277 | }
278 |
279 | export default {
280 | async fetch(request, env) {
281 | let url = new URL(request.url);
282 | let userId = url.searchParams.get("userId") || crypto.randomUUID();
283 | let id = env.ALARM_EXAMPLE.idFromName(userId);
284 | return await env.ALARM_EXAMPLE.get(id).fetch(request);
285 | },
286 | };
287 |
288 | const SECONDS = 1000;
289 |
290 | export class AlarmExample extends DurableObject {
291 | constructor(ctx, env) {
292 | this.ctx = ctx;
293 | this.storage = ctx.storage;
294 | }
295 | async fetch(request) {
296 | // If there is no alarm currently set, set one for 10 seconds from now
297 | let currentAlarm = await this.storage.getAlarm();
298 | if (currentAlarm == null) {
299 | this.storage.setAlarm(Date.now() + 10 \_ SECONDS);
300 | }
301 | }
302 | async alarm(alarmInfo) {
303 | // The alarm handler will be invoked whenever an alarm fires.
304 | // You can use this to do work, read from the Storage API, make HTTP calls
305 | // and set future alarms to run using this.storage.setAlarm() from within this handler.
306 | if (alarmInfo?.retryCount != 0) {
307 | console.log("This alarm event has been attempted ${alarmInfo?.retryCount} times before.");
308 | }
309 |
310 | // Set a new alarm for 10 seconds from now before exiting the handler
311 | this.storage.setAlarm(Date.now() + 10 \_ SECONDS);
312 | }
313 | }
314 |
315 |
316 |
317 |
351 | // src/index.ts
352 | import { Hono } from 'hono'
353 | import { cors } from 'hono/cors'
354 |
355 | interface Env {
356 | AUTH_TOKENS: KVNamespace;
357 | }
358 |
359 | const app = new Hono<{ Bindings: Env }>()
360 |
361 | // Add CORS middleware
362 | app.use('\*', cors())
363 |
364 | app.get('/', async (c) => {
365 | try {
366 | // Get token from header or cookie
367 | const token = c.req.header('Authorization')?.slice(7) ||
368 | c.req.header('Cookie')?.match(/auth_token=([^;]+)/)?.[1];
369 | if (!token) {
370 | return c.json({
371 | authenticated: false,
372 | message: 'No authentication token provided'
373 | }, 403)
374 | }
375 |
376 | // Check token in KV
377 | const userData = await c.env.AUTH_TOKENS.get(token)
378 |
379 | if (!userData) {
380 | return c.json({
381 | authenticated: false,
382 | message: 'Invalid or expired token'
383 | }, 403)
384 | }
385 |
386 | return c.json({
387 | authenticated: true,
388 | message: 'Authentication successful',
389 | data: JSON.parse(userData)
390 | })
391 |
392 | } catch (error) {
393 | console.error('Authentication error:', error)
394 | return c.json({
395 | authenticated: false,
396 | message: 'Internal server error'
397 | }, 500)
398 | }
399 | })
400 |
401 | export default app
402 |
403 |
404 |
436 | // src/producer.ts
437 | interface Env {
438 | REQUEST_QUEUE: Queue;
439 | UPSTREAM_API_URL: string;
440 | UPSTREAM_API_KEY: string;
441 | }
442 |
443 | export default {
444 | async fetch(request: Request, env: Env) {
445 | const info = {
446 | timestamp: new Date().toISOString(),
447 | method: request.method,
448 | url: request.url,
449 | headers: Object.fromEntries(request.headers),
450 | };
451 | await env.REQUEST_QUEUE.send(info);
452 |
453 | return Response.json({
454 | message: 'Request logged',
455 | requestId: crypto.randomUUID()
456 | });
457 |
458 | },
459 |
460 | async queue(batch: MessageBatch, env: Env) {
461 | const requests = batch.messages.map(msg => msg.body);
462 |
463 | const response = await fetch(env.UPSTREAM_API_URL, {
464 | method: 'POST',
465 | headers: {
466 | 'Content-Type': 'application/json',
467 | 'Authorization': `Bearer ${env.UPSTREAM_API_KEY}`
468 | },
469 | body: JSON.stringify({
470 | timestamp: new Date().toISOString(),
471 | batchSize: requests.length,
472 | requests
473 | })
474 | });
475 |
476 | if (!response.ok) {
477 | throw new Error(`Upstream API error: ${response.status}`);
478 | }
479 |
480 | }
481 | };
482 |
483 |
484 |
485 |
524 | // Postgres.js 3.4.5 or later is recommended
525 | import postgres from "postgres";
526 |
527 | export interface Env {
528 | // If you set another name in the Wrangler config file as the value for 'binding',
529 | // replace "HYPERDRIVE" with the variable name you defined.
530 | HYPERDRIVE: Hyperdrive;
531 | }
532 |
533 | export default {
534 | async fetch(request, env, ctx): Promise {
535 | console.log(JSON.stringify(env));
536 | // Create a database client that connects to your database via Hyperdrive.
537 | //
538 | // Hyperdrive generates a unique connection string you can pass to
539 | // supported drivers, including node-postgres, Postgres.js, and the many
540 | // ORMs and query builders that use these drivers.
541 | const sql = postgres(env.HYPERDRIVE.connectionString)
542 |
543 | try {
544 | // Test query
545 | const results = await sql`SELECT * FROM pg_tables`;
546 |
547 | // Clean up the client, ensuring we don't kill the worker before that is
548 | // completed.
549 | ctx.waitUntil(sql.end());
550 |
551 | // Return result rows as JSON
552 | return Response.json(results);
553 | } catch (e) {
554 | console.error(e);
555 | return Response.json(
556 | { error: e instanceof Error ? e.message : e },
557 | { status: 500 },
558 | );
559 | }
560 |
561 | },
562 | } satisfies ExportedHandler;
563 |
564 |
565 |
566 |
605 | import { WorkflowEntrypoint, WorkflowStep, WorkflowEvent } from 'cloudflare:workers';
606 |
607 | type Env = {
608 | // Add your bindings here, e.g. Workers KV, D1, Workers AI, etc.
609 | MY_WORKFLOW: Workflow;
610 | };
611 |
612 | // User-defined params passed to your workflow
613 | type Params = {
614 | email: string;
615 | metadata: Record;
616 | };
617 |
618 | export class MyWorkflow extends WorkflowEntrypoint {
619 | async run(event: WorkflowEvent, step: WorkflowStep) {
620 | // Can access bindings on `this.env`
621 | // Can access params on `event.payload`
622 | const files = await step.do('my first step', async () => {
623 | // Fetch a list of files from $SOME_SERVICE
624 | return {
625 | files: [
626 | 'doc_7392_rev3.pdf',
627 | 'report_x29_final.pdf',
628 | 'memo_2024_05_12.pdf',
629 | 'file_089_update.pdf',
630 | 'proj_alpha_v2.pdf',
631 | 'data_analysis_q2.pdf',
632 | 'notes_meeting_52.pdf',
633 | 'summary_fy24_draft.pdf',
634 | ],
635 | };
636 | });
637 |
638 | const apiResponse = await step.do('some other step', async () => {
639 | let resp = await fetch('https://api.cloudflare.com/client/v4/ips');
640 | return await resp.json();
641 | });
642 |
643 | await step.sleep('wait on something', '1 minute');
644 |
645 | await step.do(
646 | 'make a call to write that could maybe, just might, fail',
647 | // Define a retry strategy
648 | {
649 | retries: {
650 | limit: 5,
651 | delay: '5 second',
652 | backoff: 'exponential',
653 | },
654 | timeout: '15 minutes',
655 | },
656 | async () => {
657 | // Do stuff here, with access to the state from our previous steps
658 | if (Math.random() > 0.5) {
659 | throw new Error('API call to $STORAGE_SYSTEM failed');
660 | }
661 | },
662 | );
663 |
664 | }
665 | }
666 |
667 | export default {
668 | async fetch(req: Request, env: Env): Promise {
669 | let url = new URL(req.url);
670 |
671 | if (url.pathname.startsWith('/favicon')) {
672 | return Response.json({}, { status: 404 });
673 | }
674 |
675 | // Get the status of an existing instance, if provided
676 | let id = url.searchParams.get('instanceId');
677 | if (id) {
678 | let instance = await env.MY_WORKFLOW.get(id);
679 | return Response.json({
680 | status: await instance.status(),
681 | });
682 | }
683 |
684 | const data = await req.json()
685 |
686 | // Spawn a new instance and return the ID and status
687 | let instance = await env.MY_WORKFLOW.create({
688 | // Define an ID for the Workflow instance
689 | id: crypto.randomUUID(),
690 | // Pass data to the Workflow instance
691 | // Available on the WorkflowEvent
692 | params: data,
693 | });
694 |
695 | return Response.json({
696 | id: instance.id,
697 | details: await instance.status(),
698 | });
699 |
700 | },
701 | };
702 |
703 |
704 |
705 |
737 | interface Env {
738 | USER_EVENTS: AnalyticsEngineDataset;
739 | }
740 |
741 | export default {
742 | async fetch(req: Request, env: Env): Promise {
743 | let url = new URL(req.url);
744 | let path = url.pathname;
745 | let userId = url.searchParams.get("userId");
746 |
747 | // Write a datapoint for this visit, associating the data with
748 | // the userId as our Analytics Engine 'index'
749 | env.USER_EVENTS.writeDataPoint({
750 | // Write metrics data: counters, gauges or latency statistics
751 | doubles: [],
752 | // Write text labels - URLs, app names, event_names, etc
753 | blobs: [path],
754 | // Provide an index that groups your data correctly.
755 | indexes: [userId],
756 | });
757 |
758 | return Response.json({
759 | hello: "world",
760 | });
761 | ,
762 |
763 | };
764 |
765 |
766 |
767 |
817 | import puppeteer from "@cloudflare/puppeteer";
818 |
819 | interface Env {
820 | BROWSER_RENDERING: Fetcher;
821 | }
822 |
823 | export default {
824 | async fetch(request, env): Promise {
825 | const { searchParams } = new URL(request.url);
826 | let url = searchParams.get("url");
827 |
828 | if (url) {
829 | url = new URL(url).toString(); // normalize
830 | const browser = await puppeteer.launch(env.MYBROWSER);
831 | const page = await browser.newPage();
832 | await page.goto(url);
833 | // Parse the page content
834 | const content = await page.content();
835 | // Find text within the page content
836 | const text = await page.$eval("body", (el) => el.textContent);
837 | // Do something with the text
838 | // e.g. log it to the console, write it to KV, or store it in a database.
839 | console.log(text);
840 |
841 | // Ensure we close the browser session
842 | await browser.close();
843 |
844 | return Response.json({
845 | bodyText: text,
846 | })
847 | } else {
848 | return Response.json({
849 | error: "Please add an ?url=https://example.com/ parameter"
850 | }, { status: 400 })
851 | }
852 | },
853 | } satisfies ExportedHandler;
854 |
855 |
856 |
890 | // src/index.ts
891 |
892 | interface Env {
893 | ASSETS: Fetcher;
894 | }
895 |
896 | export default {
897 | fetch(request, env) {
898 | const url = new URL(request.url);
899 |
900 | if (url.pathname.startsWith("/api/")) {
901 | return Response.json({
902 | name: "Cloudflare",
903 | });
904 | }
905 |
906 | return env.ASSETS.fetch(request);
907 | },
908 | } satisfies ExportedHandler;
909 |
910 |
932 |
933 | Build an AI Agent on Cloudflare Workers, using the agents, and the state management and syncing APIs built into the agents sdk.
934 |
935 |
936 |
937 | // src/index.ts
938 | import { Agent, AgentNamespace, Connection, ConnectionContext, getAgentByName, routeAgentRequest, WSMessage } from 'agents';
939 | import { OpenAI } from "openai";
940 |
941 | interface Env {
942 | AIAgent: AgentNamespace;
943 | OPENAI_API_KEY: string;
944 | }
945 |
946 | export class AIAgent extends Agent {
947 | // Handle HTTP requests with your Agent
948 | async onRequest(request) {
949 | // Connect with AI capabilities
950 | const ai = new OpenAI({
951 | apiKey: this.env.OPENAI_API_KEY,
952 | });
953 |
954 | // Process and understand
955 | const response = await ai.chat.completions.create({
956 | model: "gpt-4",
957 | messages: [{ role: "user", content: await request.text() }],
958 | });
959 |
960 | return new Response(response.choices[0].message.content);
961 | }
962 |
963 | async processTask(task) {
964 | await this.understand(task);
965 | await this.act();
966 | await this.reflect();
967 | }
968 |
969 | // Handle WebSockets
970 | async onConnect(connection: Connection) {
971 | await this.initiate(connection);
972 | connection.accept()
973 | }
974 |
975 | async onMessage(connection, message) {
976 | const understanding = await this.comprehend(message);
977 | await this.respond(connection, understanding);
978 | }
979 |
980 | async evolve(newInsight) {
981 | this.setState({
982 | ...this.state,
983 | insights: [...(this.state.insights || []), newInsight],
984 | understanding: this.state.understanding + 1,
985 | });
986 | }
987 |
988 | onStateUpdate(state, source) {
989 | console.log("Understanding deepened:", {
990 | newState: state,
991 | origin: source,
992 | });
993 | }
994 |
995 | // Scheduling APIs
996 | // 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.
997 | //
998 | // 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.
999 | async scheduleExamples() {
1000 | // schedule a task to run in 10 seconds
1001 | let task = await this.schedule(10, "someTask", { message: "hello" });
1002 |
1003 | // schedule a task to run at a specific date
1004 | let task = await this.schedule(new Date("2025-01-01"), "someTask", {});
1005 |
1006 | // schedule a task to run every 10 seconds
1007 | let { id } = await this.schedule("*/10 * * * *", "someTask", { message: "hello" });
1008 |
1009 | // schedule a task to run every 10 seconds, but only on Mondays
1010 | let task = await this.schedule("0 0 * * 1", "someTask", { message: "hello" });
1011 |
1012 | // cancel a scheduled task
1013 | this.cancelSchedule(task.id);
1014 |
1015 | // Get a specific schedule by ID
1016 | // Returns undefined if the task does not exist
1017 | let task = await this.getSchedule(task.id)
1018 |
1019 | // Get all scheduled tasks
1020 | // Returns an array of Schedule objects
1021 | let tasks = this.getSchedules();
1022 |
1023 | // Cancel a task by its ID
1024 | // Returns true if the task was cancelled, false if it did not exist
1025 | await this.cancelSchedule(task.id);
1026 |
1027 | // Filter for specific tasks
1028 | // e.g. all tasks starting in the next hour
1029 | let tasks = this.getSchedules({
1030 | timeRange: {
1031 | start: new Date(Date.now()),
1032 | end: new Date(Date.now() + 60 * 60 * 1000),
1033 | }
1034 | });
1035 | }
1036 |
1037 | async someTask(data) {
1038 | await this.callReasoningModel(data.message);
1039 | }
1040 |
1041 | // Use the this.sql API within the Agent to access the underlying SQLite database
1042 | async callReasoningModel(prompt: Prompt) {
1043 | interface Prompt {
1044 | userId: string;
1045 | user: string;
1046 | system: string;
1047 | metadata: Record;
1048 | }
1049 |
1050 | interface History {
1051 | timestamp: Date;
1052 | entry: string;
1053 | }
1054 |
1055 | let result = this.sql`SELECT * FROM history WHERE user = ${prompt.userId} ORDER BY timestamp DESC LIMIT 1000`;
1056 | let context = [];
1057 | for await (const row of result) {
1058 | context.push(row.entry);
1059 | }
1060 |
1061 | const client = new OpenAI({
1062 | apiKey: this.env.OPENAI_API_KEY,
1063 | });
1064 |
1065 | // Combine user history with the current prompt
1066 | const systemPrompt = prompt.system || 'You are a helpful assistant.';
1067 | const userPrompt = `${prompt.user}\n\nUser history:\n${context.join('\n')}`;
1068 |
1069 | try {
1070 | const completion = await client.chat.completions.create({
1071 | model: this.env.MODEL || 'o3-mini',
1072 | messages: [
1073 | { role: 'system', content: systemPrompt },
1074 | { role: 'user', content: userPrompt },
1075 | ],
1076 | temperature: 0.7,
1077 | max_tokens: 1000,
1078 | });
1079 |
1080 | // Store the response in history
1081 | this
1082 | .sql`INSERT INTO history (timestamp, user, entry) VALUES (${new Date()}, ${prompt.userId}, ${completion.choices[0].message.content})`;
1083 |
1084 | return completion.choices[0].message.content;
1085 | } catch (error) {
1086 | console.error('Error calling reasoning model:', error);
1087 | throw error;
1088 | }
1089 | }
1090 |
1091 | // Use the SQL API with a type parameter
1092 | async queryUser(userId: string) {
1093 | type User = {
1094 | id: string;
1095 | name: string;
1096 | email: string;
1097 | };
1098 | // Supply the type paramter to the query when calling this.sql
1099 | // This assumes the results returns one or more User rows with "id", "name", and "email" columns
1100 | // You do not need to specify an array type (`User[]` or `Array`) as `this.sql` will always return an array of the specified type.
1101 | const user = await this.sql`SELECT * FROM users WHERE id = ${userId}`;
1102 | return user
1103 | }
1104 |
1105 | // Run and orchestrate Workflows from Agents
1106 | async runWorkflow(data) {
1107 | let instance = await env.MY_WORKFLOW.create({
1108 | id: data.id,
1109 | params: data,
1110 | })
1111 |
1112 | // Schedule another task that checks the Workflow status every 5 minutes...
1113 | await this.schedule("*/5 * * * *", "checkWorkflowStatus", { id: instance.id });
1114 | }
1115 | }
1116 |
1117 | export default {
1118 | async fetch(request, env, ctx): Promise {
1119 | // Routed addressing
1120 | // Automatically routes HTTP requests and/or WebSocket connections to /agents/:agent/:name
1121 | // Best for: connecting React apps directly to Agents using useAgent from @cloudflare/agents/react
1122 | return (await routeAgentRequest(request, env)) || Response.json({ msg: 'no agent here' }, { status: 404 });
1123 |
1124 | // Named addressing
1125 | // Best for: convenience method for creating or retrieving an agent by name/ID.
1126 | let namedAgent = getAgentByName(env.AIAgent, 'agent-456');
1127 | // Pass the incoming request straight to your Agent
1128 | let namedResp = (await namedAgent).fetch(request);
1129 | return namedResp;
1130 |
1131 | // Durable Objects-style addressing
1132 | // Best for: controlling ID generation, associating IDs with your existing systems,
1133 | // and customizing when/how an Agent is created or invoked
1134 | const id = env.AIAgent.newUniqueId();
1135 | const agent = env.AIAgent.get(id);
1136 | // Pass the incoming request straight to your Agent
1137 | let resp = await agent.fetch(request);
1138 |
1139 | // return Response.json({ hello: 'visit https://developers.cloudflare.com/agents for more' });
1140 | },
1141 | } satisfies ExportedHandler;
1142 |
1143 |
1144 |
1145 | // client.js
1146 | import { AgentClient } from "agents/client";
1147 |
1148 | const connection = new AgentClient({
1149 | agent: "dialogue-agent",
1150 | name: "insight-seeker",
1151 | });
1152 |
1153 | connection.addEventListener("message", (event) => {
1154 | console.log("Received:", event.data);
1155 | });
1156 |
1157 | connection.send(
1158 | JSON.stringify({
1159 | type: "inquiry",
1160 | content: "What patterns do you see?",
1161 | })
1162 | );
1163 |
1164 |
1165 |
1166 | // app.tsx
1167 | // React client hook for the agents sdk
1168 | import { useAgent } from "agents/react";
1169 | import { useState } from "react";
1170 |
1171 | // useAgent client API
1172 | function AgentInterface() {
1173 | const connection = useAgent({
1174 | agent: "dialogue-agent",
1175 | name: "insight-seeker",
1176 | onMessage: (message) => {
1177 | console.log("Understanding received:", message.data);
1178 | },
1179 | onOpen: () => console.log("Connection established"),
1180 | onClose: () => console.log("Connection closed"),
1181 | });
1182 |
1183 | const inquire = () => {
1184 | connection.send(
1185 | JSON.stringify({
1186 | type: "inquiry",
1187 | content: "What insights have you gathered?",
1188 | })
1189 | );
1190 | };
1191 |
1192 | return (
1193 |
1194 |
1195 |
1196 | );
1197 | }
1198 |
1199 | // State synchronization
1200 | function StateInterface() {
1201 | const [state, setState] = useState({ counter: 0 });
1202 |
1203 | const agent = useAgent({
1204 | agent: "thinking-agent",
1205 | onStateUpdate: (newState) => setState(newState),
1206 | });
1207 |
1208 | const increment = () => {
1209 | agent.setState({ counter: state.counter + 1 });
1210 | };
1211 |
1212 | return (
1213 |
1214 | Count: {state.counter}
1215 |
1216 |
1217 | );
1218 | }
1219 |
1220 |
1221 |
1222 | {
1223 | "durable_objects": {
1224 | "bindings": [
1225 | {
1226 | "binding": "AIAgent",
1227 | "class_name": "AIAgent"
1228 | }
1229 | ]
1230 | },
1231 | "migrations": [
1232 | {
1233 | "tag": "v1",
1234 | // Mandatory for the Agent to store state
1235 | "new_sqlite_classes": ["AIAgent"]
1236 | }
1237 | ]
1238 | }
1239 |
1240 |
1241 |
1242 | - Imports the `Agent` class from the `agents` package
1243 | - Extends the `Agent` class and implements the methods exposed by the `Agent`, including `onRequest` for HTTP requests, or `onConnect` and `onMessage` for WebSockets.
1244 | - Uses the `this.schedule` scheduling API to schedule future tasks.
1245 | - Uses the `this.setState` API within the Agent for syncing state, and uses type parameters to ensure the state is typed.
1246 | - Uses the `this.sql` as a lower-level query API.
1247 | - For frontend applications, uses the optional `useAgent` hook to connect to the Agent via WebSockets
1248 |
1249 |
1250 |
1257 | import { OpenAI } from "openai";
1258 |
1259 | interface Env {
1260 | OPENAI_API_KEY: string;
1261 | }
1262 |
1263 | // Define your JSON schema for a calendar event
1264 | const CalendarEventSchema = {
1265 | type: 'object',
1266 | properties: {
1267 | name: { type: 'string' },
1268 | date: { type: 'string' },
1269 | participants: { type: 'array', items: { type: 'string' } },
1270 | },
1271 | required: ['name', 'date', 'participants']
1272 | };
1273 |
1274 | export default {
1275 | async fetch(request: Request, env: Env) {
1276 | const client = new OpenAI({
1277 | apiKey: env.OPENAI_API_KEY,
1278 | // Optional: use AI Gateway to bring logs, evals & caching to your AI requests
1279 | // https://developers.cloudflare.com/ai-gateway/providers/openai/
1280 | // baseUrl: "https://gateway.ai.cloudflare.com/v1/{account_id}/{gateway_id}/openai"
1281 | });
1282 |
1283 | const response = await client.chat.completions.create({
1284 | model: 'gpt-4o-2024-08-06',
1285 | messages: [
1286 | { role: 'system', content: 'Extract the event information.' },
1287 | { role: 'user', content: 'Alice and Bob are going to a science fair on Friday.' },
1288 | ],
1289 | // Use the `response_format` option to request a structured JSON output
1290 | response_format: {
1291 | // Set json_schema and provide ra schema, or json_object and parse it yourself
1292 | type: 'json_schema',
1293 | schema: CalendarEventSchema, // provide a schema
1294 | },
1295 | });
1296 |
1297 | // This will be of type CalendarEventSchema
1298 | const event = response.choices[0].message.parsed;
1299 |
1300 | return Response.json({
1301 | "calendar_event": event,
1302 | })
1303 | }
1304 | }
1305 |
1306 | 172 | Start a conversation with your AI assistant. Try asking 173 | about: 174 |
175 |
199 | {JSON.stringify(m, null, 2)}
200 |
201 | )}
202 | 254 | {formatTime( 255 | new Date(m.createdAt as unknown as string) 256 | )} 257 |
258 |386 | Requests to the API, including from the frontend UI, will not 387 | work until an OpenAI API key is configured. 388 |
389 |
390 | Please configure an OpenAI API key by setting a{" "}
391 |
397 | secret
398 | {" "}
399 | named{" "}
400 |
401 | OPENAI_API_KEY
402 |
403 | .
404 | You can also use a different model provider by following these{" "}
405 |
411 | instructions.
412 |
413 |
{firstInitial}
61 | )} 62 |
74 | {JSON.stringify(toolInvocation.args, null, 2)}
75 |
76 |
115 | {(() => {
116 | const result = toolInvocation.result;
117 | if (typeof result === "object" && result.content) {
118 | return result.content
119 | .map((item: { type: string; text: string }) => {
120 | if (
121 | item.type === "text" &&
122 | item.text.startsWith("\n~ Page URL:")
123 | ) {
124 | const lines = item.text.split("\n").filter(Boolean);
125 | return lines
126 | .map(
127 | (line: string) => `- ${line.replace("\n~ ", "")}`
128 | )
129 | .join("\n");
130 | }
131 | return item.text;
132 | })
133 | .join("\n");
134 | }
135 | return JSON.stringify(result, null, 2);
136 | })()}
137 |
138 |