agents 0.0.0-ac0e999 → 0.0.0-ac74811

package/dist/mcp/index.js

@@ -1,10 +1,9 @@
 import {
   Agent
-} from "../chunk-DMJ7L3FI.js";
-import "../chunk-D6UOOELW.js";
-import "../chunk-ZKIVUOTQ.js";
-import "../chunk-25YDMV4H.js";
-import "../chunk-NOUFNU2O.js";
+} from "../chunk-JFRK72K3.js";
+import "../chunk-E3LCYPCB.js";
+import "../chunk-767EASBA.js";
+import "../chunk-NKZZ66QY.js";
 
 // src/mcp/index.ts
 import { DurableObject } from "cloudflare:workers";
@@ -17,16 +16,19 @@ import {
   JSONRPCMessageSchema
 } from "@modelcontextprotocol/sdk/types.js";
 var MAXIMUM_MESSAGE_SIZE_BYTES = 4 * 1024 * 1024;
-function corsHeaders(request, corsOptions = {}) {
+function corsHeaders(_request, corsOptions = {}) {
   const origin = "*";
   return {
-    "Access-Control-Allow-Origin": corsOptions.origin || origin,
+    "Access-Control-Allow-Headers": corsOptions.headers || "Content-Type, mcp-session-id, mcp-protocol-version",
     "Access-Control-Allow-Methods": corsOptions.methods || "GET, POST, OPTIONS",
-    "Access-Control-Allow-Headers": corsOptions.headers || "Content-Type, mcp-session-id",
-    "Access-Control-Max-Age": (corsOptions.maxAge || 86400).toString(),
-    "Access-Control-Expose-Headers": corsOptions.exposeHeaders || "mcp-session-id"
+    "Access-Control-Allow-Origin": corsOptions.origin || origin,
+    "Access-Control-Expose-Headers": corsOptions.exposeHeaders || "mcp-session-id",
+    "Access-Control-Max-Age": (corsOptions.maxAge || 86400).toString()
   };
 }
+function isDurableObjectNamespace(namespace) {
+  return typeof namespace === "object" && namespace !== null && "newUniqueId" in namespace && typeof namespace.newUniqueId === "function" && "idFromName" in namespace && typeof namespace.idFromName === "function";
+}
 function handleCORS(request, corsOptions) {
   if (request.method === "OPTIONS") {
     return new Response(null, { headers: corsHeaders(request, corsOptions) });
@@ -35,20 +37,20 @@ function handleCORS(request, corsOptions) {
 }
 var McpSSETransport = class {
   constructor(getWebSocket) {
-    this.started = false;
-    this.getWebSocket = getWebSocket;
+    this._started = false;
+    this._getWebSocket = getWebSocket;
   }
   async start() {
-    if (this.started) {
+    if (this._started) {
       throw new Error("Transport already started");
     }
-    this.started = true;
+    this._started = true;
   }
   async send(message) {
-    if (!this.started) {
+    if (!this._started) {
       throw new Error("Transport not started");
     }
-    const websocket = this.getWebSocket();
+    const websocket = this._getWebSocket();
     if (!websocket) {
       throw new Error("WebSocket not connected");
     }
@@ -65,38 +67,38 @@ var McpSSETransport = class {
 };
 var McpStreamableHttpTransport = class {
   constructor(getWebSocketForMessageID, notifyResponseIdSent) {
-    this.started = false;
-    this.getWebSocketForMessageID = getWebSocketForMessageID;
-    this.notifyResponseIdSent = notifyResponseIdSent;
-    this.getWebSocketForGetRequest = () => null;
+    this._started = false;
+    this._getWebSocketForMessageID = getWebSocketForMessageID;
+    this._notifyResponseIdSent = notifyResponseIdSent;
+    this._getWebSocketForGetRequest = () => null;
   }
   async start() {
-    if (this.started) {
+    if (this._started) {
       throw new Error("Transport already started");
     }
-    this.started = true;
+    this._started = true;
   }
   async send(message) {
-    if (!this.started) {
+    if (!this._started) {
       throw new Error("Transport not started");
     }
     let websocket = null;
     if (isJSONRPCResponse(message) || isJSONRPCError(message)) {
-      websocket = this.getWebSocketForMessageID(message.id.toString());
+      websocket = this._getWebSocketForMessageID(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 = this._getWebSocketForGetRequest();
     } else if (isJSONRPCNotification(message)) {
       websocket = null;
     }
     try {
       websocket?.send(JSON.stringify(message));
       if (isJSONRPCResponse(message)) {
-        this.notifyResponseIdSent(message.id.toString());
+        this._notifyResponseIdSent(message.id.toString());
       }
     } catch (error) {
       this.onerror?.(error);
@@ -111,12 +113,12 @@ 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();
+    this._status = "zero";
+    this._transportType = "unset";
+    this._requestIdToConnectionId = /* @__PURE__ */ new Map();
     this.initRun = false;
     const self = this;
-    this.agent = new (_a = class extends Agent {
+    this._agent = new (_a = class extends Agent {
       onStateUpdate(state, source) {
         return self.onStateUpdate(state, source);
       }
@@ -128,23 +130,24 @@ var McpAgent = class _McpAgent extends DurableObject {
     }, _a)(ctx, env);
   }
   get mcp() {
-    return this.agent.mcp;
+    return this._agent.mcp;
   }
   get state() {
-    return this.agent.state;
+    return this._agent.state;
   }
   sql(strings, ...values) {
-    return this.agent.sql(strings, ...values);
+    return this._agent.sql(strings, ...values);
   }
   setState(state) {
-    return this.agent.setState(state);
+    return this._agent.setState(state);
   }
+  // biome-ignore lint/correctness/noUnusedFunctionParameters: overriden later
   onStateUpdate(state, source) {
   }
   async onStart() {
     var _a;
     const self = this;
-    this.agent = new (_a = class extends Agent {
+    this._agent = new (_a = class extends Agent {
       constructor() {
         super(...arguments);
         this.initialState = self.initialState;
@@ -159,20 +162,20 @@ var McpAgent = class _McpAgent extends DurableObject {
       hibernate: true
     }, _a)(this.ctx, this.env);
     this.props = await this.ctx.storage.get("props");
-    this.transportType = await this.ctx.storage.get(
+    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 (this._transportType === "sse") {
+      this._transport = new McpSSETransport(() => this.getWebSocket());
+      await server.connect(this._transport);
+    } else if (this._transportType === "streamable-http") {
+      this._transport = new McpStreamableHttpTransport(
         (id) => this.getWebSocketForResponseID(id),
-        (id) => this.requestIdToConnectionId.delete(id)
+        (id) => this._requestIdToConnectionId.delete(id)
       );
-      await server.connect(this.transport);
+      await server.connect(this._transport);
     }
   }
   async _init(props) {
@@ -192,17 +195,17 @@ var McpAgent = class _McpAgent extends DurableObject {
   async isInitialized() {
     return await this.ctx.storage.get("initialized") === true;
   }
-  async initialize() {
+  async _initialize() {
     await this.ctx.blockConcurrencyWhile(async () => {
-      this.status = "starting";
+      this._status = "starting";
       await this.onStart();
-      this.status = "started";
+      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 (this._status !== "started") {
+      await this._initialize();
     }
     if (request.headers.get("Upgrade") !== "websocket") {
       return new Response("Expected WebSocket Upgrade request", {
@@ -219,24 +222,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);
+        this._transportType = "sse";
+        if (!this._transport) {
+          this._transport = new McpSSETransport(() => this.getWebSocket());
+          await server.connect(this._transport);
         }
-        return this.agent.fetch(request);
+        return this._agent.fetch(request);
       }
       case "/streamable-http": {
-        if (!this.transport) {
-          this.transport = new McpStreamableHttpTransport(
+        if (!this._transport) {
+          this._transport = new McpStreamableHttpTransport(
             (id) => this.getWebSocketForResponseID(id),
-            (id) => this.requestIdToConnectionId.delete(id)
+            (id) => this._requestIdToConnectionId.delete(id)
           );
-          await server.connect(this.transport);
+          await server.connect(this._transport);
         }
         await this.ctx.storage.put("transportType", "streamable-http");
-        this.transportType = "streamable-http";
-        return this.agent.fetch(request);
+        this._transportType = "streamable-http";
+        return this._agent.fetch(request);
       }
       default:
         return new Response(
@@ -255,19 +258,19 @@ var McpAgent = class _McpAgent extends DurableObject {
     return websockets[0];
   }
   getWebSocketForResponseID(id) {
-    const connectionId = this.requestIdToConnectionId.get(id);
+    const connectionId = this._requestIdToConnectionId.get(id);
     if (connectionId === void 0) {
       return null;
     }
-    return this.agent.getConnection(connectionId) ?? null;
+    return this._agent.getConnection(connectionId) ?? null;
   }
   // All messages received here. This is currently never called
   async onMessage(connection, event) {
-    if (this.transportType !== "streamable-http") {
+    if (this._transportType !== "streamable-http") {
       const err = new Error(
         "Internal Server Error: Expected streamable-http protocol"
       );
-      this.transport?.onerror?.(err);
+      this._transport?.onerror?.(err);
       return;
     }
     let message;
@@ -275,21 +278,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);
+      this._transport?.onerror?.(error);
       return;
     }
     if (isJSONRPCRequest(message)) {
-      this.requestIdToConnectionId.set(message.id.toString(), connection.id);
+      this._requestIdToConnectionId.set(message.id.toString(), connection.id);
     }
-    this.transport?.onmessage?.(message);
+    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();
+  async onSSEMcpMessage(_sessionId, request) {
+    if (this._status !== "started") {
+      await this._initialize();
     }
-    if (this.transportType !== "sse") {
+    if (this._transportType !== "sse") {
       return new Error("Internal Server Error: Expected SSE protocol");
     }
     try {
@@ -298,36 +301,36 @@ var McpAgent = class _McpAgent extends DurableObject {
       try {
         parsedMessage = JSONRPCMessageSchema.parse(message);
       } catch (error) {
-        this.transport?.onerror?.(error);
+        this._transport?.onerror?.(error);
         throw error;
       }
-      this.transport?.onmessage?.(parsedMessage);
+      this._transport?.onmessage?.(parsedMessage);
       return null;
     } catch (error) {
       console.error("Error forwarding message to SSE:", error);
-      this.transport?.onerror?.(error);
+      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 (this._status !== "started") {
+      await this._initialize();
     }
-    return await this.agent.webSocketMessage(ws, event);
+    return await this._agent.webSocketMessage(ws, event);
   }
   // WebSocket event handlers for hibernation support
   async webSocketError(ws, error) {
-    if (this.status !== "started") {
-      await this.initialize();
+    if (this._status !== "started") {
+      await this._initialize();
     }
-    return await this.agent.webSocketError(ws, error);
+    return await this._agent.webSocketError(ws, error);
   }
   async webSocketClose(ws, code, reason, wasClean) {
-    if (this.status !== "started") {
-      await this.initialize();
+    if (this._status !== "started") {
+      await this._initialize();
     }
-    return await this.agent.webSocketClose(ws, code, reason, wasClean);
+    return await this._agent.webSocketClose(ws, code, reason, wasClean);
   }
   static mount(path, {
     binding = "MCP_OBJECT",
@@ -357,7 +360,7 @@ var McpAgent = class _McpAgent extends DurableObject {
           );
           return new Response("Invalid binding", { status: 500 });
         }
-        if (bindingValue.toString() !== "[object DurableObjectNamespace]") {
+        if (!isDurableObjectNamespace(bindingValue)) {
           return new Response("Invalid binding", { status: 500 });
         }
         const namespace = bindingValue;
@@ -418,10 +421,10 @@ data: ${JSON.stringify(result.data)}
             onMessage(event).catch(console.error);
           });
           ws.addEventListener("error", (error) => {
-            async function onError(error2) {
+            async function onError(_error) {
               try {
                 await writer.close();
-              } catch (e) {
+              } catch (_e) {
               }
             }
             onError(error).catch(console.error);
@@ -438,9 +441,9 @@ data: ${JSON.stringify(result.data)}
           });
           return new Response(readable, {
             headers: {
-              "Content-Type": "text/event-stream",
               "Cache-Control": "no-cache",
               Connection: "keep-alive",
+              "Content-Type": "text/event-stream",
               ...corsHeaders(request, corsOptions)
             }
           });
@@ -476,23 +479,23 @@ data: ${JSON.stringify(result.data)}
           const error = await doStub.onSSEMcpMessage(sessionId, request);
           if (error) {
             return new Response(error.message, {
-              status: 400,
               headers: {
-                "Content-Type": "text/event-stream",
                 "Cache-Control": "no-cache",
                 Connection: "keep-alive",
+                "Content-Type": "text/event-stream",
                 ...corsHeaders(request, corsOptions)
-              }
+              },
+              status: 400
             });
           }
           return new Response("Accepted", {
-            status: 202,
             headers: {
-              "Content-Type": "text/event-stream",
               "Cache-Control": "no-cache",
               Connection: "keep-alive",
+              "Content-Type": "text/event-stream",
               ...corsHeaders(request, corsOptions)
-            }
+            },
+            status: 202
           });
         }
         return new Response("Not Found", { status: 404 });
@@ -522,7 +525,7 @@ data: ${JSON.stringify(result.data)}
           );
           return new Response("Invalid binding", { status: 500 });
         }
-        if (bindingValue.toString() !== "[object DurableObjectNamespace]") {
+        if (!isDurableObjectNamespace(bindingValue)) {
           return new Response("Invalid binding", { status: 500 });
         }
         const namespace = bindingValue;
@@ -530,24 +533,24 @@ data: ${JSON.stringify(result.data)}
           const acceptHeader = request.headers.get("accept");
           if (!acceptHeader?.includes("application/json") || !acceptHeader.includes("text/event-stream")) {
             const body2 = JSON.stringify({
-              jsonrpc: "2.0",
               error: {
                 code: -32e3,
                 message: "Not Acceptable: Client must accept both application/json and text/event-stream"
               },
-              id: null
+              id: null,
+              jsonrpc: "2.0"
             });
             return new Response(body2, { status: 406 });
           }
           const ct = request.headers.get("content-type");
           if (!ct || !ct.includes("application/json")) {
             const body2 = JSON.stringify({
-              jsonrpc: "2.0",
               error: {
                 code: -32e3,
                 message: "Unsupported Media Type: Content-Type must be application/json"
               },
-              id: null
+              id: null,
+              jsonrpc: "2.0"
             });
             return new Response(body2, { status: 415 });
           }
@@ -557,12 +560,12 @@ data: ${JSON.stringify(result.data)}
           );
           if (contentLength > MAXIMUM_MESSAGE_SIZE_BYTES) {
             const body2 = JSON.stringify({
-              jsonrpc: "2.0",
               error: {
                 code: -32e3,
                 message: `Request body too large. Maximum size is ${MAXIMUM_MESSAGE_SIZE_BYTES} bytes`
               },
-              id: null
+              id: null,
+              jsonrpc: "2.0"
             });
             return new Response(body2, { status: 413 });
           }
@@ -570,14 +573,14 @@ data: ${JSON.stringify(result.data)}
           let rawMessage;
           try {
             rawMessage = await request.json();
-          } catch (error) {
+          } catch (_error) {
             const body2 = JSON.stringify({
-              jsonrpc: "2.0",
               error: {
                 code: -32700,
                 message: "Parse error: Invalid JSON"
               },
-              id: null
+              id: null,
+              jsonrpc: "2.0"
             });
             return new Response(body2, { status: 400 });
           }
@@ -591,12 +594,12 @@ data: ${JSON.stringify(result.data)}
           for (const msg of arrayMessage) {
             if (!JSONRPCMessageSchema.safeParse(msg).success) {
               const body2 = JSON.stringify({
-                jsonrpc: "2.0",
                 error: {
                   code: -32700,
                   message: "Parse error: Invalid JSON-RPC message"
                 },
-                id: null
+                id: null,
+                jsonrpc: "2.0"
               });
               return new Response(body2, { status: 400 });
             }
@@ -607,34 +610,34 @@ data: ${JSON.stringify(result.data)}
           );
           if (isInitializationRequest && sessionId) {
             const body2 = JSON.stringify({
-              jsonrpc: "2.0",
               error: {
                 code: -32600,
                 message: "Invalid Request: Initialization requests must not include a sessionId"
               },
-              id: null
+              id: null,
+              jsonrpc: "2.0"
             });
             return new Response(body2, { status: 400 });
           }
           if (isInitializationRequest && messages.length > 1) {
             const body2 = JSON.stringify({
-              jsonrpc: "2.0",
               error: {
                 code: -32600,
                 message: "Invalid Request: Only one initialization request is allowed"
               },
-              id: null
+              id: null,
+              jsonrpc: "2.0"
             });
             return new Response(body2, { status: 400 });
           }
           if (!isInitializationRequest && !sessionId) {
             const body2 = JSON.stringify({
-              jsonrpc: "2.0",
               error: {
                 code: -32e3,
                 message: "Bad Request: Mcp-Session-Id header is required"
               },
-              id: null
+              id: null,
+              jsonrpc: "2.0"
             });
             return new Response(body2, { status: 400 });
           }
@@ -647,12 +650,12 @@ data: ${JSON.stringify(result.data)}
             await doStub.setInitialized();
           } else if (!isInitialized) {
             const body2 = JSON.stringify({
-              jsonrpc: "2.0",
               error: {
                 code: -32001,
                 message: "Session not found"
               },
-              id: null
+              id: null,
+              jsonrpc: "2.0"
             });
             return new Response(body2, { status: 404 });
           }
@@ -675,12 +678,12 @@ data: ${JSON.stringify(result.data)}
             console.error("Failed to establish WebSocket connection");
             await writer.close();
             const body2 = JSON.stringify({
-              jsonrpc: "2.0",
               error: {
                 code: -32001,
                 message: "Failed to establish WebSocket connection"
               },
-              id: null
+              id: null,
+              jsonrpc: "2.0"
             });
             return new Response(body2, { status: 500 });
           }
@@ -713,10 +716,10 @@ data: ${JSON.stringify(result.data)}
             onMessage(event).catch(console.error);
           });
           ws.addEventListener("error", (error) => {
-            async function onError(error2) {
+            async function onError(_error) {
               try {
                 await writer.close();
-              } catch (e) {
+              } catch (_e) {
               }
             }
             onError(error).catch(console.error);
@@ -740,8 +743,8 @@ data: ${JSON.stringify(result.data)}
             }
             ws.close();
             return new Response(null, {
-              status: 202,
-              headers: corsHeaders(request, corsOptions)
+              headers: corsHeaders(request, corsOptions),
+              status: 202
             });
           }
           for (const message of messages) {
@@ -752,9 +755,9 @@ data: ${JSON.stringify(result.data)}
           }
           return new Response(readable, {
             headers: {
-              "Content-Type": "text/event-stream",
               "Cache-Control": "no-cache",
               Connection: "keep-alive",
+              "Content-Type": "text/event-stream",
               "mcp-session-id": sessionId,
               ...corsHeaders(request, corsOptions)
             },
@@ -762,12 +765,12 @@ data: ${JSON.stringify(result.data)}
           });
         }
         const body = JSON.stringify({
-          jsonrpc: "2.0",
           error: {
             code: -32e3,
             message: "Method not allowed"
           },
-          id: null
+          id: null,
+          jsonrpc: "2.0"
         });
         return new Response(body, { status: 405 });
       }