agents 0.0.0-94d9a2e → 0.0.0-9688c15

package/dist/mcp/index.js

@@ -1,9 +1,15 @@
 import {
   Agent
-} from "../chunk-J6T74FUS.js";
-import "../chunk-BZXOAZUX.js";
-import "../chunk-QSGN3REV.js";
-import "../chunk-Y67CHZBI.js";
+} from "../chunk-YFPCCSZO.js";
+import "../chunk-D6UOOELW.js";
+import "../chunk-RN4SNE73.js";
+import "../chunk-25YDMV4H.js";
+import {
+  __privateAdd,
+  __privateGet,
+  __privateMethod,
+  __privateSet
+} from "../chunk-HMLY7DHA.js";
 
 // src/mcp/index.ts
 import { DurableObject } from "cloudflare:workers";
@@ -32,22 +38,24 @@ function handleCORS(request, corsOptions) {
   }
   return null;
 }
+var _getWebSocket, _started;
 var McpSSETransport = class {
   constructor(getWebSocket) {
-    this._started = false;
-    this._getWebSocket = getWebSocket;
+    __privateAdd(this, _getWebSocket);
+    __privateAdd(this, _started, false);
+    __privateSet(this, _getWebSocket, getWebSocket);
   }
   async start() {
-    if (this._started) {
+    if (__privateGet(this, _started)) {
       throw new Error("Transport already started");
     }
-    this._started = true;
+    __privateSet(this, _started, true);
   }
   async send(message) {
-    if (!this._started) {
+    if (!__privateGet(this, _started)) {
       throw new Error("Transport not started");
     }
-    const websocket = this._getWebSocket();
+    const websocket = __privateGet(this, _getWebSocket).call(this);
     if (!websocket) {
       throw new Error("WebSocket not connected");
     }
@@ -62,40 +70,52 @@ var McpSSETransport = class {
     this.onclose?.();
   }
 };
+_getWebSocket = new WeakMap();
+_started = new WeakMap();
+var _getWebSocketForGetRequest, _getWebSocketForMessageID, _notifyResponseIdSent, _started2;
 var McpStreamableHttpTransport = class {
   constructor(getWebSocketForMessageID, notifyResponseIdSent) {
-    this._started = false;
-    this._getWebSocketForMessageID = getWebSocketForMessageID;
-    this._notifyResponseIdSent = notifyResponseIdSent;
-    this._getWebSocketForGetRequest = () => null;
+    // TODO: If there is an open connection to send server-initiated messages
+    // back, we should use that connection
+    __privateAdd(this, _getWebSocketForGetRequest);
+    // Get the appropriate websocket connection for a given message id
+    __privateAdd(this, _getWebSocketForMessageID);
+    // Notify the server that a response has been sent for a given message id
+    // so that it may clean up it's mapping of message ids to connections
+    // once they are no longer needed
+    __privateAdd(this, _notifyResponseIdSent);
+    __privateAdd(this, _started2, false);
+    __privateSet(this, _getWebSocketForMessageID, getWebSocketForMessageID);
+    __privateSet(this, _notifyResponseIdSent, notifyResponseIdSent);
+    __privateSet(this, _getWebSocketForGetRequest, () => null);
   }
   async start() {
-    if (this._started) {
+    if (__privateGet(this, _started2)) {
       throw new Error("Transport already started");
     }
-    this._started = true;
+    __privateSet(this, _started2, true);
   }
   async send(message) {
-    if (!this._started) {
+    if (!__privateGet(this, _started2)) {
       throw new Error("Transport not started");
     }
     let websocket = null;
     if (isJSONRPCResponse(message) || isJSONRPCError(message)) {
-      websocket = this._getWebSocketForMessageID(message.id.toString());
+      websocket = __privateGet(this, _getWebSocketForMessageID).call(this, message.id.toString());
       if (!websocket) {
         throw new Error(
           `Could not find WebSocket for message id: ${message.id}`
         );
       }
     } else if (isJSONRPCRequest(message)) {
-      websocket = this._getWebSocketForGetRequest();
+      websocket = __privateGet(this, _getWebSocketForGetRequest).call(this);
     } else if (isJSONRPCNotification(message)) {
       websocket = null;
     }
     try {
       websocket?.send(JSON.stringify(message));
       if (isJSONRPCResponse(message)) {
-        this._notifyResponseIdSent(message.id.toString());
+        __privateGet(this, _notifyResponseIdSent).call(this, message.id.toString());
       }
     } catch (error) {
       this.onerror?.(error);
@@ -106,16 +126,28 @@ var McpStreamableHttpTransport = class {
     this.onclose?.();
   }
 };
-var McpAgent = class _McpAgent extends DurableObject {
+_getWebSocketForGetRequest = new WeakMap();
+_getWebSocketForMessageID = new WeakMap();
+_notifyResponseIdSent = new WeakMap();
+_started2 = new WeakMap();
+var _status, _transport, _transportType, _requestIdToConnectionId, _agent, _McpAgent_instances, initialize_fn;
+var _McpAgent = class _McpAgent extends DurableObject {
   constructor(ctx, env) {
     var _a;
     super(ctx, env);
-    this._status = "zero";
-    this._transportType = "unset";
-    this._requestIdToConnectionId = /* @__PURE__ */ new Map();
+    __privateAdd(this, _McpAgent_instances);
+    __privateAdd(this, _status, "zero");
+    __privateAdd(this, _transport);
+    __privateAdd(this, _transportType, "unset");
+    __privateAdd(this, _requestIdToConnectionId, /* @__PURE__ */ new Map());
+    /**
+     * Since McpAgent's _aren't_ yet real "Agents", let's only expose a couple of the methods
+     * to the outer class: initialState/state/setState/onStateUpdate/sql
+     */
+    __privateAdd(this, _agent);
     this.initRun = false;
     const self = this;
-    this._agent = new (_a = class extends Agent {
+    __privateSet(this, _agent, new (_a = class extends Agent {
       onStateUpdate(state, source) {
         return self.onStateUpdate(state, source);
       }
@@ -124,26 +156,26 @@ var McpAgent = class _McpAgent extends DurableObject {
       }
     }, _a.options = {
       hibernate: true
-    }, _a)(ctx, env);
+    }, _a)(ctx, env));
   }
   get mcp() {
-    return this._agent.mcp;
+    return __privateGet(this, _agent).mcp;
   }
   get state() {
-    return this._agent.state;
+    return __privateGet(this, _agent).state;
   }
   sql(strings, ...values) {
-    return this._agent.sql(strings, ...values);
+    return __privateGet(this, _agent).sql(strings, ...values);
   }
   setState(state) {
-    return this._agent.setState(state);
+    return __privateGet(this, _agent).setState(state);
   }
   onStateUpdate(state, source) {
   }
   async onStart() {
     var _a;
     const self = this;
-    this._agent = new (_a = class extends Agent {
+    __privateSet(this, _agent, new (_a = class extends Agent {
       constructor() {
         super(...arguments);
         this.initialState = self.initialState;
@@ -156,22 +188,22 @@ var McpAgent = class _McpAgent extends DurableObject {
       }
     }, _a.options = {
       hibernate: true
-    }, _a)(this.ctx, this.env);
+    }, _a)(this.ctx, this.env));
     this.props = await this.ctx.storage.get("props");
-    this._transportType = await this.ctx.storage.get(
+    __privateSet(this, _transportType, await this.ctx.storage.get(
       "transportType"
-    );
+    ));
     await this._init(this.props);
     const server = await this.server;
-    if (this._transportType === "sse") {
-      this._transport = new McpSSETransport(() => this.getWebSocket());
-      await server.connect(this._transport);
-    } else if (this._transportType === "streamable-http") {
-      this._transport = new McpStreamableHttpTransport(
+    if (__privateGet(this, _transportType) === "sse") {
+      __privateSet(this, _transport, new McpSSETransport(() => this.getWebSocket()));
+      await server.connect(__privateGet(this, _transport));
+    } else if (__privateGet(this, _transportType) === "streamable-http") {
+      __privateSet(this, _transport, new McpStreamableHttpTransport(
         (id) => this.getWebSocketForResponseID(id),
-        (id) => this._requestIdToConnectionId.delete(id)
-      );
-      await server.connect(this._transport);
+        (id) => __privateGet(this, _requestIdToConnectionId).delete(id)
+      ));
+      await server.connect(__privateGet(this, _transport));
     }
   }
   async _init(props) {
@@ -191,17 +223,10 @@ var McpAgent = class _McpAgent extends DurableObject {
   async isInitialized() {
     return await this.ctx.storage.get("initialized") === true;
   }
-  async _initialize() {
-    await this.ctx.blockConcurrencyWhile(async () => {
-      this._status = "starting";
-      await this.onStart();
-      this._status = "started";
-    });
-  }
   // Allow the worker to fetch a websocket connection to the agent
   async fetch(request) {
-    if (this._status !== "started") {
-      await this._initialize();
+    if (__privateGet(this, _status) !== "started") {
+      await __privateMethod(this, _McpAgent_instances, initialize_fn).call(this);
     }
     if (request.headers.get("Upgrade") !== "websocket") {
       return new Response("Expected WebSocket Upgrade request", {
@@ -218,24 +243,24 @@ var McpAgent = class _McpAgent extends DurableObject {
           return new Response("Websocket already connected", { status: 400 });
         }
         await this.ctx.storage.put("transportType", "sse");
-        this._transportType = "sse";
-        if (!this._transport) {
-          this._transport = new McpSSETransport(() => this.getWebSocket());
-          await server.connect(this._transport);
+        __privateSet(this, _transportType, "sse");
+        if (!__privateGet(this, _transport)) {
+          __privateSet(this, _transport, new McpSSETransport(() => this.getWebSocket()));
+          await server.connect(__privateGet(this, _transport));
         }
-        return this._agent.fetch(request);
+        return __privateGet(this, _agent).fetch(request);
       }
       case "/streamable-http": {
-        if (!this._transport) {
-          this._transport = new McpStreamableHttpTransport(
+        if (!__privateGet(this, _transport)) {
+          __privateSet(this, _transport, new McpStreamableHttpTransport(
             (id) => this.getWebSocketForResponseID(id),
-            (id) => this._requestIdToConnectionId.delete(id)
-          );
-          await server.connect(this._transport);
+            (id) => __privateGet(this, _requestIdToConnectionId).delete(id)
+          ));
+          await server.connect(__privateGet(this, _transport));
         }
         await this.ctx.storage.put("transportType", "streamable-http");
-        this._transportType = "streamable-http";
-        return this._agent.fetch(request);
+        __privateSet(this, _transportType, "streamable-http");
+        return __privateGet(this, _agent).fetch(request);
       }
       default:
         return new Response(
@@ -254,19 +279,19 @@ var McpAgent = class _McpAgent extends DurableObject {
     return websockets[0];
   }
   getWebSocketForResponseID(id) {
-    const connectionId = this._requestIdToConnectionId.get(id);
+    const connectionId = __privateGet(this, _requestIdToConnectionId).get(id);
     if (connectionId === void 0) {
       return null;
     }
-    return this._agent.getConnection(connectionId) ?? null;
+    return __privateGet(this, _agent).getConnection(connectionId) ?? null;
   }
   // All messages received here. This is currently never called
   async onMessage(connection, event) {
-    if (this._transportType !== "streamable-http") {
+    if (__privateGet(this, _transportType) !== "streamable-http") {
       const err = new Error(
         "Internal Server Error: Expected streamable-http protocol"
       );
-      this._transport?.onerror?.(err);
+      __privateGet(this, _transport)?.onerror?.(err);
       return;
     }
     let message;
@@ -274,21 +299,21 @@ var McpAgent = class _McpAgent extends DurableObject {
       const data = typeof event === "string" ? event : new TextDecoder().decode(event);
       message = JSONRPCMessageSchema.parse(JSON.parse(data));
     } catch (error) {
-      this._transport?.onerror?.(error);
+      __privateGet(this, _transport)?.onerror?.(error);
       return;
     }
     if (isJSONRPCRequest(message)) {
-      this._requestIdToConnectionId.set(message.id.toString(), connection.id);
+      __privateGet(this, _requestIdToConnectionId).set(message.id.toString(), connection.id);
     }
-    this._transport?.onmessage?.(message);
+    __privateGet(this, _transport)?.onmessage?.(message);
   }
   // All messages received over SSE after the initial connection has been established
   // will be passed here
   async onSSEMcpMessage(sessionId, request) {
-    if (this._status !== "started") {
-      await this._initialize();
+    if (__privateGet(this, _status) !== "started") {
+      await __privateMethod(this, _McpAgent_instances, initialize_fn).call(this);
     }
-    if (this._transportType !== "sse") {
+    if (__privateGet(this, _transportType) !== "sse") {
       return new Error("Internal Server Error: Expected SSE protocol");
     }
     try {
@@ -297,36 +322,36 @@ var McpAgent = class _McpAgent extends DurableObject {
       try {
         parsedMessage = JSONRPCMessageSchema.parse(message);
       } catch (error) {
-        this._transport?.onerror?.(error);
+        __privateGet(this, _transport)?.onerror?.(error);
         throw error;
       }
-      this._transport?.onmessage?.(parsedMessage);
+      __privateGet(this, _transport)?.onmessage?.(parsedMessage);
       return null;
     } catch (error) {
       console.error("Error forwarding message to SSE:", error);
-      this._transport?.onerror?.(error);
+      __privateGet(this, _transport)?.onerror?.(error);
       return error;
     }
   }
   // Delegate all websocket events to the underlying agent
   async webSocketMessage(ws, event) {
-    if (this._status !== "started") {
-      await this._initialize();
+    if (__privateGet(this, _status) !== "started") {
+      await __privateMethod(this, _McpAgent_instances, initialize_fn).call(this);
     }
-    return await this._agent.webSocketMessage(ws, event);
+    return await __privateGet(this, _agent).webSocketMessage(ws, event);
   }
   // WebSocket event handlers for hibernation support
   async webSocketError(ws, error) {
-    if (this._status !== "started") {
-      await this._initialize();
+    if (__privateGet(this, _status) !== "started") {
+      await __privateMethod(this, _McpAgent_instances, initialize_fn).call(this);
     }
-    return await this._agent.webSocketError(ws, error);
+    return await __privateGet(this, _agent).webSocketError(ws, error);
   }
   async webSocketClose(ws, code, reason, wasClean) {
-    if (this._status !== "started") {
-      await this._initialize();
+    if (__privateGet(this, _status) !== "started") {
+      await __privateMethod(this, _McpAgent_instances, initialize_fn).call(this);
     }
-    return await this._agent.webSocketClose(ws, code, reason, wasClean);
+    return await __privateGet(this, _agent).webSocketClose(ws, code, reason, wasClean);
   }
   static mount(path, {
     binding = "MCP_OBJECT",
@@ -773,6 +798,20 @@ data: ${JSON.stringify(result.data)}
     };
   }
 };
+_status = new WeakMap();
+_transport = new WeakMap();
+_transportType = new WeakMap();
+_requestIdToConnectionId = new WeakMap();
+_agent = new WeakMap();
+_McpAgent_instances = new WeakSet();
+initialize_fn = async function() {
+  await this.ctx.blockConcurrencyWhile(async () => {
+    __privateSet(this, _status, "starting");
+    await this.onStart();
+    __privateSet(this, _status, "started");
+  });
+};
+var McpAgent = _McpAgent;
 export {
   McpAgent
 };