agents 0.0.0-de168a2 → 0.0.0-df52d4b

package/README.md

@@ -66,13 +66,13 @@ export class AIAgent extends Agent {
   async onRequest(request) {
     // Connect with AI capabilities
     const ai = new OpenAI({
-      apiKey: this.env.OPENAI_API_KEY,
+      apiKey: this.env.OPENAI_API_KEY
     });
 
     // Process and understand
     const response = await ai.chat.completions.create({
       model: "gpt-4",
-      messages: [{ role: "user", content: await request.text() }],
+      messages: [{ role: "user", content: await request.text() }]
     });
 
     return new Response(response.choices[0].message.content);
@@ -96,17 +96,17 @@ Define your agent's domain:
     "bindings": [
       {
         "name": "AIAgent",
-        "class_name": "AIAgent",
-      },
-    ],
+        "class_name": "AIAgent"
+      }
+    ]
   },
   "migrations": [
     {
       "tag": "v1",
       // Mandatory for the Agent to store state
-      "new_sqlite_classes": ["AIAgent"],
-    },
-  ],
+      "new_sqlite_classes": ["AIAgent"]
+    }
+  ]
 }
 ```
 
@@ -123,7 +123,7 @@ const agent = env.AIAgent.get(id);
 await agent.processTask({
   type: "analysis",
   context: "incoming_data",
-  parameters: initialConfig,
+  parameters: initialConfig
 });
 
 // Or reconnect with an existing one
@@ -143,7 +143,7 @@ export class APIAgent extends Agent {
 
     return Response.json({
       insight: await this.process(data),
-      moment: Date.now(),
+      moment: Date.now()
     });
   }
 }
@@ -175,7 +175,7 @@ import { AgentClient } from "agents/client";
 
 const connection = new AgentClient({
   agent: "dialogue-agent",
-  name: "insight-seeker",
+  name: "insight-seeker"
 });
 
 connection.addEventListener("message", (event) => {
@@ -185,7 +185,7 @@ connection.addEventListener("message", (event) => {
 connection.send(
   JSON.stringify({
     type: "inquiry",
-    content: "What patterns do you see?",
+    content: "What patterns do you see?"
   })
 );
 ```
@@ -205,14 +205,14 @@ function AgentInterface() {
       console.log("Understanding received:", message.data);
     },
     onOpen: () => console.log("Connection established"),
-    onClose: () => console.log("Connection closed"),
+    onClose: () => console.log("Connection closed")
   });
 
   const inquire = () => {
     connection.send(
       JSON.stringify({
         type: "inquiry",
-        content: "What insights have you gathered?",
+        content: "What insights have you gathered?"
       })
     );
   };
@@ -235,14 +235,14 @@ export class ThinkingAgent extends Agent {
     this.setState({
       ...this.state,
       insights: [...(this.state.insights || []), newInsight],
-      understanding: this.state.understanding + 1,
+      understanding: this.state.understanding + 1
     });
   }
 
   onStateUpdate(state, source) {
     console.log("Understanding deepened:", {
       newState: state,
-      origin: source,
+      origin: source
     });
   }
 }
@@ -259,7 +259,7 @@ function StateInterface() {
 
   const agent = useAgent({
     agent: "thinking-agent",
-    onStateUpdate: (newState) => setState(newState),
+    onStateUpdate: (newState) => setState(newState)
   });
 
   const increment = () => {
@@ -289,7 +289,7 @@ export class TimeAwareAgent extends Agent {
 
     // Daily synthesis
     this.schedule("0 0 * * *", "dailySynthesis", {
-      depth: "comprehensive",
+      depth: "comprehensive"
     });
 
     // Milestone review
@@ -325,11 +325,11 @@ export class DialogueAgent extends AIChatAgent {
         const stream = streamText({
           model: openai("gpt-4o"),
           messages: this.messages,
-          onFinish, // call onFinish so that messages get saved
+          onFinish // call onFinish so that messages get saved
         });
 
         stream.mergeIntoDataStream(dataStream);
-      },
+      }
     });
   }
 }
@@ -346,14 +346,14 @@ import { useAgentChat } from "agents/ai-react";
 function ChatInterface() {
   // Connect to the agent
   const agent = useAgent({
-    agent: "dialogue-agent",
+    agent: "dialogue-agent"
   });
 
   // Set up the chat interaction
   const { messages, input, handleInputChange, handleSubmit, clearHistory } =
     useAgentChat({
       agent,
-      maxSteps: 5,
+      maxSteps: 5
     });
 
   return (
@@ -393,6 +393,112 @@ This creates:
 - Intuitive input handling
 - Easy conversation reset
 
+### 🔗 MCP (Model Context Protocol) Integration
+
+Agents can seamlessly integrate with the Model Context Protocol, allowing them to act as both MCP servers (providing tools to AI assistants) and MCP clients (using tools from other services).
+
+#### Creating an MCP Server
+
+```typescript
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import { McpAgent } from "agents/mcp";
+import { z } from "zod";
+
+type Env = {
+  MyMCP: DurableObjectNamespace<MyMCP>;
+};
+
+type State = { counter: number };
+
+export class MyMCP extends McpAgent<Env, State, {}> {
+  server = new McpServer({
+    name: "Demo",
+    version: "1.0.0"
+  });
+
+  initialState: State = {
+    counter: 1
+  };
+
+  async init() {
+    this.server.resource("counter", "mcp://resource/counter", (uri) => {
+      return {
+        contents: [{ text: String(this.state.counter), uri: uri.href }]
+      };
+    });
+
+    this.server.tool(
+      "add",
+      "Add to the counter, stored in the MCP",
+      { a: z.number() },
+      async ({ a }) => {
+        this.setState({ ...this.state, counter: this.state.counter + a });
+
+        return {
+          content: [
+            {
+              text: String(`Added ${a}, total is now ${this.state.counter}`),
+              type: "text"
+            }
+          ]
+        };
+      }
+    );
+  }
+
+  onStateUpdate(state: State) {
+    console.log({ stateUpdate: state });
+  }
+}
+
+// HTTP Streamable transport (recommended)
+export default MyMCP.serve("/mcp", {
+  binding: "MyMCP"
+});
+
+// Or SSE transport for legacy compatibility
+// export default MyMCP.serveSSE("/mcp", { binding: "MyMCP" });
+```
+
+#### Using MCP Tools
+
+```typescript
+import { MCPClientManager } from "agents/mcp";
+
+const client = new MCPClientManager("my-app", "1.0.0");
+
+// Connect to an MCP server
+await client.connect("https://weather-service.com/mcp", {
+  transport: { type: "streamable-http" }
+});
+
+// Use tools from the server
+const weather = await client.callTool({
+  serverId: "weather-service",
+  name: "getWeather",
+  arguments: { location: "San Francisco" }
+});
+```
+
+#### AI SDK Integration
+
+```typescript
+import { generateText } from "ai";
+
+// Convert MCP tools for AI use
+const result = await generateText({
+  model: openai("gpt-4"),
+  tools: client.unstable_getAITools(),
+  prompt: "What's the weather in Tokyo?"
+});
+```
+
+**Transport Options:**
+
+- **Auto**: Automatically determine the correct transport
+- **HTTP Streamable**: Best performance, batch requests, session management
+- **SSE**: Simple setup, legacy compatibility
+
 ### 💬 The Path Forward
 
 We're developing new dimensions of agent capability:

package/dist/ai-chat-agent.d.ts

@@ -1,7 +1,18 @@
-import { Agent, AgentContext } from "./index.js";
 import { Message, StreamTextOnFinishCallback, ToolSet } from "ai";
+import { Agent, AgentContext } from "./index.js";
 import { Connection, WSMessage } from "partyserver";
-import "node:async_hooks";
+import "cloudflare:workers";
+import "@modelcontextprotocol/sdk/client/index.js";
+import "@modelcontextprotocol/sdk/types.js";
+import "./client-DgyzBU_8.js";
+import "zod";
+import "@modelcontextprotocol/sdk/shared/protocol.js";
+import "@modelcontextprotocol/sdk/client/sse.js";
+import "@modelcontextprotocol/sdk/client/streamableHttp.js";
+import "./mcp/do-oauth-client-provider.js";
+import "@modelcontextprotocol/sdk/client/auth.js";
+import "@modelcontextprotocol/sdk/shared/auth.js";
+import "./observability/index.js";
 
 /**
  * Extension of Agent with built-in chat capabilities
@@ -11,19 +22,29 @@ declare class AIChatAgent<Env = unknown, State = unknown> extends Agent<
   Env,
   State
 > {
-  #private;
+  /**
+   * Map of message `id`s to `AbortController`s
+   * useful to propagate request cancellation signals for any external calls made by the agent
+   */
+  private _chatMessageAbortControllers;
   /** Array of chat messages for the current conversation */
   messages: Message[];
   constructor(ctx: AgentContext, env: Env);
+  private _broadcastChatMessage;
   onMessage(connection: Connection, message: WSMessage): Promise<void>;
   onRequest(request: Request): Promise<Response>;
+  private _tryCatchChat;
   /**
    * Handle incoming chat messages and generate a response
    * @param onFinish Callback to be called when the response is finished
+   * @param options.signal A signal to pass to any child requests which can be used to cancel them
    * @returns Response to send to the client or undefined
    */
   onChatMessage(
-    onFinish: StreamTextOnFinishCallback<ToolSet>
+    onFinish: StreamTextOnFinishCallback<ToolSet>,
+    options?: {
+      abortSignal: AbortSignal | undefined;
+    }
   ): Promise<Response | undefined>;
   /**
    * Save messages on the server side and trigger AI response
@@ -34,6 +55,30 @@ declare class AIChatAgent<Env = unknown, State = unknown> extends Agent<
     messages: Message[],
     excludeBroadcastIds?: string[]
   ): Promise<void>;
+  private _reply;
+  /**
+   * For the given message id, look up its associated AbortController
+   * If the AbortController does not exist, create and store one in memory
+   *
+   * returns the AbortSignal associated with the AbortController
+   */
+  private _getAbortSignal;
+  /**
+   * Remove an abort controller from the cache of pending message responses
+   */
+  private _removeAbortController;
+  /**
+   * Propagate an abort signal for any requests associated with the given message id
+   */
+  private _cancelChatRequest;
+  /**
+   * Abort all pending requests and clear the cache of AbortControllers
+   */
+  private _destroyAbortControllers;
+  /**
+   * When the DO is destroyed, cancel all pending requests
+   */
+  destroy(): Promise<void>;
 }
 
 export { AIChatAgent };

package/dist/ai-chat-agent.js

@@ -1,19 +1,16 @@
 import {
   Agent
-} from "./chunk-XG52S6YY.js";
-import {
-  __privateAdd,
-  __privateMethod
-} from "./chunk-HMLY7DHA.js";
+} from "./chunk-DQJFYHG3.js";
+import "./chunk-EM3J4KV7.js";
+import "./chunk-PVQZBKN7.js";
+import "./chunk-KUH345EY.js";
 
 // src/ai-chat-agent.ts
 import { appendResponseMessages } from "ai";
 var decoder = new TextDecoder();
-var _AIChatAgent_instances, broadcastChatMessage_fn, tryCatch_fn, reply_fn;
 var AIChatAgent = class extends Agent {
   constructor(ctx, env) {
     super(ctx, env);
-    __privateAdd(this, _AIChatAgent_instances);
     this.sql`create table if not exists cf_ai_chat_agent_messages (
       id text primary key,
       message text not null,
@@ -22,64 +19,111 @@ var AIChatAgent = class extends Agent {
     this.messages = (this.sql`select * from cf_ai_chat_agent_messages` || []).map((row) => {
       return JSON.parse(row.message);
     });
+    this._chatMessageAbortControllers = /* @__PURE__ */ new Map();
+  }
+  _broadcastChatMessage(message, exclude) {
+    this.broadcast(JSON.stringify(message), exclude);
   }
   async onMessage(connection, message) {
     if (typeof message === "string") {
       let data;
       try {
         data = JSON.parse(message);
-      } catch (error) {
+      } catch (_error) {
         return;
       }
       if (data.type === "cf_agent_use_chat_request" && data.init.method === "POST") {
         const {
-          method,
-          keepalive,
-          headers,
-          body,
+          // method,
+          // keepalive,
+          // headers,
+          body
           // we're reading this
-          redirect,
-          integrity,
-          credentials,
-          mode,
-          referrer,
-          referrerPolicy,
-          window
+          //
+          // // these might not exist?
           // dispatcher,
           // duplex
         } = data.init;
         const { messages } = JSON.parse(body);
-        __privateMethod(this, _AIChatAgent_instances, broadcastChatMessage_fn).call(this, {
-          type: "cf_agent_chat_messages",
-          messages
-        }, [connection.id]);
+        this._broadcastChatMessage(
+          {
+            messages,
+            type: "cf_agent_chat_messages"
+          },
+          [connection.id]
+        );
         await this.persistMessages(messages, [connection.id]);
-        return __privateMethod(this, _AIChatAgent_instances, tryCatch_fn).call(this, async () => {
-          const response = await this.onChatMessage(async ({ response: response2 }) => {
-            const finalMessages = appendResponseMessages({
-              messages,
-              responseMessages: response2.messages
-            });
-            await this.persistMessages(finalMessages, [connection.id]);
-          });
+        this.observability?.emit(
+          {
+            displayMessage: "Chat message request",
+            id: data.id,
+            payload: {},
+            timestamp: Date.now(),
+            type: "message:request"
+          },
+          this.ctx
+        );
+        const chatMessageId = data.id;
+        const abortSignal = this._getAbortSignal(chatMessageId);
+        return this._tryCatchChat(async () => {
+          const response = await this.onChatMessage(
+            async ({ response: response2 }) => {
+              const finalMessages = appendResponseMessages({
+                messages,
+                responseMessages: response2.messages
+              });
+              await this.persistMessages(finalMessages, [connection.id]);
+              this._removeAbortController(chatMessageId);
+              this.observability?.emit(
+                {
+                  displayMessage: "Chat message response",
+                  id: data.id,
+                  payload: {},
+                  timestamp: Date.now(),
+                  type: "message:response"
+                },
+                this.ctx
+              );
+            },
+            abortSignal ? { abortSignal } : void 0
+          );
           if (response) {
-            await __privateMethod(this, _AIChatAgent_instances, reply_fn).call(this, data.id, response);
+            await this._reply(data.id, response);
+          } else {
+            console.warn(
+              `[AIChatAgent] onChatMessage returned no response for chatMessageId: ${chatMessageId}`
+            );
+            this._broadcastChatMessage(
+              {
+                body: "No response was generated by the agent.",
+                done: true,
+                id: data.id,
+                type: "cf_agent_use_chat_response"
+              },
+              [connection.id]
+            );
           }
         });
       }
       if (data.type === "cf_agent_chat_clear") {
+        this._destroyAbortControllers();
         this.sql`delete from cf_ai_chat_agent_messages`;
         this.messages = [];
-        __privateMethod(this, _AIChatAgent_instances, broadcastChatMessage_fn).call(this, {
-          type: "cf_agent_chat_clear"
-        }, [connection.id]);
+        this._broadcastChatMessage(
+          {
+            type: "cf_agent_chat_clear"
+          },
+          [connection.id]
+        );
       } else if (data.type === "cf_agent_chat_messages") {
         await this.persistMessages(data.messages, [connection.id]);
+      } else if (data.type === "cf_agent_chat_request_cancel") {
+        this._cancelChatRequest(data.id);
       }
     }
   }
   async onRequest(request) {
-    return __privateMethod(this, _AIChatAgent_instances, tryCatch_fn).call(this, () => {
+    return this._tryCatchChat(() => {
       const url = new URL(request.url);
       if (url.pathname.endsWith("/get-messages")) {
         const messages = (this.sql`select * from cf_ai_chat_agent_messages` || []).map((row) => {
@@ -90,12 +134,20 @@ var AIChatAgent = class extends Agent {
       return super.onRequest(request);
     });
   }
+  async _tryCatchChat(fn) {
+    try {
+      return await fn();
+    } catch (e) {
+      throw this.onError(e);
+    }
+  }
   /**
    * Handle incoming chat messages and generate a response
    * @param onFinish Callback to be called when the response is finished
+   * @param options.signal A signal to pass to any child requests which can be used to cancel them
    * @returns Response to send to the client or undefined
    */
-  async onChatMessage(onFinish) {
+  async onChatMessage(onFinish, options) {
     throw new Error(
       "recieved a chat message, override onChatMessage and return a Response to send to the client"
     );
@@ -126,41 +178,79 @@ var AIChatAgent = class extends Agent {
       this.sql`insert into cf_ai_chat_agent_messages (id, message) values (${message.id},${JSON.stringify(message)})`;
     }
     this.messages = messages;
-    __privateMethod(this, _AIChatAgent_instances, broadcastChatMessage_fn).call(this, {
-      type: "cf_agent_chat_messages",
-      messages
-    }, excludeBroadcastIds);
-  }
-};
-_AIChatAgent_instances = new WeakSet();
-broadcastChatMessage_fn = function(message, exclude) {
-  this.broadcast(JSON.stringify(message), exclude);
-};
-tryCatch_fn = async function(fn) {
-  try {
-    return await fn();
-  } catch (e) {
-    throw this.onError(e);
+    this._broadcastChatMessage(
+      {
+        messages,
+        type: "cf_agent_chat_messages"
+      },
+      excludeBroadcastIds
+    );
   }
-};
-reply_fn = async function(id, response) {
-  return __privateMethod(this, _AIChatAgent_instances, tryCatch_fn).call(this, async () => {
-    for await (const chunk of response.body) {
-      const body = decoder.decode(chunk);
-      __privateMethod(this, _AIChatAgent_instances, broadcastChatMessage_fn).call(this, {
+  async _reply(id, response) {
+    return this._tryCatchChat(async () => {
+      for await (const chunk of response.body) {
+        const body = decoder.decode(chunk);
+        this._broadcastChatMessage({
+          body,
+          done: false,
+          id,
+          type: "cf_agent_use_chat_response"
+        });
+      }
+      this._broadcastChatMessage({
+        body: "",
+        done: true,
         id,
-        type: "cf_agent_use_chat_response",
-        body,
-        done: false
+        type: "cf_agent_use_chat_response"
       });
-    }
-    __privateMethod(this, _AIChatAgent_instances, broadcastChatMessage_fn).call(this, {
-      id,
-      type: "cf_agent_use_chat_response",
-      body: "",
-      done: true
     });
-  });
+  }
+  /**
+   * For the given message id, look up its associated AbortController
+   * If the AbortController does not exist, create and store one in memory
+   *
+   * returns the AbortSignal associated with the AbortController
+   */
+  _getAbortSignal(id) {
+    if (typeof id !== "string") {
+      return void 0;
+    }
+    if (!this._chatMessageAbortControllers.has(id)) {
+      this._chatMessageAbortControllers.set(id, new AbortController());
+    }
+    return this._chatMessageAbortControllers.get(id)?.signal;
+  }
+  /**
+   * Remove an abort controller from the cache of pending message responses
+   */
+  _removeAbortController(id) {
+    this._chatMessageAbortControllers.delete(id);
+  }
+  /**
+   * Propagate an abort signal for any requests associated with the given message id
+   */
+  _cancelChatRequest(id) {
+    if (this._chatMessageAbortControllers.has(id)) {
+      const abortController = this._chatMessageAbortControllers.get(id);
+      abortController?.abort();
+    }
+  }
+  /**
+   * Abort all pending requests and clear the cache of AbortControllers
+   */
+  _destroyAbortControllers() {
+    for (const controller of this._chatMessageAbortControllers.values()) {
+      controller?.abort();
+    }
+    this._chatMessageAbortControllers.clear();
+  }
+  /**
+   * When the DO is destroyed, cancel all pending requests
+   */
+  async destroy() {
+    this._destroyAbortControllers();
+    await super.destroy();
+  }
 };
 export {
   AIChatAgent