firecrawl-mcp 3.27.1 → 3.27.2

package/dist/index.js

@@ -83,12 +83,1998 @@ var alexandriaSessionFeedbackSchema = z.strictObject({
 // src/index.ts
 import FirecrawlApp from "firecrawl";
 import dotenv from "dotenv";
-import { FastMCP, UserError as UserError2 } from "fastmcp";
+
+// node_modules/.pnpm/fastmcp@4.3.2_patch_hash=08f77b633292d9ae4cb022c0fa5bd722dbd5c1aaaad600204f8ed38339bfd37b/node_modules/fastmcp/dist/chunk-LWU5CQGW.js
+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
+} from "@modelcontextprotocol/sdk/types.js";
+import { EventEmitter } from "events";
+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 as z2 } from "zod";
+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 = z2.object({
+  /**
+   * The text content of the message.
+   */
+  text: z2.string(),
+  type: z2.literal("text")
+}).strict();
+var ImageContentZodSchema = z2.object({
+  /**
+   * The base64-encoded image data.
+   */
+  data: z2.string().base64(),
+  /**
+   * The MIME type of the image. Different providers may support different image types.
+   */
+  mimeType: z2.string(),
+  type: z2.literal("image")
+}).strict();
+var AudioContentZodSchema = z2.object({
+  /**
+   * The base64-encoded audio data.
+   */
+  data: z2.string().base64(),
+  mimeType: z2.string(),
+  type: z2.literal("audio")
+}).strict();
+var ResourceContentZodSchema = z2.object({
+  resource: z2.object({
+    blob: z2.string().optional(),
+    mimeType: z2.string().optional(),
+    text: z2.string().optional(),
+    uri: z2.string()
+  }),
+  type: z2.literal("resource")
+}).strict();
+var ResourceLinkZodSchema = z2.object({
+  description: z2.string().optional(),
+  mimeType: z2.string().optional(),
+  name: z2.string(),
+  title: z2.string().optional(),
+  type: z2.literal("resource_link"),
+  uri: z2.string()
+});
+var ContentZodSchema = z2.discriminatedUnion("type", [
+  TextContentZodSchema,
+  ImageContentZodSchema,
+  AudioContentZodSchema,
+  ResourceContentZodSchema,
+  ResourceLinkZodSchema
+]);
+var ContentResultZodSchema = z2.object({
+  content: ContentZodSchema.array(),
+  isError: z2.boolean().optional(),
+  structuredContent: z2.record(z2.string(), z2.unknown()).optional()
+}).strict();
+var CompletionZodSchema = z2.object({
+  /**
+   * Indicates whether there are additional completion options beyond those provided in the current response, even if the exact total is unknown.
+   */
+  hasMore: z2.optional(z2.boolean()),
+  /**
+   * The total number of completion options available. This can exceed the number of values actually sent in the response.
+   */
+  total: z2.optional(z2.number().int()),
+  /**
+   * An array of completion values. Must not exceed 100 items.
+   */
+  values: z2.array(z2.string()).max(100)
+});
+var FastMCPSessionEventEmitterBase = EventEmitter;
+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;
+  #utils;
+  constructor({
+    auth,
+    instructions,
+    logger,
+    name: name2,
+    onToolCall,
+    ping,
+    prompts,
+    resources,
+    resourcesTemplates,
+    roots,
+    sessionId,
+    tools,
+    transportType,
+    utils,
+    version
+  }) {
+    super();
+    this.#auth = auth;
+    this.#logger = logger;
+    this.#onToolCall = onToolCall;
+    this.#pingConfig = ping;
+    this.#rootsConfig = roots;
+    this.#sessionId = sessionId;
+    this.#needsEventLoopFlush = transportType === "httpStream";
+    if (tools.length) {
+      this.#capabilities.tools = {};
+    }
+    if (resources.length || resourcesTemplates.length) {
+      this.#capabilities.resources = {};
+    }
+    if (prompts.length) {
+      for (const prompt of prompts) {
+        this.addPrompt(prompt);
+      }
+      this.#capabilities.prompts = {};
+    }
+    this.#capabilities.logging = {};
+    this.#capabilities.completions = {};
+    this.#server = new Server(
+      { name: name2, 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();
+      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 (error2) {
+      this.#logger.error("[FastMCP error]", "could not close server", error2);
+    }
+  }
+  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;
+        }
+      }
+      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 (error2) {
+      this.#connectionState = "error";
+      const errorEvent = {
+        error: error2 instanceof Error ? error2 : new Error(String(error2))
+      };
+      this.emit("error", errorEvent);
+      throw error2;
+    }
+  }
+  promptsListChanged(prompts) {
+    this.#prompts.clear();
+    for (const prompt of prompts) {
+      this.addPrompt(prompt);
+    }
+    this.setupPromptHandlers();
+    this.triggerListChangedNotification("notifications/prompts/list_changed");
+  }
+  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");
+  }
+  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 (error2) {
+      this.#logger.error(
+        `[FastMCP error] failed to send ${method} notification.
+
+${error2 instanceof Error ? error2.stack : JSON.stringify(error2)}`
+      );
+    }
+  }
+  /**
+   * 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);
+      });
+    });
+  }
+  #formatSchemaIssues(issues) {
+    return this.#utils?.formatInvalidParamsErrorMessage ? this.#utils.formatInvalidParamsErrorMessage(issues) : issues.map((issue) => {
+      const path2 = issue.path?.join(".") || "root";
+      return `${path2}: ${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 (name2, value, auth) => {
+        if (completers[name2]) {
+          return await completers[name2](value, auth);
+        }
+        if (inputPrompt.complete) {
+          return await inputPrompt.complete(name2, value, auth);
+        }
+        if (fuseInstances[name2]) {
+          const result = fuseInstances[name2].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 (name2, value, auth) => {
+        if (completers[name2]) {
+          return await completers[name2](value, auth);
+        }
+        if (inputResourceTemplate.complete) {
+          return await inputResourceTemplate.complete(name2, 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 = (error2) => {
+      this.#logger.error("[FastMCP error]", error2);
+    };
+  }
+  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 args2 = request.params.arguments;
+      for (const arg of prompt.arguments ?? []) {
+        if (arg.required && !(args2 && arg.name in args2)) {
+          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(
+          args2,
+          this.#auth
+        );
+      } catch (error2) {
+        const errorMessage = error2 instanceof Error ? error2.message : String(error2);
+        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);
+              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);
+          } catch (error2) {
+            const errorMessage = error2 instanceof Error ? error2.message : String(error2);
+            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
+        });
+      }
+    );
+  }
+  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((error2) => {
+            if (error2 instanceof McpError && error2.code === ErrorCode.MethodNotFound) {
+              this.#logger.debug(
+                "[FastMCP debug] listRoots method not supported by client"
+              );
+            } else {
+              this.#logger.error(
+                `[FastMCP error] received error listing roots.
+
+${error2 instanceof Error ? error2.stack : JSON.stringify(error2)}`
+              );
+            }
+          });
+        }
+      );
+    } 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]));
+    const listedTools = tools.filter(
+      (tool) => tool.canList ? tool.canList(this.#auth) : true
+    );
+    let cachedToolsList = null;
+    this.#server.setRequestHandler(ListToolsRequestSchema, async () => {
+      if (cachedToolsList) {
+        return {
+          tools: cachedToolsList
+        };
+      }
+      cachedToolsList = await Promise.all(
+        listedTools.map(async (tool) => {
+          return {
+            annotations: tool.annotations,
+            // Top-level Tool.title (MCP 2025-06-18). Clients such as Codex index this
+            // for tool search and do not read annotations.title.
+            ...tool.annotations?.title && { title: tool.annotations.title },
+            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}`
+        );
+      }
+      if (tool.beforeValidate) {
+        const earlyResult = await tool.beforeValidate(
+          request.params.arguments,
+          this.#auth
+        );
+        if (earlyResult !== void 0) {
+          return ContentResultZodSchema.parse(earlyResult);
+        }
+      }
+      let args2 = 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.`
+          );
+        }
+        args2 = 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 = {
+          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"
+            });
+          }
+        };
+        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: args2 ?? {},
+            toolName: request.params.name
+          });
+        }
+        const executeToolPromise = tool.execute(args2, {
+          client: {
+            version: this.#server.getClientVersion()
+          },
+          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 (error2) {
+        if (error2 instanceof UserError) {
+          return {
+            content: [{ text: error2.message, type: "text" }],
+            isError: true,
+            ...error2.extras ? { structuredContent: error2.extras } : {}
+          };
+        }
+        const errorMessage = error2 instanceof Error ? error2.message : String(error2);
+        return {
+          content: [
+            {
+              text: `Tool '${request.params.name}' execution failed: ${errorMessage}`,
+              type: "text"
+            }
+          ],
+          isError: true
+        };
+      }
+      return result;
+    });
+  }
+};
+function camelToSnakeCase(str2) {
+  return str2.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 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;
+  }
+}
+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";
+  #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") {
+      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") {
+      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") {
+      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") {
+      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") {
+      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") {
+      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") {
+      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") {
+      this.#toolsListChanged(this.#tools);
+    }
+  }
+  /**
+   * Embeds a resource by URI, making it easy to include resources in tool responses.
+   *
+   * @param uri - The URI of the resource to embed
+   * @returns Promise<ResourceContent> - The embedded resource content
+   */
+  async embedded(uri) {
+    const directResource = this.#resources.find(
+      (resource) => resource.uri === uri
+    );
+    if (directResource) {
+      const result = await directResource.load();
+      const results = Array.isArray(result) ? result : [result];
+      const firstResult = results[0];
+      const resourceData = {
+        mimeType: directResource.mimeType,
+        uri
+      };
+      if ("text" in firstResult) {
+        resourceData.text = firstResult.text;
+      }
+      if ("blob" in firstResult) {
+        resourceData.blob = firstResult.blob;
+      }
+      return resourceData;
+    }
+    for (const template of this.#resourcesTemplates) {
+      const parsedTemplate = parseURITemplate(template.uriTemplate);
+      const params = parsedTemplate.fromUri(uri);
+      if (!params) {
+        continue;
+      }
+      const result = await template.load(
+        params
+      );
+      const resourceData = {
+        mimeType: template.mimeType,
+        uri
+      };
+      if ("text" in result) {
+        resourceData.text = result.text;
+      }
+      if ("blob" in result) {
+        resourceData.blob = result.blob;
+      }
+      return resourceData;
+    }
+    throw new UnexpectedStateError(`Resource not found: ${uri}`, { uri });
+  }
+  /**
+   * Returns the underlying Hono app instance for direct access to Hono's native API.
+   * This allows you to add custom routes, middleware, and handlers using Hono's standard methods.
+   *
+   * @returns The Hono app instance
+   *
+   * @example
+   * ```typescript
+   * const app = server.getApp();
+   *
+   * // Add routes using native Hono API
+   * app.get('/api/users', async (c) => {
+   *   return c.json({ users: [] });
+   * });
+   *
+   * app.post('/api/users/:id', async (c) => {
+   *   const id = c.req.param('id');
+   *   return c.json({ id });
+   * });
+   * ```
+   */
+  getApp() {
+    return this.#honoApp;
+  }
+  /**
+   * Removes a prompt from the server.
+   */
+  removePrompt(name2) {
+    this.#prompts = this.#prompts.filter((p) => p.name !== name2);
+    if (this.#serverState === "running") {
+      this.#promptsListChanged(this.#prompts);
+    }
+  }
+  /**
+   * Removes prompts from the server.
+   */
+  removePrompts(names) {
+    for (const name2 of names) {
+      this.#prompts = this.#prompts.filter((p) => p.name !== name2);
+    }
+    if (this.#serverState === "running") {
+      this.#promptsListChanged(this.#prompts);
+    }
+  }
+  /**
+   * Removes a resource from the server.
+   */
+  removeResource(name2) {
+    this.#resources = this.#resources.filter((r) => r.name !== name2);
+    if (this.#serverState === "running") {
+      this.#resourcesListChanged(this.#resources);
+    }
+  }
+  /**
+   * Removes resources from the server.
+   */
+  removeResources(names) {
+    for (const name2 of names) {
+      this.#resources = this.#resources.filter((r) => r.name !== name2);
+    }
+    if (this.#serverState === "running") {
+      this.#resourcesListChanged(this.#resources);
+    }
+  }
+  /**
+   * Removes a resource template from the server.
+   */
+  removeResourceTemplate(name2) {
+    this.#resourcesTemplates = this.#resourcesTemplates.filter(
+      (t) => t.name !== name2
+    );
+    if (this.#serverState === "running") {
+      this.#resourceTemplatesListChanged(this.#resourcesTemplates);
+    }
+  }
+  /**
+   * Removes resource templates from the server.
+   */
+  removeResourceTemplates(names) {
+    for (const name2 of names) {
+      this.#resourcesTemplates = this.#resourcesTemplates.filter(
+        (t) => t.name !== name2
+      );
+    }
+    if (this.#serverState === "running") {
+      this.#resourceTemplatesListChanged(this.#resourcesTemplates);
+    }
+  }
+  /**
+   * Removes a tool from the server.
+   */
+  removeTool(name2) {
+    this.#tools = this.#tools.filter((t) => t.name !== name2);
+    if (this.#serverState === "running") {
+      this.#toolsListChanged(this.#tools);
+    }
+  }
+  /**
+   * Removes tools from the server.
+   */
+  removeTools(names) {
+    for (const name2 of names) {
+      this.#tools = this.#tools.filter((t) => t.name !== name2);
+    }
+    if (this.#serverState === "running") {
+      this.#toolsListChanged(this.#tools);
+    }
+  }
+  /**
+   * Starts the server.
+   */
+  async start(options) {
+    const config = this.#parseRuntimeConfig(options);
+    if (config.transportType === "stdio") {
+      const transport = new StdioServerTransport();
+      let auth;
+      if (this.#authenticate) {
+        try {
+          auth = await this.#authenticate(
+            void 0
+          );
+        } catch (error2) {
+          this.#logger.error(
+            "[FastMCP error] Authentication failed for stdio transport:",
+            error2 instanceof Error ? error2.message : String(error2)
+          );
+        }
+      }
+      const session = new FastMCPSession({
+        auth,
+        instructions: this.#options.instructions,
+        logger: this.#logger,
+        name: this.#options.name,
+        onToolCall: this.#options.onToolCall,
+        ping: this.#options.ping,
+        prompts: this.#prompts,
+        resources: this.#resources,
+        resourcesTemplates: this.#resourcesTemplates,
+        roots: this.#options.roots,
+        tools: this.#tools,
+        transportType: "stdio",
+        utils: this.#options.utils,
+        version: this.#options.version
+      });
+      await session.connect(transport);
+      this.#sessions.push(session);
+      session.once("error", () => {
+        this.#removeSession(session);
+      });
+      if (transport.onclose) {
+        const originalOnClose = transport.onclose;
+        transport.onclose = () => {
+          this.#removeSession(session);
+          if (originalOnClose) {
+            originalOnClose();
+          }
+        };
+      } else {
+        transport.onclose = () => {
+          this.#removeSession(session);
+        };
+      }
+      this.emit("connect", {
+        session
+      });
+      this.#serverState = "running";
+    } else if (config.transportType === "httpStream") {
+      const httpConfig = config.httpStream;
+      const protocol = httpConfig.sslCert || httpConfig.sslKey ? "https" : "http";
+      if (httpConfig.stateless) {
+        this.#logger.info(
+          `[FastMCP info] Starting server in stateless mode on HTTP Stream at ${protocol}://${httpConfig.host}:${httpConfig.port}${httpConfig.endpoint}`
+        );
+        this.#httpStreamServer = await startHTTPServer({
+          ...this.#authenticate ? { authenticate: this.#authenticate } : {},
+          cors: httpConfig.cors,
+          createServer: async (request) => {
+            let auth;
+            if (this.#authenticate) {
+              auth = await this.#authenticate(request);
+              if (auth === void 0 || auth === null) {
+                throw new Error("Authentication required");
+              }
+            }
+            const sessionId = Array.isArray(request.headers["mcp-session-id"]) ? request.headers["mcp-session-id"][0] : request.headers["mcp-session-id"];
+            return this.#createSession(auth, sessionId);
+          },
+          enableJsonResponse: httpConfig.enableJsonResponse,
+          eventStore: httpConfig.eventStore,
+          host: httpConfig.host,
+          ...this.#options.oauth?.enabled && this.#options.oauth.protectedResource?.resource ? {
+            oauth: {
+              protectedResource: {
+                resource: this.#options.oauth.protectedResource.resource
+              }
+            }
+          } : {},
+          // In stateless mode, we don't track sessions
+          onClose: async () => {
+          },
+          onConnect: async () => {
+            this.#logger.debug(
+              `[FastMCP debug] Stateless HTTP Stream request handled`
+            );
+          },
+          onUnhandledRequest: async (req, res) => {
+            await this.#handleUnhandledRequest(
+              req,
+              res,
+              true,
+              httpConfig.host,
+              httpConfig.endpoint
+            );
+          },
+          port: httpConfig.port,
+          sslCa: httpConfig.sslCa,
+          sslCert: httpConfig.sslCert,
+          sslKey: httpConfig.sslKey,
+          stateless: true,
+          streamEndpoint: httpConfig.endpoint
+        });
+      } else {
+        this.#httpStreamServer = await startHTTPServer({
+          ...this.#authenticate ? { authenticate: this.#authenticate } : {},
+          cors: httpConfig.cors,
+          createServer: async (request) => {
+            let auth;
+            if (this.#authenticate) {
+              auth = await this.#authenticate(request);
+            }
+            const sessionId = Array.isArray(request.headers["mcp-session-id"]) ? request.headers["mcp-session-id"][0] : request.headers["mcp-session-id"];
+            return this.#createSession(auth, sessionId);
+          },
+          enableJsonResponse: httpConfig.enableJsonResponse,
+          eventStore: httpConfig.eventStore,
+          host: httpConfig.host,
+          ...this.#options.oauth?.enabled && this.#options.oauth.protectedResource?.resource ? {
+            oauth: {
+              protectedResource: {
+                resource: this.#options.oauth.protectedResource.resource
+              }
+            }
+          } : {},
+          onClose: async (session) => {
+            const sessionIndex = this.#sessions.indexOf(session);
+            if (sessionIndex !== -1) this.#sessions.splice(sessionIndex, 1);
+            this.emit("disconnect", {
+              session
+            });
+          },
+          onConnect: async (session) => {
+            this.#sessions.push(session);
+            this.#logger.info(`[FastMCP info] HTTP Stream session established`);
+            this.emit("connect", {
+              session
+            });
+          },
+          onUnhandledRequest: async (req, res) => {
+            await this.#handleUnhandledRequest(
+              req,
+              res,
+              false,
+              httpConfig.host,
+              httpConfig.endpoint
+            );
+          },
+          port: httpConfig.port,
+          sslCa: httpConfig.sslCa,
+          sslCert: httpConfig.sslCert,
+          sslKey: httpConfig.sslKey,
+          stateless: httpConfig.stateless,
+          streamEndpoint: httpConfig.endpoint
+        });
+        this.#logger.info(
+          `[FastMCP info] server is running on HTTP Stream at ${protocol}://${httpConfig.host}:${httpConfig.port}${httpConfig.endpoint}`
+        );
+      }
+      this.#serverState = "running";
+    } else {
+      throw new Error("Invalid transport type");
+    }
+  }
+  /**
+   * Stops the server.
+   */
+  async stop() {
+    if (this.#httpStreamServer) {
+      await this.#httpStreamServer.close();
+    }
+    this.#serverState = "stopped";
+  }
+  /**
+   * Creates a new FastMCPSession instance with the current configuration.
+   * Used both for regular sessions and stateless requests.
+   */
+  #createSession(auth, sessionId) {
+    if (auth && typeof auth === "object" && "authenticated" in auth && !auth.authenticated) {
+      const errorMessage = "error" in auth && typeof auth.error === "string" ? auth.error : "Authentication failed";
+      throw new Error(errorMessage);
+    }
+    const allowedTools = auth ? this.#tools.filter(
+      (tool) => tool.canAccess ? tool.canAccess(auth) : true
+    ) : this.#tools;
+    return new FastMCPSession({
+      auth,
+      instructions: this.#options.instructions,
+      logger: this.#logger,
+      name: this.#options.name,
+      onToolCall: this.#options.onToolCall,
+      ping: this.#options.ping,
+      prompts: this.#prompts,
+      resources: this.#resources,
+      resourcesTemplates: this.#resourcesTemplates,
+      roots: this.#options.roots,
+      sessionId,
+      tools: allowedTools,
+      transportType: "httpStream",
+      utils: this.#options.utils,
+      version: this.#options.version
+    });
+  }
+  /**
+   * Handles unhandled HTTP requests with health, readiness, OAuth endpoints, and custom routes
+   */
+  #handleUnhandledRequest = async (req, res, isStateless = false, host, streamEndpoint) => {
+    const url = new URL(req.url || "", `http://${host}`);
+    try {
+      const webRequest = this.#nodeRequestToWebRequest(req, url);
+      const honoResponse = await this.#honoApp.fetch(webRequest, {
+        incoming: req,
+        outgoing: res
+      });
+      if (honoResponse.status !== 404) {
+        if (!res.headersSent) {
+          res.statusCode = honoResponse.status;
+          honoResponse.headers.forEach((value, key) => {
+            res.setHeader(key, value);
+          });
+          if (honoResponse.body) {
+            const reader = honoResponse.body.getReader();
+            try {
+              while (true) {
+                const { done, value } = await reader.read();
+                if (done) break;
+                res.write(value);
+              }
+            } finally {
+              reader.releaseLock();
+            }
+          }
+          res.end();
+        }
+        return;
+      }
+    } catch (error2) {
+      this.#logger.debug("[FastMCP debug] Hono route not matched", error2);
+    }
+    const healthConfig = this.#options.health ?? {};
+    const enabled = healthConfig.enabled === void 0 ? true : healthConfig.enabled;
+    if (enabled) {
+      const path2 = healthConfig.path ?? "/health";
+      const url2 = new URL(req.url || "", `http://${host}`);
+      try {
+        if ((req.method === "GET" || req.method === "HEAD") && url2.pathname === path2) {
+          res.writeHead(healthConfig.status ?? 200, {
+            "Content-Type": "text/plain"
+          }).end(
+            req.method === "HEAD" ? void 0 : healthConfig.message ?? "\u2713 Ok"
+          );
+          return;
+        }
+        if ((req.method === "GET" || req.method === "HEAD") && url2.pathname === "/ready") {
+          if (isStateless) {
+            const response = {
+              mode: "stateless",
+              ready: 1,
+              status: "ready",
+              total: 1
+            };
+            res.writeHead(200, {
+              "Content-Type": "application/json"
+            }).end(
+              req.method === "HEAD" ? void 0 : JSON.stringify(response)
+            );
+          } else {
+            const readySessions = this.#sessions.filter(
+              (s) => s.isReady
+            ).length;
+            const totalSessions = this.#sessions.length;
+            const allReady = readySessions === totalSessions && totalSessions > 0;
+            const response = {
+              ready: readySessions,
+              status: allReady ? "ready" : totalSessions === 0 ? "no_sessions" : "initializing",
+              total: totalSessions
+            };
+            res.writeHead(allReady ? 200 : 503, {
+              "Content-Type": "application/json"
+            }).end(
+              req.method === "HEAD" ? void 0 : JSON.stringify(response)
+            );
+          }
+          return;
+        }
+      } catch (error2) {
+        this.#logger.error("[FastMCP error] health endpoint error", error2);
+      }
+    }
+    const oauthConfig = this.#options.oauth;
+    if (oauthConfig?.enabled && req.method === "GET") {
+      const url2 = new URL(req.url || "", `http://${host}`);
+      if (url2.pathname === "/.well-known/oauth-authorization-server" && oauthConfig.authorizationServer) {
+        const metadata = convertObjectToSnakeCase(
+          oauthConfig.authorizationServer
+        );
+        res.writeHead(200, {
+          "Content-Type": "application/json"
+        }).end(JSON.stringify(metadata));
+        return;
+      }
+      if (oauthConfig.protectedResource) {
+        const wellKnownBase = "/.well-known/oauth-protected-resource";
+        let shouldServeMetadata = false;
+        if (streamEndpoint && url2.pathname === `${wellKnownBase}${streamEndpoint}`) {
+          shouldServeMetadata = true;
+        } else if (url2.pathname === wellKnownBase) {
+          shouldServeMetadata = true;
+        }
+        if (shouldServeMetadata) {
+          const metadata = convertObjectToSnakeCase(
+            oauthConfig.protectedResource
+          );
+          res.writeHead(200, {
+            "Content-Type": "application/json"
+          }).end(JSON.stringify(metadata));
+          return;
+        }
+      }
+    }
+    const oauthProxy = oauthConfig?.proxy;
+    if (oauthProxy && oauthConfig?.enabled) {
+      const url2 = new URL(req.url || "", `http://${host}`);
+      try {
+        if (req.method === "POST" && url2.pathname === "/oauth/register") {
+          await new Promise((resolve) => {
+            let body = "";
+            req.on("data", (chunk) => body += chunk);
+            req.on("end", async () => {
+              try {
+                const request = JSON.parse(body);
+                const response = await oauthProxy.registerClient(request);
+                res.writeHead(201, { "Content-Type": "application/json" }).end(JSON.stringify(response));
+              } catch (error2) {
+                const statusCode = error2.statusCode || 400;
+                res.writeHead(statusCode, { "Content-Type": "application/json" }).end(
+                  JSON.stringify(
+                    error2.toJSON?.() || {
+                      error: "invalid_request"
+                    }
+                  )
+                );
+              }
+              resolve();
+            });
+          });
+          return;
+        }
+        if (req.method === "GET" && url2.pathname === "/oauth/authorize") {
+          try {
+            const params = Object.fromEntries(url2.searchParams.entries());
+            const response = await oauthProxy.authorize(
+              params
+            );
+            const location = response.headers.get("Location");
+            if (location) {
+              res.writeHead(response.status, { Location: location }).end();
+            } else {
+              const html = await response.text();
+              res.writeHead(response.status, { "Content-Type": "text/html" }).end(html);
+            }
+          } catch (error2) {
+            res.writeHead(400, { "Content-Type": "application/json" }).end(
+              JSON.stringify(
+                error2.toJSON?.() || {
+                  error: "invalid_request"
+                }
+              )
+            );
+          }
+          return;
+        }
+        if (req.method === "GET" && url2.pathname === "/oauth/callback") {
+          try {
+            const mockRequest = new Request(`http://${host}${req.url}`);
+            const response = await oauthProxy.handleCallback(mockRequest);
+            const location = response.headers.get("Location");
+            if (location) {
+              res.writeHead(response.status, { Location: location }).end();
+            } else {
+              const text = await response.text();
+              res.writeHead(response.status).end(text);
+            }
+          } catch (error2) {
+            res.writeHead(400, { "Content-Type": "application/json" }).end(
+              JSON.stringify(
+                error2.toJSON?.() || {
+                  error: "server_error"
+                }
+              )
+            );
+          }
+          return;
+        }
+        if (req.method === "POST" && url2.pathname === "/oauth/consent") {
+          await new Promise((resolve) => {
+            let body = "";
+            req.on("data", (chunk) => body += chunk);
+            req.on("end", async () => {
+              try {
+                const mockRequest = new Request(
+                  `http://${host}/oauth/consent`,
+                  {
+                    body,
+                    headers: {
+                      "Content-Type": "application/x-www-form-urlencoded"
+                    },
+                    method: "POST"
+                  }
+                );
+                const response = await oauthProxy.handleConsent(mockRequest);
+                const location = response.headers.get("Location");
+                if (location) {
+                  res.writeHead(response.status, { Location: location }).end();
+                } else {
+                  const text = await response.text();
+                  res.writeHead(response.status).end(text);
+                }
+              } catch (error2) {
+                res.writeHead(400, { "Content-Type": "application/json" }).end(
+                  JSON.stringify(
+                    error2.toJSON?.() || {
+                      error: "server_error"
+                    }
+                  )
+                );
+              }
+              resolve();
+            });
+          });
+          return;
+        }
+        if (req.method === "POST" && url2.pathname === "/oauth/token") {
+          await new Promise((resolve) => {
+            let body = "";
+            req.on("data", (chunk) => body += chunk);
+            req.on("end", async () => {
+              try {
+                const params = new URLSearchParams(body);
+                const grantType = params.get("grant_type");
+                const basicAuth = parseBasicAuthHeader(
+                  req.headers.authorization
+                );
+                const clientId = basicAuth?.clientId || params.get("client_id") || "";
+                const clientSecret = basicAuth?.clientSecret ?? params.get("client_secret") ?? void 0;
+                let response;
+                if (grantType === "authorization_code") {
+                  response = await oauthProxy.exchangeAuthorizationCode({
+                    client_id: clientId,
+                    client_secret: clientSecret,
+                    code: params.get("code") || "",
+                    code_verifier: params.get("code_verifier") || void 0,
+                    grant_type: "authorization_code",
+                    redirect_uri: params.get("redirect_uri") || ""
+                  });
+                } else if (grantType === "refresh_token") {
+                  response = await oauthProxy.exchangeRefreshToken({
+                    client_id: clientId,
+                    client_secret: clientSecret,
+                    grant_type: "refresh_token",
+                    refresh_token: params.get("refresh_token") || "",
+                    scope: params.get("scope") || void 0
+                  });
+                } else {
+                  throw {
+                    statusCode: 400,
+                    toJSON: () => ({ error: "unsupported_grant_type" })
+                  };
+                }
+                res.writeHead(200, { "Content-Type": "application/json" }).end(JSON.stringify(response));
+              } catch (error2) {
+                const statusCode = error2.statusCode || 400;
+                res.writeHead(statusCode, { "Content-Type": "application/json" }).end(
+                  JSON.stringify(
+                    error2.toJSON?.() || {
+                      error: "invalid_request"
+                    }
+                  )
+                );
+              }
+              resolve();
+            });
+          });
+          return;
+        }
+      } catch (error2) {
+        this.#logger.error("[FastMCP error] OAuth Proxy endpoint error", error2);
+        res.writeHead(500).end();
+        return;
+      }
+    }
+  };
+  /**
+   * Converts Node.js IncomingMessage to Web Request for Hono
+   */
+  #nodeRequestToWebRequest(req, url) {
+    const method = req.method || "GET";
+    const headers = new Headers();
+    for (const [key, value] of Object.entries(req.headers)) {
+      if (value) {
+        if (Array.isArray(value)) {
+          for (const v of value) {
+            headers.append(key, v);
+          }
+        } else {
+          headers.set(key, value);
+        }
+      }
+    }
+    const hasBody = method !== "GET" && method !== "HEAD";
+    if (hasBody) {
+      return new Request(url.toString(), {
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        body: req,
+        // Node.js IncomingMessage is readable stream
+        duplex: "half",
+        // Required for streaming bodies
+        headers,
+        method
+      });
+    } else {
+      return new Request(url.toString(), {
+        headers,
+        method
+      });
+    }
+  }
+  #parseRuntimeConfig(overrides) {
+    const args2 = process.argv.slice(2);
+    const getArg = (name2) => {
+      const index = args2.findIndex((arg) => arg === `--${name2}`);
+      return index !== -1 && index + 1 < args2.length ? args2[index + 1] : void 0;
+    };
+    const transportArg = getArg("transport");
+    const portArg = getArg("port");
+    const endpointArg = getArg("endpoint");
+    const statelessArg = getArg("stateless");
+    const hostArg = getArg("host");
+    const envTransport = process.env.FASTMCP_TRANSPORT;
+    const envPort = process.env.FASTMCP_PORT;
+    const envEndpoint = process.env.FASTMCP_ENDPOINT;
+    const envStateless = process.env.FASTMCP_STATELESS;
+    const envHost = process.env.FASTMCP_HOST;
+    const transportType = overrides?.transportType || (transportArg === "http-stream" ? "httpStream" : transportArg) || envTransport || "stdio";
+    if (transportType === "httpStream") {
+      const port = parseInt(
+        overrides?.httpStream?.port?.toString() || portArg || envPort || "8080"
+      );
+      const host = overrides?.httpStream?.host || hostArg || envHost || "localhost";
+      const endpoint = overrides?.httpStream?.endpoint || endpointArg || envEndpoint || "/mcp";
+      const enableJsonResponse = overrides?.httpStream?.enableJsonResponse || false;
+      const stateless = overrides?.httpStream?.stateless || statelessArg === "true" || envStateless === "true" || false;
+      const cors = overrides?.httpStream?.cors;
+      const eventStore = overrides?.httpStream?.eventStore;
+      const sslCa = overrides?.httpStream?.sslCa;
+      const sslCert = overrides?.httpStream?.sslCert;
+      const sslKey = overrides?.httpStream?.sslKey;
+      return {
+        httpStream: {
+          cors,
+          enableJsonResponse,
+          endpoint,
+          eventStore,
+          host,
+          port,
+          sslCa,
+          sslCert,
+          sslKey,
+          stateless
+        },
+        transportType: "httpStream"
+      };
+    }
+    return { transportType: "stdio" };
+  }
+  /**
+   * Notifies all sessions that the prompts list has changed.
+   */
+  #promptsListChanged(prompts) {
+    for (const session of this.#sessions) {
+      session.promptsListChanged(prompts);
+    }
+  }
+  #removeSession(session) {
+    const sessionIndex = this.#sessions.indexOf(session);
+    if (sessionIndex !== -1) {
+      this.#sessions.splice(sessionIndex, 1);
+      this.emit("disconnect", {
+        session
+      });
+    }
+  }
+  /**
+   * Notifies all sessions that the resources list has changed.
+   */
+  #resourcesListChanged(resources) {
+    for (const session of this.#sessions) {
+      session.resourcesListChanged(resources);
+    }
+  }
+  /**
+   * Notifies all sessions that the resource templates list has changed.
+   */
+  #resourceTemplatesListChanged(templates) {
+    for (const session of this.#sessions) {
+      session.resourceTemplatesListChanged(templates);
+    }
+  }
+  /**
+   * Notifies all sessions that the tools list has changed.
+   */
+  #toolsListChanged(tools) {
+    for (const session of this.#sessions) {
+      session.toolsListChanged(tools);
+    }
+  }
+};
+
+// node_modules/.pnpm/fastmcp@4.3.2_patch_hash=08f77b633292d9ae4cb022c0fa5bd722dbd5c1aaaad600204f8ed38339bfd37b/node_modules/fastmcp/dist/chunk-OJG4XYXA.js
+import { z as z3 } from "zod";
+import { createHmac as createHmac2, pbkdf2, randomBytes } from "crypto";
+import { promisify } from "util";
+var pbkdf2Async = promisify(pbkdf2);
+
+// src/index.ts
 import { readFile } from "fs/promises";
 import { createRequire as createRequire2 } from "module";
 import { randomUUID } from "crypto";
 import path from "path";
-import { z as z8 } from "zod";
+import { z as z10 } from "zod";
 
 // src/agent-hints.ts
 var AGENT_HINTS_HEADERS = { "X-Firecrawl-Agent-Hints": "true" };
@@ -130,7 +2116,7 @@ function readErrorAgentHints(error2) {
 }
 
 // src/tool-output.ts
-import { z as z2 } from "zod";
+import { z as z4 } from "zod";
 function isRecord(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }
@@ -150,15 +2136,15 @@ function structuredJsonText(text) {
     return { content: [{ type: "text", text }] };
   }
 }
-var str = (description) => z2.string().nullable().optional().describe(description);
-var num = (description) => z2.number().nullable().optional().describe(description);
-var bool = (description) => z2.boolean().nullable().optional().describe(description);
-var unknown = (description) => z2.unknown().optional().describe(description);
+var str = (description) => z4.string().nullable().optional().describe(description);
+var num = (description) => z4.number().nullable().optional().describe(description);
+var bool = (description) => z4.boolean().nullable().optional().describe(description);
+var unknown = (description) => z4.unknown().optional().describe(description);
 var success = bool("Whether the API call succeeded.");
 var error = unknown("Error message or error object when the call did not succeed.");
 var warning = str("Non-fatal warning about the result.");
 var agentHints = {
-  agent_hints: z2.array(z2.string()).optional().describe("Optional response guidance from the Firecrawl API.")
+  agent_hints: z4.array(z4.string()).optional().describe("Optional response guidance from the Firecrawl API.")
 };
 var alexandriaEnvelope = {
   requestId: str("Identifier of this Alexandria execution."),
@@ -176,7 +2162,7 @@ var alexandriaEnvelope = {
   nextTool: unknown("A follow-up tool call (`{name, arguments}`) that continues or inspects this result."),
   feedbackTool: unknown("Pointer to the feedback tool for reporting how this result served the task.")
 };
-var scrapeOutputSchema = z2.object({
+var scrapeOutputSchema = z4.object({
   ...agentHints,
   // URL mode: the scraped document, with the formats that were requested.
   markdown: str("Page content as markdown."),
@@ -208,7 +2194,7 @@ var scrapeOutputSchema = z2.object({
   data: unknown("Alexandria mode: per-capability results in `data.alexandria`, each with `data`, `records`, or an `error`."),
   ...alexandriaEnvelope
 }).describe("A scraped document, or the Alexandria execution envelope when `alexandria` was passed.");
-var mapOutputSchema = z2.object({
+var mapOutputSchema = z4.object({
   ...agentHints,
   links: unknown("URLs discovered under the website."),
   success,
@@ -216,7 +2202,7 @@ var mapOutputSchema = z2.object({
   warning,
   id: str("Identifier of the map run, for optional map feedback.")
 }).describe("URLs indexed under the requested website.");
-var searchOutputSchema = z2.object({
+var searchOutputSchema = z4.object({
   ...agentHints,
   success,
   data: unknown("Ranked results grouped by source, such as `web`, `news`, `images`, and `alexandria`."),
@@ -228,14 +2214,14 @@ var searchOutputSchema = z2.object({
   nextTool: unknown("A follow-up tool call that continues this search."),
   feedbackTool: unknown("Pointer to the feedback tool for this search.")
 }).describe("Ranked search results grouped by source.");
-var findToolsOutputSchema = z2.object({
+var findToolsOutputSchema = z4.object({
   ...agentHints,
   success,
   data: unknown("Discovery page in `data.alexandria[0].data`, with `level`, `items`, `total`, and an optional `nextTool`."),
   error,
   ...alexandriaEnvelope
 }).describe("One page of the Alexandria catalogue: categories, providers, tools, or one contract.");
-var feedbackOutputSchema = z2.object({
+var feedbackOutputSchema = z4.object({
   ...agentHints,
   success,
   error,
@@ -253,7 +2239,7 @@ var feedbackOutputSchema = z2.object({
   data: unknown("Payload returned with the accepted feedback."),
   raw: str("Response body when it was not JSON.")
 }).describe("Result of submitting feedback.");
-var crawlOutputSchema = z2.object({
+var crawlOutputSchema = z4.object({
   ...agentHints,
   success,
   error,
@@ -268,7 +2254,7 @@ var crawlOutputSchema = z2.object({
   url: str("The URL the crawl started from."),
   data: unknown("Scraped documents collected by the crawl.")
 }).describe("Crawl job state and the documents collected so far.");
-var agentOutputSchema = z2.object({
+var agentOutputSchema = z4.object({
   ...agentHints,
   success,
   error,
@@ -277,7 +2263,7 @@ var agentOutputSchema = z2.object({
   threadId: str("Research thread this job belongs to."),
   threadTurn: num("Turn number of this job within its thread.")
 }).describe("The queued research job. The result is read with `firecrawl_agent_status`.");
-var agentStatusOutputSchema = z2.object({
+var agentStatusOutputSchema = z4.object({
   ...agentHints,
   success,
   error,
@@ -301,7 +2287,7 @@ var agentStatusOutputSchema = z2.object({
     'Set when the job ended waiting on the caller. Answer it by calling firecrawl_agent with this threadId and exchange.approve or exchange.decline carrying its id. kind "terms" lists providers whose data terms need accepting; otherwise calls lists paid calls waiting for approval.'
   )
 }).describe("Progress or final result of a research agent job.");
-var interactOutputSchema = z2.object({
+var interactOutputSchema = z4.object({
   ...agentHints,
   success,
   error: unknown("Why the interaction or the session could not run."),
@@ -316,14 +2302,14 @@ var interactOutputSchema = z2.object({
   sessionUrl: str("URL for viewing the live session."),
   liveUrl: str("URL for viewing the live session.")
 }).describe("Result of a browser interaction, with the session identifier to continue or stop it.");
-var interactStopOutputSchema = z2.object({
+var interactStopOutputSchema = z4.object({
   ...agentHints,
   success,
   error,
   message: str("Confirmation that the session was stopped."),
   scrapeId: str("Session that was stopped.")
 }).describe("Confirmation that the interact session was stopped.");
-var parseOutputSchema = z2.object({
+var parseOutputSchema = z4.object({
   ...agentHints,
   success,
   error,
@@ -331,7 +2317,7 @@ var parseOutputSchema = z2.object({
   mode: str("Which phase of the hosted flow produced this response."),
   message: str("Guidance for the next call."),
   data: unknown("Parsed document content; can include `data.metadata.scrapeId` for parse feedback."),
-  upload: z2.object({
+  upload: z4.object({
     command: str("Local command that performs the upload. It carries no Firecrawl API key."),
     method: str("HTTP method for the upload."),
     headers: unknown("Headers the upload request must send."),
@@ -342,48 +2328,48 @@ var parseOutputSchema = z2.object({
     maxSizeBytes: num("Largest file the upload URL accepts.")
   }).optional().describe("Hosted phase one: how to upload the local file."),
   nextToolCall: unknown("Hosted phase one: the second `firecrawl_parse` call to make once the upload succeeds, as `{name, arguments}`."),
-  notes: z2.array(z2.string()).nullable().optional().describe("Hosted phase one: constraints on completing the upload flow."),
+  notes: z4.array(z4.string()).nullable().optional().describe("Hosted phase one: constraints on completing the upload flow."),
   raw: str("Response body when it was not JSON.")
 }).describe("Parsed document content, or the upload instructions for the hosted two-call flow.");
-var deprecatedToolOutputSchema = z2.object({
+var deprecatedToolOutputSchema = z4.object({
   code: str("Always `DEPRECATED_TOOL`."),
   message: str("Why the tool is unavailable and what to call instead."),
   replacement: unknown("The replacement tool, with instructions and example arguments."),
   docs_url: str("Documentation for the replacement.")
 }).describe("A pointer to the replacement tool. This entry point is deprecated and always errors.");
-var monitorOutputSchema = z2.object({
+var monitorOutputSchema = z4.object({
   ...agentHints,
   success,
   error,
   data: unknown("The monitor record: configuration, schedule, targets, and current state.")
 }).describe("One monitor record.");
-var monitorListOutputSchema = z2.object({
+var monitorListOutputSchema = z4.object({
   ...agentHints,
   success,
   error,
   data: unknown("One page of monitor records."),
   pagination: unknown("Pagination metadata for the listing.")
 }).describe("One page of monitors for the authenticated account.");
-var monitorDeleteOutputSchema = z2.object({
+var monitorDeleteOutputSchema = z4.object({
   ...agentHints,
   success,
   error,
   data: unknown("Deletion details, when the API returns any.")
 }).describe("Deletion status for the monitor.");
-var monitorRunOutputSchema = z2.object({
+var monitorRunOutputSchema = z4.object({
   ...agentHints,
   success,
   error,
   data: unknown("The queued check.")
 }).describe("The check queued outside the monitor schedule.");
-var monitorChecksOutputSchema = z2.object({
+var monitorChecksOutputSchema = z4.object({
   ...agentHints,
   success,
   error,
   data: unknown("One page of check summaries."),
   pagination: unknown("Pagination metadata for the listing.")
 }).describe("One page of historical checks for the monitor.");
-var monitorCheckOutputSchema = z2.object({
+var monitorCheckOutputSchema = z4.object({
   ...agentHints,
   success,
   error,
@@ -391,47 +2377,47 @@ var monitorCheckOutputSchema = z2.object({
   pagination: unknown("Pagination metadata for the page results."),
   next: str("URL of the next page of results, when more exist.")
 }).describe("One monitor check with its page-level diff results.");
-var paperSchema = z2.looseObject({
+var paperSchema = z4.looseObject({
   paperId: str("Canonical paper identifier."),
   primaryId: str("Display identifier, ordered for citation and fetch use."),
   ids: unknown("Source identifiers by namespace, such as `arxiv`, `doi`, or `pmid`."),
   title: str("Paper title."),
   abstract: str("Paper abstract."),
   authors: unknown("Authors, as a comma-joined string or as `{name, affiliation}` entries."),
-  categories: z2.array(z2.string()).nullable().optional().describe("Paper categories, such as `cs.LG`."),
+  categories: z4.array(z4.string()).nullable().optional().describe("Paper categories, such as `cs.LG`."),
   createdDate: str("Date the paper was first indexed or published."),
   updateDate: str("Date the paper was last updated.")
 });
-var researchSearchOutputSchema = z2.object({
+var researchSearchOutputSchema = z4.object({
   ...agentHints,
-  results: z2.array(paperSchema).describe("Ranked papers, in the order the text block lists them.")
+  results: z4.array(paperSchema).describe("Ranked papers, in the order the text block lists them.")
 }).describe("Ranked papers with canonical IDs, titles, authors, and abstracts.");
-var researchPaperOutputSchema = z2.object({
+var researchPaperOutputSchema = z4.object({
   ...agentHints,
   paper: paperSchema.optional().describe("Canonical metadata for the requested paper, absent when it was not found.")
 }).describe("Canonical metadata for one paper.");
-var researchRelatedOutputSchema = z2.object({
+var researchRelatedOutputSchema = z4.object({
   ...agentHints,
-  results: z2.array(paperSchema).describe("Ranked citation-graph candidates."),
-  poolSize: z2.number().describe("Number of candidates evaluated before ranking."),
+  results: z4.array(paperSchema).describe("Ranked citation-graph candidates."),
+  poolSize: z4.number().describe("Number of candidates evaluated before ranking."),
   note: str("Note about how the candidates were produced.")
 }).describe("Ranked citation-graph candidates and the size of the evaluated pool.");
-var researchReadOutputSchema = z2.object({
+var researchReadOutputSchema = z4.object({
   ...agentHints,
-  passages: z2.array(z2.looseObject({ text: str("Passage text.") })).describe("In-body passages relevant to the question; empty when no full text is indexed.")
+  passages: z4.array(z4.looseObject({ text: str("Passage text.") })).describe("In-body passages relevant to the question; empty when no full text is indexed.")
 }).describe("Full-text passages from one paper.");
-var developerSearchOutputSchema = z2.object({
+var developerSearchOutputSchema = z4.object({
   ...agentHints,
-  results: z2.array(
-    z2.looseObject({
+  results: z4.array(
+    z4.looseObject({
       id: str("Stable result id, such as `issue:owner/repo#123` or `doc:<hash>`; its prefix gives the source type."),
       url: str("Source URL."),
       title: str("Result title."),
-      passages: z2.array(z2.looseObject({ text: str("Matched passage, in markdown.") })).optional().describe("Matched passages.")
+      passages: z4.array(z4.looseObject({ text: str("Matched passage, in markdown.") })).optional().describe("Matched passages.")
     })
   ).describe("Ranked results, in the order the text block lists them.")
 }).describe("Ranked developer-index results with their matched passages.");
-var creditUsageOutputSchema = z2.object({
+var creditUsageOutputSchema = z4.object({
   // Current view.
   remainingCredits: num("Credits left in the current billing period; can exceed `planCredits` when extra credits were purchased or granted."),
   planCredits: num("Credits included in the plan for the period."),
@@ -444,11 +2430,11 @@ var creditUsageOutputSchema = z2.object({
 }).describe("The team credit balance, or historical credit consumption by period.");
 
 // src/alexandria.ts
-import { z as z3 } from "zod";
+import { z as z5 } from "zod";
 var catalogueTypes = ["alexandria", "exchange"];
-var searchSourceSchema = z3.union([
-  z3.enum(["web", "images", "news", ...catalogueTypes]),
-  z3.object({ type: z3.enum(["web", "images", "news", ...catalogueTypes]) }).strict()
+var searchSourceSchema = z5.union([
+  z5.enum(["web", "images", "news", ...catalogueTypes]),
+  z5.object({ type: z5.enum(["web", "images", "news", ...catalogueTypes]) }).strict()
 ]);
 function hasAlexandria(sources) {
   return Array.isArray(sources) && sources.some(
@@ -471,19 +2457,19 @@ function normalizeSearchSources(sources) {
 function searchQueryIsValid(args2) {
   return !!args2.query?.trim();
 }
-var findToolsSchema = z3.object({
-  query: z3.string().trim().min(1).max(2e3).optional().describe("Semantic lookup of tools for the data you need. Selectors constrain the search."),
-  urls: z3.array(
-    z3.string().url().regex(/^https?:\/\//)
+var findToolsSchema = z5.object({
+  query: z5.string().trim().min(1).max(2e3).optional().describe("Semantic lookup of tools for the data you need. Selectors constrain the search."),
+  urls: z5.array(
+    z5.string().url().regex(/^https?:\/\//)
   ).min(1).max(100).optional(),
-  providers: z3.array(z3.string().min(1)).min(1).max(50).optional().describe("Provider IDs returned by category browsing. Lists compact tools by default."),
-  categories: z3.array(z3.string().min(1)).min(1).max(50).optional().describe("Category IDs returned by an empty call. Lists providers by default."),
-  groups: z3.array(z3.string().min(1)).min(1).max(50).optional().describe("Optional group IDs for explicit group browsing."),
-  capabilities: z3.array(z3.string().min(1)).min(1).max(50).optional().describe("Exact capability IDs. A selected capability expands its complete contract by default."),
-  level: z3.enum(["categories", "providers", "groups", "tools"]).optional(),
-  expand: z3.array(z3.enum(["options", "response", "examples"])).optional().describe('Use ["options", "response"] for inputs and output shape without example payloads; [] keeps results compact. Omit for full contracts on selected capabilities.'),
-  limit: z3.number().int().min(1).max(100).optional(),
-  offset: z3.number().int().nonnegative().optional()
+  providers: z5.array(z5.string().min(1)).min(1).max(50).optional().describe("Provider IDs returned by category browsing. Lists compact tools by default."),
+  categories: z5.array(z5.string().min(1)).min(1).max(50).optional().describe("Category IDs returned by an empty call. Lists providers by default."),
+  groups: z5.array(z5.string().min(1)).min(1).max(50).optional().describe("Optional group IDs for explicit group browsing."),
+  capabilities: z5.array(z5.string().min(1)).min(1).max(50).optional().describe("Exact capability IDs. A selected capability expands its complete contract by default."),
+  level: z5.enum(["categories", "providers", "groups", "tools"]).optional(),
+  expand: z5.array(z5.enum(["options", "response", "examples"])).optional().describe('Use ["options", "response"] for inputs and output shape without example payloads; [] keeps results compact. Omit for full contracts on selected capabilities.'),
+  limit: z5.number().int().min(1).max(100).optional(),
+  offset: z5.number().int().nonnegative().optional()
 }).strict();
 var ALEXANDRIA_CATALOGUE_VERTICALS = "companies, people, jobs, finance and filings, public records and government spending, real estate, places and restaurants, retail and prices, package registries and developer data, news, research, and more";
 var ALEXANDRIA_CATALOGUE_SENTENCE = "Alexandria is Firecrawl's catalogue of data providers and workflows across " + ALEXANDRIA_CATALOGUE_VERTICALS + "; providers return typed, sourced records through published contracts.";
@@ -587,7 +2573,7 @@ async function alexandriaOutput(payload, calls, post, recoveryRequestId, extras
 }
 
 // src/developer.ts
-import { z as z4 } from "zod";
+import { z as z6 } from "zod";
 
 // src/origin.ts
 import { createRequire } from "module";
@@ -654,12 +2640,12 @@ Search an index of public repositories, GitHub issues, merged pull requests, rep
 Returns ranked results with an ID, source type, URL, title, and the matched passages in markdown.
 `,
     outputSchema: developerSearchOutputSchema,
-    parameters: z4.object({
-      query: z4.string().min(1).describe(
+    parameters: z6.object({
+      query: z6.string().min(1).describe(
         "Natural-language developer question or search phrase, including the library, error message, or API involved when relevant."
       ),
-      k: z4.number().int().min(1).max(100).optional().describe("Number of ranked results to return (default 10)."),
-      skills: z4.enum(["only"]).optional().describe('Set to "only" to search only agent-skill files.')
+      k: z6.number().int().min(1).max(100).optional().describe("Number of ranked results to return (default 10)."),
+      skills: z6.enum(["only"]).optional().describe('Set to "only" to search only agent-skill files.')
     }),
     execute: async (args2, { session, client: mcpClient }) => {
       const { query, k, skills } = args2;
@@ -722,7 +2708,7 @@ function checkKeylessSignupUrl(value) {
 }
 
 // src/monitor.ts
-import { z as z5 } from "zod";
+import { z as z7 } from "zod";
 
 // src/session-credential.ts
 import { createHmac } from "crypto";
@@ -856,8 +2842,8 @@ async function monitorRequest(session, origin, path2, init = {}) {
 function monitorResult(data) {
   return withAgentHints(structuredText(data), data);
 }
-var pageStatusSchema = z5.enum(["same", "new", "changed", "removed", "error"]);
-var checkStatusSchema = z5.enum([
+var pageStatusSchema = z7.enum(["same", "new", "changed", "removed", "error"]);
+var checkStatusSchema = z7.enum([
   "queued",
   "running",
   "completed",
@@ -951,22 +2937,22 @@ Create a recurring scrape, crawl, or search monitor that compares each check wit
 In the simple form, a \`goal\` is required. If \`queries\` contains one or more non-empty values and is supplied with \`page\`/\`pages\`, \`queries\` create the search target and page targets are ignored. A monitor schedules future network checks and can send configured email or webhook notifications. Returns the created monitor.
 `,
     outputSchema: monitorOutputSchema,
-    parameters: z5.object({
-      body: z5.record(z5.string(), z5.any()).optional(),
-      page: z5.string().optional(),
-      pages: z5.array(z5.string()).optional(),
-      queries: z5.array(z5.string()).optional(),
-      searchWindow: z5.enum(["5m", "15m", "1h", "6h", "24h", "7d"]).optional(),
-      maxResults: z5.number().int().min(1).max(50).optional(),
-      includeDomains: z5.array(z5.string()).optional(),
-      excludeDomains: z5.array(z5.string()).optional(),
-      goal: z5.string().optional(),
-      name: z5.string().optional(),
-      scheduleText: z5.string().optional(),
-      timezone: z5.string().optional(),
-      email: z5.string().optional(),
-      includeDiffs: z5.boolean().optional(),
-      webhookUrl: z5.string().optional()
+    parameters: z7.object({
+      body: z7.record(z7.string(), z7.any()).optional(),
+      page: z7.string().optional(),
+      pages: z7.array(z7.string()).optional(),
+      queries: z7.array(z7.string()).optional(),
+      searchWindow: z7.enum(["5m", "15m", "1h", "6h", "24h", "7d"]).optional(),
+      maxResults: z7.number().int().min(1).max(50).optional(),
+      includeDomains: z7.array(z7.string()).optional(),
+      excludeDomains: z7.array(z7.string()).optional(),
+      goal: z7.string().optional(),
+      name: z7.string().optional(),
+      scheduleText: z7.string().optional(),
+      timezone: z7.string().optional(),
+      email: z7.string().optional(),
+      includeDiffs: z7.boolean().optional(),
+      webhookUrl: z7.string().optional()
     }),
     execute: async (args2, { session, log, client: mcpClient }) => {
       const body = buildMonitorCreateBody(args2);
@@ -998,9 +2984,9 @@ In the simple form, a \`goal\` is required. If \`queries\` contains one or more
 List monitors for the authenticated account with optional pagination controls. Returns one page of monitor records and pagination metadata.
 `,
     outputSchema: monitorListOutputSchema,
-    parameters: z5.object({
-      limit: z5.number().int().positive().optional(),
-      offset: z5.number().int().nonnegative().optional()
+    parameters: z7.object({
+      limit: z7.number().int().positive().optional(),
+      offset: z7.number().int().nonnegative().optional()
     }),
     execute: async (args2, { session, client: mcpClient }) => {
       const { limit, offset } = args2;
@@ -1030,7 +3016,7 @@ List monitors for the authenticated account with optional pagination controls. R
 Retrieve one monitor by ID, including its configuration and current state. This does not run or modify the monitor.
 `,
     outputSchema: monitorOutputSchema,
-    parameters: z5.object({ id: z5.string() }),
+    parameters: z7.object({ id: z7.string() }),
     execute: async (args2, { session, client: mcpClient }) => {
       const { id } = args2;
       const res = await monitorRequest(
@@ -1058,9 +3044,9 @@ Patch an existing monitor by ID. The body can change its name, active/paused sta
 Returns the updated monitor.
 `,
     outputSchema: monitorOutputSchema,
-    parameters: z5.object({
-      id: z5.string(),
-      body: z5.record(z5.string(), z5.any())
+    parameters: z7.object({
+      id: z7.string(),
+      body: z7.record(z7.string(), z7.any())
     }),
     execute: async (args2, { session, client: mcpClient }) => {
       const { id, body } = args2;
@@ -1088,7 +3074,7 @@ Returns the updated monitor.
 Permanently delete a monitor by ID and stop its future schedule. This operation cannot be undone and returns deletion status.
 `,
     outputSchema: monitorDeleteOutputSchema,
-    parameters: z5.object({ id: z5.string() }),
+    parameters: z7.object({ id: z7.string() }),
     execute: async (args2, { session, log, client: mcpClient }) => {
       const { id } = args2;
       log.info("Deleting monitor", { id });
@@ -1116,7 +3102,7 @@ Permanently delete a monitor by ID and stop its future schedule. This operation
 Queue an immediate check for a monitor outside its normal schedule. This starts network work for the monitor's configured targets and returns the queued check.
 `,
     outputSchema: monitorRunOutputSchema,
-    parameters: z5.object({ id: z5.string() }),
+    parameters: z7.object({ id: z7.string() }),
     execute: async (args2, { session, client: mcpClient }) => {
       const { id } = args2;
       const res = await monitorRequest(
@@ -1143,10 +3129,10 @@ Queue an immediate check for a monitor outside its normal schedule. This starts
 List historical checks for a monitor, optionally filtered by status and bounded by a result limit. Returns one page of check summaries and pagination metadata.
 `,
     outputSchema: monitorChecksOutputSchema,
-    parameters: z5.object({
-      id: z5.string(),
-      limit: z5.number().int().positive().optional(),
-      offset: z5.number().int().nonnegative().optional(),
+    parameters: z7.object({
+      id: z7.string(),
+      limit: z7.number().int().positive().optional(),
+      offset: z7.number().int().nonnegative().optional(),
       status: checkStatusSchema.optional()
     }),
     execute: async (args2, { session, client: mcpClient }) => {
@@ -1177,11 +3163,11 @@ Retrieve one monitor check and its page-level results, optionally filtered by pa
 Markdown tracking returns a unified text diff, JSON tracking returns field paths with previous/current values and a current snapshot, and mixed tracking returns both. Returns one page of results plus a \`next\` URL when more pages exist.
 `,
     outputSchema: monitorCheckOutputSchema,
-    parameters: z5.object({
-      id: z5.string(),
-      checkId: z5.string(),
-      limit: z5.number().int().positive().optional(),
-      skip: z5.number().int().nonnegative().optional(),
+    parameters: z7.object({
+      id: z7.string(),
+      checkId: z7.string(),
+      limit: z7.number().int().positive().optional(),
+      skip: z7.number().int().nonnegative().optional(),
       pageStatus: pageStatusSchema.optional()
     }),
     execute: async (args2, { session, client: mcpClient }) => {
@@ -1198,8 +3184,7 @@ Markdown tracking returns a unified text diff, JSON tracking returns field paths
 }
 
 // src/research.ts
-import { z as z6 } from "zod";
-import { UserError } from "fastmcp";
+import { z as z8 } from "zod";
 var BASE2 = "/v2/search/research";
 function researchHeaders(origin) {
   return { ...originHeaders(origin), ...AGENT_HINTS_HEADERS };
@@ -1318,21 +3303,21 @@ Several distinct framings of the same question surface different papers than a s
 Returns ranked papers with canonical IDs, titles, authors, and abstracts.
 `,
     outputSchema: researchSearchOutputSchema,
-    parameters: z6.object({
-      query: z6.string().min(1).describe(
+    parameters: z8.object({
+      query: z8.string().min(1).describe(
         "Natural-language research topic or question, including methods, systems, conditions, populations, interventions, or outcomes when relevant."
       ),
-      k: z6.number().int().min(1).max(500).optional().describe("Number of ranked papers to return (default 40)."),
-      authors: z6.array(z6.string()).optional().describe(
+      k: z8.number().int().min(1).max(500).optional().describe("Number of ranked papers to return (default 40)."),
+      authors: z8.array(z8.string()).optional().describe(
         "Author substring filter(s); ALL must match (case-insensitive)."
       ),
-      categories: z6.array(z6.string()).optional().describe(
+      categories: z8.array(z8.string()).optional().describe(
         "Paper category filter(s) (e.g. `cs.LG`); ALL provided values must match."
       ),
-      from: z6.string().optional().describe(
+      from: z8.string().optional().describe(
         "Inclusive lower bound on created/updated date (`YYYY-MM-DD`)."
       ),
-      to: z6.string().optional().describe(
+      to: z8.string().optional().describe(
         "Inclusive upper bound on created/updated date (`YYYY-MM-DD`)."
       )
     }),
@@ -1369,8 +3354,8 @@ Returns ranked papers with canonical IDs, titles, authors, and abstracts.
 Retrieve canonical metadata for one paper ID, such as an arXiv, PMC, PMID, or DOI identifier. Returns the title, abstract, authors, categories, source IDs, and dates as markdown.
 `,
     outputSchema: researchPaperOutputSchema,
-    parameters: z6.object({
-      paperId: z6.string().min(1).describe(
+    parameters: z8.object({
+      paperId: z8.string().min(1).describe(
         "Canonical paperId or primaryId such as `arxiv:1706.03762`, `pmcid:PMC12530322`, `pmid:40953549`, or `doi:10.1016/j.neunet.2025.108095`."
       )
     }),
@@ -1405,12 +3390,12 @@ Find citation-graph candidates from one to ten \`seed_ids\`; the first ID is the
 Returns ranked candidates and the evaluated pool size.
 `,
     outputSchema: researchRelatedOutputSchema,
-    parameters: z6.object({
-      seed_ids: z6.array(z6.string()).min(1).max(10),
-      intent: z6.string().min(1),
-      mode: z6.enum(["similar", "citers", "references"]).optional(),
-      k: z6.number().int().min(1).max(500).optional(),
-      rerank: z6.boolean().optional().describe("Apply an additional rerank over the fused candidates.")
+    parameters: z8.object({
+      seed_ids: z8.array(z8.string()).min(1).max(10),
+      intent: z8.string().min(1),
+      mode: z8.enum(["similar", "citers", "references"]).optional(),
+      k: z8.number().int().min(1).max(500).optional(),
+      rerank: z8.boolean().optional().describe("Apply an additional rerank over the fused candidates.")
     }),
     execute: async (args2, { session, client: mcpClient }) => {
       const { seed_ids, intent, mode, k, rerank } = args2;
@@ -1457,12 +3442,12 @@ Retrieve in-body passages from one paper that are relevant to a specific questio
 Returns matching passages or a notice when full text is unavailable.
 `,
     outputSchema: researchReadOutputSchema,
-    parameters: z6.object({
-      paperId: z6.string().min(1).describe(
+    parameters: z8.object({
+      paperId: z8.string().min(1).describe(
         "Canonical paperId or primaryId such as `arxiv:1706.03762`, `pmcid:PMC12530322`, `pmid:40953549`, or `doi:10.1016/j.neunet.2025.108095`."
       ),
-      question: z6.string().min(1),
-      k: z6.number().int().min(1).max(50).optional().describe("Number of passages to return (default 4).")
+      question: z8.string().min(1),
+      k: z8.number().int().min(1).max(50).optional().describe("Number of passages to return (default 4).")
     }),
     execute: async (args2, { session, client: mcpClient }) => {
       const { paperId, question, k } = args2;
@@ -1493,9 +3478,9 @@ Returns matching passages or a notice when full text is unavailable.
 Deprecated compatibility entry point. Use firecrawl_developer_search for GitHub issues, pull requests, and READMEs, plus code documentation, returned as matched passages.
 `,
     outputSchema: deprecatedToolOutputSchema,
-    parameters: z6.object({
-      query: z6.string().min(1),
-      k: z6.number().int().min(1).max(100).optional()
+    parameters: z8.object({
+      query: z8.string().min(1),
+      k: z8.number().int().min(1).max(100).optional()
     }),
     canList: () => false,
     beforeValidate: () => {
@@ -1514,7 +3499,7 @@ Deprecated compatibility entry point. Use firecrawl_developer_search for GitHub
 }
 
 // src/usage.ts
-import { z as z7 } from "zod";
+import { z as z9 } from "zod";
 function assertSuccessful(status, response, operation) {
   if (status === 200 && response.success) return;
   throw new Error(response.error || `Failed to ${operation}`);
@@ -1536,11 +3521,11 @@ The current view returns \`remainingCredits\`, \`planCredits\`, \`billingPeriodS
 The historical view returns periods sorted by start date with \`startDate\`, \`endDate\`, and \`creditsUsed\`. Set \`byApiKey\` to include separate periods per API key, identified by the optional \`apiKey\` field. The newest period's \`endDate\` can be null.
 `,
     outputSchema: creditUsageOutputSchema,
-    parameters: z7.object({
-      view: z7.enum(["current", "historical"]).optional().describe(
+    parameters: z9.object({
+      view: z9.enum(["current", "historical"]).optional().describe(
         "Select current balance or historical monthly usage. Defaults to current."
       ),
-      byApiKey: z7.boolean().optional().describe(
+      byApiKey: z9.boolean().optional().describe(
         'Break historical usage down by API key. When view is omitted, true selects the historical view; it cannot be combined with view "current".'
       )
     }),
@@ -2163,30 +4148,30 @@ function removeEmptyTopLevel(obj) {
   }
   return out;
 }
-var searchDomainSchema = z8.string().trim().toLowerCase().min(1).max(253).regex(
+var searchDomainSchema = z10.string().trim().toLowerCase().min(1).max(253).regex(
   /^(?:[a-z0-9](?:[a-z0-9-]{0,61}[a-z0-9])?\.)+[a-z0-9][a-z0-9-]{0,61}[a-z0-9]$/,
   "Domain must be a valid hostname without protocol or path"
 );
 var searchToolBaseFields = {
-  toolDetail: z8.enum(["compact", "summary", "full"]).optional().describe("Compact by default. Compact returns only provider, capability and description; full includes contracts. Inspect selected compact tools with firecrawl_find_tools providers and capabilities."),
-  query: z8.string().min(1).describe("Query for web and semantic tool discovery. Operators include quoted phrases, `-term`, `site:host`, `inurl:term`, `intitle:term`, and `related:host`; the set is non-exhaustive. Catalogue browsing is available through firecrawl_find_tools."),
-  domainTools: z8.boolean().optional().describe(
+  toolDetail: z10.enum(["compact", "summary", "full"]).optional().describe("Compact by default. Compact returns only provider, capability and description; full includes contracts. Inspect selected compact tools with firecrawl_find_tools providers and capabilities."),
+  query: z10.string().min(1).describe("Query for web and semantic tool discovery. Operators include quoted phrases, `-term`, `site:host`, `inurl:term`, `intitle:term`, and `related:host`; the set is non-exhaustive. Catalogue browsing is available through firecrawl_find_tools."),
+  domainTools: z10.boolean().optional().describe(
     "Include domain-matched tools for result URLs. Defaults to true when Alexandria is combined with web, news or images; semantic-only search leaves domain matching off."
   ),
-  highlights: z8.boolean().optional().describe(
+  highlights: z10.boolean().optional().describe(
     "Return query-relevant page excerpts for web and news results when available (default). Highlights appear in web `description` and news `snippet`; otherwise, original snippets are returned. Set to false to keep the original search snippets."
   ),
-  limit: z8.number().int().min(1).max(100).optional(),
-  tbs: z8.string().optional(),
-  filter: z8.string().optional(),
-  location: z8.string().optional(),
-  includeDomains: z8.array(searchDomainSchema).optional().describe("Hostnames to restrict results to. Mutually exclusive with excludeDomains."),
-  excludeDomains: z8.array(searchDomainSchema).optional().describe("Hostnames to leave out of results. Mutually exclusive with includeDomains."),
-  sources: z8.array(searchSourceSchema).optional().describe("Search sources; authenticated sessions default to web + alexandria, keyless sessions to web only. " + ALEXANDRIA_SOURCES_OPT_OUT + ' Use ["alexandria"] alone for provider discovery without web results.'),
-  categories: z8.array(z8.enum(["research", "pdf", "developer"])).optional().describe(
+  limit: z10.number().int().min(1).max(100).optional(),
+  tbs: z10.string().optional(),
+  filter: z10.string().optional(),
+  location: z10.string().optional(),
+  includeDomains: z10.array(searchDomainSchema).optional().describe("Hostnames to restrict results to. Mutually exclusive with excludeDomains."),
+  excludeDomains: z10.array(searchDomainSchema).optional().describe("Hostnames to leave out of results. Mutually exclusive with includeDomains."),
+  sources: z10.array(searchSourceSchema).optional().describe("Search sources; authenticated sessions default to web + alexandria, keyless sessions to web only. " + ALEXANDRIA_SOURCES_OPT_OUT + ' Use ["alexandria"] alone for provider discovery without web results.'),
+  categories: z10.array(z10.enum(["research", "pdf", "developer"])).optional().describe(
     'Limit results to specific source types. `research` restricts ordinary web results to research-affiliated websites and returns page snippets, which is separate from the `firecrawl_research_*` tools that search paper abstracts and full text across biomedical (PubMed, bioRxiv, medRxiv) and arXiv literature; `pdf` searches PDF results; `developer` searches an index built for coding agents over public repositories, GitHub issues, merged pull requests, repository READMEs, and code documentation. `developer` returns hits in `data.web` with `category: "developer"`; the other categories also filter `data.web`.'
   ),
-  enterprise: z8.array(z8.enum(["default", "anon", "zdr"])).optional()
+  enterprise: z10.array(z10.enum(["default", "anon", "zdr"])).optional()
 };
 function searchDomainsAreExclusive(args2) {
   return !(args2.includeDomains?.length && args2.excludeDomains?.length);
@@ -2194,15 +4179,15 @@ function searchDomainsAreExclusive(args2) {
 var SEARCH_DOMAINS_CONFLICT_MESSAGE = "includeDomains and excludeDomains cannot both be specified";
 var EXCHANGE_KEY_REQUIRED_MESSAGE = "Alexandria requires an API key on a team with Alexandria access";
 var EXCHANGE_MAX_CALLS = 10;
-var exchangeCallSchema = z8.object({
-  provider: z8.string().min(1).describe('Provider slug, e.g. "fred".'),
-  capability: z8.string().min(1).describe(
+var exchangeCallSchema = z10.object({
+  provider: z10.string().min(1).describe('Provider slug, e.g. "fred".'),
+  capability: z10.string().min(1).describe(
     'Capability address as returned by search or discover, e.g. "series/observations".'
   ),
-  version: z8.string().trim().min(1).max(128).optional().describe("Optional published workflow version. Omit to use the latest version."),
-  options: z8.record(z8.string(), z8.any()).optional().describe("Capability options as declared by its contract.")
+  version: z10.string().trim().min(1).max(128).optional().describe("Optional published workflow version. Omit to use the latest version."),
+  options: z10.record(z10.string(), z10.any()).optional().describe("Capability options as declared by its contract.")
 });
-var exchangeCallsSchema = z8.array(exchangeCallSchema).min(1).max(EXCHANGE_MAX_CALLS);
+var exchangeCallsSchema = z10.array(exchangeCallSchema).min(1).max(EXCHANGE_MAX_CALLS);
 function assertExchangeCredential(session) {
   if (hasCredential(session)) return;
   const payload = {
@@ -2210,7 +4195,7 @@ function assertExchangeCredential(session) {
     message: EXCHANGE_KEY_REQUIRED_MESSAGE,
     docs_url: MCP_CONNECTION_GUIDE_URL
   };
-  throw new UserError2(payload.message, payload);
+  throw new UserError(payload.message, payload);
 }
 var TERMS_REQUIRED_CODE = "THIRD_PARTY_DATA_TERMS_REQUIRED";
 function termsRequiredAction(body) {
@@ -2230,7 +4215,7 @@ function termsRequiredError(action, context, hints) {
   const requestId = context.requestId;
   const retryIdentity = requestId ? ` and requestId ${requestId}` : "";
   const message = `Alexandria provider terms required. An organization admin must accept the ${action.terms} provider's terms (version ${action.version}) before this request can run.`;
-  return new UserError2(
+  return new UserError(
     `${message}
 
 1. Read the agreement with firecrawl_scrape using alexandria: {provider: "firecrawl", capability: "terms/show", options: {provider: "${action.terms}"}} and present it to the user. Only after explicit authorization to accept that exact version and digest, use firecrawl_scrape with alexandria: {provider: "firecrawl", capability: "terms/accept", options: {provider: "${action.terms}", version: "<reviewed-version>", digest: "<reviewed-digest>", confirmed: true}}. Send terms calls separately from provider execution. If authority or eligibility requires a dashboard action, ask an organization admin to visit ${action.url} or https://www.firecrawl.dev/app/settings?tab=data-sources if that page is unavailable. Never infer acceptance from a data request.
@@ -2295,7 +4280,7 @@ async function relayExchangeError(run, context) {
     const message = typeof data?.error === "string" ? data.error : `Alexandria request failed (HTTP ${response.status})`;
     const disabledProvider = response.status === 403 ? context.providers?.find((provider) => message === `Access to ${provider} is disabled for this organization.`) : void 0;
     if (disabledProvider) {
-      throw new UserError2(
+      throw new UserError(
         `${message} Read the provider terms and status using nextTool and present them to the user. Never infer acceptance from a data request. Only after explicit authorization for the reviewed version and digest may you call firecrawl_scrape with alexandria:{provider:"firecrawl",capability:"terms/accept",options:{provider:"${disabledProvider}",version:"<reviewed-version>",digest:"<reviewed-digest>",confirmed:true}}. Send terms calls separately. Acceptance may not restore disabled access; an organization admin may need to review https://www.firecrawl.dev/app/settings?tab=data-sources. Retry the original request only after access is restored.`,
         {
           code: typeof data?.code === "string" ? data.code : "exchange_error",
@@ -2311,7 +4296,7 @@ async function relayExchangeError(run, context) {
         }
       );
     }
-    throw new UserError2(message, {
+    throw new UserError(message, {
       code: typeof data?.code === "string" ? data.code : "exchange_error",
       status: response.status,
       message,
@@ -2548,12 +4533,12 @@ async function runWithCredentialRecovery(run, requestId, session) {
       const hints = readErrorAgentHints(error2);
       if (hints) {
         const message = error2 instanceof Error ? error2.message : String(error2);
-        throw new UserError2(
+        throw new UserError(
           hints.length ? `${message}
 
 ${agentHintsText(hints)}` : message,
           {
-            ...error2 instanceof UserError2 ? error2.extras : {},
+            ...error2 instanceof UserError ? error2.extras : {},
             error: message,
             agent_hints: hints
           }
@@ -2562,7 +4547,7 @@ ${agentHintsText(hints)}` : message,
       throw error2;
     }
     const payload = recoveryPayload("CREDENTIAL_INVALID", requestId);
-    throw new UserError2(String(payload.message), payload);
+    throw new UserError(String(payload.message), payload);
   }
 }
 function recoveryPayload(code, requestId = randomUUID(), options = {}) {
@@ -2691,7 +4676,7 @@ function guardHostedTool(tool, { logActions }) {
           signupUrl: code === "KEYLESS_TOOL_NOT_AVAILABLE" ? await hostedKeylessSignupUrl(session) : void 0
         });
         if (logActions) {
-          emitActionLog(tool.name, "error", session, new UserError2(String(payload2.message), payload2), requestId, code);
+          emitActionLog(tool.name, "error", session, new UserError(String(payload2.message), payload2), requestId, code);
         }
         return {
           content: [{ type: "text", text: String(payload2.message) }],
@@ -2707,7 +4692,7 @@ function guardHostedTool(tool, { logActions }) {
           tool.name,
           "error",
           session,
-          new UserError2(`Tool validation failed: ${recoveryCode}`, payload),
+          new UserError(`Tool validation failed: ${recoveryCode}`, payload),
           randomUUID(),
           recoveryCode
         );
@@ -2728,16 +4713,16 @@ function guardHostedTool(tool, { logActions }) {
       if (invocationSession.credentialError) {
         const code = "CREDENTIAL_INVALID";
         const payload = recoveryPayload(code, requestId);
-        if (logActions) emitActionLog(tool.name, "error", invocationSession, new UserError2(String(payload.message), payload), requestId, code);
-        throw new UserError2(String(payload.message), payload);
+        if (logActions) emitActionLog(tool.name, "error", invocationSession, new UserError(String(payload.message), payload), requestId, code);
+        throw new UserError(String(payload.message), payload);
       }
       if (isHostedKeylessSession(invocationSession) && !keylessTool) {
         const code = "KEYLESS_TOOL_NOT_AVAILABLE";
         const payload = recoveryPayload(code, requestId, {
           signupUrl: await hostedKeylessSignupUrl(invocationSession)
         });
-        if (logActions) emitActionLog(tool.name, "error", invocationSession, new UserError2(String(payload.message), payload), requestId, code);
-        throw new UserError2(String(payload.message), payload);
+        if (logActions) emitActionLog(tool.name, "error", invocationSession, new UserError(String(payload.message), payload), requestId, code);
+        throw new UserError(String(payload.message), payload);
       }
       const runTool = async () => {
         try {
@@ -2969,10 +4954,10 @@ function transformScrapeParams(args2) {
   delete out.pdfOptions;
   return out;
 }
-var scrapeParamsSchema = z8.object({
-  url: z8.string().url(),
-  formats: z8.array(
-    z8.enum([
+var scrapeParamsSchema = z10.object({
+  url: z10.string().url(),
+  formats: z10.array(
+    z10.enum([
       "markdown",
       "html",
       "rawHtml",
@@ -2986,71 +4971,71 @@ var scrapeParamsSchema = z8.object({
       "audio"
     ])
   ).optional(),
-  jsonOptions: z8.object({
-    prompt: z8.string().optional(),
-    schema: z8.record(z8.string(), z8.any()).optional()
+  jsonOptions: z10.object({
+    prompt: z10.string().optional(),
+    schema: z10.record(z10.string(), z10.any()).optional()
   }).optional(),
-  queryOptions: z8.object({
-    prompt: z8.string().max(1e4),
-    mode: z8.enum(["directQuote", "freeform"]).default("freeform")
+  queryOptions: z10.object({
+    prompt: z10.string().max(1e4),
+    mode: z10.enum(["directQuote", "freeform"]).default("freeform")
   }).optional(),
-  screenshotOptions: z8.object({
-    fullPage: z8.boolean().optional(),
-    quality: z8.number().optional(),
-    viewport: z8.object({ width: z8.number(), height: z8.number() }).optional()
+  screenshotOptions: z10.object({
+    fullPage: z10.boolean().optional(),
+    quality: z10.number().optional(),
+    viewport: z10.object({ width: z10.number(), height: z10.number() }).optional()
   }).optional(),
-  parsers: z8.array(z8.enum(["pdf"])).optional(),
-  pdfOptions: z8.object({
-    maxPages: z8.number().int().min(1).max(1e4).optional()
+  parsers: z10.array(z10.enum(["pdf"])).optional(),
+  pdfOptions: z10.object({
+    maxPages: z10.number().int().min(1).max(1e4).optional()
   }).optional(),
-  onlyMainContent: z8.boolean().optional(),
-  redactPII: z8.boolean().optional(),
-  includeTags: z8.array(z8.string()).optional(),
-  excludeTags: z8.array(z8.string()).optional(),
-  waitFor: z8.number().optional(),
+  onlyMainContent: z10.boolean().optional(),
+  redactPII: z10.boolean().optional(),
+  includeTags: z10.array(z10.string()).optional(),
+  excludeTags: z10.array(z10.string()).optional(),
+  waitFor: z10.number().optional(),
   ...SAFE_MODE ? {} : {
-    actions: z8.array(
-      z8.object({
-        type: z8.enum(allowedActionTypes),
-        selector: z8.string().optional(),
-        milliseconds: z8.number().optional(),
-        text: z8.string().optional(),
-        key: z8.string().optional(),
-        direction: z8.enum(["up", "down"]).optional(),
-        script: z8.string().optional(),
-        fullPage: z8.boolean().optional()
+    actions: z10.array(
+      z10.object({
+        type: z10.enum(allowedActionTypes),
+        selector: z10.string().optional(),
+        milliseconds: z10.number().optional(),
+        text: z10.string().optional(),
+        key: z10.string().optional(),
+        direction: z10.enum(["up", "down"]).optional(),
+        script: z10.string().optional(),
+        fullPage: z10.boolean().optional()
       })
     ).optional()
   },
-  mobile: z8.boolean().optional(),
-  skipTlsVerification: z8.boolean().optional(),
-  removeBase64Images: z8.boolean().optional(),
-  location: z8.object({
-    country: z8.string().optional(),
-    languages: z8.array(z8.string()).optional()
+  mobile: z10.boolean().optional(),
+  skipTlsVerification: z10.boolean().optional(),
+  removeBase64Images: z10.boolean().optional(),
+  location: z10.object({
+    country: z10.string().optional(),
+    languages: z10.array(z10.string()).optional()
   }).optional(),
-  storeInCache: z8.boolean().optional(),
-  zeroDataRetention: z8.boolean().optional(),
-  maxAge: z8.number().optional(),
-  lockdown: z8.boolean().optional(),
-  proxy: z8.enum(["basic", "stealth", "enhanced", "auto"]).optional(),
-  profile: z8.object({
-    name: z8.string(),
-    saveChanges: z8.boolean().optional()
+  storeInCache: z10.boolean().optional(),
+  zeroDataRetention: z10.boolean().optional(),
+  maxAge: z10.number().optional(),
+  lockdown: z10.boolean().optional(),
+  proxy: z10.enum(["basic", "stealth", "enhanced", "auto"]).optional(),
+  profile: z10.object({
+    name: z10.string(),
+    saveChanges: z10.boolean().optional()
   }).optional()
 });
 var ALEXANDRIA_IGNORED_SCRAPE_OPTIONS = /* @__PURE__ */ new Set(["toolDetail", "domainTools"]);
 var scrapeToolParamsSchema = scrapeParamsSchema.extend({
-  url: z8.string().url().optional(),
-  timeout: z8.number().int().positive().optional().describe("Execution timeout in milliseconds."),
-  requestId: z8.string().regex(/^[A-Za-z0-9._:-]{1,128}$/).optional().describe(
+  url: z10.string().url().optional(),
+  timeout: z10.number().int().positive().optional().describe("Execution timeout in milliseconds."),
+  requestId: z10.string().regex(/^[A-Za-z0-9._:-]{1,128}$/).optional().describe(
     "Idempotency key bound to one Alexandria execution payload. Generated when omitted and returned with the result."
   ),
-  alexandria: z8.union([exchangeCallSchema, exchangeCallsSchema]).optional().describe(
+  alexandria: z10.union([exchangeCallSchema, exchangeCallsSchema]).optional().describe(
     "Catalogued Alexandria capability invocation, mutually exclusive with url. One {provider, capability, options} object or an array of 1-10, with contracts available through firecrawl_search or firecrawl_find_tools. Each call may include version to pin a published workflow; omitting it uses latest. Only requestId and timeout are supported alongside alexandria. " + ALEXANDRIA_CONTRACT_GUIDANCE + " Returns per-capability results in data.alexandria with data, records, or an error with a code; individual capabilities can fail even when the outer response succeeds. Requires an API key on a team with Alexandria enabled. Some providers require accepted terms; blocked requests return the applicable requirements."
   ),
-  toolDetail: z8.enum(["compact", "summary", "full"]).optional().describe("URL mode only: domain discovery detail, summary by default; compact returns provider/capability/description, full includes contracts. Ignored with alexandria."),
-  domainTools: z8.boolean().optional().describe(
+  toolDetail: z10.enum(["compact", "summary", "full"]).optional().describe("URL mode only: domain discovery detail, summary by default; compact returns provider/capability/description, full includes contracts. Ignored with alexandria."),
+  domainTools: z10.boolean().optional().describe(
     "URL mode only: include domain-matched Alexandria tools for the page in tools on the returned document. Ignored with alexandria."
   )
 }).refine(
@@ -3070,9 +5055,9 @@ var scrapeToolParamsSchema = scrapeParamsSchema.extend({
   (args2) => !args2.requestId || !!args2.alexandria,
   "requestId applies to Alexandria execution only"
 );
-var parseOptionParamsSchema = z8.object({
-  formats: z8.array(
-    z8.enum([
+var parseOptionParamsSchema = z10.object({
+  formats: z10.array(
+    z10.enum([
       "markdown",
       "html",
       "rawHtml",
@@ -3082,48 +5067,48 @@ var parseOptionParamsSchema = z8.object({
       "query"
     ])
   ).optional(),
-  jsonOptions: z8.object({
-    prompt: z8.string().optional(),
-    schema: z8.record(z8.string(), z8.any()).optional()
+  jsonOptions: z10.object({
+    prompt: z10.string().optional(),
+    schema: z10.record(z10.string(), z10.any()).optional()
   }).optional(),
-  queryOptions: z8.object({
-    prompt: z8.string().max(1e4),
-    mode: z8.enum(["directQuote", "freeform"]).default("freeform")
+  queryOptions: z10.object({
+    prompt: z10.string().max(1e4),
+    mode: z10.enum(["directQuote", "freeform"]).default("freeform")
   }).optional(),
-  parsers: z8.array(z8.enum(["pdf"])).optional(),
-  pdfOptions: z8.object({
-    maxPages: z8.number().int().min(1).max(1e4).optional()
+  parsers: z10.array(z10.enum(["pdf"])).optional(),
+  pdfOptions: z10.object({
+    maxPages: z10.number().int().min(1).max(1e4).optional()
   }).optional(),
-  onlyMainContent: z8.boolean().optional(),
-  redactPII: z8.boolean().optional(),
-  includeTags: z8.array(z8.string()).optional(),
-  excludeTags: z8.array(z8.string()).optional(),
-  removeBase64Images: z8.boolean().optional(),
-  skipTlsVerification: z8.boolean().optional(),
-  storeInCache: z8.boolean().optional(),
-  zeroDataRetention: z8.boolean().optional(),
-  maxAge: z8.number().optional().describe("Ignored: parse never reuses or stores indexed content."),
-  proxy: z8.enum(["basic", "auto"]).optional()
+  onlyMainContent: z10.boolean().optional(),
+  redactPII: z10.boolean().optional(),
+  includeTags: z10.array(z10.string()).optional(),
+  excludeTags: z10.array(z10.string()).optional(),
+  removeBase64Images: z10.boolean().optional(),
+  skipTlsVerification: z10.boolean().optional(),
+  storeInCache: z10.boolean().optional(),
+  zeroDataRetention: z10.boolean().optional(),
+  maxAge: z10.number().optional().describe("Ignored: parse never reuses or stores indexed content."),
+  proxy: z10.enum(["basic", "auto"]).optional()
 });
 var localParseParamsSchema = parseOptionParamsSchema.extend({
-  filePath: z8.string().min(1).describe(
+  filePath: z10.string().min(1).describe(
     "Absolute or relative path to a local file to parse. Supported: .html, .htm, .pdf, .docx, .doc, .odt, .rtf, .xlsx, .xls"
   ),
-  contentType: z8.string().optional().describe(
+  contentType: z10.string().optional().describe(
     "Optional MIME type override. If omitted, the server infers the file kind from the extension."
   )
 });
 var hostedParseParamsSchema = parseOptionParamsSchema.extend({
-  filePath: z8.string().min(1).optional().describe(
+  filePath: z10.string().min(1).optional().describe(
     "Phase 1 only: path to the local file on the caller/harness machine. Hosted MCP will not read or stat this path; it is used only to produce upload instructions."
   ),
-  uploadRef: z8.string().min(1).optional().describe(
+  uploadRef: z10.string().min(1).optional().describe(
     "Phase 2 only: short-lived upload reference returned by phase 1 after the local PUT upload completes."
   ),
-  contentType: z8.string().optional().describe(
+  contentType: z10.string().optional().describe(
     "Phase 1 MIME type override. If omitted, the server infers it from the file extension without reading the file."
   ),
-  declaredSizeBytes: z8.number().int().positive().optional().describe(
+  declaredSizeBytes: z10.number().int().positive().optional().describe(
     "Optional phase 1 size declaration. Hosted MCP does not stat the file; provide this only if the caller already knows it."
   )
 }).superRefine((value, ctx) => {
@@ -3131,7 +5116,7 @@ var hostedParseParamsSchema = parseOptionParamsSchema.extend({
   const hasUploadRef = typeof value.uploadRef === "string" && value.uploadRef.length > 0;
   if (hasFilePath === hasUploadRef) {
     ctx.addIssue({
-      code: z8.ZodIssueCode.custom,
+      code: z10.ZodIssueCode.custom,
       message: "Hosted firecrawl_parse requires exactly one of filePath (phase 1) or uploadRef (phase 2).",
       path: hasFilePath && hasUploadRef ? ["uploadRef"] : ["filePath"]
     });
@@ -3266,7 +5251,7 @@ async function executeHostedParse(args2, session, log, origin) {
       option: "zeroDataRetention",
       message: "Zero Data Retention is not available in anonymous keyless mode. Omit zeroDataRetention to parse with keyless access, or configure an API key for a team where Zero Data Retention is enabled, then retry."
     };
-    throw new UserError2(String(payload.message), payload);
+    throw new UserError(String(payload.message), payload);
   }
   const options = extractParseOptions(args2);
   if (hasFilePath && args2.filePath) {
@@ -3427,13 +5412,13 @@ Enumerate URLs indexed under one website through Firecrawl without fetching each
 Returns matching URLs rather than page bodies. Retrieve one page with \`firecrawl_scrape\`; collect content across multiple pages with \`firecrawl_crawl\`. Authenticated responses can include an \`id\` for optional map feedback.
 `,
   outputSchema: mapOutputSchema,
-  parameters: z8.object({
-    url: z8.string().url(),
-    search: z8.string().optional(),
-    sitemap: z8.enum(["include", "skip", "only"]).optional(),
-    includeSubdomains: z8.boolean().optional(),
-    limit: z8.number().optional(),
-    ignoreQueryParameters: z8.boolean().optional()
+  parameters: z10.object({
+    url: z10.string().url(),
+    search: z10.string().optional(),
+    sitemap: z10.enum(["include", "skip", "only"]).optional(),
+    includeSubdomains: z10.boolean().optional(),
+    limit: z10.number().optional(),
+    ignoreQueryParameters: z10.boolean().optional()
   }),
   execute: async (args2, { session, log, client: mcpClient }) => {
     const { url, ...options } = args2;
@@ -3472,7 +5457,7 @@ On an authenticated session, tool matches describe available capabilities; \`fir
 For a programming question, add \`categories: ["developer"]\`; its hits return in \`data.web\` with \`category: "developer"\`. \`categories: ["research"]\` restricts web results to research-affiliated websites; the \`firecrawl_research_*\` tools are a separate surface over paper abstracts and full text (PubMed, bioRxiv, medRxiv, arXiv). Query operators, domain filters, \`categories\`, \`toolDetail\` and \`scrapeOptions\` are described on their parameters. Returns source-type result groups and usage metadata. Authenticated responses can include an \`id\` for optional search feedback.
 `,
   outputSchema: searchOutputSchema,
-  parameters: z8.object({
+  parameters: z10.object({
     ...searchToolBaseFields,
     scrapeOptions: scrapeParamsSchema.omit({ url: true }).partial().optional().describe("Attach page content for web results in the same call. These fetches ignore maxAge, so use firecrawl_scrape when you need a live fetch. scrapeOptions fetches web pages, never Alexandria provider tools.")
   }).refine(searchDomainsAreExclusive, SEARCH_DOMAINS_CONFLICT_MESSAGE).refine(
@@ -3559,9 +5544,9 @@ async function executeExchangeCalls(session, alexandria, suppliedRequestId, time
     );
   } catch (error2) {
     if (error2?.response?.status === 401) throw error2;
-    throw new UserError2(
+    throw new UserError(
       `${error2 instanceof Error ? error2.message : String(error2)} Request ID: ${requestId}. Reuse this ID only with the identical payload.`,
-      { ...error2 instanceof UserError2 ? error2.extras : {}, requestId }
+      { ...error2 instanceof UserError ? error2.extras : {}, requestId }
     );
   }
 }
@@ -3583,7 +5568,7 @@ var findToolsTool = {
     try {
       options = findToolsOptions(args2);
     } catch (error2) {
-      throw new UserError2(error2 instanceof Error ? error2.message : String(error2));
+      throw new UserError(error2 instanceof Error ? error2.message : String(error2));
     }
     if (options.level === "categories") {
       assertExchangeCredential(session);
@@ -3593,7 +5578,7 @@ var findToolsTool = {
       );
       const rows = response?.data?.cohorts;
       if (!Array.isArray(rows) || rows.some((row) => typeof row?.cohort !== "string" || typeof row?.about !== "string")) {
-        throw new UserError2("Category discovery returned an invalid category index.");
+        throw new UserError("Category discovery returned an invalid category index.");
       }
       const offset = options.offset ?? 0;
       const items = rows.slice(offset, offset + options.limit).map((row) => ({
@@ -3695,7 +5680,7 @@ async function keylessPost(path2, body, session, originOverride) {
         retryAfterSeconds: eligibility.retryAfterSeconds,
         signupUrl: eligibility.signupUrl
       });
-      throw new UserError2(String(payload.message), payload);
+      throw new UserError(String(payload.message), payload);
     }
   }
   const headers = {
@@ -3722,7 +5707,7 @@ async function keylessPost(path2, body, session, originOverride) {
       });
       const hints = readAgentHints(json);
       if (hints) payload.agent_hints = hints;
-      throw new UserError2(String(payload.message), payload);
+      throw new UserError(String(payload.message), payload);
     }
     throw new CoreHttpError(
       json?.error || `Firecrawl request failed (HTTP ${response.status})`,
@@ -3792,17 +5777,17 @@ async function waitForCrawlCompletionWithOrigin(client, jobId, origin, pollInter
     );
   }
 }
-var feedbackIssueSchema = z8.string().trim().min(1).max(80).regex(
+var feedbackIssueSchema = z10.string().trim().min(1).max(80).regex(
   /^[a-z0-9][a-z0-9_-]*$/,
   "Issue codes must use lowercase letters, numbers, underscores, or hyphens"
 );
-var valuableSourceSchema = z8.object({
-  url: z8.string().url(),
-  reason: z8.string().max(1e3).optional()
+var valuableSourceSchema = z10.object({
+  url: z10.string().url(),
+  reason: z10.string().max(1e3).optional()
 });
-var missingContentSchema = z8.object({
-  topic: z8.string().min(1, "topic must not be empty").max(200, "topic must be 200 characters or fewer"),
-  description: z8.string().max(2e3).optional()
+var missingContentSchema = z10.object({
+  topic: z10.string().min(1, "topic must not be empty").max(200, "topic must be 200 characters or fewer"),
+  description: z10.string().max(2e3).optional()
 });
 var FEEDBACK_DISABLED_VALUES = /* @__PURE__ */ new Set(["1", "true", "yes", "on"]);
 function feedbackEnvEnabled(...keys) {
@@ -3841,24 +5826,24 @@ Records schema-validated quality feedback for a prior \`firecrawl_search\` UUID
 Eligibility is limited to successful searches within the feedback age window. The record is idempotent per search ID. Eligible first feedback for a search can refund 1 credit; refunds are subject to the team's daily cap. The response reports whether a refund was applied, along with submission and daily-cap status.
 `,
     outputSchema: feedbackOutputSchema,
-    parameters: z8.object({
-      searchId: z8.string().uuid("searchId must be the UUID returned by firecrawl_search"),
-      rating: z8.enum(["good", "bad", "partial"]),
-      valuableSources: z8.array(
-        z8.object({
-          url: z8.string().url(),
-          reason: z8.string().max(1e3).optional()
+    parameters: z10.object({
+      searchId: z10.string().uuid("searchId must be the UUID returned by firecrawl_search"),
+      rating: z10.enum(["good", "bad", "partial"]),
+      valuableSources: z10.array(
+        z10.object({
+          url: z10.string().url(),
+          reason: z10.string().max(1e3).optional()
         })
       ).max(50).optional(),
-      missingContent: z8.array(
-        z8.object({
-          topic: z8.string().min(1, "topic must not be empty").max(200, "topic must be 200 characters or fewer"),
-          description: z8.string().max(2e3).optional()
+      missingContent: z10.array(
+        z10.object({
+          topic: z10.string().min(1, "topic must not be empty").max(200, "topic must be 200 characters or fewer"),
+          description: z10.string().max(2e3).optional()
         })
       ).max(20).optional().describe(
         "Array of specific pieces of content the agent expected to find but did not. One entry per distinct topic. Each entry has a short `topic` and optional longer `description`."
       ),
-      querySuggestions: z8.string().max(2e3).optional()
+      querySuggestions: z10.string().max(2e3).optional()
     }),
     execute: async (args2, { session, log, client: mcpClient }) => {
       const origin = requestOrigin(mcpClient, session);
@@ -3960,20 +5945,20 @@ For an Alexandria session, set endpoint to \`alexandria\`, omit jobId, and provi
 Returns submission status, feedback ID, and accounting fields.
 `,
     outputSchema: feedbackOutputSchema,
-    parameters: z8.object({
-      endpoint: z8.enum(["search", "scrape", "parse", "map", "alexandria"]),
-      jobId: z8.string().uuid("jobId must be the UUID returned by Firecrawl").optional(),
+    parameters: z10.object({
+      endpoint: z10.enum(["search", "scrape", "parse", "map", "alexandria"]),
+      jobId: z10.string().uuid("jobId must be the UUID returned by Firecrawl").optional(),
       ...alexandriaFeedbackFields,
-      rating: z8.enum(["good", "bad", "partial"]),
-      issues: z8.array(feedbackIssueSchema).max(20).optional(),
-      tags: z8.array(feedbackIssueSchema).max(20).optional(),
-      note: z8.string().max(4e3).optional(),
-      valuableSources: z8.array(valuableSourceSchema).max(50).optional(),
-      missingContent: z8.array(missingContentSchema).max(50).optional(),
-      querySuggestions: z8.string().max(2e3).optional(),
-      url: z8.string().url().optional(),
-      pageNumbers: z8.array(z8.number().int().positive()).max(100).optional(),
-      metadata: z8.record(z8.string(), z8.unknown()).optional()
+      rating: z10.enum(["good", "bad", "partial"]),
+      issues: z10.array(feedbackIssueSchema).max(20).optional(),
+      tags: z10.array(feedbackIssueSchema).max(20).optional(),
+      note: z10.string().max(4e3).optional(),
+      valuableSources: z10.array(valuableSourceSchema).max(50).optional(),
+      missingContent: z10.array(missingContentSchema).max(50).optional(),
+      querySuggestions: z10.string().max(2e3).optional(),
+      url: z10.string().url().optional(),
+      pageNumbers: z10.array(z10.number().int().positive()).max(100).optional(),
+      metadata: z10.record(z10.string(), z10.unknown()).optional()
     }).superRefine((value, ctx) => {
       if (value.endpoint === "alexandria") {
         const parsed = alexandriaSessionFeedbackSchema.safeParse(value);
@@ -4085,25 +6070,25 @@ Start a multi-page crawl at a website URL, poll it to a terminal state, and retu
 
 Crawl results can be large; use conservative limits when full-site coverage is unnecessary. Webhooks and interactive scrape actions are unavailable in safe mode. Returns the crawl ID, status, and page data.
 `,
-  parameters: z8.object({
-    url: z8.string(),
-    prompt: z8.string().optional(),
-    excludePaths: z8.array(z8.string()).optional(),
-    includePaths: z8.array(z8.string()).optional(),
-    maxDiscoveryDepth: z8.number().optional(),
-    sitemap: z8.enum(["skip", "include", "only"]).optional(),
-    limit: z8.number().optional(),
-    allowExternalLinks: z8.boolean().optional(),
-    allowSubdomains: z8.boolean().optional(),
-    crawlEntireDomain: z8.boolean().optional(),
-    delay: z8.number().optional(),
-    maxConcurrency: z8.number().optional(),
+  parameters: z10.object({
+    url: z10.string(),
+    prompt: z10.string().optional(),
+    excludePaths: z10.array(z10.string()).optional(),
+    includePaths: z10.array(z10.string()).optional(),
+    maxDiscoveryDepth: z10.number().optional(),
+    sitemap: z10.enum(["skip", "include", "only"]).optional(),
+    limit: z10.number().optional(),
+    allowExternalLinks: z10.boolean().optional(),
+    allowSubdomains: z10.boolean().optional(),
+    crawlEntireDomain: z10.boolean().optional(),
+    delay: z10.number().optional(),
+    maxConcurrency: z10.number().optional(),
     ...SAFE_MODE ? {} : {
-      webhook: z8.string().optional(),
-      webhookHeaders: z8.record(z8.string(), z8.string()).optional()
+      webhook: z10.string().optional(),
+      webhookHeaders: z10.record(z10.string(), z10.string()).optional()
     },
-    deduplicateSimilarURLs: z8.boolean().optional(),
-    ignoreQueryParameters: z8.boolean().optional(),
+    deduplicateSimilarURLs: z10.boolean().optional(),
+    ignoreQueryParameters: z10.boolean().optional(),
     scrapeOptions: scrapeParamsSchema.omit({ url: true }).partial().optional()
   }),
   outputSchema: crawlOutputSchema,
@@ -4160,7 +6145,7 @@ server.addTool({
 Retrieve the current status, progress, and available results for an existing crawl ID. This only reads Firecrawl job state and does not start or modify the crawl.
 `,
   outputSchema: crawlOutputSchema,
-  parameters: z8.object({ id: z8.string() }),
+  parameters: z10.object({ id: z10.string() }),
   execute: async (args2, {
     session,
     client: mcpClient
@@ -4187,13 +6172,13 @@ server.addTool({
 Deprecated compatibility entry point. Use firecrawl_scrape once per known URL with formats: ["json"] and jsonOptions containing the prompt and schema. Use firecrawl_agent for multi-source research when the URLs are not known or the data spans several sites.
 `,
   outputSchema: deprecatedToolOutputSchema,
-  parameters: z8.object({
-    urls: z8.array(z8.string()),
-    prompt: z8.string().optional(),
-    schema: z8.record(z8.string(), z8.any()).optional(),
-    allowExternalLinks: z8.boolean().optional(),
-    enableWebSearch: z8.boolean().optional(),
-    includeSubdomains: z8.boolean().optional()
+  parameters: z10.object({
+    urls: z10.array(z10.string()),
+    prompt: z10.string().optional(),
+    schema: z10.record(z10.string(), z10.any()).optional(),
+    allowExternalLinks: z10.boolean().optional(),
+    enableWebSearch: z10.boolean().optional(),
+    includeSubdomains: z10.boolean().optional()
   }),
   canList: () => false,
   beforeValidate: () => {
@@ -4206,27 +6191,27 @@ Deprecated compatibility entry point. Use firecrawl_scrape once per known URL wi
   },
   execute: async () => {
     const payload = deprecatedExtractPayload();
-    throw new UserError2(payload.message, payload);
+    throw new UserError(payload.message, payload);
   }
 });
-var agentExchangeSchema = z8.strictObject({
-  enabled: z8.boolean().optional().describe("Let the agent call Alexandria providers. On by default."),
-  toolkits: z8.array(z8.string()).max(5).optional().describe("Pin up to 5 providers the agent may use, by slug. Omitted means the whole catalog."),
-  maxCalls: z8.number().int().min(1).max(30).optional().describe("Most provider calls the agent may make in this turn."),
-  requireApproval: z8.boolean().optional().describe(
+var agentExchangeSchema = z10.strictObject({
+  enabled: z10.boolean().optional().describe("Let the agent call Alexandria providers. On by default."),
+  toolkits: z10.array(z10.string()).max(5).optional().describe("Pin up to 5 providers the agent may use, by slug. Omitted means the whole catalog."),
+  maxCalls: z10.number().int().min(1).max(30).optional().describe("Most provider calls the agent may make in this turn."),
+  requireApproval: z10.boolean().optional().describe(
     'End the turn with a paid-call pendingApproval before any paid provider call. Requires mode "chat" on the same request, even on a follow-up.'
   ),
-  approve: z8.strictObject({
-    approvalId: z8.string().uuid(),
-    callIds: z8.array(z8.string()).optional(),
-    always: z8.boolean().optional()
+  approve: z10.strictObject({
+    approvalId: z10.string().uuid(),
+    callIds: z10.array(z10.string()).optional(),
+    always: z10.boolean().optional()
   }).optional().describe(
     "Answer yes to the pendingApproval the previous turn of this thread ended on (its id, also exchange.requiresAction.approvalId). Needs threadId. For a terms offer, send it only after the user explicitly agreed and terms/accept succeeded; callIds and always are ignored on terms offers. For paid calls, callIds picks a subset (default all) and always stops asking for the rest of the thread."
   ),
-  decline: z8.strictObject({ approvalId: z8.string().uuid() }).optional().describe(
+  decline: z10.strictObject({ approvalId: z10.string().uuid() }).optional().describe(
     "Answer no to that pendingApproval. Needs threadId. A declined terms offer keeps those providers out of the rest of the thread."
   ),
-  onTermsRequired: z8.enum(["skip", "ask"]).optional().describe(
+  onTermsRequired: z10.enum(["skip", "ask"]).optional().describe(
     `What to do when a provider the agent would use needs data terms the team has not accepted. Gated providers are never called. "skip" (default): answer with accepted providers and list the rest in exchange.skippedProviders. "ask": the same, plus a terms pendingApproval and exchange.requiresAction with the terms/show and terms/accept calls. Each provider digest is string | null and always present; when null, terms/show returns it. There is no auto-accept. Omitted on a follow-up keeps the previous turn's value.`
   )
 }).describe(
@@ -4253,21 +6238,21 @@ The job also returns a \`threadId\`. To continue that thread, pass it with a fol
 The agent only calls Alexandria providers whose data terms the team has accepted. The status result's \`exchange.skippedProviders\` lists gated providers that would have helped. With \`exchange.onTermsRequired\` "ask", a terms offer ends the turn: \`pendingApproval\` (kind "terms") and \`exchange.requiresAction\` carry the \`approvalId\` and the exact terms/show and terms/accept calls. Show the user the terms, get their EXPLICIT consent, run terms/accept through \`firecrawl_scrape\`, then call \`firecrawl_agent\` with the same \`threadId\` and \`exchange.approve: {approvalId}\`. If they decline, send \`exchange.decline: {approvalId}\` instead. Never call terms/accept without that consent; a data request is not consent.
 `,
   outputSchema: agentOutputSchema,
-  parameters: z8.object({
-    prompt: z8.string().min(1).max(1e4),
-    urls: z8.array(z8.string().url()).optional(),
-    schema: z8.record(z8.string(), z8.any()).optional(),
-    effort: z8.enum(["low", "medium", "high"]).optional().describe("Reasoning budget for the agent task."),
-    maxCredits: z8.number().int().positive().optional().describe(
+  parameters: z10.object({
+    prompt: z10.string().min(1).max(1e4),
+    urls: z10.array(z10.string().url()).optional(),
+    schema: z10.record(z10.string(), z10.any()).optional(),
+    effort: z10.enum(["low", "medium", "high"]).optional().describe("Reasoning budget for the agent task."),
+    maxCredits: z10.number().int().positive().optional().describe(
       "Spending limit in credits for this run. Defaults to 2500 on the API."
     ),
-    strictConstrainToURLs: z8.boolean().optional().describe(
+    strictConstrainToURLs: z10.boolean().optional().describe(
       "If true, agent will only visit URLs provided in the urls array."
     ),
-    threadId: z8.string().uuid().optional().describe(
+    threadId: z10.string().uuid().optional().describe(
       "Continue this thread: the threadId from an earlier firecrawl_agent or firecrawl_agent_status result. Omit to start a new thread."
     ),
-    mode: z8.enum(["extract", "chat"]).optional().describe(
+    mode: z10.enum(["extract", "chat"]).optional().describe(
       `"extract" (default) returns the complete structured result every turn. "chat" lets a follow-up that asks no new data get a short reply in message instead of a re-run; required for exchange.requireApproval. Omitted on a follow-up keeps the previous turn's mode.`
     ),
     exchange: agentExchangeSchema.optional()
@@ -4337,7 +6322,7 @@ Retrieve progress or final results for a \`firecrawl_agent\` job ID. A \`process
 Returns job status, progress information, and result data when completed.
 `,
   outputSchema: agentStatusOutputSchema,
-  parameters: z8.object({ id: z8.string() }),
+  parameters: z10.object({ id: z10.string() }),
   execute: async (args2, { session, log, client: mcpClient }) => {
     const client = getClient(session);
     const { id } = args2;
@@ -4366,13 +6351,13 @@ Open or reuse a live browser session to navigate a page, click controls, fill fi
 This acts on the live site, so actions such as form submission can create persistent external side effects. Returns execution output, stdout/stderr, exit status, and session viewing URLs.
 `,
   outputSchema: interactOutputSchema,
-  parameters: z8.object({
-    scrapeId: z8.string().trim().min(1).optional(),
-    url: z8.string().trim().url().optional(),
-    prompt: z8.string().trim().min(1).optional(),
-    code: z8.string().trim().min(1).optional(),
-    language: z8.enum(["bash", "python", "node"]).optional(),
-    timeout: z8.number().min(1).max(300).optional(),
+  parameters: z10.object({
+    scrapeId: z10.string().trim().min(1).optional(),
+    url: z10.string().trim().url().optional(),
+    prompt: z10.string().trim().min(1).optional(),
+    code: z10.string().trim().min(1).optional(),
+    language: z10.enum(["bash", "python", "node"]).optional(),
+    timeout: z10.number().min(1).max(300).optional(),
     scrapeOptions: scrapeParamsSchema.omit({ url: true }).partial().optional()
   }).refine((data) => Boolean(data.scrapeId) !== Boolean(data.url), {
     message: "Provide either 'url' (interact directly) or 'scrapeId' (reuse a previous scrape), not both."
@@ -4451,8 +6436,8 @@ server.addTool({
 Stop the live interact session associated with a \`scrapeId\` and release its resources. Returns a success confirmation.
 `,
   outputSchema: interactStopOutputSchema,
-  parameters: z8.object({
-    scrapeId: z8.string()
+  parameters: z10.object({
+    scrapeId: z10.string()
   }),
   execute: async (args2, { session, log, client: mcpClient }) => {
     const client = getClient(session);
@@ -4576,7 +6561,7 @@ ${ALEXANDRIA_SEARCH_INSTRUCTIONS}
 Returns result groups in \`data\` and an operation \`id\`.
 `,
     outputSchema: searchOutputSchema,
-    parameters: z8.object({ ...searchToolBaseFields }).strict().refine(searchDomainsAreExclusive, SEARCH_DOMAINS_CONFLICT_MESSAGE).refine(
+    parameters: z10.object({ ...searchToolBaseFields }).strict().refine(searchDomainsAreExclusive, SEARCH_DOMAINS_CONFLICT_MESSAGE).refine(
       searchQueryIsValid,
       "A query is required. Use firecrawl_find_tools to browse the catalogue."
     ),