@prefecthq/fastmcp-ts 1.3.0 → 1.4.0

package/dist/cli/index.cjs

@@ -1172,7 +1172,7 @@ var init_version = __esm({
       async run({ args }) {
         if (args.json) setJsonMode(true);
         const data = {
-          fastmcp: "1.3.0",
+          fastmcp: "1.4.0",
           "mcp-sdk": "2.0.0",
           node: process.version,
           platform: `${process.platform} ${process.arch}`
@@ -33404,7 +33404,7 @@ var init_inspect = __esm({
               // only case Python's inspect supports); over --url/--command the
               // generation is unknowable from the wire.
               generation: mode.kind === "inprocess" ? 2 : null,
-              fastmcpVersion: "1.3.0",
+              fastmcpVersion: "1.4.0",
               mcpVersion: "2.0.0",
               tools: tools2,
               prompts: prompts2,
@@ -46908,7 +46908,7 @@ init_format();
 var main = defineCommand({
   meta: {
     name: "fastmcp",
-    version: "1.3.0",
+    version: "1.4.0",
     description: "FastMCP CLI \u2014 build, run, and manage MCP servers"
   },
   args: {

package/dist/server.d.ts

@@ -1,6 +1,6 @@
 import * as _modelcontextprotocol_server from '@modelcontextprotocol/server';
 import { InputResponses, Server, CacheHint, ServerContext, ServerEventBus, Transport, McpHandlerRequestOptions, CallToolResult, OAuthClientInformationFull, AuthInfo } from '@modelcontextprotocol/server';
-export { InputRequest, InputRequests, InputRequiredResult, InputRequiredSpec, InputResponse, InputResponseView, InputResponses, ServerEventBus, acceptedContent, inputRequired, inputResponse, isInputRequiredResult } from '@modelcontextprotocol/server';
+export { AuthInfo, InputRequest, InputRequests, InputRequiredResult, InputRequiredSpec, InputResponse, InputResponseView, InputResponses, McpHandlerRequestOptions, ServerEventBus, acceptedContent, inputRequired, inputResponse, isInputRequiredResult } from '@modelcontextprotocol/server';
 import { OAuthServerProvider, AuthorizationParams } from '@modelcontextprotocol/server-legacy/auth';
 import { StandardSchemaV1 } from '@standard-schema/spec';
 import { Readable, Writable } from 'node:stream';
@@ -871,11 +871,14 @@ interface FastMCPOptions {
      */
     eventBus?: ServerEventBus;
     /**
-     * DNS-rebinding protection for the HTTP transport: validates the `Host` and
-     * `Origin` request headers (port-agnostic, by hostname) and rejects mismatches
-     * with `403`. Defends localhost servers against a malicious web page whose DNS
-     * rebinds to `127.0.0.1` (MCP transport security best practice). Only affects the
-     * HTTP transport — stdio is unaffected.
+     * DNS-rebinding protection for the HTTP listener started by `run()`: validates
+     * the `Host` and `Origin` request headers (port-agnostic, by hostname) and rejects
+     * mismatches with `403`. Defends localhost servers against a malicious web page
+     * whose DNS rebinds to `127.0.0.1` (MCP transport security best practice).
+     *
+     * This option does not apply to `fetch()`, which has no bind address from which
+     * to infer a trusted host. A framework embedding `fetch()` owns Host/Origin
+     * validation at its HTTP boundary. stdio is unaffected.
      *
      * Default posture (option omitted): protection auto-enables when, and only when,
      * `run()` binds the HTTP server to a loopback host (`127.0.0.1`, `::1`,
@@ -1249,6 +1252,19 @@ declare class FastMCP {
      */
     get isRunning(): boolean;
     connect(transport: Transport): Promise<void>;
+    /**
+     * Serve an MCP request through a web-standard, fetch-native HTTP entrypoint.
+     *
+     * This entrypoint is always stateless and does not require `run()`: legacy
+     * (2025-era) requests use a fresh server instance per request, while modern
+     * (2026-07-28) requests share the instance's modern handler and event bus.
+     * Authentication is deliberately external — `options.authInfo` is trusted and
+     * passed unchanged into the protocol handler, where it is exposed as `ctx.auth`.
+     * The embedding framework also owns Host/Origin validation and should abort its
+     * carrying requests during shutdown; stateless legacy response streams follow
+     * that request lifecycle, while `close()` terminates modern exchanges and streams.
+     */
+    fetch(request: Request, options?: McpHandlerRequestOptions): Promise<Response>;
     /**
      * Modern-era (2026-07-28) in-process fetch entrypoint — the `McpServerLike`
      * duck-type hook `fastmcp-ts/client`'s `Client` looks for when a caller pins
@@ -1265,9 +1281,9 @@ declare class FastMCP {
     /** Lazily builds the modern (2026-07-28) HTTP handler. One per FastMCP instance;
      * builds a fresh Server (via _makeServer) per request, matching createMcpHandler's
      * per-request-factory model. Modern-only (legacy: 'reject') — legacy (2025-era)
-     * traffic is routed to the existing sessionful transport by _dispatchHttp instead
-     * of createMcpHandler's own stateless legacy fallback, so session state and the
-     * legacy server-initiated-request shim keep working for 2025-era clients. */
+     * traffic is routed separately: to the existing sessionful transport by
+     * _dispatchHttp, or to the stateless fallback by fetch(). This preserves the
+     * session state and server-initiated-request shim for run()'s default HTTP path. */
     private _getModernHandler;
     /** Lazily builds the stateless legacy (2025-era) HTTP handler. One per FastMCP
      * instance, mirroring _getModernHandler's per-instance, per-request-factory model.
@@ -1276,8 +1292,9 @@ declare class FastMCP {
      * built with `sessionIdGenerator: undefined`, and answers GET and DELETE with 405
      * because both are session operations that mean nothing per request.
      *
-     * Only reachable when `_stateless` is on. The sessionful transport in
-     * _dispatchLegacyHttp is untouched and still serves every other deployment. */
+     * Used unconditionally by fetch(), and by run() only when `_stateless` is on.
+     * The sessionful transport in _dispatchLegacyHttp is untouched and remains the
+     * default for listener-based HTTP deployments. */
     private _getStatelessLegacyHandler;
     /**
      * Dual-era HTTP dispatch shared by the OAuth and non-OAuth serve paths. Assumes CORS

package/dist/server.js

@@ -2111,6 +2111,29 @@ var FastMCP = class {
     this._primaryServer = this._makeServer();
     await this._primaryServer.connect(transport);
   }
+  /**
+   * Serve an MCP request through a web-standard, fetch-native HTTP entrypoint.
+   *
+   * This entrypoint is always stateless and does not require `run()`: legacy
+   * (2025-era) requests use a fresh server instance per request, while modern
+   * (2026-07-28) requests share the instance's modern handler and event bus.
+   * Authentication is deliberately external — `options.authInfo` is trusted and
+   * passed unchanged into the protocol handler, where it is exposed as `ctx.auth`.
+   * The embedding framework also owns Host/Origin validation and should abort its
+   * carrying requests during shutdown; stateless legacy response streams follow
+   * that request lifecycle, while `close()` terminates modern exchanges and streams.
+   */
+  async fetch(request, options) {
+    if (request.method.toUpperCase() === "POST" && !isJsonContentType(request.headers.get("content-type"))) {
+      return new Response(
+        JSON.stringify({ error: "Unsupported Media Type: expected application/json" }),
+        { status: 415, headers: { "Content-Type": "application/json" } }
+      );
+    }
+    const legacy = await isLegacyRequest(request, options?.parsedBody);
+    if (legacy) return this._getStatelessLegacyHandler()(request, options);
+    return this._getModernHandler().fetch(request, options);
+  }
   /**
    * Modern-era (2026-07-28) in-process fetch entrypoint — the `McpServerLike`
    * duck-type hook `fastmcp-ts/client`'s `Client` looks for when a caller pins
@@ -2157,9 +2180,9 @@ var FastMCP = class {
   /** Lazily builds the modern (2026-07-28) HTTP handler. One per FastMCP instance;
    * builds a fresh Server (via _makeServer) per request, matching createMcpHandler's
    * per-request-factory model. Modern-only (legacy: 'reject') — legacy (2025-era)
-   * traffic is routed to the existing sessionful transport by _dispatchHttp instead
-   * of createMcpHandler's own stateless legacy fallback, so session state and the
-   * legacy server-initiated-request shim keep working for 2025-era clients. */
+   * traffic is routed separately: to the existing sessionful transport by
+   * _dispatchHttp, or to the stateless fallback by fetch(). This preserves the
+   * 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 }), {
@@ -2176,8 +2199,9 @@ var FastMCP = class {
    * built with `sessionIdGenerator: undefined`, and answers GET and DELETE with 405
    * because both are session operations that mean nothing per request.
    *
-   * Only reachable when `_stateless` is on. The sessionful transport in
-   * _dispatchLegacyHttp is untouched and still serves every other deployment. */
+   * Used unconditionally by fetch(), and by run() only when `_stateless` is on.
+   * The sessionful transport in _dispatchLegacyHttp is untouched and remains the
+   * default for listener-based HTTP deployments. */
   _getStatelessLegacyHandler() {
     if (!this._statelessLegacyHandler) {
       this._statelessLegacyHandler = legacyStatelessFallback(