@prefecthq/fastmcp-ts 1.5.1 → 1.5.2

package/dist/server.d.ts

@@ -1054,6 +1054,7 @@ declare class FastMCP {
     private _primaryServer;
     private _stdioServer;
     private _stdioState;
+    private _stdioModern;
     private _stdioHandle;
     private _modernHandler;
     private _statelessLegacyHandler;
@@ -1067,32 +1068,28 @@ declare class FastMCP {
     /**
      * Create a new Server instance with all request handlers wired up.
      *
-     * `modern` forks the advertised `resources.subscribe` capability. The legacy
-     * `resources/subscribe`/`unsubscribe` RPCs are physically absent from the
-     * 2026-07-28 wire registry (a modern client uses `subscriptions/listen`
-     * instead), so a modern-only factory (the createMcpHandler path) must NOT
-     * advertise `subscribe` — the modern `server/discover` document is pinned to
-     * `resources: { listChanged: true }`. The primary in-process server and
-     * legacy HTTP sessions are always legacy, so they always advertise it.
-     * stdio forks it per-connection too: `run()`'s stdio branch reads the
-     * `ctx.era` the SDK's `McpServerFactory` hook hands it (serveStdio only
-     * calls the factory once the opening exchange has classified the era, so
-     * the modern-vs-legacy choice is already known at construction time) and
-     * passes it straight through as `opts.modern`.
+     * `resources.subscribe` is advertised on both eras. On legacy it gates the
+     * `resources/subscribe`/`unsubscribe` RPCs. On modern (2026-07-28) the same
+     * capability gates the `subscriptions/listen` `resourceSubscriptions`
+     * filter: the SDK's listen routers silently prune the filter from the
+     * honored subset when the serving entry's capabilities omit `subscribe`,
+     * so a modern server that supports per-resource updates MUST advertise it
+     * (issue #88). The legacy RPCs are still physically absent from the modern
+     * wire registry, so advertising the capability leaks no legacy-only
+     * surface to a modern client.
      *
-     * The `completions` capability is NOT era-forked: `completion/complete` is in
-     * BOTH era wire registries (the legacy 2025-11-25 registry and the modern
-     * 2026-07-28 `dispatchRequestSchemas`), and `completions` is a valid key in
-     * both eras' ServerCapabilities schemas. So it is declared unconditionally —
-     * unlike `subscribe`, there is no legacy-only surface to hide from a modern
-     * client here, so nothing needs the era fork the way `subscribe` does. The
-     * SDK also requires this capability to be present to register the
-     * `completion/complete` handler (`assertRequestHandlerCapability`).
+     * The `completions` capability follows the same shape: `completion/complete`
+     * is in BOTH era wire registries (the legacy 2025-11-25 registry and the
+     * modern 2026-07-28 `dispatchRequestSchemas`), and `completions` is a valid
+     * key in both eras' ServerCapabilities schemas, so it is declared
+     * unconditionally. The SDK also requires this capability to be present to
+     * register the `completion/complete` handler
+     * (`assertRequestHandlerCapability`).
      *
-     * `stateless` withdraws the same capability for a different reason. A
-     * stateless server has no session for a subscription to live in and no
-     * channel to deliver `notifications/resources/updated` on, so it must not
-     * claim the capability.
+     * `stateless` withdraws the `resources.subscribe` capability. A stateless
+     * server has no session for a subscription to live in and no channel to
+     * deliver `notifications/resources/updated` on, so it must not claim the
+     * capability.
      */
     private _makeServer;
     private _resolveToken;
@@ -1126,6 +1123,9 @@ declare class FastMCP {
      *   per-stream filtering, delivering only to `subscriptions/listen` streams that
      *   opted in to this URI. Optional chaining keeps it a no-op until the first
      *   modern HTTP request has actually built the handler.
+     * - A modern stdio connection is sent the notification unconditionally; the
+     *   SDK's stdio listen router intercepts it and fans out per honored
+     *   subscription (or drops it when no stream opted in to the URI).
      *
      * Unsubscribed sessions (and the modern streams that never opted in) receive
      * nothing, so calling this for a URI with no subscribers is safe and cheap.

package/dist/server.js

@@ -1081,6 +1081,9 @@ var FastMCP = class {
   // Holds this connection's resource-subscription set; read by the resource-updated
   // fan-out. Null unless serving stdio.
   _stdioState = null;
+  // Whether the current stdio connection negotiated the modern (2026-07-28) era.
+  // Set by run()'s stdio factory; drives notifyResourceUpdated's stdio branch.
+  _stdioModern = false;
   _stdioHandle = null;
   // Modern (2026-07-28) HTTP handler — one per FastMCP instance, lazily created.
   // Builds a fresh Server (via _makeServer) per request; see createMcpHandler.
@@ -1124,32 +1127,28 @@ var FastMCP = class {
   /**
    * Create a new Server instance with all request handlers wired up.
    *
-   * `modern` forks the advertised `resources.subscribe` capability. The legacy
-   * `resources/subscribe`/`unsubscribe` RPCs are physically absent from the
-   * 2026-07-28 wire registry (a modern client uses `subscriptions/listen`
-   * instead), so a modern-only factory (the createMcpHandler path) must NOT
-   * advertise `subscribe` — the modern `server/discover` document is pinned to
-   * `resources: { listChanged: true }`. The primary in-process server and
-   * legacy HTTP sessions are always legacy, so they always advertise it.
-   * stdio forks it per-connection too: `run()`'s stdio branch reads the
-   * `ctx.era` the SDK's `McpServerFactory` hook hands it (serveStdio only
-   * calls the factory once the opening exchange has classified the era, so
-   * the modern-vs-legacy choice is already known at construction time) and
-   * passes it straight through as `opts.modern`.
+   * `resources.subscribe` is advertised on both eras. On legacy it gates the
+   * `resources/subscribe`/`unsubscribe` RPCs. On modern (2026-07-28) the same
+   * capability gates the `subscriptions/listen` `resourceSubscriptions`
+   * filter: the SDK's listen routers silently prune the filter from the
+   * honored subset when the serving entry's capabilities omit `subscribe`,
+   * so a modern server that supports per-resource updates MUST advertise it
+   * (issue #88). The legacy RPCs are still physically absent from the modern
+   * wire registry, so advertising the capability leaks no legacy-only
+   * surface to a modern client.
    *
-   * The `completions` capability is NOT era-forked: `completion/complete` is in
-   * BOTH era wire registries (the legacy 2025-11-25 registry and the modern
-   * 2026-07-28 `dispatchRequestSchemas`), and `completions` is a valid key in
-   * both eras' ServerCapabilities schemas. So it is declared unconditionally —
-   * unlike `subscribe`, there is no legacy-only surface to hide from a modern
-   * client here, so nothing needs the era fork the way `subscribe` does. The
-   * SDK also requires this capability to be present to register the
-   * `completion/complete` handler (`assertRequestHandlerCapability`).
+   * The `completions` capability follows the same shape: `completion/complete`
+   * is in BOTH era wire registries (the legacy 2025-11-25 registry and the
+   * modern 2026-07-28 `dispatchRequestSchemas`), and `completions` is a valid
+   * key in both eras' ServerCapabilities schemas, so it is declared
+   * unconditionally. The SDK also requires this capability to be present to
+   * register the `completion/complete` handler
+   * (`assertRequestHandlerCapability`).
    *
-   * `stateless` withdraws the same capability for a different reason. A
-   * stateless server has no session for a subscription to live in and no
-   * channel to deliver `notifications/resources/updated` on, so it must not
-   * claim the capability.
+   * `stateless` withdraws the `resources.subscribe` capability. A stateless
+   * server has no session for a subscription to live in and no channel to
+   * deliver `notifications/resources/updated` on, so it must not claim the
+   * capability.
    */
   _makeServer(sessionState, opts) {
     const state = sessionState ?? this._primaryState;
@@ -1157,7 +1156,7 @@ var FastMCP = class {
     const server = new Server2(
       { name: this.name, version: this.version },
       {
-        capabilities: { tools: { listChanged: true }, resources: { listChanged: true, ...opts?.modern || opts?.stateless ? {} : { subscribe: true } }, prompts: { listChanged: true }, logging: {}, completions: {}, ...extensions ? { extensions } : {} },
+        capabilities: { tools: { listChanged: true }, resources: { listChanged: true, ...opts?.stateless ? {} : { subscribe: true } }, prompts: { listChanged: true }, logging: {}, completions: {}, ...extensions ? { extensions } : {} },
         ...this._cacheHints ? { cacheHints: this._cacheHints } : {},
         ...this._requestStateCodec ? { requestState: { verify: this._requestStateCodec.verify.bind(this._requestStateCodec) } } : {},
         ...this._inputRequiredOptions ? { inputRequired: this._inputRequiredOptions } : {}
@@ -1749,6 +1748,9 @@ var FastMCP = class {
    *   per-stream filtering, delivering only to `subscriptions/listen` streams that
    *   opted in to this URI. Optional chaining keeps it a no-op until the first
    *   modern HTTP request has actually built the handler.
+   * - A modern stdio connection is sent the notification unconditionally; the
+   *   SDK's stdio listen router intercepts it and fans out per honored
+   *   subscription (or drops it when no stream opted in to the URI).
    *
    * Unsubscribed sessions (and the modern streams that never opted in) receive
    * nothing, so calling this for a URI with no subscribers is safe and cheap.
@@ -1760,7 +1762,11 @@ var FastMCP = class {
       });
     };
     pushIfSubscribed(this._primaryServer, this._primaryState);
-    if (this._stdioServer) pushIfSubscribed(this._stdioServer, this._stdioState);
+    if (this._stdioServer) {
+      if (this._stdioModern) this._stdioServer.sendResourceUpdated({ uri }).catch(() => {
+      });
+      else pushIfSubscribed(this._stdioServer, this._stdioState);
+    }
     for (const { server, state } of this._sessions.values()) pushIfSubscribed(server, state);
     this._modernHandler?.notify.resourceUpdated(uri);
   }
@@ -2280,7 +2286,8 @@ var FastMCP = class {
         (ctx) => {
           const stdioState = /* @__PURE__ */ new Map();
           this._stdioState = stdioState;
-          this._stdioServer = this._makeServer(stdioState, { modern: ctx.era === "modern" });
+          this._stdioModern = ctx.era === "modern";
+          this._stdioServer = this._makeServer(stdioState);
           return this._stdioServer;
         },
         { transport: stdioTransport }
@@ -2317,7 +2324,7 @@ var FastMCP = class {
    * session state and server-initiated-request shim for run()'s default HTTP path. */
   _getModernHandler() {
     if (!this._modernHandler) {
-      this._modernHandler = createMcpHandler(() => this._makeServer(/* @__PURE__ */ new Map(), { modern: true }), {
+      this._modernHandler = createMcpHandler(() => this._makeServer(/* @__PURE__ */ new Map()), {
         legacy: "reject",
         ...this._eventBus ? { bus: this._eventBus } : {}
       });
@@ -2585,6 +2592,7 @@ var FastMCP = class {
       this._stdioHandle = null;
       this._stdioServer = null;
       this._stdioState = null;
+      this._stdioModern = false;
     }
     if (this._httpServer) {
       await new Promise((resolve, reject) => {