@prefecthq/fastmcp-ts 1.2.0 → 1.3.0

package/dist/server.js

@@ -8,6 +8,9 @@ import { ProtocolError as ProtocolError3, ProtocolErrorCode as ProtocolErrorCode
 import { randomUUID as randomUUID2 } from "crypto";
 
 // src/server/auth/types.ts
+function isRequestVerifier(v) {
+  return "verifyRequest" in v;
+}
 var AuthorizationError = class extends Error {
   constructor(message) {
     super(message);
@@ -57,12 +60,94 @@ var BoundedEventStore = class {
 
 // src/server/context.ts
 import { AsyncLocalStorage } from "async_hooks";
+
+// src/server/httpContext.ts
+var DEFAULT_SENSITIVE_HEADERS = [
+  "authorization",
+  "cookie",
+  "proxy-authorization",
+  "mcp-session-id"
+];
+function resolveSensitiveHeaders(options) {
+  const set = new Set(DEFAULT_SENSITIVE_HEADERS);
+  for (const h of options?.redactHeaders ?? []) set.add(h.toLowerCase());
+  for (const h of options?.exposeHeaders ?? []) set.delete(h.toLowerCase());
+  return set;
+}
+function buildHttpRequestContext(req, sensitiveHeaders) {
+  const headers = new Headers();
+  const redacted = [];
+  req.headers.forEach((value, name) => {
+    if (sensitiveHeaders.has(name)) {
+      redacted.push(name);
+      return;
+    }
+    headers.append(name, value);
+  });
+  redacted.sort();
+  let url;
+  try {
+    const u = new URL(req.url);
+    url = u.pathname + u.search;
+  } catch {
+    url = req.url;
+  }
+  return { headers, redactedHeaderNames: redacted, method: req.method, url };
+}
+function nodeRequestToHttpContext(req) {
+  const headers = new Headers();
+  for (const [name, value] of Object.entries(req.headers)) {
+    if (value === void 0) continue;
+    if (Array.isArray(value)) {
+      for (const v of value) headers.append(name, v);
+    } else {
+      headers.append(name, value);
+    }
+  }
+  return { headers, redactedHeaderNames: [], method: req.method ?? "GET", url: req.url ?? "/" };
+}
+var UNFORWARDABLE = /* @__PURE__ */ new Set([
+  // credentials (see also DEFAULT_SENSITIVE_HEADERS; kept here too so the
+  // helper is safe on Headers that did not come from a redacted ctx.http)
+  "authorization",
+  "cookie",
+  "proxy-authorization",
+  "proxy-authenticate",
+  // hop-by-hop (RFC 9110 §7.6.1) and connection management
+  "connection",
+  "keep-alive",
+  "te",
+  "trailer",
+  "transfer-encoding",
+  "upgrade",
+  "proxy-connection",
+  // message framing / target-specific
+  "host",
+  "content-length",
+  "content-type",
+  "expect"
+]);
+function forwardableHeaders(headers, options) {
+  const include = new Set((options?.include ?? []).map((h) => h.toLowerCase()));
+  const out = new Headers();
+  headers.forEach((value, name) => {
+    if (include.has(name)) {
+      out.append(name, value);
+      return;
+    }
+    if (UNFORWARDABLE.has(name) || name.startsWith("mcp-")) return;
+    out.append(name, value);
+  });
+  return out;
+}
+
+// src/server/context.ts
 var contextStore = new AsyncLocalStorage();
 var SESSION_CLOSE_CALLBACKS_KEY = "__fastmcp_session_close_callbacks";
 var SESSION_STATE_MODERN_HTTP_ERROR = "[fastmcp] Session state is not available on modern HTTP requests (protocol revision 2026-07-28). Each request runs statelessly with no shared session store. Use ctx.requestState() to read per-request state. Use ctx.mintRequestState() to carry state across a multi-round-trip flow.";
 var SESSION_STATE_STATELESS_HTTP_ERROR = "[fastmcp] Session state is not available on a stateless HTTP server (RunOptions.stateless or FASTMCP_STATELESS_HTTP). Each request runs against a fresh store that is discarded when the request ends. Use ctx.requestState() to read per-request state. Use ctx.mintRequestState() to carry state across a multi-round-trip flow. Turn stateless off to use session state, or keep state in your own external store.";
 var SERVER_INITIATED_STATELESS_HTTP_ERROR = "[fastmcp] Server-initiated requests (ctx.elicit, ctx.sample, ctx.listRoots) are not available on a stateless HTTP server (RunOptions.stateless or FASTMCP_STATELESS_HTTP). They need a session: client capabilities are negotiated once at initialize, and the client replies on a separate request. Return inputRequired({ requestState }) to carry a multi-round-trip flow without a session; the embedded-request form of inputRequired needs a session too. Turn stateless off to use server-initiated requests.";
-function createContext(server, sdkCtx, auth, sessionState, requestStateCodec, stateless) {
+function createContext(server, sdkCtx, auth, sessionState, requestStateCodec, stateless, sensitiveHeaders) {
   const requestId = String(sdkCtx.mcpReq.id);
   const progressToken = sdkCtx.mcpReq._meta?.progressToken;
   const isModernEra = sdkCtx.mcpReq.envelope !== void 0;
@@ -75,9 +160,12 @@ function createContext(server, sdkCtx, auth, sessionState, requestStateCodec, st
   async function log(level, message, loggerName) {
     await sdkCtx.mcpReq.log(level, message, loggerName);
   }
+  const httpReq = sdkCtx.http?.req;
+  const sensitive = sensitiveHeaders ?? resolveSensitiveHeaders();
   return {
     auth,
     requestId,
+    http: httpReq ? buildHttpRequestContext(httpReq, sensitive) : void 0,
     log,
     debug: (msg, logger) => log("debug", msg, logger),
     info: (msg, logger) => log("info", msg, logger),
@@ -683,6 +771,12 @@ function convertResourceResult(value, uri, mimeType, stateless) {
   }
   return { contents: [{ uri, mimeType: mimeType ?? "text/plain", text: String(value) }] };
 }
+function attachResourceUiMeta(result, ui, uiCapable) {
+  if (!ui || !uiCapable || isInputRequiredResult(result)) return result;
+  return {
+    contents: result.contents.map((c) => ({ ...c, _meta: { ui, ...c._meta } }))
+  };
+}
 function isUriTemplate(uri) {
   return uri.includes("{");
 }
@@ -820,7 +914,7 @@ function toAccessToken(authInfo) {
 }
 var _cliEnvToken;
 async function resolveCliEnvToken(verifier) {
-  if (!verifier) return void 0;
+  if (!verifier || !("verify" in verifier)) return void 0;
   if (_cliEnvToken !== void 0) return _cliEnvToken ?? void 0;
   const raw = process.env["FASTMCP_CLI_AUTH_TOKEN"];
   if (!raw) {
@@ -851,6 +945,7 @@ var FastMCP = class {
   version;
   _auth;
   _oauth;
+  _sensitiveHeaders;
   _toolsPageSize;
   _resourcesPageSize;
   _tools = /* @__PURE__ */ new Map();
@@ -900,6 +995,7 @@ var FastMCP = class {
     this.version = options.version ?? "0.0.1";
     this._auth = options.auth;
     this._oauth = options.oauth;
+    this._sensitiveHeaders = resolveSensitiveHeaders(options.http);
     this._toolsPageSize = options.toolsPageSize ?? 50;
     this._resourcesPageSize = options.resourcesPageSize ?? 50;
     this._promptsPageSize = options.promptsPageSize ?? 50;
@@ -976,7 +1072,7 @@ var FastMCP = class {
   _setupHandlers(server, sessionState, opts) {
     server.setRequestHandler("tools/list", async (req, sdkCtx) => {
       const token = await this._resolveToken(sdkCtx.http?.authInfo);
-      const ctx = createContext(server, sdkCtx, token, sessionState, this._requestStateCodec, opts?.stateless);
+      const ctx = createContext(server, sdkCtx, token, sessionState, this._requestStateCodec, opts?.stateless, this._sensitiveHeaders);
       return contextStore.run(
         ctx,
         () => runMiddlewareChain(this._middleware, "tools/list", req.params, ctx, async () => {
@@ -1055,7 +1151,7 @@ var FastMCP = class {
       const synthTool = synthesizedList.find((s) => s.name === requestedName);
       if (synthTool) {
         if (synthTool.auth) await runAuthCheck(synthTool.auth, token);
-        const ctx2 = createContext(server, sdkCtx, token, sessionState, this._requestStateCodec, opts?.stateless);
+        const ctx2 = createContext(server, sdkCtx, token, sessionState, this._requestStateCodec, opts?.stateless, this._sensitiveHeaders);
         try {
           return await contextStore.run(
             ctx2,
@@ -1108,7 +1204,7 @@ var FastMCP = class {
       if (tool.config.auth) await runAuthCheck(tool.config.auth, token);
       const resolvedTool = tool;
       const rawArgs = req.params.arguments ?? {};
-      const ctx = createContext(server, sdkCtx, token, sessionState, this._requestStateCodec, opts?.stateless);
+      const ctx = createContext(server, sdkCtx, token, sessionState, this._requestStateCodec, opts?.stateless, this._sensitiveHeaders);
       try {
         return await contextStore.run(
           ctx,
@@ -1150,7 +1246,7 @@ var FastMCP = class {
     });
     server.setRequestHandler("resources/list", async (req, sdkCtx) => {
       const token = await this._resolveToken(sdkCtx.http?.authInfo);
-      const ctx = createContext(server, sdkCtx, token, sessionState, this._requestStateCodec, opts?.stateless);
+      const ctx = createContext(server, sdkCtx, token, sessionState, this._requestStateCodec, opts?.stateless, this._sensitiveHeaders);
       return contextStore.run(
         ctx,
         () => runMiddlewareChain(this._middleware, "resources/list", req.params, ctx, async () => {
@@ -1197,7 +1293,7 @@ var FastMCP = class {
     });
     server.setRequestHandler("resources/templates/list", async (req, sdkCtx) => {
       const token = await this._resolveToken(sdkCtx.http?.authInfo);
-      const ctx = createContext(server, sdkCtx, token, sessionState, this._requestStateCodec, opts?.stateless);
+      const ctx = createContext(server, sdkCtx, token, sessionState, this._requestStateCodec, opts?.stateless, this._sensitiveHeaders);
       return contextStore.run(
         ctx,
         () => runMiddlewareChain(this._middleware, "resources/templates/list", req.params, ctx, async () => {
@@ -1249,7 +1345,7 @@ var FastMCP = class {
       const resource = resolved.resource;
       const templateParams = resolved.templateParams;
       if (resource.config.auth) await runAuthCheck(resource.config.auth, token);
-      const ctx = createContext(server, sdkCtx, token, sessionState, this._requestStateCodec, opts?.stateless);
+      const ctx = createContext(server, sdkCtx, token, sessionState, this._requestStateCodec, opts?.stateless, this._sensitiveHeaders);
       return contextStore.run(
         ctx,
         () => runMiddlewareChain(this._middleware, "resources/read", req.params, ctx, async () => {
@@ -1268,7 +1364,8 @@ var FastMCP = class {
             );
           }
           const result = await executePromise;
-          return convertResourceResult(result, requestedUri, resource.config.mimeType, opts?.stateless);
+          const converted = convertResourceResult(result, requestedUri, resource.config.mimeType, opts?.stateless);
+          return attachResourceUiMeta(converted, resource.config.ui, isUiCapable(server.getClientCapabilities()));
         })
       );
     });
@@ -1282,7 +1379,7 @@ var FastMCP = class {
       }
       const resource = resolved.resource;
       if (resource.config.auth) await runAuthCheck(resource.config.auth, token);
-      const ctx = createContext(server, sdkCtx, token, sessionState, this._requestStateCodec, opts?.stateless);
+      const ctx = createContext(server, sdkCtx, token, sessionState, this._requestStateCodec, opts?.stateless, this._sensitiveHeaders);
       return contextStore.run(
         ctx,
         () => runMiddlewareChain(this._middleware, "resources/subscribe", req.params, ctx, async () => {
@@ -1300,7 +1397,7 @@ var FastMCP = class {
       if (opts?.stateless) throw new ProtocolError3(ProtocolErrorCode3.MethodNotFound, STATELESS_SUBSCRIBE_ERROR);
       const uri = req.params.uri;
       const token = await this._resolveToken(sdkCtx.http?.authInfo);
-      const ctx = createContext(server, sdkCtx, token, sessionState, this._requestStateCodec, opts?.stateless);
+      const ctx = createContext(server, sdkCtx, token, sessionState, this._requestStateCodec, opts?.stateless, this._sensitiveHeaders);
       return contextStore.run(
         ctx,
         () => runMiddlewareChain(this._middleware, "resources/unsubscribe", req.params, ctx, async () => {
@@ -1312,7 +1409,7 @@ var FastMCP = class {
     });
     server.setRequestHandler("prompts/list", async (req, sdkCtx) => {
       const token = await this._resolveToken(sdkCtx.http?.authInfo);
-      const ctx = createContext(server, sdkCtx, token, sessionState, this._requestStateCodec, opts?.stateless);
+      const ctx = createContext(server, sdkCtx, token, sessionState, this._requestStateCodec, opts?.stateless, this._sensitiveHeaders);
       return contextStore.run(
         ctx,
         () => runMiddlewareChain(this._middleware, "prompts/list", req.params, ctx, async () => {
@@ -1392,7 +1489,7 @@ var FastMCP = class {
           );
         }
       }
-      const ctx = createContext(server, sdkCtx, token, sessionState, this._requestStateCodec, opts?.stateless);
+      const ctx = createContext(server, sdkCtx, token, sessionState, this._requestStateCodec, opts?.stateless, this._sensitiveHeaders);
       return contextStore.run(
         ctx,
         () => runMiddlewareChain(this._middleware, "prompts/get", req.params, ctx, async () => {
@@ -1416,7 +1513,7 @@ var FastMCP = class {
     });
     server.setRequestHandler("completion/complete", async (req, sdkCtx) => {
       const token = await this._resolveToken(sdkCtx.http?.authInfo);
-      const ctx = createContext(server, sdkCtx, token, sessionState, this._requestStateCodec, opts?.stateless);
+      const ctx = createContext(server, sdkCtx, token, sessionState, this._requestStateCodec, opts?.stateless, this._sensitiveHeaders);
       return contextStore.run(
         ctx,
         () => runMiddlewareChain(this._middleware, "completion/complete", req.params, ctx, async () => {
@@ -2237,14 +2334,26 @@ var FastMCP = class {
       }
       for (const [k, v] of Object.entries(corsHeaders)) res.setHeader(k, v);
       if (auth) {
-        const authHeader = req.headers.authorization;
-        const bearer = authHeader?.startsWith("Bearer ") ? authHeader.slice(7) : null;
-        if (!bearer) {
-          res.writeHead(401, { "Content-Type": "application/json", "WWW-Authenticate": 'Bearer realm="mcp"' }).end(JSON.stringify({ error: "Missing bearer token" }));
-          return;
-        }
-        try {
-          const accessToken = await auth.verify(bearer);
+        if (isRequestVerifier(auth)) {
+          let accessToken;
+          try {
+            accessToken = await auth.verifyRequest(nodeRequestToHttpContext(req));
+          } catch (err) {
+            if (err instanceof AuthorizationError) {
+              res.writeHead(403, { "Content-Type": "application/json" }).end(JSON.stringify({ error: err.message }));
+            } else {
+              res.writeHead(401, { "Content-Type": "application/json" }).end(JSON.stringify({ error: err instanceof Error ? err.message : "Authentication failed" }));
+            }
+            return;
+          }
+          if (!accessToken.token) {
+            console.error(
+              "[fastmcp] RequestVerifier.verifyRequest must set AccessToken.token to a stable, non-empty per-identity value. It keys response-cache partitioning and downstream identity."
+            );
+            res.writeHead(500, { "Content-Type": "application/json" }).end(JSON.stringify({ error: "verifyRequest returned an AccessToken with an empty token" }));
+            return;
+          }
+          ;
           req.auth = {
             token: accessToken.token,
             clientId: accessToken.clientId ?? "",
@@ -2252,13 +2361,30 @@ var FastMCP = class {
             expiresAt: accessToken.expiresAt,
             extra: accessToken.claims
           };
-        } catch (err) {
-          if (err instanceof AuthorizationError) {
-            res.writeHead(403, { "Content-Type": "application/json" }).end(JSON.stringify({ error: err.message }));
-          } else {
-            res.writeHead(401, { "Content-Type": "application/json", "WWW-Authenticate": 'Bearer realm="mcp"' }).end(JSON.stringify({ error: err instanceof Error ? err.message : "Authentication failed" }));
+        } else {
+          const authHeader = req.headers.authorization;
+          const bearer = authHeader?.startsWith("Bearer ") ? authHeader.slice(7) : null;
+          if (!bearer) {
+            res.writeHead(401, { "Content-Type": "application/json", "WWW-Authenticate": 'Bearer realm="mcp"' }).end(JSON.stringify({ error: "Missing bearer token" }));
+            return;
+          }
+          try {
+            const accessToken = await auth.verify(bearer);
+            req.auth = {
+              token: accessToken.token,
+              clientId: accessToken.clientId ?? "",
+              scopes: accessToken.scopes,
+              expiresAt: accessToken.expiresAt,
+              extra: accessToken.claims
+            };
+          } catch (err) {
+            if (err instanceof AuthorizationError) {
+              res.writeHead(403, { "Content-Type": "application/json" }).end(JSON.stringify({ error: err.message }));
+            } else {
+              res.writeHead(401, { "Content-Type": "application/json", "WWW-Authenticate": 'Bearer realm="mcp"' }).end(JSON.stringify({ error: err instanceof Error ? err.message : "Authentication failed" }));
+            }
+            return;
           }
-          return;
         }
       }
       await this._dispatchHttp(req, res);
@@ -2816,6 +2942,1472 @@ async function createProxy(config, name) {
   return buildProxyFromClient(client, { cacheTtl: config.cacheTtl, name });
 }
 
+// src/server/openapi/internal.ts
+function truthy(value) {
+  if (value === null || value === void 0 || value === false) return false;
+  if (typeof value === "number") return value !== 0;
+  if (typeof value === "string") return value.length > 0;
+  if (Array.isArray(value)) return value.length > 0;
+  if (typeof value === "object") return Object.keys(value).length > 0;
+  return true;
+}
+function isPlainObject(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function deepEqual(a, b) {
+  if (a === b) return true;
+  if (Array.isArray(a) && Array.isArray(b)) {
+    return a.length === b.length && a.every((item, i) => deepEqual(item, b[i]));
+  }
+  if (isPlainObject(a) && isPlainObject(b)) {
+    const aKeys = Object.keys(a);
+    const bKeys = Object.keys(b);
+    return aKeys.length === bKeys.length && aKeys.every((k) => Object.prototype.hasOwnProperty.call(b, k) && deepEqual(a[k], b[k]));
+  }
+  return false;
+}
+function warn(message) {
+  console.warn(`[fastmcp] ${message}`);
+}
+
+// src/server/openapi/parser.ts
+import { parse as parseYaml } from "yaml";
+
+// src/server/openapi/jsonSchema.ts
+var OPENAPI_SPECIFIC_FIELDS = [
+  "nullable",
+  "discriminator",
+  "readOnly",
+  "writeOnly",
+  "xml",
+  "externalDocs",
+  "deprecated"
+];
+var RECURSIVE_MAP_FIELDS = ["properties", "$defs", "$definitions"];
+var RECURSIVE_SINGLE_FIELDS = ["items", "additionalProperties", "not"];
+var RECURSIVE_LIST_FIELDS = ["allOf", "anyOf", "oneOf"];
+function convertOpenAPISchemaToJsonSchema(schema, openapiVersion) {
+  if (!isPlainObject(schema)) return schema;
+  let result = { ...schema };
+  if (openapiVersion?.startsWith("3.0")) {
+    result = convertNullableField(result);
+  }
+  if ("oneOf" in result) {
+    result.anyOf = result.oneOf;
+    delete result.oneOf;
+  }
+  result = requireDiscriminatorProperty(result);
+  for (const field of OPENAPI_SPECIFIC_FIELDS) {
+    delete result[field];
+  }
+  for (const field of RECURSIVE_MAP_FIELDS) {
+    const map = result[field];
+    if (isPlainObject(map)) {
+      result[field] = Object.fromEntries(
+        Object.entries(map).map(([name, sub]) => [
+          name,
+          isPlainObject(sub) ? convertOpenAPISchemaToJsonSchema(sub, openapiVersion) : sub
+        ])
+      );
+    }
+  }
+  for (const field of RECURSIVE_SINGLE_FIELDS) {
+    const sub = result[field];
+    if (isPlainObject(sub)) {
+      result[field] = convertOpenAPISchemaToJsonSchema(sub, openapiVersion);
+    }
+  }
+  for (const field of RECURSIVE_LIST_FIELDS) {
+    const list = result[field];
+    if (Array.isArray(list)) {
+      result[field] = list.map(
+        (item) => isPlainObject(item) ? convertOpenAPISchemaToJsonSchema(item, openapiVersion) : item
+      );
+    }
+  }
+  return result;
+}
+function convertNullableField(schema) {
+  if (!("nullable" in schema)) return schema;
+  const result = { ...schema };
+  const nullableValue = result.nullable;
+  delete result.nullable;
+  if (!nullableValue) return result;
+  const currentType = result.type;
+  if ("type" in result) {
+    if (typeof currentType === "string") {
+      result.type = [currentType, "null"];
+    } else if (Array.isArray(currentType) && !currentType.includes("null")) {
+      result.type = [...currentType, "null"];
+    }
+  } else if ("oneOf" in result) {
+    result.anyOf = [...result.oneOf, { type: "null" }];
+    delete result.oneOf;
+  } else if ("anyOf" in result) {
+    const anyOf = result.anyOf;
+    if (!anyOf.some((item) => isPlainObject(item) && item.type === "null")) {
+      result.anyOf = [...anyOf, { type: "null" }];
+    }
+  } else if ("allOf" in result) {
+    result.anyOf = [{ allOf: result.allOf }, { type: "null" }];
+    delete result.allOf;
+  }
+  if (Array.isArray(result.enum) && !result.enum.includes(null)) {
+    result.enum = [...result.enum, null];
+  }
+  return result;
+}
+function requireProperty(schema, propertyName) {
+  const required = schema.required;
+  if (required === void 0 || required === null) {
+    return { ...schema, required: [propertyName] };
+  }
+  if (Array.isArray(required) && !required.includes(propertyName)) {
+    return { ...schema, required: [...required, propertyName] };
+  }
+  return schema;
+}
+function requireDiscriminatorProperty(schema) {
+  const discriminator = schema.discriminator;
+  if (!isPlainObject(discriminator)) return schema;
+  const propertyName = discriminator.propertyName;
+  if (typeof propertyName !== "string") return schema;
+  const result = { ...schema };
+  for (const key of ["anyOf", "oneOf"]) {
+    const variants = result[key];
+    if (!Array.isArray(variants)) continue;
+    result[key] = variants.map(
+      (variant) => isPlainObject(variant) ? requireProperty(variant, propertyName) : variant
+    );
+  }
+  return result;
+}
+
+// src/server/openapi/schemas.ts
+var EXTERNAL_REF_MESSAGE = "External or non-local reference not supported";
+function isExternalRefError(error) {
+  return error instanceof Error && error.message.includes(EXTERNAL_REF_MESSAGE);
+}
+function replaceRefWithDefs(info, description) {
+  const schema = { ...info };
+  const refPath = schema.$ref;
+  if (truthy(refPath)) {
+    if (typeof refPath === "string") {
+      if (refPath.startsWith("#/components/schemas/")) {
+        schema.$ref = `#/$defs/${refPath.split("/").pop()}`;
+      } else if (!refPath.startsWith("#/")) {
+        throw new Error(
+          `${EXTERNAL_REF_MESSAGE}: ${refPath}. FastMCP only supports local schema references starting with '#/'. Please include all schema definitions within the OpenAPI document.`
+        );
+      }
+    }
+  } else if (truthy(schema.properties)) {
+    const properties = schema.properties;
+    if ("$ref" in properties) {
+      schema.properties = replaceRefWithDefs(properties);
+    } else {
+      schema.properties = Object.fromEntries(
+        Object.entries(properties).map(([name, prop]) => [
+          name,
+          isPlainObject(prop) ? replaceRefWithDefs(prop) : prop
+        ])
+      );
+    }
+  } else if (truthy(schema.items)) {
+    if (isPlainObject(schema.items)) {
+      schema.items = replaceRefWithDefs(schema.items);
+    }
+  }
+  for (const section of ["anyOf", "allOf", "oneOf"]) {
+    const list = schema[section];
+    if (Array.isArray(list)) {
+      schema[section] = list.map((item) => isPlainObject(item) ? replaceRefWithDefs(item) : item);
+    }
+  }
+  const additionalProperties = schema.additionalProperties;
+  if (truthy(additionalProperties) && isPlainObject(additionalProperties)) {
+    schema.additionalProperties = replaceRefWithDefs(additionalProperties);
+  }
+  const propertyNames = schema.propertyNames;
+  if (truthy(propertyNames) && isPlainObject(propertyNames)) {
+    schema.propertyNames = replaceRefWithDefs(propertyNames);
+  }
+  const patternProperties = schema.patternProperties;
+  if (truthy(patternProperties) && isPlainObject(patternProperties)) {
+    schema.patternProperties = Object.fromEntries(
+      Object.entries(patternProperties).map(([pattern, sub]) => [
+        pattern,
+        isPlainObject(sub) ? replaceRefWithDefs(sub) : sub
+      ])
+    );
+  }
+  if (info.description === void 0 && truthy(description) && !truthy(schema.description)) {
+    schema.description = description;
+  }
+  return schema;
+}
+function allofMembers(schema, schemaDefs, resolving = /* @__PURE__ */ new Set()) {
+  const ref = schema.$ref;
+  if (typeof ref === "string") {
+    for (const prefix of ["#/$defs/", "#/components/schemas/"]) {
+      if (ref.startsWith(prefix)) {
+        const name = ref.slice(prefix.length);
+        const referenced = schemaDefs[name];
+        if (isPlainObject(referenced) && !resolving.has(name)) {
+          const siblings = Object.fromEntries(
+            Object.entries(schema).filter(([key]) => key !== "$ref")
+          );
+          const members = allofMembers(referenced, schemaDefs, /* @__PURE__ */ new Set([...resolving, name]));
+          return truthy(siblings) ? [...members, siblings] : members;
+        }
+        break;
+      }
+    }
+  }
+  const allOf = schema.allOf;
+  if (Array.isArray(allOf)) {
+    const members = [];
+    for (const member of allOf) {
+      if (isPlainObject(member)) {
+        members.push(...allofMembers(member, schemaDefs, resolving));
+      }
+    }
+    const siblings = Object.fromEntries(Object.entries(schema).filter(([key]) => key !== "allOf"));
+    return truthy(siblings) ? [...members, siblings] : members;
+  }
+  return [schema];
+}
+function discriminatorTargetName(target) {
+  for (const prefix of ["#/$defs/", "#/components/schemas/"]) {
+    if (target.startsWith(prefix)) {
+      return target.slice(prefix.length) || null;
+    }
+  }
+  if (target.startsWith("#") || target.includes("/")) return null;
+  return target || null;
+}
+function flattenDiscriminatorSubtypes(schema, schemaDefs) {
+  const discriminator = schema.discriminator;
+  if (!isPlainObject(discriminator)) return null;
+  const propertyName = discriminator.propertyName;
+  const mapping = discriminator.mapping;
+  if (typeof propertyName !== "string" || !isPlainObject(mapping)) return null;
+  const ownProps = isPlainObject(schema.properties) ? schema.properties : {};
+  const alternatives = /* @__PURE__ */ new Map();
+  const values = [];
+  const variants = [];
+  for (const [value, target] of Object.entries(mapping)) {
+    if (typeof target !== "string") continue;
+    const name = discriminatorTargetName(target);
+    const subtype = name !== null ? schemaDefs[name] : void 0;
+    if (!isPlainObject(subtype)) continue;
+    const variantFields = [];
+    for (const member of allofMembers(subtype, schemaDefs)) {
+      const memberProps = isPlainObject(member.properties) ? member.properties : {};
+      for (const [propName, propSchema] of Object.entries(memberProps)) {
+        if (propName in ownProps) continue;
+        if (!variantFields.includes(propName)) variantFields.push(propName);
+        const seen = alternatives.get(propName) ?? [];
+        if (!seen.some((existing2) => deepEqual(existing2, propSchema))) seen.push(propSchema);
+        alternatives.set(propName, seen);
+      }
+    }
+    values.push(`'${value}'`);
+    if (variantFields.length > 0) {
+      variants.push(`'${value}' uses ${variantFields.join(", ")}`);
+    }
+  }
+  if (values.length === 0) return null;
+  const subtypeProps = Object.fromEntries(
+    [...alternatives.entries()].map(([propName, schemas]) => [
+      propName,
+      schemas.length === 1 ? schemas[0] : { anyOf: schemas }
+    ])
+  );
+  const properties = { ...ownProps, ...subtypeProps };
+  let note = `Selects the variant. Accepted values: ${values.join(", ")}.`;
+  if (variants.length > 0) {
+    note += ` ${variants.join("; ")}. Send only the fields belonging to the selected variant.`;
+  }
+  const existing = properties[propertyName];
+  const tagSchema = isPlainObject(existing) ? existing : { type: "string" };
+  const existingDesc = tagSchema.description;
+  properties[propertyName] = {
+    ...tagSchema,
+    description: truthy(existingDesc) ? `${existingDesc} ${note}` : note
+  };
+  return properties;
+}
+function capitalize(text) {
+  return text.charAt(0).toUpperCase() + text.slice(1);
+}
+function combineSchemasAndMapParams(route) {
+  const properties = {};
+  const required = [];
+  const parameterMap = {};
+  const paramNamesByLocation = {
+    path: /* @__PURE__ */ new Set(),
+    query: /* @__PURE__ */ new Set(),
+    header: /* @__PURE__ */ new Set(),
+    cookie: /* @__PURE__ */ new Set()
+  };
+  let bodySchema = {};
+  let bodyProps = {};
+  for (const param of route.parameters) {
+    paramNamesByLocation[param.location].add(param.name);
+  }
+  const requestBody = route.requestBody;
+  if (requestBody && truthy(requestBody.contentSchema)) {
+    const contentType = Object.keys(requestBody.contentSchema)[0];
+    bodySchema = requestBody.contentSchema[contentType];
+    if (truthy(requestBody.description) && !truthy(bodySchema.description)) {
+      bodySchema.description = requestBody.description;
+    }
+    if ("allOf" in bodySchema && Array.isArray(bodySchema.allOf)) {
+      const mergedProps = {};
+      const mergedRequired = [];
+      for (const subSchema of allofMembers(bodySchema, route.requestSchemas)) {
+        if ("properties" in subSchema && isPlainObject(subSchema.properties)) {
+          Object.assign(mergedProps, subSchema.properties);
+        }
+        if ("required" in subSchema && Array.isArray(subSchema.required)) {
+          mergedRequired.push(...subSchema.required);
+        }
+      }
+      bodySchema.properties = mergedProps;
+      if (mergedRequired.length > 0) {
+        bodySchema.required = [...new Set(mergedRequired)];
+      }
+      delete bodySchema.allOf;
+    }
+    const flattenedProps = flattenDiscriminatorSubtypes(bodySchema, route.requestSchemas);
+    if (flattenedProps !== null) {
+      bodySchema.properties = flattenedProps;
+      delete bodySchema.discriminator;
+    }
+    bodyProps = isPlainObject(bodySchema.properties) ? bodySchema.properties : {};
+  }
+  const allNonBodyParams = /* @__PURE__ */ new Set();
+  for (const names of Object.values(paramNamesByLocation)) {
+    for (const name of names) allNonBodyParams.add(name);
+  }
+  const bodyParamNames = new Set(Object.keys(bodyProps));
+  const paramCounts = /* @__PURE__ */ new Map();
+  for (const param of route.parameters) {
+    paramCounts.set(param.name, (paramCounts.get(param.name) ?? 0) + 1);
+  }
+  const collidingParams = /* @__PURE__ */ new Set();
+  for (const name of allNonBodyParams) {
+    if (bodyParamNames.has(name)) collidingParams.add(name);
+  }
+  for (const [name, count] of paramCounts) {
+    if (count > 1) collidingParams.add(name);
+  }
+  for (const param of route.parameters) {
+    const paramSchema = { ...param.schema };
+    if (truthy(param.description) && !truthy(paramSchema.description)) {
+      paramSchema.description = param.description;
+    }
+    if (collidingParams.has(param.name)) {
+      const suffixedName = `${param.name}__${param.location}`;
+      if (param.required) required.push(suffixedName);
+      parameterMap[suffixedName] = { location: param.location, openapiName: param.name };
+      const originalDesc = truthy(paramSchema.description) ? paramSchema.description : "";
+      const locationDesc = `(${capitalize(param.location)} parameter)`;
+      paramSchema.description = originalDesc ? `${originalDesc} ${locationDesc}` : locationDesc;
+      properties[suffixedName] = paramSchema;
+    } else {
+      if (param.required) required.push(param.name);
+      parameterMap[param.name] = { location: param.location, openapiName: param.name };
+      properties[param.name] = paramSchema;
+    }
+  }
+  if (requestBody && truthy(requestBody.contentSchema)) {
+    if ("$ref" in bodySchema && !truthy(bodyProps)) {
+      properties.body = bodySchema;
+      if (requestBody.required) required.push("body");
+      parameterMap.body = { location: "body", openapiName: "body" };
+    } else if (truthy(bodyProps)) {
+      for (const [propName, propSchema] of Object.entries(bodyProps)) {
+        properties[propName] = propSchema;
+        parameterMap[propName] = { location: "body", openapiName: propName };
+      }
+      if (requestBody.required) {
+        required.push(...bodySchema.required ?? []);
+      }
+    } else {
+      let paramName = String(
+        typeof bodySchema.title === "string" ? bodySchema.title : "body"
+      ).toLowerCase();
+      paramName = paramName.replace(/[^a-zA-Z0-9_]/g, "_");
+      if (!paramName || /^\d/.test(paramName)) paramName = "body_data";
+      properties[paramName] = bodySchema;
+      if (requestBody.required) required.push(paramName);
+      parameterMap[paramName] = { location: "body", openapiName: paramName };
+    }
+  }
+  let result = { type: "object", properties, required };
+  if (truthy(route.requestSchemas)) {
+    result.$defs = route.requestSchemas;
+  }
+  if (route.openapiVersion?.startsWith("3")) {
+    result = convertOpenAPISchemaToJsonSchema(result, route.openapiVersion);
+  }
+  return [result, parameterMap];
+}
+var SUCCESS_CODE_PRIORITY = ["200", "201", "202", "204"];
+var JSON_COMPATIBLE_TYPES = [
+  "application/json",
+  "application/vnd.api+json",
+  "application/hal+json",
+  "application/ld+json",
+  "text/json"
+];
+function extractOutputSchemaFromResponses(responses, schemaDefinitions, openapiVersion) {
+  if (!truthy(responses)) return null;
+  let responseInfo;
+  for (const statusCode of SUCCESS_CODE_PRIORITY) {
+    if (statusCode in responses) {
+      responseInfo = responses[statusCode];
+      break;
+    }
+  }
+  if (responseInfo === void 0) {
+    for (const [statusCode, respInfo] of Object.entries(responses)) {
+      if (statusCode.startsWith("2")) {
+        responseInfo = respInfo;
+        break;
+      }
+    }
+  }
+  if (responseInfo === void 0 || !truthy(responseInfo.contentSchema)) return null;
+  let schema;
+  for (const contentType of JSON_COMPATIBLE_TYPES) {
+    if (contentType in responseInfo.contentSchema) {
+      schema = responseInfo.contentSchema[contentType];
+      break;
+    }
+  }
+  if (schema === void 0) {
+    const firstContentType = Object.keys(responseInfo.contentSchema)[0];
+    schema = responseInfo.contentSchema[firstContentType];
+  }
+  if (!truthy(schema) || !isPlainObject(schema)) return null;
+  let outputSchema = replaceRefWithDefs(schema);
+  if (typeof outputSchema.$ref === "string" && schemaDefinitions && truthy(schemaDefinitions)) {
+    const refPath = outputSchema.$ref;
+    if (refPath.startsWith("#/$defs/")) {
+      const schemaName = refPath.split("/").pop();
+      if (schemaName in schemaDefinitions) {
+        outputSchema = replaceRefWithDefs(schemaDefinitions[schemaName]);
+      }
+    }
+  }
+  if (openapiVersion?.startsWith("3")) {
+    outputSchema = convertOpenAPISchemaToJsonSchema(outputSchema, openapiVersion);
+  }
+  if (outputSchema.type !== "object") {
+    outputSchema = {
+      type: "object",
+      properties: { result: outputSchema },
+      required: ["result"],
+      "x-fastmcp-wrap-result": true
+    };
+  }
+  if (schemaDefinitions && truthy(schemaDefinitions)) {
+    const processedDefs = { ...schemaDefinitions };
+    for (const [name, defSchema] of Object.entries(processedDefs)) {
+      if (isPlainObject(defSchema)) {
+        processedDefs[name] = replaceRefWithDefs(defSchema);
+      }
+    }
+    if (openapiVersion?.startsWith("3")) {
+      for (const name of Object.keys(processedDefs)) {
+        processedDefs[name] = convertOpenAPISchemaToJsonSchema(processedDefs[name], openapiVersion);
+      }
+    }
+    outputSchema.$defs = processedDefs;
+  }
+  return outputSchema;
+}
+
+// src/server/openapi/parser.ts
+function loadSpec(spec) {
+  if (typeof spec !== "string") return spec;
+  const parsed = parseYaml(spec);
+  if (!isPlainObject(parsed)) {
+    throw new Error("OpenAPI spec text must parse to an object");
+  }
+  return parsed;
+}
+var HTTP_METHODS_LOWER = [
+  "get",
+  "put",
+  "post",
+  "delete",
+  "options",
+  "head",
+  "patch",
+  "trace"
+];
+var PRIMARY_SUCCESS_PRIORITY = ["200", "201", "202", "204", "207"];
+var PARAMETER_LOCATIONS = ["path", "query", "header", "cookie"];
+function isSuccessStatusCode(statusCode) {
+  if (/^\s*[+-]?\d+\s*$/.test(statusCode)) {
+    const code = parseInt(statusCode, 10);
+    return code >= 200 && code < 300;
+  }
+  return ["default", "2xx"].includes(statusCode.toLowerCase());
+}
+function parseOpenAPIToHttpRoutes(spec) {
+  const openapiVersion = typeof spec.openapi === "string" ? spec.openapi : "";
+  return new SpecParser(spec, openapiVersion).parse();
+}
+var SpecParser = class {
+  constructor(spec, openapiVersion) {
+    this.spec = spec;
+    this.openapiVersion = openapiVersion;
+  }
+  spec;
+  openapiVersion;
+  toParameterLocation(paramIn) {
+    if (PARAMETER_LOCATIONS.includes(paramIn)) {
+      return paramIn;
+    }
+    warn(`Unknown parameter location: ${paramIn}, defaulting to 'query'`);
+    return "query";
+  }
+  /** Resolve a `{$ref}` object to its target within the spec (local only). */
+  resolveRef(item) {
+    if (!isPlainObject(item) || typeof item.$ref !== "string") return item;
+    const ref = item.$ref;
+    try {
+      if (!ref.startsWith("#/")) {
+        throw new Error(`External or non-local reference not supported: ${ref}`);
+      }
+      const parts = ref.replace(/^[#/]+/, "").replace(/[#/]+$/, "").split("/");
+      let target = this.spec;
+      for (const part of parts) {
+        if (/^\d+$/.test(part) && Array.isArray(target)) {
+          target = target[Number(part)];
+        } else if (isPlainObject(target)) {
+          target = target[part];
+        } else {
+          throw new Error(`Cannot traverse part '${part}' in reference '${ref}'`);
+        }
+        if (target === null || target === void 0) {
+          throw new Error(`Reference part '${part}' not found in path '${ref}'`);
+        }
+      }
+      if (isPlainObject(target) && typeof target.$ref === "string") {
+        return this.resolveRef(target);
+      }
+      return target;
+    } catch (error) {
+      throw new Error(`Failed to resolve reference '${ref}': ${error.message}`);
+    }
+  }
+  /** Resolve a schema (or ref to one) and return it as a ref-converted copy. */
+  extractSchemaAsDict(schemaObj) {
+    try {
+      const resolved = this.resolveRef(schemaObj);
+      let result;
+      if (isPlainObject(resolved)) {
+        result = structuredClone(resolved);
+      } else {
+        warn(`Expected a schema object after resolving, got ${typeof resolved}. Using empty schema.`);
+        result = {};
+      }
+      return replaceRefWithDefs(result);
+    } catch (error) {
+      if (isExternalRefError(error)) throw error;
+      warn(`Failed to extract schema: ${error.message}`);
+      return {};
+    }
+  }
+  extractParameters(operationParams, pathItemParams) {
+    const extracted = [];
+    const seen = /* @__PURE__ */ new Set();
+    const all = [
+      ...Array.isArray(operationParams) ? operationParams : [],
+      ...Array.isArray(pathItemParams) ? pathItemParams : []
+    ];
+    for (const paramOrRef of all) {
+      try {
+        const parameter = this.resolveRef(paramOrRef);
+        if (!isPlainObject(parameter) || typeof parameter.name !== "string" || typeof parameter.in !== "string") {
+          warn(`Expected a parameter object after resolving. Skipping.`);
+          continue;
+        }
+        const location = this.toParameterLocation(parameter.in);
+        const key = `${parameter.name}\0${parameter.in}`;
+        if (seen.has(key)) continue;
+        seen.add(key);
+        let paramSchema = {};
+        if (truthy(parameter.schema)) {
+          paramSchema = this.extractSchemaAsDict(parameter.schema);
+        } else if (isPlainObject(parameter.content) && truthy(parameter.content)) {
+          const firstMediaType = Object.values(parameter.content)[0];
+          if (isPlainObject(firstMediaType) && truthy(firstMediaType.schema)) {
+            paramSchema = this.extractSchemaAsDict(firstMediaType.schema);
+          }
+        }
+        extracted.push({
+          name: parameter.name,
+          location,
+          required: Boolean(parameter.required),
+          schema: paramSchema,
+          ...typeof parameter.description === "string" ? { description: parameter.description } : {},
+          ...typeof parameter.explode === "boolean" ? { explode: parameter.explode } : {},
+          ...typeof parameter.style === "string" ? { style: parameter.style } : {}
+        });
+      } catch (error) {
+        warn(`Failed to extract parameter: ${error.message}`);
+      }
+    }
+    return extracted;
+  }
+  extractRequestBody(requestBodyOrRef) {
+    if (!truthy(requestBodyOrRef)) return void 0;
+    try {
+      const requestBody = this.resolveRef(requestBodyOrRef);
+      if (!isPlainObject(requestBody)) {
+        warn(`Expected a request body object after resolving. Skipping request body.`);
+        return void 0;
+      }
+      const info = {
+        required: Boolean(requestBody.required),
+        contentSchema: {},
+        ...typeof requestBody.description === "string" ? { description: requestBody.description } : {}
+      };
+      if (isPlainObject(requestBody.content)) {
+        for (const [mediaType, mediaTypeObj] of Object.entries(requestBody.content)) {
+          if (isPlainObject(mediaTypeObj) && truthy(mediaTypeObj.schema)) {
+            try {
+              info.contentSchema[mediaType] = this.extractSchemaAsDict(mediaTypeObj.schema);
+            } catch (error) {
+              if (isExternalRefError(error)) throw error;
+              warn(`Failed to extract schema for media type '${mediaType}': ${error.message}`);
+            }
+          }
+        }
+      }
+      return info;
+    } catch (error) {
+      if (isExternalRefError(error)) throw error;
+      warn(`Failed to extract request body: ${error.message}`);
+      return void 0;
+    }
+  }
+  getPrimarySuccessResponse(operationResponses) {
+    for (const code of PRIMARY_SUCCESS_PRIORITY) {
+      if (code in operationResponses) return [code, operationResponses[code]];
+    }
+    for (const [statusCode, respOrRef] of Object.entries(operationResponses)) {
+      if (isSuccessStatusCode(statusCode)) return [statusCode, respOrRef];
+    }
+    return null;
+  }
+  /** Extract only the primary success response for the MCP component. */
+  extractResponses(operationResponses) {
+    const extracted = {};
+    if (!isPlainObject(operationResponses) || !truthy(operationResponses)) return extracted;
+    const primary = this.getPrimarySuccessResponse(operationResponses);
+    if (primary === null) return extracted;
+    const [statusCode, respOrRef] = primary;
+    try {
+      const response = this.resolveRef(respOrRef);
+      if (!isPlainObject(response)) {
+        warn(`Expected a response object after resolving for status code ${statusCode}. Skipping.`);
+        return extracted;
+      }
+      const respInfo = {
+        contentSchema: {},
+        ...typeof response.description === "string" ? { description: response.description } : {}
+      };
+      if (isPlainObject(response.content)) {
+        for (const [mediaType, mediaTypeObj] of Object.entries(response.content)) {
+          if (isPlainObject(mediaTypeObj) && truthy(mediaTypeObj.schema)) {
+            try {
+              let topLevelSchemaName = null;
+              const mediaSchema = mediaTypeObj.schema;
+              if (isPlainObject(mediaSchema) && typeof mediaSchema.$ref === "string") {
+                if (mediaSchema.$ref.startsWith("#/components/schemas/")) {
+                  topLevelSchemaName = mediaSchema.$ref.split("/").pop();
+                }
+              }
+              const schemaDict = this.extractSchemaAsDict(mediaSchema);
+              if (topLevelSchemaName !== null) {
+                schemaDict["x-fastmcp-top-level-schema"] = topLevelSchemaName;
+              }
+              respInfo.contentSchema[mediaType] = schemaDict;
+            } catch (error) {
+              if (isExternalRefError(error)) throw error;
+              warn(
+                `Failed to extract schema for media type '${mediaType}' in response ${statusCode}: ${error.message}`
+              );
+            }
+          } else {
+            respInfo.contentSchema[mediaType] ??= {};
+          }
+        }
+      }
+      extracted[statusCode] = respInfo;
+    } catch (error) {
+      if (isExternalRefError(error)) throw error;
+      warn(`Failed to extract response for status code ${statusCode}: ${error.message}`);
+    }
+    return extracted;
+  }
+  /** Collect schema names referenced by `schema`, transitively. */
+  extractSchemaDependencies(schema, allSchemas, collected = /* @__PURE__ */ new Set(), followDiscriminator = false) {
+    const collect = (schemaName) => {
+      if (!collected.has(schemaName) && schemaName in allSchemas) {
+        collected.add(schemaName);
+        findRefs(allSchemas[schemaName]);
+      }
+    };
+    const findRefs = (obj) => {
+      if (isPlainObject(obj)) {
+        if (typeof obj.$ref === "string") {
+          const ref = obj.$ref;
+          if (ref.startsWith("#/$defs/") || ref.startsWith("#/components/schemas/")) {
+            collect(ref.split("/").pop());
+          }
+        }
+        if (followDiscriminator) {
+          const discriminator = obj.discriminator;
+          if (isPlainObject(discriminator) && isPlainObject(discriminator.mapping)) {
+            for (const target of Object.values(discriminator.mapping)) {
+              if (typeof target !== "string") continue;
+              const name = discriminatorTargetName(target);
+              if (name !== null) collect(name);
+            }
+          }
+        }
+        for (const value of Object.values(obj)) findRefs(value);
+      } else if (Array.isArray(obj)) {
+        for (const item of obj) findRefs(item);
+      }
+    };
+    findRefs(schema);
+    return collected;
+  }
+  extractInputSchemaDependencies(parameters, requestBody, allSchemas) {
+    const needed = /* @__PURE__ */ new Set();
+    for (const param of parameters) {
+      if (truthy(param.schema)) {
+        this.extractSchemaDependencies(param.schema, allSchemas, needed);
+      }
+    }
+    if (requestBody && truthy(requestBody.contentSchema)) {
+      for (const contentSchema of Object.values(requestBody.contentSchema)) {
+        this.extractSchemaDependencies(contentSchema, allSchemas, needed, true);
+      }
+    }
+    return Object.fromEntries([...needed].filter((n) => n in allSchemas).map((n) => [n, allSchemas[n]]));
+  }
+  extractOutputSchemaDependencies(responses, allSchemas) {
+    if (!truthy(responses) || !truthy(allSchemas)) return {};
+    const needed = /* @__PURE__ */ new Set();
+    for (const response of Object.values(responses)) {
+      if (!truthy(response.contentSchema)) continue;
+      for (const contentSchema of Object.values(response.contentSchema)) {
+        this.extractSchemaDependencies(contentSchema, allSchemas, needed);
+        const schemaName = contentSchema["x-fastmcp-top-level-schema"];
+        if (typeof schemaName === "string" && schemaName in allSchemas) {
+          needed.add(schemaName);
+          this.extractSchemaDependencies(allSchemas[schemaName], allSchemas, needed);
+        }
+      }
+    }
+    return Object.fromEntries([...needed].filter((n) => n in allSchemas).map((n) => [n, allSchemas[n]]));
+  }
+  parse() {
+    const routes = [];
+    const paths = this.spec.paths;
+    if (!isPlainObject(paths) || !truthy(paths)) {
+      warn("OpenAPI schema has no paths defined.");
+      return [];
+    }
+    const schemaDefinitions = {};
+    const components = this.spec.components;
+    if (isPlainObject(components) && isPlainObject(components.schemas)) {
+      for (const [name, schema] of Object.entries(components.schemas)) {
+        try {
+          schemaDefinitions[name] = this.extractSchemaAsDict(this.resolveRef(schema));
+        } catch (error) {
+          warn(`Failed to extract schema definition '${name}': ${error.message}`);
+        }
+      }
+    }
+    for (const [name, schema] of Object.entries(schemaDefinitions)) {
+      if (isPlainObject(schema)) {
+        schemaDefinitions[name] = replaceRefWithDefs(schema);
+      }
+    }
+    for (const [pathStr, pathItemObj] of Object.entries(paths)) {
+      if (!isPlainObject(pathItemObj)) {
+        warn(`Skipping invalid path item for path '${pathStr}'`);
+        continue;
+      }
+      const pathLevelParams = pathItemObj.parameters;
+      for (const methodLower of HTTP_METHODS_LOWER) {
+        const operation = pathItemObj[methodLower];
+        if (!isPlainObject(operation)) continue;
+        const method = methodLower.toUpperCase();
+        try {
+          const parameters = this.extractParameters(operation.parameters, pathLevelParams);
+          const requestBody = this.extractRequestBody(operation.requestBody);
+          const responses = this.extractResponses(operation.responses);
+          const extensions = Object.fromEntries(
+            Object.entries(operation).filter(([key]) => key.startsWith("x-"))
+          );
+          const requestSchemas = this.extractInputSchemaDependencies(
+            parameters,
+            requestBody,
+            schemaDefinitions
+          );
+          const responseSchemas = this.extractOutputSchemaDependencies(
+            responses,
+            schemaDefinitions
+          );
+          const route = {
+            path: pathStr,
+            method,
+            ...typeof operation.operationId === "string" ? { operationId: operation.operationId } : {},
+            ...typeof operation.summary === "string" ? { summary: operation.summary } : {},
+            ...typeof operation.description === "string" ? { description: operation.description } : {},
+            tags: Array.isArray(operation.tags) ? [...operation.tags] : [],
+            parameters,
+            ...requestBody !== void 0 ? { requestBody } : {},
+            responses,
+            requestSchemas,
+            responseSchemas,
+            extensions,
+            openapiVersion: this.openapiVersion,
+            flatParamSchema: {},
+            parameterMap: {}
+          };
+          try {
+            const [flatSchema, parameterMap] = combineSchemasAndMapParams(route);
+            route.flatParamSchema = flatSchema;
+            route.parameterMap = parameterMap;
+          } catch (error) {
+            warn(
+              `Failed to pre-calculate schema for route ${method} ${pathStr}: ${error.message}`
+            );
+            route.flatParamSchema = { type: "object", properties: {} };
+            route.parameterMap = {};
+          }
+          routes.push(route);
+        } catch (error) {
+          if (isExternalRefError(error)) throw error;
+          const opId = typeof operation.operationId === "string" ? operation.operationId : "unknown";
+          warn(
+            `Failed to process operation ${method} ${pathStr} (ID: ${opId}): ${error.message}`
+          );
+        }
+      }
+    }
+    return routes;
+  }
+};
+
+// src/server/openapi/routing.ts
+var DEFAULT_ROUTE_MAPPINGS = [{ mcpType: "tool" }];
+function patternMatches(pattern, path) {
+  if (pattern === void 0) return true;
+  if (typeof pattern === "string") return new RegExp(pattern).test(path);
+  return path.search(pattern) !== -1;
+}
+function determineRouteType(route, mappings) {
+  for (const routeMap of mappings) {
+    const methods = routeMap.methods ?? "*";
+    if (methods !== "*" && !methods.includes(route.method)) continue;
+    if (!patternMatches(routeMap.pattern, route.path)) continue;
+    if (routeMap.tags && routeMap.tags.length > 0) {
+      const routeTags = new Set(route.tags ?? []);
+      if (!routeMap.tags.every((tag) => routeTags.has(tag))) continue;
+    }
+    return routeMap;
+  }
+  return { mcpType: "tool" };
+}
+
+// src/server/openapi/naming.ts
+function slugify(text) {
+  if (!text) return "";
+  return text.replace(/[\s\-.]+/g, "_").replace(/[^a-zA-Z0-9_]/g, "").replace(/_+/g, "_").replace(/^_+|_+$/g, "");
+}
+function generateDefaultName(route, names) {
+  let name;
+  if (route.operationId) {
+    name = names?.[route.operationId] ?? route.operationId.split("__")[0];
+  } else {
+    name = route.summary || `${route.method}_${route.path}`;
+  }
+  name = slugify(name);
+  if (name.length > 56) name = name.slice(0, 56);
+  return name;
+}
+var NameRegistry = class {
+  counters = {
+    tool: /* @__PURE__ */ new Map(),
+    resource: /* @__PURE__ */ new Map(),
+    resourceTemplate: /* @__PURE__ */ new Map(),
+    prompt: /* @__PURE__ */ new Map()
+  };
+  getUniqueName(name, componentType) {
+    const counter = this.counters[componentType];
+    const count = (counter.get(name) ?? 0) + 1;
+    counter.set(name, count);
+    if (count === 1) return name;
+    return `${name}_${count}`;
+  }
+};
+
+// src/server/openapi/director.ts
+function queryScalarToStr(value) {
+  if (typeof value === "boolean") return value ? "true" : "false";
+  return String(value);
+}
+var STYLE_DELIMITERS = {
+  form: ",",
+  spaceDelimited: " ",
+  pipeDelimited: "|"
+};
+function unflattenArguments(route, flatArgs) {
+  const pathParams = {};
+  const queryParams = {};
+  const headerParams = {};
+  const cookieParams = {};
+  const bodyProps = {};
+  const buckets = {
+    path: pathParams,
+    query: queryParams,
+    header: headerParams,
+    cookie: cookieParams,
+    body: bodyProps
+  };
+  if (Object.keys(route.parameterMap).length > 0) {
+    for (const [argName, value] of Object.entries(flatArgs)) {
+      if (value === null || value === void 0) continue;
+      const mapping = route.parameterMap[argName];
+      if (mapping === void 0) {
+        warn(`Argument '${argName}' not found in parameter map for ${route.operationId ?? route.path}`);
+        continue;
+      }
+      buckets[mapping.location][mapping.openapiName] = value;
+    }
+  } else {
+    const paramLocations = new Map(route.parameters.map((p) => [p.name, p.location]));
+    for (const [argName, value] of Object.entries(flatArgs)) {
+      if (value === null || value === void 0) continue;
+      const suffixIdx = argName.lastIndexOf("__");
+      if (suffixIdx !== -1) {
+        const baseName = argName.slice(0, suffixIdx);
+        const location2 = argName.slice(suffixIdx + 2);
+        if (location2 in buckets && location2 !== "body") {
+          buckets[location2][baseName] = value;
+          continue;
+        }
+      }
+      const location = paramLocations.get(argName);
+      if (location !== void 0) {
+        buckets[location][argName] = value;
+      } else {
+        bodyProps[argName] = value;
+      }
+    }
+  }
+  let body;
+  if (Object.keys(bodyProps).length > 0) {
+    const contentSchema = route.requestBody?.contentSchema;
+    if (contentSchema && Object.keys(contentSchema).length > 0) {
+      const contentType = Object.keys(contentSchema)[0];
+      const bodySchema = contentSchema[contentType];
+      if (isPlainObject(bodySchema) && bodySchema.type === "object") {
+        body = bodyProps;
+      } else if (Object.keys(bodyProps).length === 1) {
+        body = Object.values(bodyProps)[0];
+      } else {
+        body = bodyProps;
+      }
+    } else {
+      body = bodyProps;
+    }
+  }
+  return { pathParams, queryParams, headerParams, cookieParams, body };
+}
+function serializeQueryParams(route, queryParams) {
+  if (Object.keys(queryParams).length === 0) return queryParams;
+  const paramLookup = new Map(
+    route.parameters.filter((p) => p.location === "query").map((p) => [p.name, p])
+  );
+  const serialized = {};
+  for (const [key, value] of Object.entries(queryParams)) {
+    const paramInfo = paramLookup.get(key);
+    if (paramInfo !== void 0) {
+      const explode = paramInfo.explode ?? true;
+      if (isPlainObject(value)) {
+        if (Object.keys(value).length === 0) continue;
+        if (explode) {
+          for (const [propKey, propValue] of Object.entries(value)) {
+            const propertyName = paramInfo.style === "deepObject" ? `${key}[${queryScalarToStr(propKey)}]` : queryScalarToStr(propKey);
+            serialized[propertyName] = queryScalarToStr(propValue);
+          }
+        } else {
+          const delimiter = STYLE_DELIMITERS[paramInfo.style ?? "form"] ?? ",";
+          const parts = [];
+          for (const [propKey, propValue] of Object.entries(value)) {
+            parts.push(queryScalarToStr(propKey), queryScalarToStr(propValue));
+          }
+          serialized[key] = parts.join(delimiter);
+        }
+        continue;
+      }
+      if (!explode && Array.isArray(value)) {
+        if (value.length === 0) continue;
+        const delimiter = STYLE_DELIMITERS[paramInfo.style ?? "form"] ?? ",";
+        serialized[key] = value.map(queryScalarToStr).join(delimiter);
+        continue;
+      }
+    }
+    serialized[key] = value;
+  }
+  return serialized;
+}
+function quotePathValue(value) {
+  return encodeURIComponent(value).replace(/[!'()*]/g, (c) => `%${c.charCodeAt(0).toString(16).toUpperCase()}`).replace(/\./g, "%2E");
+}
+function buildUrl(pathTemplate, pathParams, baseUrl) {
+  let urlPath = pathTemplate;
+  for (const [paramName, paramValue] of Object.entries(pathParams)) {
+    const placeholder = `{${paramName}}`;
+    if (urlPath.includes(placeholder)) {
+      urlPath = urlPath.split(placeholder).join(quotePathValue(String(paramValue)));
+    }
+  }
+  const base = `${baseUrl.replace(/\/+$/, "")}/`;
+  return new URL(urlPath.replace(/^\/+/, ""), base).toString();
+}
+function buildRequest(route, flatArgs, baseUrl) {
+  const { pathParams, queryParams, headerParams, cookieParams, body } = unflattenArguments(
+    route,
+    flatArgs
+  );
+  const serializedQuery = serializeQueryParams(route, queryParams);
+  const url = new URL(buildUrl(route.path, pathParams, baseUrl));
+  for (const [key, value] of Object.entries(serializedQuery)) {
+    if (Array.isArray(value)) {
+      for (const item of value) url.searchParams.append(key, queryScalarToStr(item));
+    } else {
+      url.searchParams.append(key, queryScalarToStr(value));
+    }
+  }
+  const headers = {};
+  for (const [key, value] of Object.entries(headerParams)) {
+    headers[key] = queryScalarToStr(value);
+  }
+  const cookiePairs = Object.entries(cookieParams).map(
+    ([key, value]) => `${key}=${queryScalarToStr(value)}`
+  );
+  if (cookiePairs.length > 0) {
+    headers.cookie = cookiePairs.join("; ");
+  }
+  let rawContentType;
+  let declaredContentType;
+  const contentSchema = route.requestBody?.contentSchema;
+  if (contentSchema && Object.keys(contentSchema).length > 0) {
+    rawContentType = Object.keys(contentSchema)[0];
+    declaredContentType = rawContentType.split(";")[0].trim().toLowerCase();
+  }
+  let requestBody;
+  if (body !== null && body !== void 0) {
+    if (declaredContentType === "multipart/form-data" && isPlainObject(body)) {
+      const form = new FormData();
+      for (const [key, value] of Object.entries(body)) {
+        if (value instanceof Uint8Array) {
+          form.append(key, new Blob([value]));
+        } else {
+          form.append(key, queryScalarToStr(value));
+        }
+      }
+      requestBody = form;
+    } else if (declaredContentType === "application/x-www-form-urlencoded" && isPlainObject(body)) {
+      const params = new URLSearchParams();
+      for (const [key, value] of Object.entries(body)) {
+        params.append(key, queryScalarToStr(value));
+      }
+      requestBody = params;
+    } else if (isPlainObject(body) || Array.isArray(body)) {
+      requestBody = JSON.stringify(body);
+      headers["content-type"] = declaredContentType !== void 0 && declaredContentType !== "application/json" && declaredContentType.includes("json") ? rawContentType : "application/json";
+    } else {
+      requestBody = String(body);
+      if (rawContentType !== void 0) {
+        headers["content-type"] = rawContentType;
+      }
+    }
+  }
+  return {
+    method: route.method.toUpperCase(),
+    url: url.toString(),
+    headers,
+    ...requestBody !== void 0 ? { body: requestBody } : {}
+  };
+}
+function pathArgumentName(route, parameterName) {
+  for (const [argumentName, mapping] of Object.entries(route.parameterMap)) {
+    if (mapping.location === "path" && mapping.openapiName === parameterName) {
+      return argumentName;
+    }
+  }
+  return parameterName;
+}
+
+// src/server/openapi/execute.ts
+var DEFAULT_TIMEOUT_MS = 3e4;
+function fillServerVariables(url, variables) {
+  if (!isPlainObject(variables)) return url;
+  let filled = url;
+  for (const [name, variable] of Object.entries(variables)) {
+    const fallback = isPlainObject(variable) ? variable.default : void 0;
+    filled = filled.split(`{${name}}`).join(typeof fallback === "string" ? fallback : "");
+  }
+  return filled;
+}
+function resolveClient(options, spec) {
+  let baseUrl = options.baseUrl;
+  if (baseUrl === void 0) {
+    const servers = spec.servers;
+    const first = Array.isArray(servers) ? servers[0] : void 0;
+    const serverUrl = isPlainObject(first) && typeof first.url === "string" ? first.url : void 0;
+    if (serverUrl === void 0) {
+      throw new Error(
+        "No server URL found in OpenAPI spec. Either add a 'servers' entry to the spec or provide client.baseUrl explicitly."
+      );
+    }
+    baseUrl = fillServerVariables(serverUrl, first?.variables);
+  }
+  try {
+    new URL(baseUrl);
+  } catch {
+    throw new Error(
+      `OpenAPI base URL must be absolute, got '${baseUrl}'. Provide client.baseUrl explicitly.`
+    );
+  }
+  return {
+    baseUrl,
+    headers: options.headers ?? {},
+    ...options.auth !== void 0 ? { auth: options.auth } : {},
+    fetch: options.fetch ?? globalThis.fetch,
+    timeoutMs: options.timeoutMs ?? DEFAULT_TIMEOUT_MS
+  };
+}
+function isTimeoutError(error) {
+  return error instanceof Error && (error.name === "TimeoutError" || error.name === "AbortError");
+}
+async function sendRequest(client, route, args) {
+  let url;
+  let init;
+  try {
+    const directed = buildRequest(route, args, client.baseUrl);
+    const authHeaders = client.auth ? await client.auth.getHeaders() : {};
+    const headers = {};
+    for (const source of [client.headers, authHeaders, directed.headers]) {
+      for (const [name, value] of Object.entries(source)) {
+        headers[name.toLowerCase()] = value;
+      }
+    }
+    url = directed.url;
+    init = {
+      method: directed.method,
+      headers,
+      ...directed.body !== void 0 ? { body: directed.body } : {},
+      signal: AbortSignal.timeout(client.timeoutMs)
+    };
+  } catch (error) {
+    const e = error;
+    throw new Error(
+      `Error building request for ${route.method.toUpperCase()} ${route.path}: ${e.name}: ${e.message}`
+    );
+  }
+  let response;
+  try {
+    response = await client.fetch(url, init);
+  } catch (error) {
+    if (isTimeoutError(error)) {
+      throw new Error(`HTTP request timed out (${error.name})`);
+    }
+    const e = error;
+    throw new Error(`Request error (${e.name}): ${e.message}`);
+  }
+  if (!response.ok) {
+    let message = `HTTP error ${response.status}: ${response.statusText}`;
+    const text = await response.text().catch(() => "");
+    if (text) message += ` - ${text}`;
+    throw new Error(message);
+  }
+  return response;
+}
+async function runToolRequest(client, route, args, outputSchema) {
+  const response = await sendRequest(client, route, args);
+  const text = await response.text();
+  let result;
+  try {
+    result = JSON.parse(text);
+  } catch {
+    return new ToolResult({ content: [{ type: "text", text }] });
+  }
+  let structured;
+  if (outputSchema !== null && outputSchema !== void 0) {
+    structured = truthy(outputSchema["x-fastmcp-wrap-result"]) ? { result } : result;
+  } else if (!isPlainObject(result)) {
+    structured = { result };
+  } else {
+    structured = result;
+  }
+  if (!isPlainObject(structured)) {
+    structured = { result: structured };
+  }
+  return new ToolResult({
+    content: [{ type: "text", text: JSON.stringify(structured) }],
+    structuredContent: structured
+  });
+}
+async function readResourceRequest(client, route, args, uri, mimeType) {
+  const response = await sendRequest(client, route, args);
+  const contentType = (response.headers.get("content-type") ?? "").toLowerCase();
+  if (contentType.includes("application/json")) {
+    const result = JSON.parse(await response.text());
+    return new ResourceResult([
+      { uri, mimeType: "application/json", text: JSON.stringify(result) }
+    ]);
+  }
+  if (contentType.includes("text/") || contentType.includes("application/xml")) {
+    return new ResourceResult([{ uri, mimeType, text: await response.text() }]);
+  }
+  const bytes = Buffer.from(await response.arrayBuffer());
+  return new ResourceResult([{ uri, mimeType, blob: bytes.toString("base64") }]);
+}
+
+// src/server/openapi/index.ts
+var DEFAULT_MIME_TYPE = "application/json";
+var JSON_COMPATIBLE_TYPES2 = [
+  "application/json",
+  "application/vnd.api+json",
+  "application/hal+json",
+  "application/ld+json",
+  "text/json"
+];
+function extractMimeTypeFromRoute(route) {
+  if (!truthy(route.responses)) return DEFAULT_MIME_TYPE;
+  let responseInfo = void 0;
+  for (const statusCode of ["200", "201", "202", "204"]) {
+    if (statusCode in route.responses) {
+      responseInfo = route.responses[statusCode];
+      break;
+    }
+  }
+  if (responseInfo === void 0) {
+    for (const [statusCode, respInfo] of Object.entries(route.responses)) {
+      if (statusCode.startsWith("2")) {
+        responseInfo = respInfo;
+        break;
+      }
+    }
+  }
+  if (responseInfo === void 0 || !truthy(responseInfo.contentSchema)) return DEFAULT_MIME_TYPE;
+  const contentTypes = Object.keys(responseInfo.contentSchema);
+  if (contentTypes.length === 1) return contentTypes[0];
+  for (const contentType of JSON_COMPATIBLE_TYPES2) {
+    if (contentType in responseInfo.contentSchema) return contentType;
+  }
+  return contentTypes[0];
+}
+function expandTemplateUri(uriTemplate, params) {
+  let uri = uriTemplate;
+  for (const [name, value] of Object.entries(params)) {
+    uri = uri.split(`{${name}}`).join(encodeURIComponent(value));
+  }
+  return uri;
+}
+function templateArguments(route, params) {
+  const args = {};
+  for (const parameter of route.parameters) {
+    if (parameter.location !== "path") continue;
+    const argumentName = pathArgumentName(route, parameter.name);
+    if (parameter.name in params) {
+      args[argumentName] = params[parameter.name];
+      continue;
+    }
+    const normalizedName = parameter.name.replace(/-/g, "_");
+    if (normalizedName in params) {
+      args[argumentName] = params[normalizedName];
+    }
+  }
+  return args;
+}
+function createOpenAPIServer(options) {
+  const spec = loadSpec(options.spec);
+  const client = resolveClient(options.client ?? {}, spec);
+  const routes = parseOpenAPIToHttpRoutes(spec);
+  const server = new FastMCP({
+    name: options.name ?? "OpenAPI Server",
+    ...options.version !== void 0 ? { version: options.version } : {},
+    ...options.serverOptions
+  });
+  const routeMaps = [...options.routeMaps ?? [], ...DEFAULT_ROUTE_MAPPINGS];
+  const registry = new NameRegistry();
+  const validateOutput = options.validateOutput ?? true;
+  for (const route of routes) {
+    const routeMap = determineRouteType(route, routeMaps);
+    let routeType = routeMap.mcpType;
+    if (options.routeMapFn !== void 0) {
+      try {
+        const result = options.routeMapFn(route, routeType);
+        if (result !== null && result !== void 0) {
+          routeType = result;
+        }
+      } catch (error) {
+        warn(
+          `Error in routeMapFn for ${route.method} ${route.path}: ${error.message}. Using mapped type.`
+        );
+      }
+    }
+    const componentName = generateDefaultName(route, options.names);
+    const componentTags = [
+      .../* @__PURE__ */ new Set([...route.tags, ...routeMap.mcpTags ?? [], ...options.tags ?? []])
+    ].sort();
+    if (routeType === "tool") {
+      createTool(server, client, route, componentName, componentTags, registry, validateOutput, options.componentFn);
+    } else if (routeType === "resource") {
+      createResource(server, client, route, componentName, componentTags, registry, options.componentFn);
+    } else if (routeType === "resourceTemplate") {
+      createTemplate(server, client, route, componentName, componentTags, registry, options.componentFn);
+    }
+  }
+  return server;
+}
+function applyComponentFn(componentFn, route, component) {
+  if (componentFn === void 0) return;
+  try {
+    componentFn(route, component);
+  } catch (error) {
+    warn(
+      `Error in componentFn for ${component.kind} '${component.name}': ${error.message}`
+    );
+  }
+}
+function createTool(server, client, route, name, tags, registry, validateOutput, componentFn) {
+  let outputSchema = extractOutputSchemaFromResponses(
+    route.responses,
+    route.responseSchemas,
+    route.openapiVersion
+  );
+  if (!validateOutput && outputSchema !== null) {
+    const permissive = { type: "object", additionalProperties: true };
+    if (truthy(outputSchema["x-fastmcp-wrap-result"])) {
+      permissive["x-fastmcp-wrap-result"] = true;
+    }
+    outputSchema = permissive;
+  }
+  const component = {
+    kind: "tool",
+    name: registry.getUniqueName(name, "tool"),
+    description: route.description || route.summary || `Executes ${route.method} ${route.path}`,
+    inputSchema: route.flatParamSchema,
+    ...outputSchema !== null ? { outputSchema } : {},
+    tags
+  };
+  applyComponentFn(componentFn, route, component);
+  server.tool(
+    {
+      name: component.name,
+      description: component.description,
+      inputSchema: component.inputSchema,
+      ...component.outputSchema !== void 0 ? { outputSchema: component.outputSchema } : {},
+      tags: component.tags
+    },
+    async (args) => runToolRequest(client, route, isPlainObject(args) ? args : {}, component.outputSchema)
+  );
+}
+function createResource(server, client, route, name, tags, registry, componentFn) {
+  const uniqueName = registry.getUniqueName(name, "resource");
+  const component = {
+    kind: "resource",
+    uri: `resource://${uniqueName}`,
+    name: uniqueName,
+    description: route.description || route.summary || `Represents ${route.path}`,
+    mimeType: extractMimeTypeFromRoute(route),
+    tags
+  };
+  applyComponentFn(componentFn, route, component);
+  server.resource(
+    {
+      uri: component.uri,
+      name: component.name,
+      description: component.description,
+      mimeType: component.mimeType,
+      tags: component.tags
+    },
+    async () => readResourceRequest(client, route, {}, component.uri, component.mimeType)
+  );
+}
+function createTemplate(server, client, route, name, tags, registry, componentFn) {
+  const uniqueName = registry.getUniqueName(name, "resourceTemplate");
+  const pathParams = route.parameters.filter((p) => p.location === "path").map((p) => p.name).sort();
+  let uriTemplate = `resource://${uniqueName}`;
+  if (pathParams.length > 0) {
+    uriTemplate += "/" + pathParams.map((p) => `{${p}}`).join("/");
+  }
+  const parametersSchema = {
+    type: "object",
+    properties: Object.fromEntries(
+      route.parameters.filter((p) => p.location === "path").map((p) => [
+        p.name,
+        {
+          ...isPlainObject(p.schema) ? p.schema : {},
+          ...truthy(p.description) && !(isPlainObject(p.schema) && "description" in p.schema) ? { description: p.description } : {}
+        }
+      ])
+    ),
+    required: route.parameters.filter((p) => p.location === "path" && p.required).map((p) => p.name)
+  };
+  const component = {
+    kind: "resourceTemplate",
+    uriTemplate,
+    name: uniqueName,
+    description: route.description || route.summary || `Template for ${route.path}`,
+    mimeType: extractMimeTypeFromRoute(route),
+    parameters: parametersSchema,
+    tags
+  };
+  applyComponentFn(componentFn, route, component);
+  server.resource(
+    {
+      uri: component.uriTemplate,
+      name: component.name,
+      description: component.description,
+      mimeType: component.mimeType,
+      tags: component.tags
+    },
+    async (params) => {
+      const matched = params ?? {};
+      const concreteUri = expandTemplateUri(component.uriTemplate, matched);
+      return readResourceRequest(
+        client,
+        route,
+        templateArguments(route, matched),
+        concreteUri,
+        component.mimeType
+      );
+    }
+  );
+}
+
 // src/server/apps/FastMCPApp.ts
 var FastMCPApp = class {
   server;
@@ -3353,8 +4945,10 @@ export {
   VersionFilter,
   acceptedContent,
   actionRef,
+  createOpenAPIServer,
   createProxy,
   debugTokenVerifier,
+  forwardableHeaders,
   inputRequired,
   inputResponse,
   introspectionVerifier,