fastmcp 4.16.2 → 4.16.4

package/dist/edge/index.cjs

@@ -17,6 +17,7 @@ var _zodtojsonschema = require('zod-to-json-schema');
 
 
 
+
 var MAXIMUM_MESSAGE_SIZE = 4 * 1024 * 1024;
 var WebStreamableHTTPServerTransport = (_class = class {
   
@@ -29,12 +30,27 @@ var WebStreamableHTTPServerTransport = (_class = class {
   __init3() {this._jsonResponseCollectors = /* @__PURE__ */ new Map()}
   
   
-  __init4() {this._requestToStreamMapping = /* @__PURE__ */ new Map()}
-  __init5() {this._standaloneSseStreamId = "_GET_stream"}
-  __init6() {this._started = false}
-  __init7() {this._streamMapping = /* @__PURE__ */ new Map()}
+  /**
+   * Replays whose stream id is still being resolved. `replayEventsAfter` only
+   * reveals which stream it was replaying once it settles, so a standalone
+   * send during that window has nothing to test against; persist rather than
+   * drop, since over-storing for the length of a replay beats losing an event.
+   */
+  __init4() {this._replaysInFlight = 0}
+  __init5() {this._requestToStreamMapping = /* @__PURE__ */ new Map()}
+  __init6() {this._standaloneSseStreamId = "_GET_stream"}
+  /**
+   * Whether a client has held the standalone GET stream during this session.
+   * Latched rather than read from `_streamMapping`, so persistence survives
+   * the disconnect window the store exists to cover while still telling a
+   * dropped stream apart from one that was never opened. Reset with the rest
+   * of the per-session state, since the next session starts with no stream.
+   */
+  __init7() {this._standaloneStreamOpened = false}
+  __init8() {this._started = false}
+  __init9() {this._streamMapping = /* @__PURE__ */ new Map()}
   
-  constructor(options) {;_class.prototype.__init.call(this);_class.prototype.__init2.call(this);_class.prototype.__init3.call(this);_class.prototype.__init4.call(this);_class.prototype.__init5.call(this);_class.prototype.__init6.call(this);_class.prototype.__init7.call(this);
+  constructor(options) {;_class.prototype.__init.call(this);_class.prototype.__init2.call(this);_class.prototype.__init3.call(this);_class.prototype.__init4.call(this);_class.prototype.__init5.call(this);_class.prototype.__init6.call(this);_class.prototype.__init7.call(this);_class.prototype.__init8.call(this);_class.prototype.__init9.call(this);
     this.sessionIdGenerator = options.sessionIdGenerator;
     this._enableJsonResponse = _nullishCoalesce(options.enableJsonResponse, () => ( false));
     this._eventStore = options.eventStore;
@@ -52,6 +68,7 @@ var WebStreamableHTTPServerTransport = (_class = class {
       }
     }
     this._streamMapping.clear();
+    this._standaloneStreamOpened = false;
     this.releasePendingRequests();
     this._started = false;
     _optionalChain([this, 'access', _ => _.onclose, 'optionalCall', _2 => _2()]);
@@ -91,11 +108,12 @@ var WebStreamableHTTPServerTransport = (_class = class {
         return;
       }
       const writer = this._streamMapping.get(streamId);
-      if (writer || this._eventStore) {
+      const store = this.shouldPersist(streamId, writer) ? this._eventStore : void 0;
+      if (writer || store) {
         try {
           let eventId;
-          if (this._eventStore) {
-            eventId = await this._eventStore.storeEvent(streamId, message);
+          if (store) {
+            eventId = await store.storeEvent(streamId, message);
           }
           if (writer) {
             if (eventId === void 0) {
@@ -104,23 +122,29 @@ var WebStreamableHTTPServerTransport = (_class = class {
               await this.writeSSEEventWithId(writer, eventId, message);
             }
           }
-          if (requestId !== void 0 && isResponse) {
-            this._requestToStreamMapping.delete(requestId);
-            const streamInUse = Array.from(
-              this._requestToStreamMapping.values()
-            ).includes(streamId);
-            if (!streamInUse) {
-              this._streamMapping.delete(streamId);
-              if (writer) {
-                await writer.close();
-              }
-            }
-          }
         } catch (error) {
           _optionalChain([this, 'access', _4 => _4.onerror, 'optionalCall', _5 => _5(
             error instanceof Error ? error : new Error(String(error))
           )]);
         }
+        if (requestId !== void 0 && isResponse) {
+          this._requestToStreamMapping.delete(requestId);
+          const streamInUse = Array.from(
+            this._requestToStreamMapping.values()
+          ).includes(streamId);
+          if (!streamInUse) {
+            this._streamMapping.delete(streamId);
+            if (writer) {
+              try {
+                await writer.close();
+              } catch (error) {
+                _optionalChain([this, 'access', _6 => _6.onerror, 'optionalCall', _7 => _7(
+                  error instanceof Error ? error : new Error(String(error))
+                )]);
+              }
+            }
+          }
+        }
       }
     }
   }
@@ -183,8 +207,9 @@ var WebStreamableHTTPServerTransport = (_class = class {
       }
     }
     this._streamMapping.clear();
+    this._standaloneStreamOpened = false;
     this.releasePendingRequests();
-    await _optionalChain([this, 'access', _6 => _6._onsessionclosed, 'optionalCall', _7 => _7(_nullishCoalesce(this.sessionId, () => ( "")))]);
+    await _optionalChain([this, 'access', _8 => _8._onsessionclosed, 'optionalCall', _9 => _9(_nullishCoalesce(this.sessionId, () => ( "")))]);
     this.sessionId = void 0;
     return new Response(null, {
       headers: this.getResponseHeaders(),
@@ -196,7 +221,7 @@ var WebStreamableHTTPServerTransport = (_class = class {
    */
   async handleGetRequest(request) {
     const acceptHeader = request.headers.get("accept");
-    if (!_optionalChain([acceptHeader, 'optionalAccess', _8 => _8.includes, 'call', _9 => _9("text/event-stream")])) {
+    if (!_optionalChain([acceptHeader, 'optionalAccess', _10 => _10.includes, 'call', _11 => _11("text/event-stream")])) {
       return this.createErrorResponse(
         406,
         -32e3,
@@ -245,7 +270,7 @@ var WebStreamableHTTPServerTransport = (_class = class {
    */
   async handlePostRequest(request, parsedBody) {
     const acceptHeader = request.headers.get("accept");
-    if (!_optionalChain([acceptHeader, 'optionalAccess', _10 => _10.includes, 'call', _11 => _11("application/json")]) && !_optionalChain([acceptHeader, 'optionalAccess', _12 => _12.includes, 'call', _13 => _13("text/event-stream")])) {
+    if (!_optionalChain([acceptHeader, 'optionalAccess', _12 => _12.includes, 'call', _13 => _13("application/json")]) && !_optionalChain([acceptHeader, 'optionalAccess', _14 => _14.includes, 'call', _15 => _15("text/event-stream")])) {
       return this.createErrorResponse(
         406,
         -32e3,
@@ -253,7 +278,7 @@ var WebStreamableHTTPServerTransport = (_class = class {
       );
     }
     const contentType = request.headers.get("content-type");
-    if (!_optionalChain([contentType, 'optionalAccess', _14 => _14.includes, 'call', _15 => _15("application/json")])) {
+    if (!_optionalChain([contentType, 'optionalAccess', _16 => _16.includes, 'call', _17 => _17("application/json")])) {
       return this.createErrorResponse(
         415,
         -32e3,
@@ -323,14 +348,14 @@ var WebStreamableHTTPServerTransport = (_class = class {
     }
     if (hasInitRequest && this.sessionIdGenerator) {
       this.sessionId = this.sessionIdGenerator();
-      await _optionalChain([this, 'access', _16 => _16._onsessioninitialized, 'optionalCall', _17 => _17(this.sessionId)]);
+      await _optionalChain([this, 'access', _18 => _18._onsessioninitialized, 'optionalCall', _19 => _19(this.sessionId)]);
     } else if (requestSessionId) {
       if (this.sessionIdGenerator && this.sessionId !== requestSessionId) {
         return this.createErrorResponse(404, -32001, "Session not found");
       }
     }
     const requestIds = messages.filter((msg) => _typesjs.isJSONRPCRequest.call(void 0, msg)).map((msg) => msg.id);
-    const useJsonResponse = this._enableJsonResponse && Boolean(_optionalChain([acceptHeader, 'optionalAccess', _18 => _18.includes, 'call', _19 => _19("application/json")]));
+    const useJsonResponse = this._enableJsonResponse && Boolean(_optionalChain([acceptHeader, 'optionalAccess', _20 => _20.includes, 'call', _21 => _21("application/json")]));
     let jsonResponses;
     let sseReadable;
     if (requestIds.length > 0) {
@@ -359,7 +384,7 @@ var WebStreamableHTTPServerTransport = (_class = class {
       }
     }
     for (const message of messages) {
-      _optionalChain([this, 'access', _20 => _20.onmessage, 'optionalCall', _21 => _21(message, { authInfo: void 0 })]);
+      _optionalChain([this, 'access', _22 => _22.onmessage, 'optionalCall', _23 => _23(message, { authInfo: void 0 })]);
     }
     if (requestIds.length === 0) {
       return new Response(null, {
@@ -369,6 +394,12 @@ var WebStreamableHTTPServerTransport = (_class = class {
     }
     if (jsonResponses) {
       const responses = await jsonResponses;
+      if (responses.length === 0) {
+        return new Response(null, {
+          headers: this.getResponseHeaders(),
+          status: 202
+        });
+      }
       const responseBody = JSON.stringify(isBatch ? responses : responses[0]);
       return new Response(responseBody, {
         headers: {
@@ -401,6 +432,7 @@ var WebStreamableHTTPServerTransport = (_class = class {
     }
     const { readable, writable } = new TransformStream();
     const writer = writable.getWriter();
+    this._replaysInFlight += 1;
     try {
       const streamId = await this._eventStore.replayEventsAfter(lastEventId, {
         send: async (eventId, message) => {
@@ -411,6 +443,8 @@ var WebStreamableHTTPServerTransport = (_class = class {
     } catch (error) {
       await writer.close();
       return this.createErrorResponse(500, -32e3, `Replay failed: ${error}`);
+    } finally {
+      this._replaysInFlight -= 1;
     }
     return new Response(readable, {
       headers: {
@@ -433,13 +467,19 @@ var WebStreamableHTTPServerTransport = (_class = class {
    * therefore never produce a response: the same drain `send()` performs once
    * a response has been written, minus the response. Idempotent, so it is a
    * no-op if the response won the race against the cancellation.
-   *
-   * JSON-mode POSTs are left alone: `_jsonResponseCollectors` owns their
-   * settlement.
    */
   async releaseCancelledRequest(requestId) {
     const streamId = this._requestToStreamMapping.get(requestId);
-    if (streamId === void 0 || this._jsonResponseCollectors.has(streamId)) {
+    if (streamId === void 0) {
+      return;
+    }
+    const collector = this._jsonResponseCollectors.get(streamId);
+    if (collector) {
+      collector.expectedIds = collector.expectedIds.filter(
+        (id) => id !== requestId
+      );
+      this._requestToStreamMapping.delete(requestId);
+      this.settleJsonResponse(streamId, collector);
       return;
     }
     this._requestToStreamMapping.delete(requestId);
@@ -455,7 +495,7 @@ var WebStreamableHTTPServerTransport = (_class = class {
       try {
         await writer.close();
       } catch (error) {
-        _optionalChain([this, 'access', _22 => _22.onerror, 'optionalCall', _23 => _23(
+        _optionalChain([this, 'access', _24 => _24.onerror, 'optionalCall', _25 => _25(
           error instanceof Error ? error : new Error(String(error))
         )]);
       }
@@ -469,7 +509,20 @@ var WebStreamableHTTPServerTransport = (_class = class {
   releasePendingRequests() {
     for (const collector of this._jsonResponseCollectors.values()) {
       collector.resolve(
-        collector.expectedIds.map((id) => collector.responses.get(id)).filter((response) => response !== void 0)
+        collector.expectedIds.map(
+          (id) => _nullishCoalesce(collector.responses.get(id), () => ( // Nobody can answer this one now. Dropping it silently would leave
+          // the POST with an empty body for a single request and an empty
+          // array for a batch, neither of which a client can read as a
+          // result.
+          {
+            error: {
+              code: _typesjs.ErrorCode.ConnectionClosed,
+              message: "Connection closed: the session ended before this request was answered"
+            },
+            id,
+            jsonrpc: "2.0"
+          }))
+        )
       );
     }
     this._jsonResponseCollectors.clear();
@@ -493,7 +546,32 @@ var WebStreamableHTTPServerTransport = (_class = class {
     }
     collector.resolve(responses);
   }
+  /**
+   * Whether an event addressed to `streamId` should go to the event store.
+   *
+   * Everything but the standalone stream is persisted whenever a store is
+   * configured: those ids exist only because their stream did. The standalone
+   * id is a constant, so it resolves whether or not a client ever opened that
+   * stream, and storing before the first GET writes events nothing can reach —
+   * replay is keyed off Last-Event-Id, and a client that never held the stream
+   * was never handed an id to resume from.
+   */
+  shouldPersist(streamId, writer) {
+    if (this._eventStore === void 0) {
+      return false;
+    }
+    if (streamId !== this._standaloneSseStreamId) {
+      return true;
+    }
+    return this._standaloneStreamOpened || // A live writer means the stream is open now, which is stronger evidence
+    // than the latch. Belt and braces: it keeps a writer reaching this point
+    // without `trackStream` from producing an SSE event with no `id:`.
+    writer !== void 0 || this._replaysInFlight > 0;
+  }
   trackStream(streamId, writer) {
+    if (streamId === this._standaloneSseStreamId) {
+      this._standaloneStreamOpened = true;
+    }
     this._streamMapping.set(streamId, writer);
     const removeStreamIfCurrent = () => {
       if (this._streamMapping.get(streamId) !== writer) {
@@ -624,7 +702,7 @@ var EdgeFastMCP = class {
    */
   async #handleMcpRequest(request) {
     const acceptHeader = request.headers.get("accept");
-    if (!_optionalChain([acceptHeader, 'optionalAccess', _24 => _24.includes, 'call', _25 => _25("application/json")]) && !_optionalChain([acceptHeader, 'optionalAccess', _26 => _26.includes, 'call', _27 => _27("text/event-stream")])) {
+    if (!_optionalChain([acceptHeader, 'optionalAccess', _26 => _26.includes, 'call', _27 => _27("application/json")]) && !_optionalChain([acceptHeader, 'optionalAccess', _28 => _28.includes, 'call', _29 => _29("text/event-stream")])) {
       return this.#errorResponse(
         406,
         -32e3,
@@ -632,7 +710,7 @@ var EdgeFastMCP = class {
       );
     }
     const contentType = request.headers.get("content-type");
-    if (!_optionalChain([contentType, 'optionalAccess', _28 => _28.includes, 'call', _29 => _29("application/json")])) {
+    if (!_optionalChain([contentType, 'optionalAccess', _30 => _30.includes, 'call', _31 => _31("application/json")])) {
       return this.#errorResponse(
         415,
         -32e3,
@@ -677,7 +755,7 @@ var EdgeFastMCP = class {
    */
   async #handleMcpSseRequest(request) {
     const acceptHeader = request.headers.get("accept");
-    if (!_optionalChain([acceptHeader, 'optionalAccess', _30 => _30.includes, 'call', _31 => _31("text/event-stream")])) {
+    if (!_optionalChain([acceptHeader, 'optionalAccess', _32 => _32.includes, 'call', _33 => _33("text/event-stream")])) {
       return this.#errorResponse(
         406,
         -32e3,
@@ -745,8 +823,8 @@ var EdgeFastMCP = class {
    * Handle prompts/get request
    */
   async #handlePromptsGet(id, params) {
-    const promptName = _optionalChain([params, 'optionalAccess', _32 => _32.name]);
-    const promptArgs = _optionalChain([params, 'optionalAccess', _33 => _33.arguments]);
+    const promptName = _optionalChain([params, 'optionalAccess', _34 => _34.name]);
+    const promptArgs = _optionalChain([params, 'optionalAccess', _35 => _35.arguments]);
     const prompt = this.#prompts.find((p) => p.name === promptName);
     if (!prompt) {
       return this.#rpcError(
@@ -808,7 +886,7 @@ var EdgeFastMCP = class {
    * Handle resources/read request
    */
   async #handleResourcesRead(id, params) {
-    const uri = _optionalChain([params, 'optionalAccess', _34 => _34.uri]);
+    const uri = _optionalChain([params, 'optionalAccess', _36 => _36.uri]);
     const resource = this.#resources.find((r) => r.uri === uri);
     if (!resource) {
       return this.#rpcError(
@@ -837,8 +915,8 @@ var EdgeFastMCP = class {
    * Handle tools/call request
    */
   async #handleToolsCall(id, params) {
-    const toolName = _optionalChain([params, 'optionalAccess', _35 => _35.name]);
-    const toolArgs = _optionalChain([params, 'optionalAccess', _36 => _36.arguments]);
+    const toolName = _optionalChain([params, 'optionalAccess', _37 => _37.name]);
+    const toolArgs = _optionalChain([params, 'optionalAccess', _38 => _38.arguments]);
     const tool = this.#tools.find((t) => t.name === toolName);
     if (!tool) {
       return this.#rpcError(
@@ -861,7 +939,7 @@ var EdgeFastMCP = class {
       }
       if (parsed.issues) {
         const friendlyErrors = parsed.issues.map((issue) => {
-          const path = _optionalChain([issue, 'access', _37 => _37.path, 'optionalAccess', _38 => _38.join, 'call', _39 => _39(".")]) || "root";
+          const path = _optionalChain([issue, 'access', _39 => _39.path, 'optionalAccess', _40 => _40.join, 'call', _41 => _41(".")]) || "root";
           return `${path}: ${issue.message}`;
         }).join(", ");
         return this.#rpcError(