fastmcp/dist/chunk-WPAZXREN.js

A TypeScript framework for building MCP servers.

// src/FastMCP.ts
import { Server } from "@modelcontextprotocol/sdk/server/index.js";
import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
import {
  CallToolRequestSchema,
  CompleteRequestSchema,
  ErrorCode,
  GetPromptRequestSchema,
  ListPromptsRequestSchema,
  ListResourcesRequestSchema,
  ListResourceTemplatesRequestSchema,
  ListToolsRequestSchema,
  McpError,
  ReadResourceRequestSchema,
  RootsListChangedNotificationSchema,
  SetLevelRequestSchema,
  SubscribeRequestSchema,
  UnsubscribeRequestSchema
} from "@modelcontextprotocol/sdk/types.js";
import { EventEmitter } from "events";
import { readFile } from "fs/promises";
import Fuse from "fuse.js";
import { Hono } from "hono";
import { startHTTPServer } from "mcp-proxy";
import { setTimeout as delay } from "timers/promises";
import { fetch as fetch2 } from "undici";
import parseURITemplate from "uri-templates";
import { strictJsonSchema, toJsonSchema } from "xsschema";
import { z } from "zod";

// src/DiscoveryDocumentCache.ts
var DiscoveryDocumentCache = class {
  get size() {
    return this.#cache.size;
  }
  #cache = /* @__PURE__ */ new Map();
  #inFlight = /* @__PURE__ */ new Map();
  #ttl;
  /**
   * @param options - configuration options
   * @param options.ttl - time-to-live in miliseconds
   */
  constructor(options = {}) {
    this.#ttl = options.ttl ?? 36e5;
  }
  /**
   * @param url - optional URL to clear. if omitted, clears all cached documents.
   */
  clear(url) {
    if (url) {
      this.#cache.delete(url);
    } else {
      this.#cache.clear();
    }
  }
  /**
   * fetches a discovery document from the given URL.
   * uses cached value if available and not expired.
   * coalesces concurrent requests for the same URL to prevent duplicate fetches.
   *
   * @param url - the discovery document URL (e.g., /.well-known/openid-configuration)
   * @returns the discovery document as a JSON object
   * @throws Error if the fetch fails or returns non-OK status
   */
  async get(url) {
    const now = Date.now();
    const cached = this.#cache.get(url);
    if (cached && cached.expiresAt > now) {
      return cached.data;
    }
    const inFlight = this.#inFlight.get(url);
    if (inFlight) {
      return inFlight;
    }
    const fetchPromise = this.#fetchAndCache(url);
    this.#inFlight.set(url, fetchPromise);
    try {
      const data = await fetchPromise;
      return data;
    } finally {
      this.#inFlight.delete(url);
    }
  }
  /**
   * @param url - the URL to check
   * @returns true if the URL is cached and nott expired
   */
  has(url) {
    const cached = this.#cache.get(url);
    if (!cached) {
      return false;
    }
    const now = Date.now();
    if (cached.expiresAt <= now) {
      this.#cache.delete(url);
      return false;
    }
    return true;
  }
  async #fetchAndCache(url) {
    const res = await fetch(url);
    if (!res.ok) {
      throw new Error(
        `Failed to fetch discovery document from ${url}: ${res.status} ${res.statusText}`
      );
    }
    const data = await res.json();
    const expiresAt = Date.now() + this.#ttl;
    this.#cache.set(url, {
      data,
      expiresAt
    });
    return data;
  }
};

// src/jsonSchemaAdapter.ts
function jsonSchemaAdapter(schema) {
  let compiled;
  const getValidator = () => {
    compiled ??= compileSchema(schema).catch((error) => {
      compiled = void 0;
      throw error;
    });
    return compiled;
  };
  return {
    "~standard": {
      jsonSchema: {
        input: () => schema,
        output: () => schema
      },
      validate: async (data) => {
        const validate = await getValidator();
        if (validate(data)) {
          return { value: data };
        }
        return { issues: (validate.errors ?? []).map(toIssue) };
      },
      vendor: "json-schema",
      version: 1
    }
  };
}
async function compileSchema(schema) {
  let ajvModule;
  try {
    ajvModule = await import("ajv");
  } catch {
    throw new Error(
      'The "ajv" package is required to validate JSON Schema tool parameters. Install it with: npm install ajv'
    );
  }
  const Ajv = unwrapDefault(unwrapDefault(ajvModule));
  const ajv = new Ajv({ allErrors: true, strict: false });
  try {
    const formatsModule = await import("ajv-formats");
    const addFormats = unwrapDefault(
      unwrapDefault(formatsModule)
    );
    addFormats(ajv);
  } catch {
  }
  return ajv.compile(schema);
}
function toIssue(error) {
  const path = error.instancePath.split("/").filter(Boolean).map((segment) => segment.replaceAll("~1", "/").replaceAll("~0", "~")).map((segment) => {
    const index = Number(segment);
    return Number.isInteger(index) && segment !== "" ? index : segment;
  });
  const missingProperty = error.params?.missingProperty;
  if (error.keyword === "required" && typeof missingProperty === "string") {
    path.push(missingProperty);
  }
  return {
    message: error.message || "Validation error",
    path
  };
}
function unwrapDefault(value) {
  return typeof value === "object" && value !== null && "default" in value ? value.default : value;
}

// src/FastMCP.ts
var imageContent = async (input) => {
  let rawData;
  try {
    if ("url" in input) {
      try {
        const response = await fetch2(input.url);
        if (!response.ok) {
          throw new Error(
            `Server responded with status: ${response.status} - ${response.statusText}`
          );
        }
        rawData = Buffer.from(await response.arrayBuffer());
      } catch (error) {
        throw new Error(
          `Failed to fetch image from URL (${input.url}): ${error instanceof Error ? error.message : String(error)}`
        );
      }
    } else if ("path" in input) {
      try {
        rawData = await readFile(input.path);
      } catch (error) {
        throw new Error(
          `Failed to read image from path (${input.path}): ${error instanceof Error ? error.message : String(error)}`
        );
      }
    } else if ("buffer" in input) {
      rawData = input.buffer;
    } else {
      throw new Error(
        "Invalid input: Provide a valid 'url', 'path', or 'buffer'"
      );
    }
    const { fileTypeFromBuffer } = await import("file-type");
    const mimeType = await fileTypeFromBuffer(rawData);
    if (!mimeType || !mimeType.mime.startsWith("image/")) {
      console.warn(
        `Warning: Content may not be a valid image. Detected MIME: ${mimeType?.mime || "unknown"}`
      );
    }
    const base64Data = rawData.toString("base64");
    return {
      data: base64Data,
      mimeType: mimeType?.mime ?? "image/png",
      type: "image"
    };
  } catch (error) {
    if (error instanceof Error) {
      throw error;
    } else {
      throw new Error(`Unexpected error processing image: ${String(error)}`);
    }
  }
};
var audioContent = async (input) => {
  let rawData;
  try {
    if ("url" in input) {
      try {
        const response = await fetch2(input.url);
        if (!response.ok) {
          throw new Error(
            `Server responded with status: ${response.status} - ${response.statusText}`
          );
        }
        rawData = Buffer.from(await response.arrayBuffer());
      } catch (error) {
        throw new Error(
          `Failed to fetch audio from URL (${input.url}): ${error instanceof Error ? error.message : String(error)}`
        );
      }
    } else if ("path" in input) {
      try {
        rawData = await readFile(input.path);
      } catch (error) {
        throw new Error(
          `Failed to read audio from path (${input.path}): ${error instanceof Error ? error.message : String(error)}`
        );
      }
    } else if ("buffer" in input) {
      rawData = input.buffer;
    } else {
      throw new Error(
        "Invalid input: Provide a valid 'url', 'path', or 'buffer'"
      );
    }
    const { fileTypeFromBuffer } = await import("file-type");
    const mimeType = await fileTypeFromBuffer(rawData);
    if (!mimeType || !mimeType.mime.startsWith("audio/")) {
      console.warn(
        `Warning: Content may not be a valid audio file. Detected MIME: ${mimeType?.mime || "unknown"}`
      );
    }
    const base64Data = rawData.toString("base64");
    return {
      data: base64Data,
      mimeType: mimeType?.mime ?? "audio/mpeg",
      type: "audio"
    };
  } catch (error) {
    if (error instanceof Error) {
      throw error;
    } else {
      throw new Error(`Unexpected error processing audio: ${String(error)}`);
    }
  }
};
var FastMCPError = class extends Error {
  constructor(message) {
    super(message);
    this.name = new.target.name;
  }
};
var UnexpectedStateError = class extends FastMCPError {
  extras;
  constructor(message, extras) {
    super(message);
    this.name = new.target.name;
    this.extras = extras;
  }
};
var UserError = class extends UnexpectedStateError {
};
var TextContentZodSchema = z.object({
  /**
   * The text content of the message.
   */
  text: z.string(),
  type: z.literal("text")
}).strict();
var ImageContentZodSchema = z.object({
  /**
   * The base64-encoded image data.
   */
  data: z.string().base64(),
  /**
   * The MIME type of the image. Different providers may support different image types.
   */
  mimeType: z.string(),
  type: z.literal("image")
}).strict();
var AudioContentZodSchema = z.object({
  /**
   * The base64-encoded audio data.
   */
  data: z.string().base64(),
  mimeType: z.string(),
  type: z.literal("audio")
}).strict();
var ResourceContentZodSchema = z.object({
  resource: z.object({
    blob: z.string().optional(),
    mimeType: z.string().optional(),
    text: z.string().optional(),
    uri: z.string()
  }),
  type: z.literal("resource")
}).strict();
var ResourceLinkZodSchema = z.object({
  description: z.string().optional(),
  mimeType: z.string().optional(),
  name: z.string(),
  title: z.string().optional(),
  type: z.literal("resource_link"),
  uri: z.string()
});
var ContentZodSchema = z.discriminatedUnion("type", [
  TextContentZodSchema,
  ImageContentZodSchema,
  AudioContentZodSchema,
  ResourceContentZodSchema,
  ResourceLinkZodSchema
]);
var ContentResultZodSchema = z.object({
  _meta: z.record(z.string(), z.unknown()).optional(),
  content: ContentZodSchema.array(),
  isError: z.boolean().optional(),
  structuredContent: z.record(z.string(), z.unknown()).optional()
}).strict();
var CompletionZodSchema = z.object({
  /**
   * Indicates whether there are additional completion options beyond those provided in the current response, even if the exact total is unknown.
   */
  hasMore: z.optional(z.boolean()),
  /**
   * The total number of completion options available. This can exceed the number of values actually sent in the response.
   */
  total: z.optional(z.number().int()),
  /**
   * An array of completion values. Must not exceed 100 items.
   */
  values: z.array(z.string()).max(100)
});
var FastMCPSessionEventEmitterBase = EventEmitter;
var ServerState = /* @__PURE__ */ ((ServerState2) => {
  ServerState2["Error"] = "error";
  ServerState2["Running"] = "running";
  ServerState2["Stopped"] = "stopped";
  return ServerState2;
})(ServerState || {});
var FastMCPSessionEventEmitter = class extends FastMCPSessionEventEmitterBase {
};
var FastMCPSession = class extends FastMCPSessionEventEmitter {
  get clientCapabilities() {
    return this.#clientCapabilities ?? null;
  }
  get isReady() {
    return this.#connectionState === "ready";
  }
  get loggingLevel() {
    return this.#loggingLevel;
  }
  get roots() {
    return this.#roots;
  }
  get server() {
    return this.#server;
  }
  get sessionId() {
    return this.#sessionId;
  }
  set sessionId(value) {
    this.#sessionId = value;
  }
  #auth;
  #capabilities = {};
  #clientCapabilities;
  #connectionState = "connecting";
  #logger;
  #loggingLevel = "info";
  #needsEventLoopFlush = false;
  #onToolCall;
  #pingConfig;
  #pingInterval = null;
  #prompts = /* @__PURE__ */ new Map();
  #resources = /* @__PURE__ */ new Map();
  #resourceTemplates = /* @__PURE__ */ new Map();
  #roots = [];
  #rootsConfig;
  #server;
  /**
   * Session ID from the Mcp-Session-Id header (HTTP transports only).
   * Used to track per-session state across multiple requests.
   */
  #sessionId;
  /**
   * Whether this session serves a single stateless HTTP request. The client
   * handshake belongs to a different session — potentially on a different
   * instance — so capabilities can never be inferred here.
   */
  #stateless;
  /**
   * Resource URIs the connected client has subscribed to via
   * `resources/subscribe`. Used to scope `notifications/resources/updated`
   * to interested clients only.
   */
  #subscriptions = /* @__PURE__ */ new Set();
  #utils;
  constructor({
    auth,
    instructions,
    logger,
    name,
    onToolCall,
    ping,
    prompts,
    resources,
    resourcesTemplates,
    roots,
    sessionId,
    stateless = false,
    tools,
    transportType,
    utils,
    version
  }) {
    super();
    this.#auth = auth;
    this.#logger = logger;
    this.#onToolCall = onToolCall;
    this.#pingConfig = ping;
    this.#rootsConfig = roots;
    this.#sessionId = sessionId;
    this.#stateless = stateless;
    this.#needsEventLoopFlush = transportType === "httpStream";
    if (tools.length) {
      this.#capabilities.tools = {};
    }
    if (resources.length || resourcesTemplates.length) {
      this.#capabilities.resources = { listChanged: true, subscribe: true };
    }
    if (prompts.length) {
      for (const prompt of prompts) {
        this.addPrompt(prompt);
      }
      this.#capabilities.prompts = { listChanged: true };
    }
    this.#capabilities.logging = {};
    this.#capabilities.completions = {};
    this.#server = new Server(
      { name, version },
      { capabilities: this.#capabilities, instructions }
    );
    this.#utils = utils;
    this.setupErrorHandling();
    this.setupLoggingHandlers();
    this.setupRootsHandlers();
    this.setupCompleteHandlers();
    if (tools.length) {
      this.setupToolHandlers(tools);
    }
    if (resources.length || resourcesTemplates.length) {
      for (const resource of resources) {
        this.addResource(resource);
      }
      this.setupResourceHandlers();
      this.setupResourceSubscriptionHandlers();
      if (resourcesTemplates.length) {
        for (const resourceTemplate of resourcesTemplates) {
          this.addResourceTemplate(resourceTemplate);
        }
        this.setupResourceTemplateHandlers();
      }
    }
    if (prompts.length) {
      this.setupPromptHandlers();
    }
  }
  async close() {
    this.#connectionState = "closed";
    if (this.#pingInterval) {
      clearInterval(this.#pingInterval);
    }
    try {
      await this.#server.close();
    } catch (error) {
      this.#logger.error("[FastMCP error]", "could not close server", error);
    }
  }
  async connect(transport) {
    if (this.#server.transport) {
      throw new UnexpectedStateError("Server is already connected");
    }
    this.#connectionState = "connecting";
    try {
      await this.#server.connect(transport);
      if ("sessionId" in transport) {
        const transportWithSessionId = transport;
        if (typeof transportWithSessionId.sessionId === "string") {
          this.#sessionId = transportWithSessionId.sessionId;
        }
      }
      if (!this.#stateless) {
        let attempt = 0;
        const maxAttempts = 10;
        const retryDelay = 100;
        while (attempt++ < maxAttempts) {
          const capabilities = this.#server.getClientCapabilities();
          if (capabilities) {
            this.#clientCapabilities = capabilities;
            break;
          }
          await delay(retryDelay);
        }
        if (!this.#clientCapabilities) {
          this.#logger.warn(
            `[FastMCP warning] could not infer client capabilities after ${maxAttempts} attempts. Connection may be unstable.`
          );
        }
      }
      if (this.#rootsConfig?.enabled !== false && this.#clientCapabilities?.roots?.listChanged && typeof this.#server.listRoots === "function") {
        try {
          const roots = await this.#server.listRoots();
          this.#roots = roots?.roots || [];
        } catch (e) {
          if (e instanceof McpError && e.code === ErrorCode.MethodNotFound) {
            this.#logger.debug(
              "[FastMCP debug] listRoots method not supported by client"
            );
          } else {
            this.#logger.error(
              `[FastMCP error] received error listing roots.

${e instanceof Error ? e.stack : JSON.stringify(e)}`
            );
          }
        }
      }
      if (this.#clientCapabilities) {
        const pingConfig = this.#getPingConfig(transport);
        if (pingConfig.enabled) {
          this.#pingInterval = setInterval(async () => {
            try {
              await this.#server.ping();
            } catch {
              const logLevel = pingConfig.logLevel;
              if (logLevel === "debug") {
                this.#logger.debug("[FastMCP debug] server ping failed");
              } else if (logLevel === "warning") {
                this.#logger.warn(
                  "[FastMCP warning] server is not responding to ping"
                );
              } else if (logLevel === "error") {
                this.#logger.error(
                  "[FastMCP error] server is not responding to ping"
                );
              } else {
                this.#logger.info("[FastMCP info] server ping failed");
              }
            }
          }, pingConfig.intervalMs);
        }
      }
      this.#connectionState = "ready";
      this.emit("ready");
    } catch (error) {
      this.#connectionState = "error";
      const errorEvent = {
        error: error instanceof Error ? error : new Error(String(error))
      };
      this.emit("error", errorEvent);
      throw error;
    }
  }
  promptsListChanged(prompts) {
    this.#prompts.clear();
    for (const prompt of prompts) {
      this.addPrompt(prompt);
    }
    this.setupPromptHandlers();
    this.triggerListChangedNotification("notifications/prompts/list_changed");
  }
  async requestElicitation(params, options) {
    return this.#server.elicitInput(params, options);
  }
  async requestSampling(message, options) {
    return this.#server.createMessage(message, options);
  }
  resourcesListChanged(resources) {
    this.#resources.clear();
    for (const resource of resources) {
      this.addResource(resource);
    }
    this.setupResourceHandlers();
    this.triggerListChangedNotification("notifications/resources/list_changed");
  }
  resourceTemplatesListChanged(resourceTemplates) {
    this.#resourceTemplates.clear();
    for (const resourceTemplate of resourceTemplates) {
      this.addResourceTemplate(resourceTemplate);
    }
    this.setupResourceTemplateHandlers();
    this.triggerListChangedNotification("notifications/resources/list_changed");
  }
  /**
   * Notifies the connected client that the contents of a resource have changed.
   *
   * The `notifications/resources/updated` notification is only sent when the
   * client has subscribed to the URI via `resources/subscribe`; otherwise this
   * is a no-op.
   */
  async sendResourceUpdated(uri) {
    if (!this.#subscriptions.has(uri)) {
      return;
    }
    try {
      await this.#server.sendResourceUpdated({ uri });
    } catch (error) {
      this.#logger.error(
        `[FastMCP error] failed to send resources/updated notification for '${uri}'.

${error instanceof Error ? error.stack : JSON.stringify(error)}`
      );
    }
  }
  toolsListChanged(tools) {
    const allowedTools = tools.filter(
      (tool) => tool.canAccess ? tool.canAccess(this.#auth) : true
    );
    this.setupToolHandlers(allowedTools);
    this.triggerListChangedNotification("notifications/tools/list_changed");
  }
  async triggerListChangedNotification(method) {
    try {
      await this.#server.notification({
        method
      });
    } catch (error) {
      this.#logger.error(
        `[FastMCP error] failed to send ${method} notification.

${error instanceof Error ? error.stack : JSON.stringify(error)}`
      );
    }
  }
  /**
   * Update the session's authentication context.
   * Called by mcp-proxy when a new token is validated on subsequent requests.
   */
  updateAuth(auth) {
    this.#auth = auth;
  }
  waitForReady() {
    if (this.isReady) {
      return Promise.resolve();
    }
    if (this.#connectionState === "error" || this.#connectionState === "closed") {
      return Promise.reject(
        new Error(`Connection is in ${this.#connectionState} state`)
      );
    }
    return new Promise((resolve, reject) => {
      const timeout = setTimeout(() => {
        reject(
          new Error(
            "Connection timeout: Session failed to become ready within 5 seconds"
          )
        );
      }, 5e3);
      this.once("ready", () => {
        clearTimeout(timeout);
        resolve();
      });
      this.once("error", (event) => {
        clearTimeout(timeout);
        reject(event.error);
      });
    });
  }
  /**
   * Builds the context object passed as the third argument to
   * `resource.load` / `resourceTemplate.load` / `prompt.load`.
   *
   * This mirrors the `client`, `elicit`, `log`, `requestId`, `session`,
   * and `sessionId` fields available to `tool.execute` via {@link Context}.
   * `reportProgress` and `streamContent` are intentionally omitted: they
   * are tied to a tool call's progress token / streaming notification,
   * which resource and prompt reads do not have.
   */
  #createLoadContext(meta) {
    return {
      client: {
        version: this.#server.getClientVersion()
      },
      elicit: (params, options) => this.#server.elicitInput(params, options),
      log: this.#createLog(),
      requestId: typeof meta?.requestId === "string" ? meta.requestId : void 0,
      session: this.#auth,
      sessionId: this.#sessionId
    };
  }
  #createLog() {
    return {
      debug: (message, context) => {
        this.#server.sendLoggingMessage({
          data: {
            context,
            message
          },
          level: "debug"
        });
      },
      error: (message, context) => {
        this.#server.sendLoggingMessage({
          data: {
            context,
            message
          },
          level: "error"
        });
      },
      info: (message, context) => {
        this.#server.sendLoggingMessage({
          data: {
            context,
            message
          },
          level: "info"
        });
      },
      warn: (message, context) => {
        this.#server.sendLoggingMessage({
          data: {
            context,
            message
          },
          level: "warning"
        });
      }
    };
  }
  #formatSchemaIssues(issues) {
    return this.#utils?.formatInvalidParamsErrorMessage ? this.#utils.formatInvalidParamsErrorMessage(issues) : issues.map((issue) => {
      const path = issue.path?.join(".") || "root";
      return `${path}: ${issue.message}`;
    }).join(", ");
  }
  #getPingConfig(transport) {
    const pingConfig = this.#pingConfig || {};
    let defaultEnabled = false;
    if ("type" in transport) {
      if (transport.type === "httpStream") {
        defaultEnabled = true;
      }
    }
    return {
      enabled: pingConfig.enabled !== void 0 ? pingConfig.enabled : defaultEnabled,
      intervalMs: pingConfig.intervalMs || 5e3,
      logLevel: pingConfig.logLevel || "debug"
    };
  }
  async #validateStructuredContent(tool, value, toolName) {
    if (!tool.outputSchema) {
      return value;
    }
    const parsed = await tool.outputSchema["~standard"].validate(value);
    if (parsed.issues) {
      throw new UserError(
        `Tool '${toolName}' structured output validation failed: ${this.#formatSchemaIssues(parsed.issues)}. Please check the result matches the tool's outputSchema.`
      );
    }
    return parsed.value;
  }
  addPrompt(inputPrompt) {
    const completers = {};
    const enums = {};
    const fuseInstances = {};
    for (const argument of inputPrompt.arguments ?? []) {
      if (argument.complete) {
        completers[argument.name] = argument.complete;
      }
      if (argument.enum) {
        enums[argument.name] = argument.enum;
        fuseInstances[argument.name] = new Fuse(argument.enum, {
          includeScore: true,
          threshold: 0.3
          // More flexible matching!
        });
      }
    }
    const prompt = {
      ...inputPrompt,
      complete: async (name, value, auth) => {
        if (completers[name]) {
          return await completers[name](value, auth);
        }
        if (inputPrompt.complete) {
          return await inputPrompt.complete(name, value, auth);
        }
        if (fuseInstances[name]) {
          const result = fuseInstances[name].search(value);
          return {
            total: result.length,
            values: result.map((item) => item.item)
          };
        }
        return {
          values: []
        };
      }
    };
    this.#prompts.set(prompt.name, prompt);
  }
  addResource(inputResource) {
    this.#resources.set(inputResource.uri, inputResource);
  }
  addResourceTemplate(inputResourceTemplate) {
    const completers = {};
    for (const argument of inputResourceTemplate.arguments ?? []) {
      if (argument.complete) {
        completers[argument.name] = argument.complete;
      }
    }
    const resourceTemplate = {
      ...inputResourceTemplate,
      complete: async (name, value, auth) => {
        if (completers[name]) {
          return await completers[name](value, auth);
        }
        if (inputResourceTemplate.complete) {
          return await inputResourceTemplate.complete(name, value, auth);
        }
        return {
          values: []
        };
      }
    };
    this.#resourceTemplates.set(resourceTemplate.name, resourceTemplate);
  }
  setupCompleteHandlers() {
    this.#server.setRequestHandler(CompleteRequestSchema, async (request) => {
      if (request.params.ref.type === "ref/prompt") {
        const ref = request.params.ref;
        const prompt = "name" in ref && this.#prompts.get(ref.name);
        if (!prompt) {
          throw new UnexpectedStateError("Unknown prompt", {
            request
          });
        }
        if (!prompt.complete) {
          throw new UnexpectedStateError("Prompt does not support completion", {
            request
          });
        }
        const completion = CompletionZodSchema.parse(
          await prompt.complete(
            request.params.argument.name,
            request.params.argument.value,
            this.#auth
          )
        );
        return {
          completion
        };
      }
      if (request.params.ref.type === "ref/resource") {
        const ref = request.params.ref;
        const resource = "uri" in ref && Array.from(this.#resourceTemplates.values()).find(
          (resource2) => resource2.uriTemplate === ref.uri
        );
        if (!resource) {
          throw new UnexpectedStateError("Unknown resource", {
            request
          });
        }
        if (!("uriTemplate" in resource)) {
          throw new UnexpectedStateError("Unexpected resource");
        }
        if (!resource.complete) {
          throw new UnexpectedStateError(
            "Resource does not support completion",
            {
              request
            }
          );
        }
        const completion = CompletionZodSchema.parse(
          await resource.complete(
            request.params.argument.name,
            request.params.argument.value,
            this.#auth
          )
        );
        return {
          completion
        };
      }
      throw new UnexpectedStateError("Unexpected completion request", {
        request
      });
    });
  }
  setupErrorHandling() {
    this.#server.onerror = (error) => {
      this.#logger.error("[FastMCP error]", error);
    };
  }
  setupLoggingHandlers() {
    this.#server.setRequestHandler(SetLevelRequestSchema, (request) => {
      this.#loggingLevel = request.params.level;
      return {};
    });
  }
  setupPromptHandlers() {
    let cachedPromptsList = null;
    this.#server.setRequestHandler(ListPromptsRequestSchema, async () => {
      if (cachedPromptsList) {
        return {
          prompts: cachedPromptsList
        };
      }
      cachedPromptsList = Array.from(this.#prompts.values()).map((prompt) => {
        return {
          arguments: prompt.arguments,
          complete: prompt.complete,
          description: prompt.description,
          name: prompt.name
        };
      });
      return {
        prompts: cachedPromptsList
      };
    });
    this.#server.setRequestHandler(GetPromptRequestSchema, async (request) => {
      const prompt = this.#prompts.get(request.params.name);
      if (!prompt) {
        throw new McpError(
          ErrorCode.MethodNotFound,
          `Unknown prompt: ${request.params.name}`
        );
      }
      const args = request.params.arguments;
      for (const arg of prompt.arguments ?? []) {
        if (arg.required && !(args && arg.name in args)) {
          throw new McpError(
            ErrorCode.InvalidRequest,
            `Prompt '${request.params.name}' requires argument '${arg.name}': ${arg.description || "No description provided"}`
          );
        }
      }
      let result;
      try {
        result = await prompt.load(
          args,
          this.#auth,
          this.#createLoadContext(request.params?._meta)
        );
      } catch (error) {
        const errorMessage = error instanceof Error ? error.message : String(error);
        throw new McpError(
          ErrorCode.InternalError,
          `Failed to load prompt '${request.params.name}': ${errorMessage}`
        );
      }
      if (typeof result === "string") {
        return {
          description: prompt.description,
          messages: [
            {
              content: { text: result, type: "text" },
              role: "user"
            }
          ]
        };
      } else {
        return {
          description: prompt.description,
          messages: result.messages
        };
      }
    });
  }
  setupResourceHandlers() {
    let cachedResourcesList = null;
    this.#server.setRequestHandler(ListResourcesRequestSchema, async () => {
      if (cachedResourcesList) {
        return {
          resources: cachedResourcesList
        };
      }
      cachedResourcesList = Array.from(this.#resources.values()).map(
        (resource) => ({
          description: resource.description,
          mimeType: resource.mimeType,
          name: resource.name,
          uri: resource.uri
        })
      );
      return {
        resources: cachedResourcesList
      };
    });
    this.#server.setRequestHandler(
      ReadResourceRequestSchema,
      async (request) => {
        if ("uri" in request.params) {
          const resource = this.#resources.get(request.params.uri);
          if (!resource) {
            for (const resourceTemplate of this.#resourceTemplates.values()) {
              const uriTemplate = parseURITemplate(
                resourceTemplate.uriTemplate
              );
              const match = uriTemplate.fromUri(request.params.uri);
              if (!match) {
                continue;
              }
              const uri = uriTemplate.fill(match);
              const result = await resourceTemplate.load(
                match,
                this.#auth,
                this.#createLoadContext(request.params?._meta)
              );
              const resources = Array.isArray(result) ? result : [result];
              return {
                contents: resources.map((resource2) => ({
                  ...resource2,
                  description: resourceTemplate.description,
                  mimeType: resource2.mimeType ?? resourceTemplate.mimeType,
                  name: resourceTemplate.name,
                  uri: resource2.uri ?? uri
                }))
              };
            }
            throw new McpError(
              ErrorCode.MethodNotFound,
              `Resource not found: '${request.params.uri}'. Available resources: ${Array.from(this.#resources.values()).map((r) => r.uri).join(", ") || "none"}`
            );
          }
          if (!("uri" in resource)) {
            throw new UnexpectedStateError("Resource does not support reading");
          }
          let maybeArrayResult;
          try {
            maybeArrayResult = await resource.load(
              this.#auth,
              this.#createLoadContext(request.params?._meta)
            );
          } catch (error) {
            const errorMessage = error instanceof Error ? error.message : String(error);
            throw new McpError(
              ErrorCode.InternalError,
              `Failed to load resource '${resource.name}' (${resource.uri}): ${errorMessage}`,
              {
                uri: resource.uri
              }
            );
          }
          const resourceResults = Array.isArray(maybeArrayResult) ? maybeArrayResult : [maybeArrayResult];
          return {
            contents: resourceResults.map((result) => ({
              ...result,
              mimeType: result.mimeType ?? resource.mimeType,
              name: resource.name,
              uri: result.uri ?? resource.uri
            }))
          };
        }
        throw new UnexpectedStateError("Unknown resource request", {
          request
        });
      }
    );
  }
  setupResourceSubscriptionHandlers() {
    this.#server.setRequestHandler(SubscribeRequestSchema, (request) => {
      this.#subscriptions.add(request.params.uri);
      return {};
    });
    this.#server.setRequestHandler(UnsubscribeRequestSchema, (request) => {
      this.#subscriptions.delete(request.params.uri);
      return {};
    });
  }
  setupResourceTemplateHandlers() {
    let cachedResourceTemplatesList = null;
    this.#server.setRequestHandler(
      ListResourceTemplatesRequestSchema,
      async () => {
        if (cachedResourceTemplatesList) {
          return {
            resourceTemplates: cachedResourceTemplatesList
          };
        }
        cachedResourceTemplatesList = Array.from(
          this.#resourceTemplates.values()
        ).map((resourceTemplate) => ({
          description: resourceTemplate.description,
          mimeType: resourceTemplate.mimeType,
          name: resourceTemplate.name,
          uriTemplate: resourceTemplate.uriTemplate
        }));
        return {
          resourceTemplates: cachedResourceTemplatesList
        };
      }
    );
  }
  setupRootsHandlers() {
    if (this.#rootsConfig?.enabled === false) {
      this.#logger.debug(
        "[FastMCP debug] roots capability explicitly disabled via config"
      );
      return;
    }
    if (typeof this.#server.listRoots === "function") {
      this.#server.setNotificationHandler(
        RootsListChangedNotificationSchema,
        () => {
          this.#server.listRoots().then((roots) => {
            this.#roots = roots.roots;
            this.emit("rootsChanged", {
              roots: roots.roots
            });
          }).catch((error) => {
            if (error instanceof McpError && error.code === ErrorCode.MethodNotFound) {
              this.#logger.debug(
                "[FastMCP debug] listRoots method not supported by client"
              );
            } else {
              this.#logger.error(
                `[FastMCP error] received error listing roots.

${error instanceof Error ? error.stack : JSON.stringify(error)}`
              );
            }
          });
        }
      );
    } else {
      this.#logger.debug(
        "[FastMCP debug] roots capability not available, not setting up notification handler"
      );
    }
  }
  setupToolHandlers(tools) {
    const toolsMap = new Map(tools.map((tool) => [tool.name, tool]));
    let cachedToolsList = null;
    this.#server.setRequestHandler(ListToolsRequestSchema, async () => {
      if (cachedToolsList) {
        return {
          tools: cachedToolsList
        };
      }
      cachedToolsList = await Promise.all(
        tools.map(async (tool) => {
          return {
            annotations: tool.annotations,
            description: tool.description,
            inputSchema: tool.parameters ? strictJsonSchema(await toJsonSchema(tool.parameters)) : {
              additionalProperties: false,
              properties: {},
              type: "object"
            },
            name: tool.name,
            ...tool.outputSchema && {
              outputSchema: strictJsonSchema(
                await toJsonSchema(tool.outputSchema)
              )
            },
            // Pass through _meta for MCP ext-apps UI support (issue #229)
            ...tool._meta && { _meta: tool._meta }
          };
        })
      );
      return {
        tools: cachedToolsList
      };
    });
    this.#server.setRequestHandler(CallToolRequestSchema, async (request) => {
      const tool = toolsMap.get(request.params.name);
      if (!tool) {
        throw new McpError(
          ErrorCode.MethodNotFound,
          `Unknown tool: ${request.params.name}`
        );
      }
      let args = void 0;
      if (tool.parameters) {
        const parsed = await tool.parameters["~standard"].validate(
          request.params.arguments
        );
        if (parsed.issues) {
          const friendlyErrors = this.#formatSchemaIssues(parsed.issues);
          throw new McpError(
            ErrorCode.InvalidParams,
            `Tool '${request.params.name}' parameter validation failed: ${friendlyErrors}. Please check the parameter types and values according to the tool's schema.`
          );
        }
        args = parsed.value;
      }
      const progressToken = request.params?._meta?.progressToken;
      let result;
      try {
        const reportProgress = async (progress) => {
          if (progressToken === void 0) {
            return;
          }
          try {
            await this.#server.notification({
              method: "notifications/progress",
              params: {
                ...progress,
                progressToken
              }
            });
            if (this.#needsEventLoopFlush) {
              await new Promise((resolve) => setImmediate(resolve));
            }
          } catch (progressError) {
            this.#logger.warn(
              `[FastMCP warning] Failed to report progress for tool '${request.params.name}':`,
              progressError instanceof Error ? progressError.message : String(progressError)
            );
          }
        };
        const log = this.#createLog();
        const streamContent = async (content) => {
          const contentArray = Array.isArray(content) ? content : [content];
          try {
            await this.#server.notification({
              method: "notifications/tool/streamContent",
              params: {
                content: contentArray,
                toolName: request.params.name
              }
            });
            if (this.#needsEventLoopFlush) {
              await new Promise((resolve) => setImmediate(resolve));
            }
          } catch (streamError) {
            this.#logger.warn(
              `[FastMCP warning] Failed to stream content for tool '${request.params.name}':`,
              streamError instanceof Error ? streamError.message : String(streamError)
            );
          }
        };
        if (this.#onToolCall) {
          await this.#onToolCall({
            arguments: args ?? {},
            toolName: request.params.name
          });
        }
        const executeToolPromise = tool.execute(args, {
          client: {
            version: this.#server.getClientVersion()
          },
          elicit: (params, options) => this.#server.elicitInput(params, options),
          log,
          reportProgress,
          requestId: typeof request.params?._meta?.requestId === "string" ? request.params._meta.requestId : void 0,
          session: this.#auth,
          sessionId: this.#sessionId,
          streamContent
        });
        const maybeStringResult = await (tool.timeoutMs ? Promise.race([
          executeToolPromise,
          new Promise((_, reject) => {
            const timeoutId = setTimeout(() => {
              reject(
                new UserError(
                  `Tool '${request.params.name}' timed out after ${tool.timeoutMs}ms. Consider increasing timeoutMs or optimizing the tool implementation.`
                )
              );
            }, tool.timeoutMs);
            executeToolPromise.then(
              () => clearTimeout(timeoutId),
              () => clearTimeout(timeoutId)
            );
          })
        ]) : executeToolPromise);
        await delay(1);
        if (maybeStringResult === void 0 || maybeStringResult === null) {
          result = ContentResultZodSchema.parse({
            content: []
          });
        } else if (typeof maybeStringResult === "string") {
          result = ContentResultZodSchema.parse({
            content: [{ text: maybeStringResult, type: "text" }]
          });
        } else if ("type" in maybeStringResult) {
          result = ContentResultZodSchema.parse({
            content: [maybeStringResult]
          });
        } else if ("content" in maybeStringResult) {
          result = ContentResultZodSchema.parse(maybeStringResult);
          if (result.structuredContent !== void 0 && tool.outputSchema) {
            result.structuredContent = await this.#validateStructuredContent(
              tool,
              result.structuredContent,
              request.params.name
            );
          }
        } else if (tool.outputSchema) {
          const structuredContent = await this.#validateStructuredContent(
            tool,
            maybeStringResult,
            request.params.name
          );
          result = ContentResultZodSchema.parse({
            content: [
              {
                text: JSON.stringify(structuredContent),
                type: "text"
              }
            ],
            structuredContent
          });
        } else {
          result = ContentResultZodSchema.parse(maybeStringResult);
        }
      } catch (error) {
        if (error instanceof UserError) {
          return {
            content: [{ text: error.message, type: "text" }],
            isError: true,
            ...error.extras ? { structuredContent: error.extras } : {}
          };
        }
        const errorMessage = error instanceof Error ? error.message : String(error);
        return {
          content: [
            {
              text: `Tool '${request.params.name}' execution failed: ${errorMessage}`,
              type: "text"
            }
          ],
          isError: true
        };
      }
      return result;
    });
  }
};
function camelToSnakeCase(str) {
  return str.replace(/[A-Z]/g, (letter) => `_${letter.toLowerCase()}`);
}
function convertObjectToSnakeCase(obj) {
  const result = {};
  for (const [key, value] of Object.entries(obj)) {
    const snakeKey = camelToSnakeCase(key);
    result[snakeKey] = value;
  }
  return result;
}
function joinPaths(basePath, path) {
  return `${basePath}${normalizePath(path)}`;
}
function normalizeBasePath(path) {
  if (!path || path === "/") {
    return "";
  }
  const withLeadingSlash = path.startsWith("/") ? path : `/${path}`;
  const withoutTrailingSlash = withLeadingSlash.replace(/\/+$/, "");
  return withoutTrailingSlash ? withoutTrailingSlash : "";
}
function normalizePath(path) {
  return path.startsWith("/") ? path : `/${path}`;
}
function parseBasicAuthHeader(authHeader) {
  const basicMatch = authHeader?.match(/^Basic\s+(.+)$/);
  if (!basicMatch) return null;
  try {
    const credentials = Buffer.from(basicMatch[1], "base64").toString("utf-8");
    const credMatch = credentials.match(/^([^:]+):(.*)$/);
    if (!credMatch) return null;
    return { clientId: credMatch[1], clientSecret: credMatch[2] };
  } catch {
    return null;
  }
}
function stripBasePath(path, basePath) {
  if (!basePath) {
    return path;
  }
  if (path === basePath) {
    return "/";
  }
  if (path.startsWith(`${basePath}/`)) {
    return path.slice(basePath.length);
  }
  return null;
}
var FastMCPEventEmitterBase = EventEmitter;
var FastMCPEventEmitter = class extends FastMCPEventEmitterBase {
};
var FastMCP = class extends FastMCPEventEmitter {
  constructor(options) {
    super();
    this.options = options;
    this.#options = options;
    this.#logger = options.logger || console;
    if (options.auth) {
      if (!options.authenticate) {
        this.#authenticate = ((request) => options.auth.authenticate(request));
      } else {
        this.#authenticate = options.authenticate;
      }
      if (!options.oauth) {
        this.#options = {
          ...options,
          oauth: options.auth.getOAuthConfig()
        };
      }
    } else {
      this.#authenticate = options.authenticate;
    }
  }
  get serverState() {
    return this.#serverState;
  }
  get sessions() {
    return this.#sessions;
  }
  #authenticate;
  #honoApp = new Hono();
  #httpStreamServer = null;
  #logger;
  #options;
  #prompts = [];
  #resources = [];
  #resourcesTemplates = [];
  #serverState = "stopped" /* Stopped */;
  #sessions = [];
  #tools = [];
  /**
   * Adds a prompt to the server.
   */
  addPrompt(prompt) {
    this.#prompts = this.#prompts.filter((p) => p.name !== prompt.name);
    this.#prompts.push(prompt);
    if (this.#serverState === "running" /* Running */) {
      this.#promptsListChanged(this.#prompts);
    }
  }
  /**
   * Adds prompts to the server.
   */
  addPrompts(prompts) {
    const newPromptNames = new Set(prompts.map((prompt) => prompt.name));
    this.#prompts = this.#prompts.filter((p) => !newPromptNames.has(p.name));
    this.#prompts.push(...prompts);
    if (this.#serverState === "running" /* Running */) {
      this.#promptsListChanged(this.#prompts);
    }
  }
  /**
   * Adds a resource to the server.
   */
  addResource(resource) {
    this.#resources = this.#resources.filter((r) => r.name !== resource.name);
    this.#resources.push(resource);
    if (this.#serverState === "running" /* Running */) {
      this.#resourcesListChanged(this.#resources);
    }
  }
  /**
   * Adds resources to the server.
   */
  addResources(resources) {
    const newResourceNames = new Set(
      resources.map((resource) => resource.name)
    );
    this.#resources = this.#resources.filter(
      (r) => !newResourceNames.has(r.name)
    );
    this.#resources.push(...resources);
    if (this.#serverState === "running" /* Running */) {
      this.#resourcesListChanged(this.#resources);
    }
  }
  /**
   * Adds a resource template to the server.
   */
  addResourceTemplate(resource) {
    this.#resourcesTemplates = this.#resourcesTemplates.filter(
      (t) => t.name !== resource.name
    );
    this.#resourcesTemplates.push(resource);
    if (this.#serverState === "running" /* Running */) {
      this.#resourceTemplatesListChanged(this.#resourcesTemplates);
    }
  }
  /**
   * Adds resource templates to the server.
   */
  addResourceTemplates(resources) {
    const newResourceTemplateNames = new Set(
      resources.map((resource) => resource.name)
    );
    this.#resourcesTemplates = this.#resourcesTemplates.filter(
      (t) => !newResourceTemplateNames.has(t.name)
    );
    this.#resourcesTemplates.push(...resources);
    if (this.#serverState === "running" /* Running */) {
      this.#resourceTemplatesListChanged(this.#resourcesTemplates);
    }
  }
  /**
   * Adds a tool to the server.
   */
  addTool(tool) {
    this.#tools = this.#tools.filter((t) => t.name !== tool.name);
    this.#tools.push(tool);
    if (this.#serverState === "running" /* Running */) {
      this.#toolsListChanged(this.#tools);
    }
  }
  /**
   * Adds tools to the server.
   */
  addTools(tools) {
    const newToolNames = new Set(tools.map((tool) => tool.name));
    this.#tools = this.#tools.filter((t) => !newToolNames.has(t.name));
    this.#tools.push(...tools);
    if (this.#serverState === "running" /* Running */) {
      this.#toolsListChanged(this.#tools);
    }
  }
  /**
   * Connects the server to a transport you constructed yourself, instead of
   * letting {@link FastMCP.start} create one.
   *
   * The session is built from the tools, resources and prompts registered on
   * this instance — exactly as `start()` does — so tests exercise the same
   * wiring the real server uses. The main use case is driving a server
   * in-process over `InMemoryTransport` without binding a port:
   *
   * ```ts
   * const [clientTransport, serverTransport] =
   *   InMemoryTransport.createLinkedPair();
   *
   * await Promise.all([
   *   server.connect(serverTransport),
   *   client.connect(clientTransport),
   * ]);
   * ```
   *
   * The transport's lifecycle belongs to the caller: `stop()` does not close
   * transports passed here. Close the returned session (or the transport) when
   * you are done with it.
   *
   * @param transport - An already-constructed MCP server transport.
   * @param auth - Session auth, equivalent to what `authenticate` would return.
   * @returns The session bound to the transport.
   */
  async connect(transport, auth) {
    const session = this.#createSession(auth);
    await session.connect(transport);
    this.#sessions.push(session);
    session.once("error", () => {
      this.#removeSession(session);
    });
    const originalOnClose = transport.onclose;
    transport.onclose = () => {
      this.#removeSession(session);
      if (originalOnClose) {
        originalOnClose();
      }
    };
    this.emit("connect", {
      session
    });
    this.#serverState = "running" /* Running */;
    return session;
  }
  /**
   * Embeds a resource by URI, making it easy to include r