@prefecthq/fastmcp-ts 0.0.2-alpha.0

package/dist/server.js

@@ -0,0 +1,2863 @@
+import {
+  __export
+} from "./chunk-PZ5AY32C.js";
+
+// src/server/FastMCP.ts
+import { Server } from "@modelcontextprotocol/sdk/server";
+import {
+  ListToolsRequestSchema,
+  CallToolRequestSchema,
+  ListResourcesRequestSchema,
+  ListResourceTemplatesRequestSchema,
+  ReadResourceRequestSchema,
+  ListPromptsRequestSchema,
+  GetPromptRequestSchema,
+  McpError as McpError3,
+  ErrorCode as ErrorCode3
+} from "@modelcontextprotocol/sdk/types";
+import { randomUUID } from "crypto";
+
+// src/server/auth/types.ts
+var AuthorizationError = class extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "AuthorizationError";
+  }
+};
+
+// src/server/context.ts
+import { AsyncLocalStorage } from "async_hooks";
+var contextStore = new AsyncLocalStorage();
+var SESSION_CLOSE_CALLBACKS_KEY = "__fastmcp_session_close_callbacks";
+function createContext(server, requestId, progressToken, auth, sessionState) {
+  async function log(level, message, loggerName) {
+    await server.sendLoggingMessage({
+      level,
+      data: message,
+      ...loggerName !== void 0 ? { logger: loggerName } : {}
+    });
+  }
+  return {
+    auth,
+    requestId,
+    log,
+    debug: (msg, logger) => log("debug", msg, logger),
+    info: (msg, logger) => log("info", msg, logger),
+    notice: (msg, logger) => log("notice", msg, logger),
+    warning: (msg, logger) => log("warning", msg, logger),
+    error: (msg, logger) => log("error", msg, logger),
+    critical: (msg, logger) => log("critical", msg, logger),
+    alert: (msg, logger) => log("alert", msg, logger),
+    emergency: (msg, logger) => log("emergency", msg, logger),
+    async reportProgress(progress, total, message) {
+      if (progressToken === void 0) return;
+      await server.notification({
+        method: "notifications/progress",
+        params: {
+          progressToken,
+          progress,
+          ...total !== void 0 ? { total } : {},
+          ...message !== void 0 ? { message } : {}
+        }
+      });
+    },
+    async sample(params) {
+      const caps = server.getClientCapabilities();
+      if (!caps?.sampling) {
+        throw new Error(
+          "[fastmcp] Client does not support sampling. Ensure the client advertises the sampling capability before calling ctx.sample()."
+        );
+      }
+      const result = await server.createMessage({
+        messages: params.messages,
+        maxTokens: params.maxTokens ?? 1024,
+        ...params.systemPrompt !== void 0 ? { systemPrompt: params.systemPrompt } : {},
+        ...params.temperature !== void 0 ? { temperature: params.temperature } : {},
+        ...params.stopSequences !== void 0 ? { stopSequences: params.stopSequences } : {},
+        ...params.modelPreferences !== void 0 ? { modelPreferences: params.modelPreferences } : {}
+      });
+      return {
+        role: "assistant",
+        content: result.content,
+        model: result.model,
+        stopReason: result.stopReason
+      };
+    },
+    async elicit(message, schema) {
+      const caps = server.getClientCapabilities();
+      if (!caps?.elicitation) {
+        throw new Error(
+          "[fastmcp] Client does not support elicitation. Ensure the client advertises the elicitation capability before calling ctx.elicit()."
+        );
+      }
+      const result = await server.elicitInput({
+        message,
+        // Cast: our simplified ElicitationSchema is a subset of the SDK's PrimitiveSchemaDefinition union
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        requestedSchema: schema
+      });
+      return {
+        action: result.action,
+        content: result.content
+      };
+    },
+    async listRoots() {
+      const caps = server.getClientCapabilities();
+      if (!caps?.roots) {
+        throw new Error(
+          "[fastmcp] Client does not support roots. Ensure the client advertises the roots capability before calling ctx.listRoots()."
+        );
+      }
+      const result = await server.listRoots();
+      return result.roots;
+    },
+    getState: (key) => sessionState.get(key),
+    setState: (key, value) => {
+      sessionState.set(key, value);
+    },
+    deleteState: (key) => {
+      sessionState.delete(key);
+    },
+    resolveToolName: (name) => name,
+    onClose(callback) {
+      const existing = sessionState.get(SESSION_CLOSE_CALLBACKS_KEY) ?? [];
+      sessionState.set(SESSION_CLOSE_CALLBACKS_KEY, [...existing, callback]);
+    }
+  };
+}
+
+// src/server/middleware.ts
+import { McpError, ErrorCode, CancelledNotificationSchema } from "@modelcontextprotocol/sdk/types";
+var METHOD_HOOK_KEY = {
+  "tools/call": "onCallTool",
+  "tools/list": "onListTools",
+  "resources/read": "onReadResource",
+  "resources/list": "onListResources",
+  "resources/templates/list": "onListResourceTemplates",
+  "prompts/get": "onGetPrompt",
+  "prompts/list": "onListPrompts"
+};
+function selectHook(mw, method) {
+  const key = METHOD_HOOK_KEY[method];
+  const specific = key ? mw[key] : void 0;
+  if (specific) return specific.bind(mw);
+  if (mw.onRequest) return mw.onRequest.bind(mw);
+  return null;
+}
+function runMiddlewareChain(middleware, method, request, mcpContext, handler) {
+  const hooks = [];
+  for (const mw of middleware) {
+    const hook = selectHook(mw, method);
+    if (hook) hooks.push(hook);
+  }
+  const ctx = { method, request, mcpContext };
+  function dispatch(i) {
+    if (i >= hooks.length) return handler();
+    return hooks[i](ctx, () => dispatch(i + 1));
+  }
+  return dispatch(0);
+}
+var LoggingMiddleware = class {
+  constructor(emit = console.log) {
+    this.emit = emit;
+  }
+  emit;
+  async onRequest(ctx, next) {
+    const t0 = Date.now();
+    this.emit(`[fastmcp] \u2192 ${ctx.method}`);
+    try {
+      const result = await next();
+      this.emit(`[fastmcp] \u2190 ${ctx.method} (${Date.now() - t0}ms)`);
+      return result;
+    } catch (err) {
+      this.emit(
+        `[fastmcp] \u2717 ${ctx.method} (${Date.now() - t0}ms): ${err instanceof Error ? err.message : String(err)}`
+      );
+      throw err;
+    }
+  }
+};
+var CachingMiddleware = class {
+  constructor(ttl = 6e4, _keyFn) {
+    this.ttl = ttl;
+    this._keyFn = _keyFn;
+  }
+  ttl;
+  _keyFn;
+  _cache = /* @__PURE__ */ new Map();
+  async onRequest(ctx, next) {
+    const key = this._keyFn ? this._keyFn(ctx) : `${ctx.method}:${JSON.stringify(ctx.request)}`;
+    const entry = this._cache.get(key);
+    if (entry && entry.expiresAt > Date.now()) return entry.value;
+    const result = await next();
+    this._cache.set(key, { value: result, expiresAt: Date.now() + this.ttl });
+    return result;
+  }
+};
+var RateLimitingMiddleware = class {
+  constructor(limit, windowMs = 6e4) {
+    this.limit = limit;
+    this.windowMs = windowMs;
+    this._tokens = limit;
+    this._lastRefill = Date.now();
+  }
+  limit;
+  windowMs;
+  _tokens;
+  _lastRefill;
+  async onRequest(ctx, next) {
+    const now = Date.now();
+    if (now - this._lastRefill >= this.windowMs) {
+      this._tokens = this.limit;
+      this._lastRefill = now;
+    }
+    if (this._tokens <= 0) {
+      throw new McpError(ErrorCode.InvalidRequest, "Rate limit exceeded");
+    }
+    this._tokens--;
+    return next();
+  }
+};
+var SizeLimitingMiddleware = class {
+  constructor(maxBytes) {
+    this.maxBytes = maxBytes;
+  }
+  maxBytes;
+  async onRequest(ctx, next) {
+    const result = await next();
+    const size = Buffer.byteLength(JSON.stringify(result), "utf8");
+    if (size > this.maxBytes) {
+      throw new McpError(
+        ErrorCode.InternalError,
+        `Response size (${size} bytes) exceeds limit (${this.maxBytes} bytes)`
+      );
+    }
+    return result;
+  }
+};
+var ErrorNormalizationMiddleware = class {
+  async onCallTool(ctx, next) {
+    try {
+      return await next();
+    } catch (err) {
+      if (err instanceof McpError) throw err;
+      return {
+        content: [{ type: "text", text: err instanceof Error ? err.message : String(err) }],
+        isError: true
+      };
+    }
+  }
+  async onRequest(ctx, next) {
+    try {
+      return await next();
+    } catch (err) {
+      if (err instanceof McpError) throw err;
+      throw new McpError(
+        ErrorCode.InternalError,
+        err instanceof Error ? err.message : String(err)
+      );
+    }
+  }
+};
+var CancellationMiddleware = class {
+  _inFlight = /* @__PURE__ */ new Map();
+  setup(server) {
+    server.setNotificationHandler(CancelledNotificationSchema, (notification) => {
+      const requestId = String(notification.params.requestId);
+      this._inFlight.get(requestId)?.abort();
+    });
+  }
+  async onRequest(ctx, next) {
+    const { requestId } = ctx.mcpContext;
+    if (!requestId) return next();
+    const controller = new AbortController();
+    this._inFlight.set(requestId, controller);
+    const abortPromise = new Promise((_, reject) => {
+      controller.signal.addEventListener(
+        "abort",
+        () => reject(new McpError(ErrorCode.InternalError, "Request was cancelled by the client"))
+      );
+    });
+    try {
+      return await Promise.race([next(), abortPromise]);
+    } finally {
+      this._inFlight.delete(requestId);
+    }
+  }
+};
+
+// src/server/transform.ts
+function applyTransformChain(value, transforms, pick) {
+  let current = value;
+  for (const t of transforms) {
+    if (current === null) break;
+    const next = pick(t, current);
+    if (next !== void 0) current = next;
+  }
+  return current;
+}
+function renameTool(originalName, newName) {
+  return {
+    transformTool: (v) => v.name === originalName ? { ...v, name: newName } : v
+  };
+}
+function redescribeTool(toolName, description) {
+  return {
+    transformTool: (v) => v.name === toolName ? { ...v, description } : v
+  };
+}
+var FilterTransform = class {
+  constructor(predicates) {
+    this.predicates = predicates;
+  }
+  predicates;
+  transformTool(v) {
+    return this.predicates.tools?.(v) ?? true ? v : null;
+  }
+  transformResource(v) {
+    return this.predicates.resources?.(v) ?? true ? v : null;
+  }
+  transformResourceTemplate(v) {
+    const pred = this.predicates.resourceTemplates ?? this.predicates.resources;
+    return pred?.(v) ?? true ? v : null;
+  }
+  transformPrompt(v) {
+    return this.predicates.prompts?.(v) ?? true ? v : null;
+  }
+};
+var NamespaceTransform = class {
+  constructor(prefix) {
+    this.prefix = prefix;
+  }
+  prefix;
+  transformTool(v) {
+    return { ...v, name: `${this.prefix}${v.name}` };
+  }
+  transformResource(v) {
+    return { ...v, name: `${this.prefix}${v.name}` };
+  }
+  transformResourceTemplate(v) {
+    return { ...v, name: `${this.prefix}${v.name}` };
+  }
+  transformPrompt(v) {
+    return { ...v, name: `${this.prefix}${v.name}` };
+  }
+};
+var ResourcesAsTools = class {
+  synthesizeTools(resources) {
+    return [
+      {
+        name: "list_resources",
+        description: "List all available MCP resources",
+        inputSchema: { type: "object", properties: {} },
+        handler: () => resources.map((r) => ({ uri: r.uri, name: r.name, mimeType: r.mimeType }))
+      }
+    ];
+  }
+};
+var PromptsAsTools = class {
+  synthesizeTools(_resources, prompts) {
+    return [
+      {
+        name: "list_prompts",
+        description: "List all available MCP prompts",
+        inputSchema: { type: "object", properties: {} },
+        handler: () => prompts.map((p) => ({ name: p.name, description: p.description }))
+      }
+    ];
+  }
+};
+var VersionFilter = class {
+  constructor(version) {
+    this.version = version;
+  }
+  version;
+  _matches(tags) {
+    return tags.includes(this.version);
+  }
+  transformTool(v) {
+    return this._matches(v.tags) ? v : null;
+  }
+  transformResource(v) {
+    return this._matches(v.tags) ? v : null;
+  }
+  transformResourceTemplate(v) {
+    return this._matches(v.tags) ? v : null;
+  }
+  transformPrompt(v) {
+    return this._matches(v.tags) ? v : null;
+  }
+};
+
+// src/server/tool.ts
+import { McpError as McpError2, ErrorCode as ErrorCode2 } from "@modelcontextprotocol/sdk/types";
+var Image = class {
+  constructor(buffer, mimeType) {
+    this.buffer = buffer;
+    this.mimeType = mimeType;
+  }
+  buffer;
+  mimeType;
+};
+var File = class {
+  constructor(buffer, name, mimeType) {
+    this.buffer = buffer;
+    this.name = name;
+    this.mimeType = mimeType;
+  }
+  buffer;
+  name;
+  mimeType;
+};
+var ToolResult = class {
+  constructor(result) {
+    this.result = result;
+  }
+  result;
+};
+function convertResult(value) {
+  if (value instanceof ToolResult) {
+    return value.result;
+  }
+  if (value instanceof Image) {
+    return {
+      content: [
+        {
+          type: "image",
+          data: Buffer.from(value.buffer).toString("base64"),
+          mimeType: value.mimeType
+        }
+      ]
+    };
+  }
+  if (value instanceof File) {
+    return {
+      content: [
+        {
+          type: "resource",
+          resource: {
+            uri: `file://${value.name}`,
+            mimeType: value.mimeType,
+            blob: Buffer.from(value.buffer).toString("base64")
+          }
+        }
+      ]
+    };
+  }
+  if (value === void 0 || value === null) {
+    return { content: [] };
+  }
+  if (Array.isArray(value)) {
+    console.warn(
+      "[fastmcp] Tool returned an array \u2014 structuredContent will not be set (MCP spec requires a plain object). Wrap in an object or use ToolResult to suppress this warning."
+    );
+    return {
+      content: [{ type: "text", text: JSON.stringify(value) }]
+    };
+  }
+  if (typeof value === "object") {
+    const json = JSON.stringify(value);
+    return {
+      content: [{ type: "text", text: json }],
+      structuredContent: value
+    };
+  }
+  return {
+    content: [{ type: "text", text: String(value) }]
+  };
+}
+async function toJsonSchema(schema, context) {
+  const maybeNative = schema;
+  if (typeof maybeNative.toJsonSchema === "function") {
+    try {
+      const result = maybeNative.toJsonSchema();
+      if (result !== null && typeof result === "object") {
+        return result;
+      }
+    } catch {
+    }
+  }
+  try {
+    const { z } = await import("./zod-P5QUYVPB.js");
+    return z.toJSONSchema(
+      schema
+    );
+  } catch {
+  }
+  const where = context ? ` for ${context}` : "";
+  console.warn(
+    `[fastmcp] Could not auto-generate JSON schema${where}. Sending { type: 'object' } to clients. Provide an explicit 'inputSchema' in ToolConfig to suppress this warning.`
+  );
+  return { type: "object" };
+}
+async function validateInput(schema, input, throwAsProtocolError = false) {
+  const result = await schema["~standard"].validate(input);
+  if (result.issues) {
+    const messages = result.issues.map((i) => i.message).join("; ");
+    if (throwAsProtocolError) {
+      throw new McpError2(ErrorCode2.InvalidParams, `Validation failed: ${messages}`);
+    }
+    throw new Error(`Validation failed: ${messages}`);
+  }
+  return result.value;
+}
+
+// src/server/resource.ts
+var ResourceResult = class {
+  constructor(contents) {
+    this.contents = contents;
+  }
+  contents;
+};
+function convertResourceResult(value, uri, mimeType) {
+  if (value instanceof ResourceResult) {
+    return { contents: value.contents };
+  }
+  if (value instanceof Buffer || value instanceof Uint8Array) {
+    return {
+      contents: [
+        {
+          uri,
+          mimeType: mimeType ?? "application/octet-stream",
+          blob: Buffer.from(value).toString("base64")
+        }
+      ]
+    };
+  }
+  if (value === null || value === void 0) {
+    return { contents: [{ uri, mimeType: mimeType ?? "text/plain", text: "" }] };
+  }
+  if (typeof value === "object") {
+    return {
+      contents: [{ uri, mimeType: mimeType ?? "application/json", text: JSON.stringify(value) }]
+    };
+  }
+  return { contents: [{ uri, mimeType: mimeType ?? "text/plain", text: String(value) }] };
+}
+function isUriTemplate(uri) {
+  return uri.includes("{");
+}
+function matchTemplate(uriTemplate, uri) {
+  const qIdx = uri.indexOf("?");
+  const baseUri = qIdx >= 0 ? uri.slice(0, qIdx) : uri;
+  const queryString = qIdx >= 0 ? uri.slice(qIdx + 1) : "";
+  const queryParamNames = [];
+  const baseTemplate = uriTemplate.replace(/\{[?][^}]+\}/g, (match) => {
+    match.slice(2, -1).split(",").map((s) => s.trim()).forEach((n) => queryParamNames.push(n));
+    return "";
+  });
+  const names = [];
+  const segments = baseTemplate.split(/(\{[^}]+\})/g);
+  let pattern = "^";
+  for (const seg of segments) {
+    if (seg.startsWith("{") && seg.endsWith("}")) {
+      const inner = seg.slice(1, -1);
+      if (inner.endsWith("*")) {
+        names.push(inner.slice(0, -1));
+        pattern += "(.+)";
+      } else {
+        names.push(inner);
+        pattern += "([^/?]+)";
+      }
+    } else if (seg) {
+      pattern += seg.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+    }
+  }
+  pattern += "$";
+  const pathMatch = baseUri.match(new RegExp(pattern));
+  if (!pathMatch) return null;
+  const params = {};
+  names.forEach((name, i) => {
+    params[name] = decodeURIComponent(pathMatch[i + 1]);
+  });
+  if (queryParamNames.length > 0 && queryString) {
+    const sp = new URLSearchParams(queryString);
+    for (const name of queryParamNames) {
+      const val = sp.get(name);
+      if (val !== null) params[name] = val;
+    }
+  }
+  return params;
+}
+
+// src/server/apps/types.ts
+var UI_EXTENSION_KEY = "io.modelcontextprotocol/ui";
+
+// src/server/prompt.ts
+var PromptResult = class {
+  constructor(messages, description) {
+    this.messages = messages;
+    this.description = description;
+  }
+  messages;
+  description;
+};
+function isPromptMessage(value) {
+  if (value === null || typeof value !== "object") return false;
+  const v = value;
+  if (v.role !== "user" && v.role !== "assistant") return false;
+  if (!v.content || typeof v.content !== "object") return false;
+  return typeof v.content.type === "string";
+}
+function convertPromptResult(value) {
+  if (value instanceof PromptResult) {
+    return { description: value.description, messages: value.messages };
+  }
+  if (typeof value === "string") {
+    return { messages: [{ role: "user", content: { type: "text", text: value } }] };
+  }
+  if (isPromptMessage(value)) {
+    return { messages: [value] };
+  }
+  if (Array.isArray(value) && value.every(isPromptMessage)) {
+    return { messages: value };
+  }
+  throw new Error(
+    `Prompt handler returned an unsupported value. Expected string, PromptMessage, PromptMessage[], or PromptResult.`
+  );
+}
+
+// src/server/FastMCP.ts
+function prefixResourceUri(uri, prefix) {
+  const idx = uri.indexOf("://");
+  if (idx === -1) return `${prefix}/${uri}`;
+  return `${uri.slice(0, idx + 3)}${prefix}/${uri.slice(idx + 3)}`;
+}
+function inferDescription(name) {
+  return name.replace(/([A-Z])/g, " $1").replace(/[-_]+/g, " ").trim().toLowerCase();
+}
+function toAccessToken(authInfo) {
+  if (!authInfo) return void 0;
+  return {
+    token: authInfo.token,
+    clientId: authInfo.clientId || void 0,
+    scopes: authInfo.scopes,
+    expiresAt: authInfo.expiresAt,
+    claims: authInfo.extra ?? {}
+  };
+}
+var _cliEnvToken;
+async function resolveCliEnvToken(verifier) {
+  if (!verifier) return void 0;
+  if (_cliEnvToken !== void 0) return _cliEnvToken ?? void 0;
+  const raw = process.env["FASTMCP_CLI_AUTH_TOKEN"];
+  if (!raw) {
+    _cliEnvToken = null;
+    return void 0;
+  }
+  try {
+    _cliEnvToken = await verifier.verify(raw);
+    return _cliEnvToken;
+  } catch {
+    _cliEnvToken = null;
+    return void 0;
+  }
+}
+async function runAuthCheck(check, token) {
+  if (!token) throw new McpError3(ErrorCode3.InvalidRequest, "Authentication required");
+  try {
+    await check(token);
+  } catch (err) {
+    if (err instanceof AuthorizationError) {
+      throw new McpError3(ErrorCode3.InvalidRequest, err.message);
+    }
+    throw err;
+  }
+}
+var FastMCP = class {
+  name;
+  version;
+  _auth;
+  _oauth;
+  _toolsPageSize;
+  _resourcesPageSize;
+  _tools = /* @__PURE__ */ new Map();
+  _staticResources = /* @__PURE__ */ new Map();
+  _templateResources = /* @__PURE__ */ new Map();
+  _prompts = /* @__PURE__ */ new Map();
+  _promptsPageSize;
+  _middleware;
+  _transforms;
+  _primaryState = /* @__PURE__ */ new Map();
+  _httpServer = null;
+  _address = null;
+  _sessions = /* @__PURE__ */ new Map();
+  // Primary server used by connect() and stdio
+  _primaryServer;
+  _toolRegisteredCallbacks = [];
+  _resourceRegisteredCallbacks = [];
+  _promptRegisteredCallbacks = [];
+  _proxyCloseCallbacks = [];
+  _mountedChildren = /* @__PURE__ */ new Set();
+  constructor(options) {
+    this.name = options.name;
+    this.version = options.version ?? "0.0.1";
+    this._auth = options.auth;
+    this._oauth = options.oauth;
+    this._toolsPageSize = options.toolsPageSize ?? 50;
+    this._resourcesPageSize = options.resourcesPageSize ?? 50;
+    this._promptsPageSize = options.promptsPageSize ?? 50;
+    this._middleware = options.middleware ? [...options.middleware] : [];
+    this._transforms = options.transforms ? [...options.transforms] : [];
+    this._primaryServer = this._makeServer();
+  }
+  _hasUiComponents() {
+    for (const t of this._tools.values()) {
+      if (t.config.ui) return true;
+    }
+    for (const r of this._staticResources.values()) {
+      if (r.config.ui || r.config.uri.startsWith("ui://")) return true;
+    }
+    for (const r of this._templateResources.values()) {
+      if (r.config.uri.startsWith("ui://")) return true;
+    }
+    return false;
+  }
+  /** Create a new Server instance with all request handlers wired up. */
+  _makeServer(sessionState) {
+    const state = sessionState ?? this._primaryState;
+    const extensions = this._hasUiComponents() ? { [UI_EXTENSION_KEY]: {} } : void 0;
+    const server = new Server(
+      { name: this.name, version: this.version },
+      { capabilities: { tools: { listChanged: true }, resources: { listChanged: true }, prompts: { listChanged: true }, logging: {}, ...extensions ? { extensions } : {} } }
+    );
+    for (const mw of this._middleware) mw.setup?.(server);
+    this._setupHandlers(server, state);
+    return server;
+  }
+  async _resolveToken(authInfo) {
+    return toAccessToken(authInfo) ?? await resolveCliEnvToken(this._auth);
+  }
+  _setupHandlers(server, sessionState) {
+    server.setRequestHandler(ListToolsRequestSchema, async (req, extra) => {
+      const token = await this._resolveToken(extra.authInfo);
+      const ctx = createContext(server, extra.requestId !== void 0 ? String(extra.requestId) : void 0, void 0, token, sessionState);
+      return contextStore.run(
+        ctx,
+        () => runMiddlewareChain(this._middleware, "tools/list", req.params, ctx, async () => {
+          const clientIsUiCapable = !!server.getClientCapabilities()?.extensions?.[UI_EXTENSION_KEY];
+          const allVisible = (await Promise.all(
+            [...this._tools.values()].map(async (t) => {
+              if (t.config.disabled) return null;
+              if (t.config.ui?.visibility && !t.config.ui.visibility.includes("model")) return null;
+              if (!t.config.auth) return t;
+              if (!token) return null;
+              try {
+                await t.config.auth(token);
+                return t;
+              } catch {
+                return null;
+              }
+            })
+          )).filter((t) => t !== null);
+          const transformedTools = this._applyTransformsToTools(allVisible);
+          const { resourceViews, promptViews } = await this._getVisibleViews(token);
+          const synthesized = this._buildSynthesizedTools(resourceViews, promptViews);
+          const allEntries = [
+            ...transformedTools.map(
+              (t) => ({ kind: "registered", name: t.name, title: t.title, description: t.description, config: t.config })
+            ),
+            ...synthesized.map(
+              (s) => ({ kind: "synthesized", name: s.name, title: s.title, description: s.description, inputSchema: s.inputSchema })
+            )
+          ];
+          const pageSize = this._toolsPageSize;
+          const cursorName = req.params?.cursor ? Buffer.from(req.params.cursor, "base64url").toString() : null;
+          let startIdx = 0;
+          if (cursorName !== null) {
+            const idx = allEntries.findIndex((e) => e.name === cursorName);
+            if (idx < 0) throw new McpError3(ErrorCode3.InvalidParams, "Invalid or expired cursor");
+            startIdx = idx + 1;
+          }
+          const page = allEntries.slice(startIdx, startIdx + pageSize);
+          const nextCursor = startIdx + pageSize < allEntries.length ? Buffer.from(page[page.length - 1].name).toString("base64url") : void 0;
+          const tools = await Promise.all(
+            page.map(async (entry) => {
+              if (entry.kind === "synthesized") {
+                return {
+                  name: entry.name,
+                  ...entry.title !== void 0 ? { title: entry.title } : {},
+                  description: entry.description,
+                  inputSchema: entry.inputSchema ?? { type: "object" }
+                };
+              }
+              const t = entry.config;
+              const inputSchema = t.inputSchema ?? (t.input ? await toJsonSchema(t.input, `tool "${t.name}" input`) : { type: "object" });
+              const outputSchema = t.outputSchema ?? (t.output ? await toJsonSchema(t.output, `tool "${t.name}" output`) : void 0);
+              const uiMeta = clientIsUiCapable && t.ui ? {
+                resourceUri: t.ui.resourceUri ?? `ui://${t.name}`,
+                ...t.ui.visibility ? { visibility: t.ui.visibility } : {}
+              } : void 0;
+              return {
+                name: entry.name,
+                ...entry.title !== void 0 ? { title: entry.title } : {},
+                description: entry.description,
+                inputSchema,
+                ...outputSchema ? { outputSchema } : {},
+                ...uiMeta ? { _meta: { ui: uiMeta } } : {}
+              };
+            })
+          );
+          return { tools, ...nextCursor ? { nextCursor } : {} };
+        })
+      );
+    });
+    server.setRequestHandler(CallToolRequestSchema, async (req, extra) => {
+      const requestedName = req.params.name;
+      const token = await this._resolveToken(extra.authInfo);
+      const { resourceViews, promptViews } = await this._getVisibleViews(token);
+      const synthesizedList = this._buildSynthesizedTools(resourceViews, promptViews);
+      const synthTool = synthesizedList.find((s) => s.name === requestedName);
+      if (synthTool) {
+        if (synthTool.auth) await runAuthCheck(synthTool.auth, token);
+        const ctx2 = createContext(
+          server,
+          extra.requestId !== void 0 ? String(extra.requestId) : void 0,
+          extra._meta?.progressToken,
+          token,
+          sessionState
+        );
+        try {
+          return await contextStore.run(
+            ctx2,
+            () => runMiddlewareChain(this._middleware, "tools/call", req.params, ctx2, async () => {
+              let executePromise = Promise.resolve(
+                synthTool.handler(req.params.arguments ?? {})
+              );
+              if (synthTool.timeout) {
+                const ms = synthTool.timeout;
+                let timer;
+                const timeoutPromise = new Promise((_, reject) => {
+                  timer = setTimeout(
+                    () => reject(new Error(`Tool "${requestedName}" timed out after ${ms}ms`)),
+                    ms
+                  );
+                });
+                executePromise = Promise.race([executePromise, timeoutPromise]).finally(
+                  () => clearTimeout(timer)
+                );
+              }
+              return convertResult(await executePromise);
+            })
+          );
+        } catch (err) {
+          if (err instanceof McpError3) throw err;
+          return {
+            content: [{ type: "text", text: err instanceof Error ? err.message : String(err) }],
+            isError: true
+          };
+        }
+      }
+      let tool;
+      if (this._transforms.length > 0) {
+        for (const t of this._tools.values()) {
+          const view = applyTransformChain(
+            { name: t.config.name, description: t.config.description, tags: t.config.tags ?? [] },
+            this._transforms,
+            (tr, v) => tr.transformTool?.(v)
+          );
+          if (view && view.name === requestedName) {
+            tool = t;
+            break;
+          }
+        }
+      }
+      if (!tool) tool = this._tools.get(requestedName);
+      if (!tool || tool.config.disabled) {
+        throw new McpError3(ErrorCode3.InvalidParams, `Unknown tool: "${requestedName}"`);
+      }
+      if (tool.config.auth) await runAuthCheck(tool.config.auth, token);
+      const resolvedTool = tool;
+      const rawArgs = req.params.arguments ?? {};
+      const ctx = createContext(
+        server,
+        extra.requestId !== void 0 ? String(extra.requestId) : void 0,
+        extra._meta?.progressToken,
+        token,
+        sessionState
+      );
+      try {
+        return await contextStore.run(
+          ctx,
+          () => runMiddlewareChain(this._middleware, "tools/call", req.params, ctx, async () => {
+            const args = resolvedTool.config.input ? await validateInput(resolvedTool.config.input, rawArgs, true) : rawArgs;
+            let executePromise = Promise.resolve(resolvedTool.handler(args));
+            if (resolvedTool.config.timeout) {
+              const ms = resolvedTool.config.timeout;
+              let timer;
+              const timeoutPromise = new Promise((_, reject) => {
+                timer = setTimeout(
+                  () => reject(new Error(`Tool "${requestedName}" timed out after ${ms}ms`)),
+                  ms
+                );
+              });
+              executePromise = Promise.race([executePromise, timeoutPromise]).finally(
+                () => clearTimeout(timer)
+              );
+            }
+            let resultValue = await executePromise;
+            if (resolvedTool.config.output) resultValue = await validateInput(resolvedTool.config.output, resultValue);
+            const callResult = convertResult(resultValue);
+            if (resolvedTool.config.ui) {
+              const clientIsUi = !!server.getClientCapabilities()?.extensions?.[UI_EXTENSION_KEY];
+              if (!clientIsUi && callResult.structuredContent !== void 0) {
+                return { content: [{ type: "text", text: "[UI not available in this client]" }] };
+              }
+            }
+            return callResult;
+          })
+        );
+      } catch (err) {
+        if (err instanceof McpError3) throw err;
+        return {
+          content: [{ type: "text", text: err instanceof Error ? err.message : String(err) }],
+          isError: true
+        };
+      }
+    });
+    server.setRequestHandler(ListResourcesRequestSchema, async (req, extra) => {
+      const token = await this._resolveToken(extra.authInfo);
+      const ctx = createContext(server, extra.requestId !== void 0 ? String(extra.requestId) : void 0, void 0, token, sessionState);
+      return contextStore.run(
+        ctx,
+        () => runMiddlewareChain(this._middleware, "resources/list", req.params, ctx, async () => {
+          const allVisible = (await Promise.all(
+            [...this._staticResources.values()].map(async (r) => {
+              if (r.config.disabled) return null;
+              if (!r.config.auth) return r;
+              if (!token) return null;
+              try {
+                await r.config.auth(token);
+                return r;
+              } catch {
+                return null;
+              }
+            })
+          )).filter((r) => r !== null);
+          const transformedResources = this._applyTransformsToResources(allVisible);
+          const pageSize = this._resourcesPageSize;
+          const cursorUri = req.params?.cursor ? Buffer.from(req.params.cursor, "base64url").toString() : null;
+          let startIdx = 0;
+          if (cursorUri !== null) {
+            const idx = transformedResources.findIndex((r) => r.uri === cursorUri);
+            if (idx < 0) throw new McpError3(ErrorCode3.InvalidParams, "Invalid or expired cursor");
+            startIdx = idx + 1;
+          }
+          const page = transformedResources.slice(startIdx, startIdx + pageSize);
+          const nextCursor = startIdx + pageSize < transformedResources.length ? Buffer.from(page[page.length - 1].uri).toString("base64url") : void 0;
+          const clientIsUiCapableRes = !!server.getClientCapabilities()?.extensions?.[UI_EXTENSION_KEY];
+          return {
+            resources: page.map((r) => ({
+              uri: r.uri,
+              name: r.name,
+              ...r.config.title !== void 0 ? { title: r.config.title } : {},
+              ...r.config.description !== void 0 ? { description: r.config.description } : {},
+              ...r.config.mimeType !== void 0 ? { mimeType: r.config.mimeType } : {},
+              ...r.config.size !== void 0 ? { size: r.config.size } : {},
+              ...r.config.annotations !== void 0 ? { annotations: r.config.annotations } : {},
+              ...clientIsUiCapableRes && r.config.ui ? { _meta: { ui: r.config.ui } } : {}
+            })),
+            ...nextCursor ? { nextCursor } : {}
+          };
+        })
+      );
+    });
+    server.setRequestHandler(ListResourceTemplatesRequestSchema, async (req, extra) => {
+      const token = await this._resolveToken(extra.authInfo);
+      const ctx = createContext(server, extra.requestId !== void 0 ? String(extra.requestId) : void 0, void 0, token, sessionState);
+      return contextStore.run(
+        ctx,
+        () => runMiddlewareChain(this._middleware, "resources/templates/list", req.params, ctx, async () => {
+          const allVisible = (await Promise.all(
+            [...this._templateResources.values()].map(async (r) => {
+              if (r.config.disabled) return null;
+              if (!r.config.auth) return r;
+              if (!token) return null;
+              try {
+                await r.config.auth(token);
+                return r;
+              } catch {
+                return null;
+              }
+            })
+          )).filter((r) => r !== null);
+          const transformedTemplates = this._applyTransformsToResourceTemplates(allVisible);
+          const pageSize = this._resourcesPageSize;
+          const cursorUri = req.params?.cursor ? Buffer.from(req.params.cursor, "base64url").toString() : null;
+          let startIdx = 0;
+          if (cursorUri !== null) {
+            const idx = transformedTemplates.findIndex((r) => r.uri === cursorUri);
+            if (idx < 0) throw new McpError3(ErrorCode3.InvalidParams, "Invalid or expired cursor");
+            startIdx = idx + 1;
+          }
+          const page = transformedTemplates.slice(startIdx, startIdx + pageSize);
+          const nextCursor = startIdx + pageSize < transformedTemplates.length ? Buffer.from(page[page.length - 1].uri).toString("base64url") : void 0;
+          return {
+            resourceTemplates: page.map((r) => ({
+              uriTemplate: r.uri,
+              name: r.name,
+              ...r.config.title !== void 0 ? { title: r.config.title } : {},
+              ...r.config.description !== void 0 ? { description: r.config.description } : {},
+              ...r.config.mimeType !== void 0 ? { mimeType: r.config.mimeType } : {},
+              ...r.config.annotations !== void 0 ? { annotations: r.config.annotations } : {}
+            })),
+            ...nextCursor ? { nextCursor } : {}
+          };
+        })
+      );
+    });
+    server.setRequestHandler(ReadResourceRequestSchema, async (req, extra) => {
+      const requestedUri = req.params.uri;
+      const token = await this._resolveToken(extra.authInfo);
+      let resource = this._staticResources.get(requestedUri);
+      let templateParams;
+      if (!resource) {
+        for (const r of this._templateResources.values()) {
+          if (r.config.disabled) continue;
+          const params = matchTemplate(r.config.uri, requestedUri);
+          if (params !== null) {
+            resource = r;
+            templateParams = params;
+            break;
+          }
+        }
+      }
+      if (!resource && this._transforms.length > 0) {
+        for (const r of this._staticResources.values()) {
+          if (r.config.disabled) continue;
+          const view = applyTransformChain(
+            { uri: r.config.uri, name: r.config.name ?? r.config.uri, tags: r.config.tags ?? [], mimeType: r.config.mimeType, title: r.config.title },
+            this._transforms,
+            (t, v) => t.transformResource?.(v)
+          );
+          if (view && view.uri === requestedUri) {
+            resource = r;
+            break;
+          }
+        }
+      }
+      if (!resource && this._transforms.length > 0) {
+        for (const r of this._templateResources.values()) {
+          if (r.config.disabled) continue;
+          const view = applyTransformChain(
+            { uri: r.config.uri, name: r.config.name ?? r.config.uri, tags: r.config.tags ?? [], mimeType: r.config.mimeType, title: r.config.title },
+            this._transforms,
+            (t, v) => t.transformResourceTemplate?.(v)
+          );
+          if (view) {
+            const params = matchTemplate(view.uri, requestedUri);
+            if (params !== null) {
+              resource = r;
+              templateParams = params;
+              break;
+            }
+          }
+        }
+      }
+      if (!resource || resource.config.disabled) {
+        throw new McpError3(ErrorCode3.InvalidParams, `Unknown resource: "${requestedUri}"`);
+      }
+      if (resource.config.auth) await runAuthCheck(resource.config.auth, token);
+      const ctx = createContext(
+        server,
+        extra.requestId !== void 0 ? String(extra.requestId) : void 0,
+        extra._meta?.progressToken,
+        token,
+        sessionState
+      );
+      return contextStore.run(
+        ctx,
+        () => runMiddlewareChain(this._middleware, "resources/read", req.params, ctx, async () => {
+          let executePromise = Promise.resolve(resource.handler(templateParams));
+          if (resource.config.timeout) {
+            const ms = resource.config.timeout;
+            let timer;
+            const timeoutPromise = new Promise((_, reject) => {
+              timer = setTimeout(
+                () => reject(new Error(`Resource "${requestedUri}" timed out after ${ms}ms`)),
+                ms
+              );
+            });
+            executePromise = Promise.race([executePromise, timeoutPromise]).finally(
+              () => clearTimeout(timer)
+            );
+          }
+          const result = await executePromise;
+          return convertResourceResult(result, requestedUri, resource.config.mimeType);
+        })
+      );
+    });
+    server.setRequestHandler(ListPromptsRequestSchema, async (req, extra) => {
+      const token = await this._resolveToken(extra.authInfo);
+      const ctx = createContext(server, extra.requestId !== void 0 ? String(extra.requestId) : void 0, void 0, token, sessionState);
+      return contextStore.run(
+        ctx,
+        () => runMiddlewareChain(this._middleware, "prompts/list", req.params, ctx, async () => {
+          const allVisible = (await Promise.all(
+            [...this._prompts.values()].map(async (p) => {
+              if (p.config.disabled) return null;
+              if (!p.config.auth) return p;
+              if (!token) return null;
+              try {
+                await p.config.auth(token);
+                return p;
+              } catch {
+                return null;
+              }
+            })
+          )).filter((p) => p !== null);
+          const transformedPrompts = this._applyTransformsToPrompts(allVisible);
+          const pageSize = this._promptsPageSize;
+          const cursorName = req.params?.cursor ? Buffer.from(req.params.cursor, "base64url").toString() : null;
+          let startIdx = 0;
+          if (cursorName !== null) {
+            const idx = transformedPrompts.findIndex((p) => p.name === cursorName);
+            if (idx < 0) throw new McpError3(ErrorCode3.InvalidParams, "Invalid or expired cursor");
+            startIdx = idx + 1;
+          }
+          const page = transformedPrompts.slice(startIdx, startIdx + pageSize);
+          const nextCursor = startIdx + pageSize < transformedPrompts.length ? Buffer.from(page[page.length - 1].name).toString("base64url") : void 0;
+          return {
+            prompts: page.map((p) => ({
+              name: p.name,
+              ...p.config.title !== void 0 ? { title: p.config.title } : {},
+              description: p.description,
+              ...p.config.arguments?.length ? { arguments: p.config.arguments } : {}
+            })),
+            ...nextCursor ? { nextCursor } : {}
+          };
+        })
+      );
+    });
+    server.setRequestHandler(GetPromptRequestSchema, async (req, extra) => {
+      const requestedName = req.params.name;
+      let prompt;
+      if (this._transforms.length > 0) {
+        for (const p of this._prompts.values()) {
+          const view = applyTransformChain(
+            { name: p.config.name, description: p.config.description, tags: p.config.tags ?? [] },
+            this._transforms,
+            (t, v) => t.transformPrompt?.(v)
+          );
+          if (view && view.name === requestedName) {
+            prompt = p;
+            break;
+          }
+        }
+      }
+      if (!prompt) prompt = this._prompts.get(requestedName);
+      if (!prompt || prompt.config.disabled) {
+        throw new McpError3(ErrorCode3.InvalidParams, `Unknown prompt: "${requestedName}"`);
+      }
+      const resolvedPrompt = prompt;
+      const token = await this._resolveToken(extra.authInfo);
+      if (resolvedPrompt.config.auth) await runAuthCheck(resolvedPrompt.config.auth, token);
+      const suppliedArgs = req.params.arguments ?? {};
+      for (const arg of resolvedPrompt.config.arguments ?? []) {
+        if (arg.required && !(arg.name in suppliedArgs)) {
+          throw new McpError3(
+            ErrorCode3.InvalidParams,
+            `Missing required argument "${arg.name}" for prompt "${requestedName}"`
+          );
+        }
+      }
+      const ctx = createContext(
+        server,
+        extra.requestId !== void 0 ? String(extra.requestId) : void 0,
+        extra._meta?.progressToken,
+        token,
+        sessionState
+      );
+      return contextStore.run(
+        ctx,
+        () => runMiddlewareChain(this._middleware, "prompts/get", req.params, ctx, async () => {
+          let executePromise = Promise.resolve(resolvedPrompt.handler(suppliedArgs));
+          if (resolvedPrompt.config.timeout) {
+            const ms = resolvedPrompt.config.timeout;
+            let timer;
+            const timeoutPromise = new Promise((_, reject) => {
+              timer = setTimeout(
+                () => reject(new Error(`Prompt "${requestedName}" timed out after ${ms}ms`)),
+                ms
+              );
+            });
+            executePromise = Promise.race([executePromise, timeoutPromise]).finally(
+              () => clearTimeout(timer)
+            );
+          }
+          return convertPromptResult(await executePromise);
+        })
+      );
+    });
+  }
+  _notifyToolListChanged() {
+    this._primaryServer.sendToolListChanged().catch(() => {
+    });
+    for (const { server } of this._sessions.values()) {
+      server.sendToolListChanged().catch(() => {
+      });
+    }
+  }
+  _notifyResourceListChanged() {
+    this._primaryServer.sendResourceListChanged().catch(() => {
+    });
+    for (const { server } of this._sessions.values()) {
+      server.sendResourceListChanged().catch(() => {
+      });
+    }
+  }
+  _notifyPromptListChanged() {
+    this._primaryServer.sendPromptListChanged().catch(() => {
+    });
+    for (const { server } of this._sessions.values()) {
+      server.sendPromptListChanged().catch(() => {
+      });
+    }
+  }
+  // Implementation (handler typed as any to satisfy both overload signatures)
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  tool(config, handler) {
+    const registered = { config, handler };
+    this._tools.set(config.name, registered);
+    this._notifyToolListChanged();
+    for (const cb of this._toolRegisteredCallbacks) cb(registered);
+  }
+  prompt(config, handler) {
+    const name = config.name ?? handler.name;
+    if (!name) throw new Error("Prompt name must be provided in config or inferrable from the handler function name");
+    const description = config.description ?? inferDescription(name);
+    const resolvedConfig = { ...config, name, description };
+    const registered = { config: resolvedConfig, handler };
+    this._prompts.set(name, registered);
+    this._notifyPromptListChanged();
+    for (const cb of this._promptRegisteredCallbacks) cb(registered);
+  }
+  resource(config, handler) {
+    const registered = { config, handler };
+    if (isUriTemplate(config.uri)) {
+      this._templateResources.set(config.uri, registered);
+    } else {
+      this._staticResources.set(config.uri, registered);
+    }
+    this._notifyResourceListChanged();
+    for (const cb of this._resourceRegisteredCallbacks) cb(registered);
+  }
+  _removeTool(name) {
+    if (!this._tools.has(name)) return false;
+    this._tools.delete(name);
+    this._notifyToolListChanged();
+    return true;
+  }
+  _removeResource(uri) {
+    if (this._staticResources.has(uri)) {
+      this._staticResources.delete(uri);
+      this._notifyResourceListChanged();
+      return true;
+    }
+    if (this._templateResources.has(uri)) {
+      this._templateResources.delete(uri);
+      this._notifyResourceListChanged();
+      return true;
+    }
+    return false;
+  }
+  _removePrompt(name) {
+    if (!this._prompts.has(name)) return false;
+    this._prompts.delete(name);
+    this._notifyPromptListChanged();
+    return true;
+  }
+  /** Add a transform to the pipeline. Applied to list responses in registration order. */
+  transform(t) {
+    this._transforms.push(t);
+    return this;
+  }
+  /**
+   * Dispatch a tool call through this server's middleware chain using an inherited context.
+   * Used by parent servers to honour child-level middleware when routing mounted tool calls.
+   */
+  async _dispatchTool(name, rawArgs, ctx) {
+    const tool = this._tools.get(name);
+    if (!tool || tool.config.disabled) {
+      throw new McpError3(ErrorCode3.InvalidParams, `Unknown tool: "${name}"`);
+    }
+    if (tool.config.auth) await runAuthCheck(tool.config.auth, ctx.auth);
+    try {
+      return await contextStore.run(
+        ctx,
+        () => runMiddlewareChain(this._middleware, "tools/call", { name, arguments: rawArgs }, ctx, async () => {
+          const args = tool.config.input ? await validateInput(tool.config.input, rawArgs, true) : rawArgs;
+          let executePromise = Promise.resolve(tool.handler(args));
+          if (tool.config.timeout) {
+            const ms = tool.config.timeout;
+            let timer;
+            const timeoutPromise = new Promise((_, reject) => {
+              timer = setTimeout(
+                () => reject(new Error(`Tool "${name}" timed out after ${ms}ms`)),
+                ms
+              );
+            });
+            executePromise = Promise.race([executePromise, timeoutPromise]).finally(
+              () => clearTimeout(timer)
+            );
+          }
+          let resultValue = await executePromise;
+          if (tool.config.output) resultValue = await validateInput(tool.config.output, resultValue);
+          return convertResult(resultValue);
+        })
+      );
+    } catch (err) {
+      if (err instanceof McpError3) throw err;
+      return {
+        content: [{ type: "text", text: err instanceof Error ? err.message : String(err) }],
+        isError: true
+      };
+    }
+  }
+  /**
+   * Run a resource read through this server's middleware chain using an inherited context.
+   * Returns the raw handler result so the parent can apply convertResourceResult with the
+   * actual requested URI (important for template resources).
+   */
+  async _dispatchResource(uri, params, ctx) {
+    const resource = isUriTemplate(uri) ? this._templateResources.get(uri) : this._staticResources.get(uri);
+    if (!resource || resource.config.disabled) {
+      throw new McpError3(ErrorCode3.InvalidParams, `Unknown resource: "${uri}"`);
+    }
+    if (resource.config.auth) await runAuthCheck(resource.config.auth, ctx.auth);
+    return contextStore.run(
+      ctx,
+      () => runMiddlewareChain(this._middleware, "resources/read", { uri }, ctx, async () => {
+        let executePromise = Promise.resolve(resource.handler(params));
+        if (resource.config.timeout) {
+          const ms = resource.config.timeout;
+          let timer;
+          const timeoutPromise = new Promise((_, reject) => {
+            timer = setTimeout(
+              () => reject(new Error(`Resource "${uri}" timed out after ${ms}ms`)),
+              ms
+            );
+          });
+          executePromise = Promise.race([executePromise, timeoutPromise]).finally(
+            () => clearTimeout(timer)
+          );
+        }
+        return await executePromise;
+      })
+    );
+  }
+  /**
+   * Dispatch a prompt render through this server's middleware chain using an inherited context.
+   */
+  async _dispatchPrompt(name, args, ctx) {
+    const prompt = this._prompts.get(name);
+    if (!prompt || prompt.config.disabled) {
+      throw new McpError3(ErrorCode3.InvalidParams, `Unknown prompt: "${name}"`);
+    }
+    if (prompt.config.auth) await runAuthCheck(prompt.config.auth, ctx.auth);
+    for (const arg of prompt.config.arguments ?? []) {
+      if (arg.required && !(arg.name in args)) {
+        throw new McpError3(
+          ErrorCode3.InvalidParams,
+          `Missing required argument "${arg.name}" for prompt "${name}"`
+        );
+      }
+    }
+    return contextStore.run(
+      ctx,
+      () => runMiddlewareChain(this._middleware, "prompts/get", { name, arguments: args }, ctx, async () => {
+        let executePromise = Promise.resolve(prompt.handler(args));
+        if (prompt.config.timeout) {
+          const ms = prompt.config.timeout;
+          let timer;
+          const timeoutPromise = new Promise((_, reject) => {
+            timer = setTimeout(
+              () => reject(new Error(`Prompt "${name}" timed out after ${ms}ms`)),
+              ms
+            );
+          });
+          executePromise = Promise.race([executePromise, timeoutPromise]).finally(
+            () => clearTimeout(timer)
+          );
+        }
+        return convertPromptResult(await executePromise);
+      })
+    );
+  }
+  _mirrorTool(child, tool, prefix) {
+    const originalName = tool.config.name;
+    const key = prefix ? `${prefix}_${originalName}` : originalName;
+    if (this._tools.has(key)) throw new Error(`Tool name collision on mount: "${key}" is already registered`);
+    const forwardedConfig = { ...tool.config, name: key, input: void 0, output: void 0 };
+    this.tool(forwardedConfig, (args) => {
+      const parentCtx = contextStore.getStore();
+      const childCtx = prefix ? { ...parentCtx, resolveToolName: (name) => `${prefix}_${name}` } : parentCtx;
+      return child._dispatchTool(originalName, args, childCtx).then((result) => new ToolResult(result));
+    });
+  }
+  _mirrorResource(child, resource, prefix) {
+    const name = resource.config.name ?? resource.config.uri;
+    const originalUri = resource.config.uri;
+    const targetUri = prefix ? prefixResourceUri(originalUri, prefix) : originalUri;
+    if (this._staticResources.has(targetUri) || this._templateResources.has(targetUri)) {
+      throw new Error(`Resource URI collision on mount: "${targetUri}" is already registered`);
+    }
+    const forwardedConfig = {
+      ...resource.config,
+      uri: targetUri,
+      name: prefix ? `${prefix}_${name}` : name
+    };
+    this.resource(forwardedConfig, (params) => {
+      const ctx = contextStore.getStore();
+      return child._dispatchResource(originalUri, params, ctx);
+    });
+  }
+  _mirrorPrompt(child, prompt, prefix) {
+    const originalName = prompt.config.name;
+    const key = prefix ? `${prefix}_${originalName}` : originalName;
+    if (this._prompts.has(key)) throw new Error(`Prompt name collision on mount: "${key}" is already registered`);
+    const forwardedConfig = { ...prompt.config, name: key };
+    this.prompt(forwardedConfig, (args) => {
+      const ctx = contextStore.getStore();
+      return child._dispatchPrompt(originalName, args ?? {}, ctx).then((result) => new PromptResult(result.messages, result.description));
+    });
+  }
+  /** Mount a child server onto this server. All tools, resources, and prompts from the child become accessible via this server. Pass a prefix to namespace names and prevent collisions. */
+  mount(child, prefix) {
+    if (child === this) throw new Error("Cannot mount a server onto itself");
+    if (this._mountedChildren.has(child)) return this;
+    this._mountedChildren.add(child);
+    for (const tool of child._tools.values()) this._mirrorTool(child, tool, prefix);
+    for (const resource of child._staticResources.values()) this._mirrorResource(child, resource, prefix);
+    for (const resource of child._templateResources.values()) this._mirrorResource(child, resource, prefix);
+    for (const prompt of child._prompts.values()) this._mirrorPrompt(child, prompt, prefix);
+    child._toolRegisteredCallbacks.push((tool) => this._mirrorTool(child, tool, prefix));
+    child._resourceRegisteredCallbacks.push((resource) => this._mirrorResource(child, resource, prefix));
+    child._promptRegisteredCallbacks.push((prompt) => this._mirrorPrompt(child, prompt, prefix));
+    this._proxyCloseCallbacks.push(async () => {
+      await Promise.all(child._proxyCloseCallbacks.map((cb) => cb().catch(() => {
+      })));
+      child._proxyCloseCallbacks.length = 0;
+    });
+    return this;
+  }
+  /** Register a callback invoked when this server is closed — used by proxy connections. */
+  _addCloseCallback(cb) {
+    this._proxyCloseCallbacks.push(cb);
+  }
+  /**
+   * Register a provider (FastMCPApp or FastMCP) on this server.
+   * All tools, resources, and prompts from the provider are mounted without a prefix.
+   * For FastMCPApp, pass provider.server; for FastMCP, pass directly.
+   */
+  addProvider(provider) {
+    const child = "server" in provider ? provider.server : provider;
+    return this.mount(child);
+  }
+  _applyTransformsToTools(tools) {
+    return tools.flatMap((tool) => {
+      const view = applyTransformChain(
+        { name: tool.config.name, title: tool.config.title, description: tool.config.description, tags: tool.config.tags ?? [] },
+        this._transforms,
+        (t, v) => t.transformTool?.(v)
+      );
+      return view ? [{ name: view.name, title: view.title, description: view.description, originalName: tool.config.name, config: tool.config, handler: tool.handler }] : [];
+    });
+  }
+  _applyTransformsToResources(resources) {
+    return resources.flatMap((r) => {
+      const resolvedName = r.config.name ?? r.config.uri;
+      const view = applyTransformChain(
+        { uri: r.config.uri, name: resolvedName, tags: r.config.tags ?? [], mimeType: r.config.mimeType, title: r.config.title },
+        this._transforms,
+        (t, v) => t.transformResource?.(v)
+      );
+      return view ? [{ uri: view.uri, name: view.name, originalUri: r.config.uri, config: r.config, handler: r.handler }] : [];
+    });
+  }
+  _applyTransformsToResourceTemplates(templates) {
+    return templates.flatMap((r) => {
+      const resolvedName = r.config.name ?? r.config.uri;
+      const view = applyTransformChain(
+        { uri: r.config.uri, name: resolvedName, tags: r.config.tags ?? [], mimeType: r.config.mimeType, title: r.config.title },
+        this._transforms,
+        (t, v) => t.transformResourceTemplate?.(v)
+      );
+      return view ? [{ uri: view.uri, name: view.name, originalUri: r.config.uri, config: r.config, handler: r.handler }] : [];
+    });
+  }
+  _applyTransformsToPrompts(prompts) {
+    return prompts.flatMap((p) => {
+      const view = applyTransformChain(
+        { name: p.config.name, description: p.config.description, tags: p.config.tags ?? [] },
+        this._transforms,
+        (t, v) => t.transformPrompt?.(v)
+      );
+      return view ? [{ name: view.name, description: view.description, originalName: p.config.name, config: p.config, handler: p.handler }] : [];
+    });
+  }
+  _buildSynthesizedTools(resourceViews, promptViews) {
+    if (this._transforms.length === 0) return [];
+    const raw = this._transforms.flatMap((t) => t.synthesizeTools?.(resourceViews, promptViews) ?? []);
+    return raw.flatMap((s) => {
+      const view = applyTransformChain(
+        { name: s.name, title: s.title, description: s.description, tags: [] },
+        this._transforms,
+        (t, v) => t.transformTool?.(v)
+      );
+      return view ? [{ ...s, name: view.name, title: view.title, description: view.description }] : [];
+    });
+  }
+  async _getVisibleViews(token) {
+    const visibleStatic = (await Promise.all(
+      [...this._staticResources.values()].map(async (r) => {
+        if (r.config.disabled) return null;
+        if (!r.config.auth) return r;
+        if (!token) return null;
+        try {
+          await r.config.auth(token);
+          return r;
+        } catch {
+          return null;
+        }
+      })
+    )).filter((r) => r !== null);
+    const visibleTemplates = (await Promise.all(
+      [...this._templateResources.values()].map(async (r) => {
+        if (r.config.disabled) return null;
+        if (!r.config.auth) return r;
+        if (!token) return null;
+        try {
+          await r.config.auth(token);
+          return r;
+        } catch {
+          return null;
+        }
+      })
+    )).filter((r) => r !== null);
+    const visiblePrompts = (await Promise.all(
+      [...this._prompts.values()].map(async (p) => {
+        if (p.config.disabled) return null;
+        if (!p.config.auth) return p;
+        if (!token) return null;
+        try {
+          await p.config.auth(token);
+          return p;
+        } catch {
+          return null;
+        }
+      })
+    )).filter((p) => p !== null);
+    const resourceViews = [
+      ...this._applyTransformsToResources(visibleStatic),
+      ...this._applyTransformsToResourceTemplates(visibleTemplates)
+    ].map((r) => ({
+      uri: r.uri,
+      name: r.name,
+      tags: r.config.tags ?? [],
+      mimeType: r.config.mimeType,
+      title: r.config.title
+    }));
+    const promptViews = this._applyTransformsToPrompts(visiblePrompts).map((p) => ({
+      name: p.name,
+      description: p.description,
+      tags: p.config.tags ?? []
+    }));
+    return { resourceViews, promptViews };
+  }
+  /**
+   * Add a middleware to the pipeline.
+   *
+   * Can be called at any point before the first request arrives. `setup()` is
+   * called immediately on the primary server so that notification handlers and
+   * other server-level side-effects are active before `connect()` / `run()` is
+   * called. HTTP sessions created after `use()` will also have `setup()` called
+   * via `_makeServer()`.
+   */
+  use(mw) {
+    this._middleware.push(mw);
+    mw.setup?.(this._primaryServer);
+    return this;
+  }
+  getContext() {
+    const ctx = contextStore.getStore();
+    if (!ctx) throw new Error("getContext() called outside of a request handler");
+    return ctx;
+  }
+  /** The bound address after run() resolves for the http transport. Null for stdio or before run(). */
+  get address() {
+    return this._address;
+  }
+  async connect(transport) {
+    this._primaryServer = this._makeServer();
+    await this._primaryServer.connect(transport);
+  }
+  async run(options) {
+    const rawTransport = process.env.MCP_TRANSPORT ?? options?.transport ?? "stdio";
+    if (rawTransport !== "stdio" && rawTransport !== "http") {
+      throw new Error(`Unknown transport: "${rawTransport}". Supported: stdio, http.`);
+    }
+    const transport = rawTransport;
+    const port = options?.port ?? parseInt(process.env.MCP_PORT ?? process.env.PORT ?? "3000", 10);
+    const host = options?.host ?? process.env.MCP_HOST ?? "0.0.0.0";
+    const path = options?.path ?? process.env.MCP_PATH ?? "/mcp";
+    if (transport === "stdio") {
+      const { StdioServerTransport } = await import("@modelcontextprotocol/sdk/server/stdio");
+      await this.connect(new StdioServerTransport(options?.stdin, options?.stdout));
+    } else if (this._oauth) {
+      await this._runHttpOAuth(port, host, path);
+    } else {
+      await this._runHttpSimple(port, host, path);
+    }
+  }
+  async _runHttpOAuth(port, host, path) {
+    const { StreamableHTTPServerTransport } = await import("@modelcontextprotocol/sdk/server/streamableHttp");
+    const express = (await import("express")).default;
+    const { mcpAuthRouter } = await import("@modelcontextprotocol/sdk/server/auth/router");
+    const { requireBearerAuth } = await import("@modelcontextprotocol/sdk/server/auth/middleware/bearerAuth");
+    const oauth = this._oauth;
+    const app = express();
+    const httpServer = await new Promise((resolve, reject) => {
+      const srv = app.listen(port, host, () => resolve(srv));
+      srv.on("error", reject);
+    });
+    const bound = httpServer.address();
+    const issuerUrl = oauth.issuerUrl ?? new URL(`http://${bound.address}:${bound.port}`);
+    app.use(
+      mcpAuthRouter({
+        provider: oauth.provider,
+        issuerUrl,
+        scopesSupported: oauth.scopes
+      })
+    );
+    app.all(
+      path,
+      requireBearerAuth({ verifier: oauth.provider }),
+      async (req, res, _next) => {
+        const sessionId = req.headers["mcp-session-id"];
+        let mcpTransport;
+        if (sessionId) {
+          const existing = this._sessions.get(sessionId);
+          if (!existing) {
+            res.status(404).json({ error: "Session not found" });
+            return;
+          }
+          mcpTransport = existing.transport;
+        } else {
+          const sessionState = /* @__PURE__ */ new Map();
+          const sessionServer = this._makeServer(sessionState);
+          mcpTransport = new StreamableHTTPServerTransport({
+            sessionIdGenerator: () => randomUUID(),
+            onsessioninitialized: (id) => {
+              this._sessions.set(id, { transport: mcpTransport, server: sessionServer, state: sessionState });
+            },
+            onsessionclosed: (id) => {
+              const session = this._sessions.get(id);
+              if (session) {
+                const callbacks = session.state.get(SESSION_CLOSE_CALLBACKS_KEY) ?? [];
+                for (const cb of callbacks) cb();
+              }
+              this._sessions.delete(id);
+            }
+          });
+          await sessionServer.connect(mcpTransport);
+        }
+        await mcpTransport.handleRequest(req, res);
+      }
+    );
+    this._httpServer = httpServer;
+    this._address = { host: bound.address, port: bound.port, path };
+  }
+  async _runHttpSimple(port, host, path) {
+    const { StreamableHTTPServerTransport } = await import("@modelcontextprotocol/sdk/server/streamableHttp");
+    const { createServer } = await import("http");
+    const auth = this._auth;
+    const corsHeaders = {
+      "Access-Control-Allow-Origin": "*",
+      "Access-Control-Allow-Methods": "GET, POST, DELETE, OPTIONS",
+      "Access-Control-Allow-Headers": "Content-Type, Authorization, Mcp-Session-Id"
+    };
+    const httpServer = createServer(async (req, res) => {
+      if (req.method === "OPTIONS") {
+        res.writeHead(204, corsHeaders).end();
+        return;
+      }
+      if (req.url?.split("?")[0] !== path) {
+        res.writeHead(404).end();
+        return;
+      }
+      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);
+          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;
+        }
+      }
+      const sessionId = req.headers["mcp-session-id"];
+      let mcpTransport;
+      if (sessionId) {
+        const existing = this._sessions.get(sessionId);
+        if (!existing) {
+          res.writeHead(404, { "Content-Type": "application/json" }).end(JSON.stringify({ error: "Session not found" }));
+          return;
+        }
+        mcpTransport = existing.transport;
+      } else {
+        const sessionState = /* @__PURE__ */ new Map();
+        const sessionServer = this._makeServer(sessionState);
+        mcpTransport = new StreamableHTTPServerTransport({
+          sessionIdGenerator: () => randomUUID(),
+          onsessioninitialized: (id) => {
+            this._sessions.set(id, { transport: mcpTransport, server: sessionServer, state: sessionState });
+          },
+          onsessionclosed: (id) => {
+            const session = this._sessions.get(id);
+            if (session) {
+              const callbacks = session.state.get(SESSION_CLOSE_CALLBACKS_KEY) ?? [];
+              for (const cb of callbacks) cb();
+            }
+            this._sessions.delete(id);
+          }
+        });
+        await sessionServer.connect(mcpTransport);
+      }
+      await mcpTransport.handleRequest(req, res);
+    });
+    this._httpServer = httpServer;
+    await new Promise((resolve, reject) => {
+      httpServer.once("error", reject);
+      httpServer.listen(port, host, resolve);
+    });
+    const bound = httpServer.address();
+    this._address = { host: bound.address, port: bound.port, path };
+  }
+  async close() {
+    await Promise.all(this._proxyCloseCallbacks.map((cb) => cb().catch(() => {
+    })));
+    this._proxyCloseCallbacks.length = 0;
+    await Promise.all(
+      [...this._sessions.values()].map(({ transport }) => transport.close().catch(() => {
+      }))
+    );
+    this._sessions.clear();
+    if (this._httpServer) {
+      await new Promise((resolve, reject) => {
+        this._httpServer.close((err) => err != null ? reject(err) : resolve());
+      });
+      this._httpServer = null;
+    }
+    this._address = null;
+    await this._primaryServer.close();
+  }
+};
+
+// src/server/auth/authorization.ts
+function requireScopes(...scopes) {
+  return async (token) => {
+    for (const scope of scopes) {
+      if (!token.scopes.includes(scope)) {
+        throw new AuthorizationError(`Missing required scope: "${scope}"`);
+      }
+    }
+  };
+}
+
+// src/server/auth/multiAuth.ts
+function multiAuth(...verifiers) {
+  return {
+    async verify(token) {
+      const errors = [];
+      for (const verifier of verifiers) {
+        try {
+          return await verifier.verify(token);
+        } catch (err) {
+          errors.push(err instanceof Error ? err.message : String(err));
+        }
+      }
+      throw new Error(`All auth sources rejected the token: ${errors.join("; ")}`);
+    }
+  };
+}
+
+// src/server/auth/verifiers/jwt.ts
+import { createRemoteJWKSet, jwtVerify } from "jose";
+function jwtVerifier(options) {
+  const JWKS = createRemoteJWKSet(new URL(options.jwksUri));
+  return {
+    async verify(token) {
+      const { payload } = await jwtVerify(token, JWKS, {
+        issuer: options.issuer,
+        audience: options.audience,
+        clockTolerance: options.leeway ?? 0
+      });
+      const scopes = typeof payload.scope === "string" ? payload.scope.split(" ").filter(Boolean) : Array.isArray(payload.scope) ? payload.scope : [];
+      return {
+        token,
+        clientId: typeof payload.sub === "string" ? payload.sub : void 0,
+        scopes,
+        expiresAt: payload.exp,
+        claims: payload
+      };
+    }
+  };
+}
+
+// src/server/auth/verifiers/introspection.ts
+function introspectionVerifier(options) {
+  const cache = options.cacheTtl ? /* @__PURE__ */ new Map() : null;
+  return {
+    async verify(rawToken) {
+      if (cache) {
+        const cached = cache.get(rawToken);
+        if (cached && Date.now() < cached.expiresAt) {
+          return cached.token;
+        }
+        cache.delete(rawToken);
+      }
+      const credentials = Buffer.from(
+        `${options.credentials.clientId}:${options.credentials.clientSecret}`
+      ).toString("base64");
+      const response = await fetch(options.endpoint, {
+        method: "POST",
+        headers: {
+          "Content-Type": "application/x-www-form-urlencoded",
+          Authorization: `Basic ${credentials}`
+        },
+        body: new URLSearchParams({ token: rawToken })
+      });
+      if (!response.ok) {
+        throw new Error(`Introspection endpoint returned ${response.status}`);
+      }
+      const data = await response.json();
+      if (!data.active) {
+        throw new Error("Token is not active");
+      }
+      const accessToken = {
+        token: rawToken,
+        clientId: data.client_id,
+        scopes: data.scope ? data.scope.split(" ").filter(Boolean) : [],
+        expiresAt: data.exp,
+        claims: data
+      };
+      if (cache && options.cacheTtl) {
+        cache.set(rawToken, {
+          token: accessToken,
+          expiresAt: Date.now() + options.cacheTtl * 1e3
+        });
+      }
+      return accessToken;
+    }
+  };
+}
+
+// src/server/auth/verifiers/static.ts
+function staticTokenVerifier(map) {
+  return {
+    async verify(token) {
+      const entry = map[token];
+      if (!entry) {
+        throw new Error("Unknown token");
+      }
+      if (entry.expiresAt !== void 0 && entry.expiresAt < Math.floor(Date.now() / 1e3)) {
+        throw new Error("Token has expired");
+      }
+      return {
+        token,
+        clientId: entry.clientId,
+        scopes: entry.scopes ?? [],
+        expiresAt: entry.expiresAt,
+        claims: entry.claims ?? {}
+      };
+    }
+  };
+}
+function debugTokenVerifier() {
+  console.warn("[fastmcp] debugTokenVerifier() accepts all bearer tokens \u2014 never use in production");
+  return {
+    async verify(token) {
+      if (!token) {
+        throw new Error("Empty token");
+      }
+      return { token, scopes: [], claims: {} };
+    }
+  };
+}
+
+// src/server/auth/oauth/provider.ts
+import { randomUUID as randomUUID2 } from "crypto";
+import { UnsupportedGrantTypeError } from "@modelcontextprotocol/sdk/server/auth/errors";
+function oauthProvider(options = {}) {
+  const clients = /* @__PURE__ */ new Map();
+  const codes = /* @__PURE__ */ new Map();
+  const tokens = /* @__PURE__ */ new Map();
+  const clientsStore = {
+    async getClient(clientId) {
+      return clients.get(clientId);
+    },
+    async registerClient(client) {
+      const full = client;
+      clients.set(full.client_id, full);
+      return full;
+    }
+  };
+  return {
+    clientsStore,
+    async authorize(client, params, res) {
+      if (options.onAuthorize) {
+        return options.onAuthorize(client, params, res);
+      }
+      const code = randomUUID2();
+      codes.set(code, { client, params });
+      const redirectUrl = new URL(params.redirectUri);
+      redirectUrl.searchParams.set("code", code);
+      if (params.state) redirectUrl.searchParams.set("state", params.state);
+      res.redirect(redirectUrl.toString());
+    },
+    async challengeForAuthorizationCode(_client, authorizationCode) {
+      const data = codes.get(authorizationCode);
+      if (!data) throw new Error("Invalid authorization code");
+      return data.params.codeChallenge;
+    },
+    async exchangeAuthorizationCode(client, authorizationCode) {
+      const data = codes.get(authorizationCode);
+      if (!data) throw new Error("Invalid authorization code");
+      if (data.client.client_id !== client.client_id) {
+        throw new Error("Authorization code was not issued to this client");
+      }
+      codes.delete(authorizationCode);
+      const token = randomUUID2();
+      const ttl = options.tokenTtl ?? 3600;
+      const requestedScopes = data.params.scopes ?? [];
+      const grantedScopes = options.scopes !== void 0 ? requestedScopes.filter((s) => options.scopes.includes(s)) : requestedScopes;
+      tokens.set(token, {
+        clientId: client.client_id,
+        scopes: grantedScopes,
+        expiresAt: Math.floor(Date.now() / 1e3) + ttl
+      });
+      return {
+        access_token: token,
+        token_type: "bearer",
+        expires_in: ttl,
+        scope: grantedScopes.join(" ")
+      };
+    },
+    async exchangeRefreshToken() {
+      throw new UnsupportedGrantTypeError("Refresh tokens are not supported by this provider");
+    },
+    async verifyAccessToken(token) {
+      const data = tokens.get(token);
+      if (!data) throw new Error("Invalid token");
+      if (data.expiresAt < Math.floor(Date.now() / 1e3)) throw new Error("Token has expired");
+      return {
+        token,
+        clientId: data.clientId,
+        scopes: data.scopes,
+        expiresAt: data.expiresAt
+      };
+    }
+  };
+}
+
+// src/server/auth/oauth/proxy.ts
+function oauthProxy(options) {
+  const clients = /* @__PURE__ */ new Map();
+  const clientsStore = {
+    async getClient(clientId) {
+      return clients.get(clientId);
+    },
+    // DCR for incoming MCP clients — stored locally, not proxied upstream
+    async registerClient(client) {
+      const full = client;
+      clients.set(full.client_id, full);
+      return full;
+    }
+  };
+  return {
+    clientsStore,
+    // Let the upstream server validate PKCE — we pass code_verifier through
+    skipLocalPkceValidation: true,
+    async authorize(_client, params, res) {
+      const targetUrl = new URL(options.endpoints.authorizationUrl);
+      targetUrl.searchParams.set("client_id", options.upstreamCredentials.clientId);
+      targetUrl.searchParams.set("response_type", "code");
+      targetUrl.searchParams.set("redirect_uri", params.redirectUri);
+      targetUrl.searchParams.set("code_challenge", params.codeChallenge);
+      targetUrl.searchParams.set("code_challenge_method", "S256");
+      if (params.state) targetUrl.searchParams.set("state", params.state);
+      if (params.scopes?.length) targetUrl.searchParams.set("scope", params.scopes.join(" "));
+      res.redirect(targetUrl.toString());
+    },
+    async challengeForAuthorizationCode() {
+      return "";
+    },
+    async exchangeAuthorizationCode(_client, authorizationCode, codeVerifier, redirectUri) {
+      const body = new URLSearchParams({
+        grant_type: "authorization_code",
+        client_id: options.upstreamCredentials.clientId,
+        code: authorizationCode
+      });
+      if (options.upstreamCredentials.clientSecret) {
+        body.set("client_secret", options.upstreamCredentials.clientSecret);
+      }
+      if (codeVerifier) body.set("code_verifier", codeVerifier);
+      if (redirectUri) body.set("redirect_uri", redirectUri);
+      const response = await fetch(options.endpoints.tokenUrl, {
+        method: "POST",
+        headers: { "Content-Type": "application/x-www-form-urlencoded" },
+        body: body.toString()
+      });
+      if (!response.ok) {
+        await response.body?.cancel();
+        throw new Error(`Upstream token exchange failed: ${response.status}`);
+      }
+      return response.json();
+    },
+    async exchangeRefreshToken(_client, refreshToken, scopes) {
+      const body = new URLSearchParams({
+        grant_type: "refresh_token",
+        client_id: options.upstreamCredentials.clientId,
+        refresh_token: refreshToken
+      });
+      if (options.upstreamCredentials.clientSecret) {
+        body.set("client_secret", options.upstreamCredentials.clientSecret);
+      }
+      if (scopes?.length) body.set("scope", scopes.join(" "));
+      const response = await fetch(options.endpoints.tokenUrl, {
+        method: "POST",
+        headers: { "Content-Type": "application/x-www-form-urlencoded" },
+        body: body.toString()
+      });
+      if (!response.ok) {
+        await response.body?.cancel();
+        throw new Error(`Upstream token refresh failed: ${response.status}`);
+      }
+      return response.json();
+    },
+    verifyAccessToken: options.verifyAccessToken,
+    ...options.endpoints.revocationUrl ? {
+      async revokeToken(_client, request) {
+        const body = new URLSearchParams({
+          token: request.token,
+          client_id: options.upstreamCredentials.clientId
+        });
+        if (options.upstreamCredentials.clientSecret) {
+          body.set("client_secret", options.upstreamCredentials.clientSecret);
+        }
+        if (request.token_type_hint) {
+          body.set("token_type_hint", request.token_type_hint);
+        }
+        const response = await fetch(options.endpoints.revocationUrl, {
+          method: "POST",
+          headers: { "Content-Type": "application/x-www-form-urlencoded" },
+          body: body.toString()
+        });
+        if (!response.ok) {
+          await response.body?.cancel();
+        }
+      }
+    } : {}
+  };
+}
+
+// src/server/proxy.ts
+import { Client } from "@modelcontextprotocol/sdk/client/index";
+import {
+  CallToolResultSchema,
+  ToolListChangedNotificationSchema,
+  ResourceListChangedNotificationSchema,
+  PromptListChangedNotificationSchema
+} from "@modelcontextprotocol/sdk/types";
+import { parseTemplate } from "url-template";
+async function buildProxyFromClient(client, options) {
+  const cacheTtl = options?.cacheTtl ?? 3e4;
+  const serverInfo = client.getServerVersion();
+  const proxyName = options?.name ?? serverInfo?.name ?? "proxy";
+  const proxyVersion = serverInfo?.version ?? "0.0.1";
+  const proxy = new FastMCP({ name: proxyName, version: proxyVersion });
+  const proxiedTools = /* @__PURE__ */ new Set();
+  const proxiedResources = /* @__PURE__ */ new Set();
+  const proxiedPrompts = /* @__PURE__ */ new Set();
+  const lastSync = { tools: 0, resources: 0, prompts: 0 };
+  async function resyncTools() {
+    const tools = [];
+    let cursor;
+    do {
+      const page = await client.listTools({ cursor });
+      tools.push(...page.tools);
+      cursor = page.nextCursor;
+    } while (cursor);
+    const incoming = new Set(tools.map((t) => t.name));
+    for (const name of proxiedTools) {
+      if (!incoming.has(name)) {
+        proxy._removeTool(name);
+        proxiedTools.delete(name);
+      }
+    }
+    for (const tool of tools) {
+      if (proxiedTools.has(tool.name)) {
+        proxy._removeTool(tool.name);
+        proxiedTools.delete(tool.name);
+      }
+      proxy.tool(
+        {
+          name: tool.name,
+          ...tool.title !== void 0 ? { title: tool.title } : {},
+          description: tool.description ?? tool.name,
+          inputSchema: tool.inputSchema ?? {}
+        },
+        async (args) => {
+          const result = await client.callTool(
+            { name: tool.name, arguments: args },
+            CallToolResultSchema
+          );
+          return new ToolResult(result);
+        }
+      );
+      proxiedTools.add(tool.name);
+    }
+    lastSync.tools = Date.now();
+  }
+  async function resyncResources() {
+    const incoming = /* @__PURE__ */ new Set();
+    try {
+      const resources = [];
+      let cursor;
+      do {
+        const page = await client.listResources({ cursor });
+        resources.push(...page.resources);
+        cursor = page.nextCursor;
+      } while (cursor);
+      for (const resource of resources) {
+        incoming.add(resource.uri);
+        if (!proxiedResources.has(resource.uri)) {
+          proxy.resource(
+            {
+              uri: resource.uri,
+              name: resource.name,
+              ...resource.description !== void 0 ? { description: resource.description } : {},
+              ...resource.mimeType !== void 0 ? { mimeType: resource.mimeType } : {}
+            },
+            async () => {
+              const result = await client.readResource({ uri: resource.uri });
+              return new ResourceResult(
+                result.contents
+              );
+            }
+          );
+          proxiedResources.add(resource.uri);
+        }
+      }
+    } catch {
+    }
+    try {
+      const resourceTemplates = [];
+      let templateCursor;
+      do {
+        const page = await client.listResourceTemplates({ cursor: templateCursor });
+        resourceTemplates.push(...page.resourceTemplates);
+        templateCursor = page.nextCursor;
+      } while (templateCursor);
+      for (const template of resourceTemplates) {
+        const uriTemplate = template.uriTemplate;
+        incoming.add(uriTemplate);
+        if (!proxiedResources.has(uriTemplate)) {
+          const expander = parseTemplate(uriTemplate);
+          proxy.resource(
+            {
+              uri: uriTemplate,
+              name: template.name,
+              ...template.description !== void 0 ? { description: template.description } : {},
+              ...template.mimeType !== void 0 ? { mimeType: template.mimeType } : {}
+            },
+            async (params) => {
+              const actualUri = params ? expander.expand(params) : uriTemplate;
+              const result = await client.readResource({ uri: actualUri });
+              return new ResourceResult(
+                result.contents
+              );
+            }
+          );
+          proxiedResources.add(uriTemplate);
+        }
+      }
+    } catch {
+    }
+    for (const uri of proxiedResources) {
+      if (!incoming.has(uri)) {
+        proxy._removeResource(uri);
+        proxiedResources.delete(uri);
+      }
+    }
+    lastSync.resources = Date.now();
+  }
+  async function resyncPrompts() {
+    const prompts = [];
+    let cursor;
+    do {
+      const page = await client.listPrompts({ cursor });
+      prompts.push(...page.prompts);
+      cursor = page.nextCursor;
+    } while (cursor);
+    const incoming = new Set(prompts.map((p) => p.name));
+    for (const name of proxiedPrompts) {
+      if (!incoming.has(name)) {
+        proxy._removePrompt(name);
+        proxiedPrompts.delete(name);
+      }
+    }
+    for (const prompt of prompts) {
+      if (!proxiedPrompts.has(prompt.name)) {
+        proxy.prompt(
+          {
+            name: prompt.name,
+            description: prompt.description,
+            ...prompt.arguments?.length ? { arguments: prompt.arguments } : {}
+          },
+          async (args) => {
+            const result = await client.getPrompt({ name: prompt.name, arguments: args });
+            return new PromptResult(result.messages, result.description);
+          }
+        );
+        proxiedPrompts.add(prompt.name);
+      }
+    }
+    lastSync.prompts = Date.now();
+  }
+  await Promise.all([
+    resyncTools().catch(() => {
+    }),
+    resyncResources().catch(() => {
+    }),
+    resyncPrompts().catch(() => {
+    })
+  ]);
+  client.setNotificationHandler(ToolListChangedNotificationSchema, () => {
+    resyncTools().catch(() => {
+    });
+  });
+  client.setNotificationHandler(ResourceListChangedNotificationSchema, () => {
+    resyncResources().catch(() => {
+    });
+  });
+  client.setNotificationHandler(PromptListChangedNotificationSchema, () => {
+    resyncPrompts().catch(() => {
+    });
+  });
+  if (cacheTtl > 0) {
+    proxy.use({
+      async onListTools(ctx, next) {
+        if (Date.now() - lastSync.tools > cacheTtl) await resyncTools().catch(() => {
+        });
+        return next();
+      },
+      async onListResources(ctx, next) {
+        if (Date.now() - lastSync.resources > cacheTtl) await resyncResources().catch(() => {
+        });
+        return next();
+      },
+      async onListResourceTemplates(ctx, next) {
+        if (Date.now() - lastSync.resources > cacheTtl) await resyncResources().catch(() => {
+        });
+        return next();
+      },
+      async onListPrompts(ctx, next) {
+        if (Date.now() - lastSync.prompts > cacheTtl) await resyncPrompts().catch(() => {
+        });
+        return next();
+      }
+    });
+  }
+  proxy._addCloseCallback(async () => {
+    await client.close();
+  });
+  return proxy;
+}
+async function createProxy(config, name) {
+  let transport;
+  if (config.type === "stdio") {
+    const { StdioClientTransport } = await import("@modelcontextprotocol/sdk/client/stdio");
+    transport = new StdioClientTransport({
+      command: config.command,
+      args: config.args,
+      env: config.env,
+      cwd: config.cwd
+    });
+  } else {
+    const { StreamableHTTPClientTransport } = await import("@modelcontextprotocol/sdk/client/streamableHttp");
+    transport = new StreamableHTTPClientTransport(new URL(config.url), {
+      requestInit: config.requestInit
+    });
+  }
+  const client = new Client(
+    { name: name ?? "fastmcp-proxy", version: "0.0.1" },
+    { capabilities: {} }
+  );
+  await client.connect(transport);
+  return buildProxyFromClient(client, { cacheTtl: config.cacheTtl, name });
+}
+
+// src/server/apps/FastMCPApp.ts
+var FastMCPApp = class {
+  server;
+  constructor(options) {
+    this.server = new FastMCP({ name: options.name, version: options.version });
+  }
+  /**
+   * Register an entry-point tool.
+   * Entry-points are visible to the LLM (visibility: ['model', 'app']) and
+   * automatically linked to a generated ui:// resource URI.
+   */
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  entrypoint(config, handler) {
+    const resourceUri = `ui://${config.name}`;
+    const toolConfig = {
+      name: config.name,
+      description: config.description,
+      ...config.title !== void 0 ? { title: config.title } : {},
+      ui: { visibility: ["model", "app"], resourceUri }
+    };
+    this.server.tool(toolConfig, handler);
+    this.server.resource(
+      { uri: resourceUri, mimeType: "text/html;profile=mcp-app", name: config.name },
+      () => `<!doctype html><html><head><meta charset="utf-8"></head><body><!-- fastmcp ui-runtime placeholder --></body></html>`
+    );
+  }
+  /**
+   * Register a backend tool.
+   * Backend tools are hidden from listTools by default (visibility: ['app']).
+   */
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  backendTool(config, handler) {
+    const visibility = config.visibility ?? ["app"];
+    const toolConfig = {
+      name: config.name,
+      description: config.description,
+      ...config.title !== void 0 ? { title: config.title } : {},
+      ui: { visibility }
+    };
+    this.server.tool(toolConfig, handler);
+  }
+  /**
+   * Returns a reference to a tool that resolves to the correct external name
+   * (including any mount prefix) when evaluated inside a request handler.
+   * Call inside a handler function — not at definition time.
+   */
+  toolRef(name) {
+    const ctx = contextStore.getStore();
+    if (!ctx) return name;
+    return ctx.resolveToolName(name);
+  }
+};
+
+// src/server/apps/actionRef.ts
+function actionRef(name) {
+  return contextStore.getStore()?.resolveToolName(name) ?? name;
+}
+
+// src/server/apps/generative.ts
+import { runInNewContext } from "vm";
+
+// src/server/apps/components.ts
+var components_exports = {};
+__export(components_exports, {
+  Area: () => Area,
+  Badge: () => Badge,
+  Bar: () => Bar,
+  Button: () => Button,
+  COMPONENT_CATALOG: () => COMPONENT_CATALOG,
+  Column: () => Column,
+  ForEach: () => ForEach,
+  Grid: () => Grid,
+  If: () => If,
+  Input: () => Input,
+  Line: () => Line,
+  Pie: () => Pie,
+  Row: () => Row,
+  Rx: () => Rx,
+  Select: () => Select,
+  Table: () => Table,
+  Text: () => Text
+});
+var COMPONENT_CATALOG = [
+  { type: "column", description: "Vertical stack layout. Props: gap, align, padding. Children: any components." },
+  { type: "row", description: "Horizontal stack layout. Props: gap, align, justify, wrap. Children: any components." },
+  { type: "grid", description: "CSS grid layout. Props: columns, gap. Children: any components." },
+  { type: "text", description: "Text display. Props: content (string or Rx), variant (heading|body|caption|code), color." },
+  { type: "badge", description: "Status badge. Props: text, color, variant." },
+  { type: "table", description: "Data table. Props: columns (string[]), rows (string[][]). No children." },
+  { type: "chart-bar", description: "Bar chart. Props: data (object[]), xKey, yKey, title." },
+  { type: "chart-line", description: "Line chart. Props: data (object[]), xKey, yKey, title." },
+  { type: "chart-area", description: "Area chart. Props: data (object[]), xKey, yKey, title." },
+  { type: "chart-pie", description: "Pie chart. Props: data (object[]), labelKey, valueKey, title." },
+  { type: "input", description: "Form text input. Props: name, label, type (text|email|number|password), placeholder, required." },
+  { type: "select", description: "Dropdown select. Props: name, label, options (string[] or {value,label}[]), required." },
+  { type: "button", description: "Clickable button. Props: label, action (tool name string), variant, disabled." },
+  { type: "if", description: "Conditional rendering. branches: [{condition, node}], fallback." },
+  { type: "foreach", description: "Dynamic list. Props: items (binding expression). Children: [template]." },
+  { type: "rx", description: "Reactive value. Props: expression (client-side state binding). Embeddable as prop." }
+];
+function withChildren(type, props, children) {
+  const node = { type };
+  if (props && Object.keys(props).length > 0) node.props = props;
+  if (children && children.length > 0) node.children = children;
+  return node;
+}
+function withProps(type, props) {
+  return { type, props };
+}
+function Column(props, children) {
+  return withChildren("column", props, children);
+}
+function Row(props, children) {
+  return withChildren("row", props, children);
+}
+function Grid(props, children) {
+  return withChildren("grid", props, children);
+}
+function Text(content, extraProps) {
+  return withProps("text", { content, ...extraProps });
+}
+function Badge(text, extraProps) {
+  return withProps("badge", { text, ...extraProps });
+}
+function Table(props) {
+  return withProps("table", props);
+}
+function Bar(props) {
+  return withProps("chart-bar", props);
+}
+function Line(props) {
+  return withProps("chart-line", props);
+}
+function Area(props) {
+  return withProps("chart-area", props);
+}
+function Pie(props) {
+  return withProps("chart-pie", props);
+}
+function Input(props) {
+  return withProps("input", props);
+}
+function Select(props) {
+  return withProps("select", props);
+}
+function Button(props) {
+  return withProps("button", props);
+}
+function makeIfNode(branches, fallback) {
+  const node = { type: "if", branches, ...fallback !== void 0 ? { fallback } : {} };
+  Object.defineProperty(node, "elif", {
+    enumerable: false,
+    value(condition, child) {
+      return makeIfNode([...branches, { condition, node: child }], fallback);
+    }
+  });
+  Object.defineProperty(node, "else", {
+    enumerable: false,
+    value(child) {
+      return makeIfNode(branches, child);
+    }
+  });
+  return node;
+}
+function If(condition, then, fallback) {
+  return makeIfNode([{ condition, node: then }], fallback);
+}
+function ForEach(items, template) {
+  return { type: "foreach", props: { items }, children: [template] };
+}
+function Rx(expression) {
+  return withProps("rx", { expression });
+}
+
+// src/server/apps/generative.ts
+var GenerativeUI = class {
+  server;
+  constructor() {
+    this.server = new FastMCP({ name: "generative-ui" });
+    this.server.tool(
+      {
+        name: "search_components",
+        description: "List available UI components with their types and descriptions"
+      },
+      () => new ToolResult({
+        content: [{ type: "text", text: JSON.stringify(COMPONENT_CATALOG) }]
+      })
+    );
+    this.server.tool(
+      {
+        name: "generate_ui",
+        description: "Execute a UI component expression and return the component tree. Use search_components to discover available component APIs first.",
+        inputSchema: {
+          type: "object",
+          properties: {
+            code: { type: "string", description: "A JavaScript expression using the component builders (Column, Text, Button, etc.) that evaluates to a component tree" }
+          },
+          required: ["code"]
+        }
+      },
+      (args) => {
+        const { code } = args;
+        const sandbox = { ...components_exports };
+        delete sandbox["COMPONENT_CATALOG"];
+        try {
+          return runInNewContext(code, sandbox, { timeout: 2e3 });
+        } catch (err) {
+          throw new Error(`[generate_ui] ${err instanceof Error ? err.message : String(err)}`);
+        }
+      }
+    );
+  }
+};
+
+// src/server/apps/providers/Approval.ts
+var Approval = class {
+  server;
+  constructor() {
+    this.server = new FastMCP({ name: "approval" });
+    this.server.tool(
+      {
+        name: "approval_request",
+        description: "Present a confirm/deny approval card to the user",
+        inputSchema: {
+          type: "object",
+          properties: {
+            message: { type: "string", description: "The question or action to seek approval for" }
+          },
+          required: ["message"]
+        },
+        ui: { visibility: ["model", "app"] }
+      },
+      (args) => {
+        const message = args.message ?? "Approve?";
+        return Column({}, [
+          Text(message),
+          Button({ label: "Confirm", action: actionRef("approval_confirm") }),
+          Button({ label: "Deny", action: actionRef("approval_deny"), variant: "secondary" })
+        ]);
+      }
+    );
+    this.server.resource(
+      { uri: "ui://approval_request", mimeType: "text/html;profile=mcp-app", name: "approval_request" },
+      () => `<!doctype html><html><head><meta charset="utf-8"></head><body><!-- fastmcp ui-runtime placeholder --></body></html>`
+    );
+    this.server.tool(
+      {
+        name: "approval_confirm",
+        description: "Record a confirmed approval decision",
+        ui: { visibility: ["app"] }
+      },
+      () => ({ decision: "approved" })
+    );
+    this.server.tool(
+      {
+        name: "approval_deny",
+        description: "Record a denied approval decision",
+        ui: { visibility: ["app"] }
+      },
+      () => ({ decision: "denied" })
+    );
+  }
+};
+
+// src/server/apps/providers/Choice.ts
+var Choice = class {
+  server;
+  constructor() {
+    this.server = new FastMCP({ name: "choice" });
+    this.server.tool(
+      {
+        name: "choice_present",
+        description: "Present a list of options for the user to choose from",
+        inputSchema: {
+          type: "object",
+          properties: {
+            question: { type: "string", description: "The question to ask the user" },
+            options: { type: "array", items: { type: "string" }, description: "The options to present" }
+          },
+          required: ["question", "options"]
+        },
+        ui: { visibility: ["model", "app"] }
+      },
+      (args) => {
+        const options = args.options ?? [];
+        return Row(
+          {},
+          // Each button carries its option value as args so the host can
+          // forward it to choice_select without extra state.
+          options.map(
+            (opt) => Button({ label: opt, action: actionRef("choice_select"), args: { option: opt } })
+          )
+        );
+      }
+    );
+    this.server.resource(
+      { uri: "ui://choice_present", mimeType: "text/html;profile=mcp-app", name: "choice_present" },
+      () => `<!doctype html><html><head><meta charset="utf-8"></head><body><!-- fastmcp ui-runtime placeholder --></body></html>`
+    );
+    this.server.tool(
+      {
+        name: "choice_select",
+        description: "Record the user's selection",
+        ui: { visibility: ["app"] }
+      },
+      (args) => ({ selected: args.option })
+    );
+  }
+};
+
+// src/server/apps/providers/FileUpload.ts
+import { randomUUID as randomUUID3 } from "crypto";
+function makeInMemoryAdapter() {
+  const store = /* @__PURE__ */ new Map();
+  return {
+    save: (handle, file) => store.set(handle, file),
+    load: (handle) => store.get(handle),
+    delete: (handle) => store.delete(handle)
+  };
+}
+var SESSION_HANDLES_KEY = "__fastmcp_file_handles";
+var FileUpload = class {
+  server;
+  _storage;
+  constructor(options) {
+    this._storage = options?.storage ?? makeInMemoryAdapter();
+    this.server = new FastMCP({ name: "file-upload" });
+    const storage = this._storage;
+    this.server.tool(
+      {
+        name: "file_upload_open",
+        description: "Open a file picker UI for the user to upload a file",
+        inputSchema: {
+          type: "object",
+          properties: {
+            prompt: { type: "string", description: "Instructions shown above the file picker" }
+          }
+        },
+        ui: { visibility: ["model", "app"] }
+      },
+      (args) => {
+        return Column({}, [
+          Text(args.prompt ?? "Upload a file"),
+          Button({ label: "Choose file", action: actionRef("file_upload_submit") })
+        ]);
+      }
+    );
+    this.server.tool(
+      {
+        name: "file_upload_submit",
+        description: "Receive and store uploaded file bytes server-side",
+        inputSchema: {
+          type: "object",
+          properties: {
+            name: { type: "string", description: "File name" },
+            mimeType: { type: "string", description: "MIME type of the file" },
+            data: { type: "string", description: "Base64-encoded file content" }
+          },
+          required: ["name", "mimeType", "data"]
+        },
+        ui: { visibility: ["app"] }
+      },
+      (args) => {
+        const handle = randomUUID3();
+        const fileData = Buffer.from(args.data, "base64");
+        storage.save(handle, {
+          handle,
+          name: args.name,
+          mimeType: args.mimeType,
+          data: fileData
+        });
+        const ctx = contextStore.getStore();
+        if (ctx) {
+          const existing = ctx.getState(SESSION_HANDLES_KEY) ?? [];
+          ctx.setState(SESSION_HANDLES_KEY, [...existing, handle]);
+          ctx.onClose(() => storage.delete(handle));
+        }
+        const uri = `ui://files/${handle}`;
+        return { handle, uri };
+      }
+    );
+    this.server.tool(
+      {
+        name: "file_upload_delete",
+        description: "Delete a previously uploaded file by its handle",
+        inputSchema: {
+          type: "object",
+          properties: {
+            handle: { type: "string", description: "The file handle returned by file_upload_submit" }
+          },
+          required: ["handle"]
+        },
+        ui: { visibility: ["app"] }
+      },
+      (args) => {
+        const handle = args.handle;
+        storage.delete(handle);
+        const ctx = contextStore.getStore();
+        if (ctx) {
+          const existing = ctx.getState(SESSION_HANDLES_KEY) ?? [];
+          ctx.setState(SESSION_HANDLES_KEY, existing.filter((h) => h !== handle));
+        }
+        return { deleted: handle };
+      }
+    );
+    this.server.resource(
+      { uri: "ui://files/{handle}", name: "uploaded-file", mimeType: "application/octet-stream" },
+      (params) => {
+        const h = params?.handle;
+        if (!h) throw new Error("Missing file handle");
+        const file = storage.load(h);
+        if (!file) throw new Error(`File not found: ${h}`);
+        const uri = `ui://files/${h}`;
+        if (file.mimeType.startsWith("text/")) {
+          return new ResourceResult([{ uri, mimeType: file.mimeType, text: file.data.toString("utf8") }]);
+        }
+        return new ResourceResult([{ uri, mimeType: file.mimeType, blob: file.data.toString("base64") }]);
+      }
+    );
+  }
+};
+
+// src/server/apps/providers/FormInput.ts
+function buildField(fieldName, fieldSchema, required) {
+  const isRequired = required.includes(fieldName);
+  const type = fieldSchema.type;
+  if (Array.isArray(fieldSchema.enum)) {
+    return Select({ name: fieldName, label: fieldName, options: fieldSchema.enum, required: isRequired });
+  }
+  if (type === "number" || type === "integer") {
+    return Input({ name: fieldName, label: fieldName, type: "number", required: isRequired });
+  }
+  return Input({ name: fieldName, label: fieldName, type: "text", required: isRequired });
+}
+async function validateWithSchema(schema, data) {
+  const result = await schema["~standard"].validate(data);
+  if (result.issues && result.issues.length > 0) {
+    const errors = {};
+    for (const issue of result.issues) {
+      const path = issue.path?.map((p) => String(typeof p === "object" ? p.key : p)).join(".") ?? "root";
+      errors[path] = String(issue.message);
+    }
+    return { valid: false, errors };
+  }
+  return { valid: true, value: result.value };
+}
+var FormInput = class {
+  server;
+  constructor(options) {
+    this.server = new FastMCP({ name: options.name });
+    const { name, description, schema } = options;
+    const submitName = `${name}_submit`;
+    this.server.resource(
+      { uri: `ui://${name}`, mimeType: "text/html;profile=mcp-app", name },
+      () => `<!doctype html><html><head><meta charset="utf-8"></head><body><!-- fastmcp ui-runtime placeholder --></body></html>`
+    );
+    this.server.tool(
+      { name, description, ui: { visibility: ["model", "app"] } },
+      async () => {
+        const jsonSchema = await toJsonSchema(schema, `form "${name}"`);
+        const properties = jsonSchema.properties ?? {};
+        const required = jsonSchema.required ?? [];
+        const fields = Object.entries(properties).map(
+          ([fieldName, fieldSchema]) => buildField(fieldName, fieldSchema, required)
+        );
+        return Column({}, [...fields, Button({ label: "Submit", action: actionRef(submitName) })]);
+      }
+    );
+    this.server.tool(
+      {
+        name: submitName,
+        description: `Submit ${name} form data`,
+        inputSchema: {
+          type: "object",
+          properties: {
+            data: { type: "object", description: "Form field values keyed by field name" }
+          },
+          required: ["data"]
+        },
+        ui: { visibility: ["app"] }
+      },
+      async (args) => {
+        const result = await validateWithSchema(schema, args.data);
+        if (!result.valid) {
+          return { errors: result.errors };
+        }
+        return result.value;
+      }
+    );
+  }
+};
+export {
+  Approval,
+  Area,
+  AuthorizationError,
+  Badge,
+  Bar,
+  Button,
+  CachingMiddleware,
+  CancellationMiddleware,
+  Choice,
+  Column,
+  ErrorNormalizationMiddleware,
+  FastMCP,
+  FastMCPApp,
+  File,
+  FileUpload,
+  FilterTransform,
+  ForEach,
+  FormInput,
+  GenerativeUI,
+  Grid,
+  If,
+  Image,
+  Input,
+  Line,
+  LoggingMiddleware,
+  NamespaceTransform,
+  Pie,
+  PromptResult,
+  PromptsAsTools,
+  RateLimitingMiddleware,
+  ResourceResult,
+  ResourcesAsTools,
+  Row,
+  Rx,
+  Select,
+  SizeLimitingMiddleware,
+  Table,
+  Text,
+  ToolResult,
+  VersionFilter,
+  actionRef,
+  createProxy,
+  debugTokenVerifier,
+  introspectionVerifier,
+  jwtVerifier,
+  multiAuth,
+  oauthProvider,
+  oauthProxy,
+  redescribeTool,
+  renameTool,
+  requireScopes,
+  staticTokenVerifier
+};
+//# sourceMappingURL=server.js.map