firecrawl-mcp 3.20.6 → 3.21.1

package/dist/index.js

@@ -1,475 +1,2503 @@
 #!/usr/bin/env node
-import FirecrawlApp from '@mendable/firecrawl-js';
-import dotenv from 'dotenv';
-import { FastMCP } from 'firecrawl-fastmcp';
-import { readFile } from 'node:fs/promises';
-import path from 'node:path';
-import { z } from 'zod';
-import { registerMonitorTools } from './monitor.js';
-import { registerResearchTools } from './research.js';
-dotenv.config({ debug: false, quiet: true });
-/**
- * Decide whether the research tools should be visible for a session.
- * Local/stdio/self-hosted: gated by `FIRECRAWL_RESEARCH=true`.
- * Remote (HTTP): additionally enabled by a `?research=true` query param on the
- * incoming MCP request URL.
- */
-function isResearchEnabled(request) {
-    if (process.env.FIRECRAWL_RESEARCH === 'true')
-        return true;
-    const url = request?.url;
-    if (url) {
+
+// src/index.ts
+import FirecrawlApp from "@mendable/firecrawl-js";
+import dotenv from "dotenv";
+import { readFile } from "fs/promises";
+import { createRequire } from "module";
+import path from "path";
+import { z as z4 } from "zod";
+
+// src/fastmcp/FastMCP.ts
+import { Server } from "@modelcontextprotocol/sdk/server/index.js";
+import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
+import {
+  CallToolRequestSchema,
+  CompleteRequestSchema,
+  ErrorCode,
+  GetPromptRequestSchema,
+  ListPromptsRequestSchema,
+  ListResourcesRequestSchema,
+  ListResourceTemplatesRequestSchema,
+  ListToolsRequestSchema,
+  McpError,
+  ReadResourceRequestSchema,
+  RootsListChangedNotificationSchema,
+  SetLevelRequestSchema
+} from "@modelcontextprotocol/sdk/types.js";
+import { EventEmitter } from "events";
+import Fuse from "fuse.js";
+import { startHTTPServer } from "mcp-proxy";
+import { setTimeout as delay } from "timers/promises";
+import parseURITemplate from "uri-templates";
+import { toJsonSchema } from "xsschema";
+import { z } 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 = z.object({
+  /**
+   * The text content of the message.
+   */
+  text: z.string(),
+  type: z.literal("text")
+}).strict();
+var ImageContentZodSchema = z.object({
+  /**
+   * The base64-encoded image data.
+   */
+  data: z.string().base64(),
+  /**
+   * The MIME type of the image. Different providers may support different image types.
+   */
+  mimeType: z.string(),
+  type: z.literal("image")
+}).strict();
+var AudioContentZodSchema = z.object({
+  /**
+   * The base64-encoded audio data.
+   */
+  data: z.string().base64(),
+  mimeType: z.string(),
+  type: z.literal("audio")
+}).strict();
+var ResourceContentZodSchema = z.object({
+  resource: z.object({
+    blob: z.string().optional(),
+    mimeType: z.string().optional(),
+    text: z.string().optional(),
+    uri: z.string()
+  }),
+  type: z.literal("resource")
+}).strict();
+var ResourceLinkZodSchema = z.object({
+  description: z.string().optional(),
+  mimeType: z.string().optional(),
+  name: z.string(),
+  title: z.string().optional(),
+  type: z.literal("resource_link"),
+  uri: z.string()
+});
+var ContentZodSchema = z.discriminatedUnion("type", [
+  TextContentZodSchema,
+  ImageContentZodSchema,
+  AudioContentZodSchema,
+  ResourceContentZodSchema,
+  ResourceLinkZodSchema
+]);
+var ContentResultZodSchema = z.object({
+  content: ContentZodSchema.array(),
+  isError: z.boolean().optional()
+}).strict();
+var CompletionZodSchema = z.object({
+  /**
+   * Indicates whether there are additional completion options beyond those provided in the current response, even if the exact total is unknown.
+   */
+  hasMore: z.optional(z.boolean()),
+  /**
+   * The total number of completion options available. This can exceed the number of values actually sent in the response.
+   */
+  total: z.optional(z.number().int()),
+  /**
+   * An array of completion values. Must not exceed 100 items.
+   */
+  values: z.array(z.string()).max(100)
+});
+var FastMCPSessionEventEmitterBase = EventEmitter;
+var escapeWWWAuthenticateValue = (value) => {
+  return value.replace(/\\/g, "\\\\").replace(/"/g, '\\"');
+};
+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;
+  }
+  #auth;
+  #capabilities = {};
+  #clientCapabilities;
+  #connectionState = "connecting";
+  #logger;
+  #loggingLevel = "info";
+  #needsEventLoopFlush = false;
+  #pingConfig;
+  #pingInterval = null;
+  #prompts = [];
+  #resources = [];
+  #resourceTemplates = [];
+  #roots = [];
+  #rootsConfig;
+  #server;
+  #utils;
+  constructor({
+    auth,
+    instructions,
+    logger,
+    name,
+    ping,
+    prompts,
+    resources,
+    resourcesTemplates,
+    roots,
+    tools,
+    transportType,
+    utils,
+    version
+  }) {
+    super();
+    this.#auth = auth;
+    this.#logger = logger;
+    this.#pingConfig = ping;
+    this.#rootsConfig = roots;
+    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.#server = new Server(
+      { name, version },
+      { capabilities: this.#capabilities, instructions }
+    );
+    this.#utils = utils;
+    this.setupErrorHandling();
+    this.setupLoggingHandlers();
+    this.setupRootsHandlers();
+    this.setupCompleteHandlers();
+    if (tools.length) {
+      this.setupToolHandlers(tools);
+    }
+    if (resources.length || resourcesTemplates.length) {
+      for (const resource of resources) {
+        this.addResource(resource);
+      }
+      this.setupResourceHandlers(resources);
+      if (resourcesTemplates.length) {
+        for (const resourceTemplate of resourcesTemplates) {
+          this.addResourceTemplate(resourceTemplate);
+        }
+        this.setupResourceTemplateHandlers(resourcesTemplates);
+      }
+    }
+    if (prompts.length) {
+      this.setupPromptHandlers(prompts);
+    }
+  }
+  async close() {
+    this.#connectionState = "closed";
+    if (this.#pingInterval) {
+      clearInterval(this.#pingInterval);
+    }
+    try {
+      await this.#server.close();
+    } catch (error) {
+      this.#logger.error("[FastMCP error]", "could not close server", error);
+    }
+  }
+  async connect(transport) {
+    if (this.#server.transport) {
+      throw new UnexpectedStateError("Server is already connected");
+    }
+    this.#connectionState = "connecting";
+    try {
+      await this.#server.connect(transport);
+      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.#clientCapabilities?.roots?.listChanged && typeof this.#server.listRoots === "function") {
         try {
-            const research = new URL(url, 'http://localhost').searchParams.get('research');
-            if (research === 'true')
-                return true;
+          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)}`
+            );
+          }
         }
-        catch {
-            // malformed URL — fall through to disabled
+      }
+      if (this.#clientCapabilities) {
+        const pingConfig = this.#getPingConfig(transport);
+        if (pingConfig.enabled) {
+          this.#pingInterval = setInterval(async () => {
+            try {
+              await this.#server.ping();
+            } catch {
+              const logLevel = pingConfig.logLevel;
+              if (logLevel === "debug") {
+                this.#logger.debug("[FastMCP debug] server ping failed");
+              } else if (logLevel === "warning") {
+                this.#logger.warn(
+                  "[FastMCP warning] server is not responding to ping"
+                );
+              } else if (logLevel === "error") {
+                this.#logger.error(
+                  "[FastMCP error] server is not responding to ping"
+                );
+              } else {
+                this.#logger.info("[FastMCP info] server ping failed");
+              }
+            }
+          }, pingConfig.intervalMs);
         }
+      }
+      this.#connectionState = "ready";
+      this.emit("ready");
+    } catch (error) {
+      this.#connectionState = "error";
+      const errorEvent = {
+        error: error instanceof Error ? error : new Error(String(error))
+      };
+      this.emit("error", errorEvent);
+      throw error;
     }
-    return false;
+  }
+  async requestSampling(message, options) {
+    return this.#server.createMessage(message, options);
+  }
+  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);
+      });
+    });
+  }
+  #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"
+    };
+  }
+  addPrompt(inputPrompt) {
+    const completers = {};
+    const enums = {};
+    const fuseInstances = {};
+    for (const argument of inputPrompt.arguments ?? []) {
+      if (argument.complete) {
+        completers[argument.name] = argument.complete;
+      }
+      if (argument.enum) {
+        enums[argument.name] = argument.enum;
+        fuseInstances[argument.name] = new Fuse(argument.enum, {
+          includeScore: true,
+          threshold: 0.3
+          // More flexible matching!
+        });
+      }
+    }
+    const prompt = {
+      ...inputPrompt,
+      complete: async (name, value, auth) => {
+        if (completers[name]) {
+          return await completers[name](value, auth);
+        }
+        if (fuseInstances[name]) {
+          const result = fuseInstances[name].search(value);
+          return {
+            total: result.length,
+            values: result.map((item) => item.item)
+          };
+        }
+        return {
+          values: []
+        };
+      }
+    };
+    this.#prompts.push(prompt);
+  }
+  addResource(inputResource) {
+    this.#resources.push(inputResource);
+  }
+  addResourceTemplate(inputResourceTemplate) {
+    const completers = {};
+    for (const argument of inputResourceTemplate.arguments ?? []) {
+      if (argument.complete) {
+        completers[argument.name] = argument.complete;
+      }
+    }
+    const resourceTemplate = {
+      ...inputResourceTemplate,
+      complete: async (name, value, auth) => {
+        if (completers[name]) {
+          return await completers[name](value, auth);
+        }
+        return {
+          values: []
+        };
+      }
+    };
+    this.#resourceTemplates.push(resourceTemplate);
+  }
+  setupCompleteHandlers() {
+    this.#server.setRequestHandler(CompleteRequestSchema, async (request) => {
+      if (request.params.ref.type === "ref/prompt") {
+        const prompt = this.#prompts.find(
+          (prompt2) => prompt2.name === request.params.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 resource = this.#resourceTemplates.find(
+          (resource2) => resource2.uriTemplate === request.params.ref.uri
+        );
+        if (!resource) {
+          throw new UnexpectedStateError("Unknown resource", {
+            request
+          });
+        }
+        if (!("uriTemplate" in resource)) {
+          throw new UnexpectedStateError("Unexpected resource");
+        }
+        if (!resource.complete) {
+          throw new UnexpectedStateError(
+            "Resource does not support completion",
+            {
+              request
+            }
+          );
+        }
+        const completion = CompletionZodSchema.parse(
+          await resource.complete(
+            request.params.argument.name,
+            request.params.argument.value,
+            this.#auth
+          )
+        );
+        return {
+          completion
+        };
+      }
+      throw new UnexpectedStateError("Unexpected completion request", {
+        request
+      });
+    });
+  }
+  setupErrorHandling() {
+    this.#server.onerror = (error) => {
+      this.#logger.error("[FastMCP error]", error);
+    };
+  }
+  setupLoggingHandlers() {
+    this.#server.setRequestHandler(SetLevelRequestSchema, (request) => {
+      this.#loggingLevel = request.params.level;
+      return {};
+    });
+  }
+  setupPromptHandlers(prompts) {
+    this.#server.setRequestHandler(ListPromptsRequestSchema, async () => {
+      return {
+        prompts: prompts.map((prompt) => {
+          return {
+            arguments: prompt.arguments,
+            complete: prompt.complete,
+            description: prompt.description,
+            name: prompt.name
+          };
+        })
+      };
+    });
+    this.#server.setRequestHandler(GetPromptRequestSchema, async (request) => {
+      const prompt = prompts.find(
+        (prompt2) => prompt2.name === 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 (error) {
+        const errorMessage = error instanceof Error ? error.message : String(error);
+        throw new McpError(
+          ErrorCode.InternalError,
+          `Failed to load prompt '${request.params.name}': ${errorMessage}`
+        );
+      }
+      if (typeof result === "string") {
+        return {
+          description: prompt.description,
+          messages: [
+            {
+              content: { text: result, type: "text" },
+              role: "user"
+            }
+          ]
+        };
+      } else {
+        return {
+          description: prompt.description,
+          messages: result.messages
+        };
+      }
+    });
+  }
+  setupResourceHandlers(resources) {
+    this.#server.setRequestHandler(ListResourcesRequestSchema, async () => {
+      return {
+        resources: resources.map((resource) => ({
+          description: resource.description,
+          mimeType: resource.mimeType,
+          name: resource.name,
+          uri: resource.uri
+        }))
+      };
+    });
+    this.#server.setRequestHandler(
+      ReadResourceRequestSchema,
+      async (request) => {
+        if ("uri" in request.params) {
+          const resource = resources.find(
+            (resource2) => "uri" in resource2 && resource2.uri === request.params.uri
+          );
+          if (!resource) {
+            for (const resourceTemplate of this.#resourceTemplates) {
+              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 resources2 = Array.isArray(result) ? result : [result];
+              return {
+                contents: resources2.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: ${resources.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 (error) {
+            const errorMessage = error instanceof Error ? error.message : String(error);
+            throw new McpError(
+              ErrorCode.InternalError,
+              `Failed to load resource '${resource.name}' (${resource.uri}): ${errorMessage}`,
+              {
+                uri: resource.uri
+              }
+            );
+          }
+          const resourceResults = Array.isArray(maybeArrayResult) ? maybeArrayResult : [maybeArrayResult];
+          return {
+            contents: resourceResults.map((result) => ({
+              ...result,
+              mimeType: result.mimeType ?? resource.mimeType,
+              name: resource.name,
+              uri: result.uri ?? resource.uri
+            }))
+          };
+        }
+        throw new UnexpectedStateError("Unknown resource request", {
+          request
+        });
+      }
+    );
+  }
+  setupResourceTemplateHandlers(resourceTemplates) {
+    this.#server.setRequestHandler(
+      ListResourceTemplatesRequestSchema,
+      async () => {
+        return {
+          resourceTemplates: resourceTemplates.map((resourceTemplate) => ({
+            description: resourceTemplate.description,
+            mimeType: resourceTemplate.mimeType,
+            name: resourceTemplate.name,
+            uriTemplate: resourceTemplate.uriTemplate
+          }))
+        };
+      }
+    );
+  }
+  setupRootsHandlers() {
+    if (this.#rootsConfig?.enabled === false) {
+      this.#logger.debug(
+        "[FastMCP debug] roots capability explicitly disabled via config"
+      );
+      return;
+    }
+    if (typeof this.#server.listRoots === "function") {
+      this.#server.setNotificationHandler(
+        RootsListChangedNotificationSchema,
+        () => {
+          this.#server.listRoots().then((roots) => {
+            this.#roots = roots.roots;
+            this.emit("rootsChanged", {
+              roots: roots.roots
+            });
+          }).catch((error) => {
+            if (error instanceof McpError && error.code === ErrorCode.MethodNotFound) {
+              this.#logger.debug(
+                "[FastMCP debug] listRoots method not supported by client"
+              );
+            } else {
+              this.#logger.error(
+                `[FastMCP error] received error listing roots.
+
+${error instanceof Error ? error.stack : JSON.stringify(error)}`
+              );
+            }
+          });
+        }
+      );
+    } else {
+      this.#logger.debug(
+        "[FastMCP debug] roots capability not available, not setting up notification handler"
+      );
+    }
+  }
+  setupToolHandlers(tools) {
+    this.#server.setRequestHandler(ListToolsRequestSchema, async () => {
+      return {
+        tools: await Promise.all(
+          tools.map(async (tool) => {
+            return {
+              annotations: tool.annotations,
+              description: tool.description,
+              inputSchema: tool.parameters ? await toJsonSchema(tool.parameters) : {
+                additionalProperties: false,
+                properties: {},
+                type: "object"
+              },
+              // More complete schema for Cursor compatibility
+              name: tool.name
+            };
+          })
+        )
+      };
+    });
+    this.#server.setRequestHandler(CallToolRequestSchema, async (request) => {
+      const tool = tools.find((tool2) => tool2.name === request.params.name);
+      if (!tool) {
+        throw new McpError(
+          ErrorCode.MethodNotFound,
+          `Unknown tool: ${request.params.name}`
+        );
+      }
+      let args2 = void 0;
+      if (tool.parameters) {
+        const parsed = await tool.parameters["~standard"].validate(
+          request.params.arguments
+        );
+        if (parsed.issues) {
+          const friendlyErrors = this.#utils?.formatInvalidParamsErrorMessage ? this.#utils.formatInvalidParamsErrorMessage(parsed.issues) : parsed.issues.map((issue) => {
+            const path2 = issue.path?.join(".") || "root";
+            return `${path2}: ${issue.message}`;
+          }).join(", ");
+          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) => {
+          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)
+            );
+          }
+        };
+        const executeToolPromise = tool.execute(args2, {
+          client: {
+            version: this.#server.getClientVersion()
+          },
+          log,
+          reportProgress,
+          session: this.#auth,
+          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.finally(() => 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 {
+          result = ContentResultZodSchema.parse(maybeStringResult);
+        }
+      } catch (error) {
+        if (error instanceof UserError) {
+          return {
+            content: [{ text: error.message, type: "text" }],
+            isError: true
+          };
+        }
+        const errorMessage = error instanceof Error ? error.message : String(error);
+        return {
+          content: [
+            {
+              text: `Tool '${request.params.name}' execution failed: ${errorMessage}`,
+              type: "text"
+            }
+          ],
+          isError: true
+        };
+      }
+      return result;
+    });
+  }
+};
+function camelToSnakeCase(str) {
+  return str.replace(/[A-Z]/g, (letter) => `_${letter.toLowerCase()}`);
 }
+function convertObjectToSnakeCase(obj) {
+  const result = {};
+  for (const [key, value] of Object.entries(obj)) {
+    const snakeKey = camelToSnakeCase(key);
+    result[snakeKey] = value;
+  }
+  return result;
+}
+var FastMCPEventEmitterBase = EventEmitter;
+var FastMCPEventEmitter = class extends FastMCPEventEmitterBase {
+};
+var FastMCP = class extends FastMCPEventEmitter {
+  constructor(options) {
+    super();
+    this.options = options;
+    this.#options = options;
+    this.#authenticate = options.authenticate;
+    this.#logger = options.logger || console;
+  }
+  options;
+  get sessions() {
+    return this.#sessions;
+  }
+  #authenticate;
+  #httpStreamServer = null;
+  #logger;
+  #options;
+  #prompts = [];
+  #resources = [];
+  #resourcesTemplates = [];
+  #sessions = [];
+  #tools = [];
+  /**
+   * Adds a prompt to the server.
+   */
+  addPrompt(prompt) {
+    this.#prompts.push(prompt);
+  }
+  /**
+   * Adds a resource to the server.
+   */
+  addResource(resource) {
+    this.#resources.push(resource);
+  }
+  /**
+   * Adds a resource template to the server.
+   */
+  addResourceTemplate(resource) {
+    this.#resourcesTemplates.push(resource);
+  }
+  /**
+   * Adds a tool to the server.
+   */
+  addTool(tool) {
+    this.#tools.push(tool);
+  }
+  /**
+   * 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 templateBase = template.uriTemplate.split("{")[0];
+      if (uri.startsWith(templateBase)) {
+        const params = {};
+        const templateParts = template.uriTemplate.split("/");
+        const uriParts = uri.split("/");
+        for (let i = 0; i < templateParts.length; i++) {
+          const templatePart = templateParts[i];
+          if (templatePart?.startsWith("{") && templatePart.endsWith("}")) {
+            const paramName = templatePart.slice(1, -1);
+            const paramValue = uriParts[i];
+            if (paramValue) {
+              params[paramName] = paramValue;
+            }
+          }
+        }
+        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 });
+  }
+  /**
+   * 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 (error) {
+          this.#logger.error(
+            "[FastMCP error] Authentication failed for stdio transport:",
+            error instanceof Error ? error.message : String(error)
+          );
+        }
+      }
+      const session = new FastMCPSession({
+        auth,
+        instructions: this.#options.instructions,
+        logger: this.#logger,
+        name: this.#options.name,
+        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
+      });
+    } else if (config.transportType === "httpStream") {
+      const httpConfig = config.httpStream;
+      if (httpConfig.stateless) {
+        this.#logger.info(
+          `[FastMCP info] Starting server in stateless mode on HTTP Stream at http://${httpConfig.host}:${httpConfig.port}${httpConfig.endpoint}`
+        );
+        this.#httpStreamServer = await startHTTPServer({
+          createServer: async (request) => {
+            const auth = await this.#authenticateRequest(request);
+            return this.#createSession(auth);
+          },
+          enableJsonResponse: httpConfig.enableJsonResponse,
+          eventStore: httpConfig.eventStore,
+          host: httpConfig.host,
+          oauth: this.#options.oauth,
+          // 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);
+          },
+          port: httpConfig.port,
+          sseEndpoint: "/sse",
+          // Server-Sent Events endpoint for streaming events
+          stateless: true,
+          streamEndpoint: httpConfig.endpoint
+        });
+      } else {
+        this.#httpStreamServer = await startHTTPServer({
+          createServer: async (request) => {
+            const auth = await this.#authenticateRequest(request);
+            return this.#createSession(auth);
+          },
+          enableJsonResponse: httpConfig.enableJsonResponse,
+          eventStore: httpConfig.eventStore,
+          host: httpConfig.host,
+          oauth: this.#options.oauth,
+          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
+            );
+          },
+          port: httpConfig.port,
+          sseEndpoint: "/sse",
+          streamEndpoint: httpConfig.endpoint
+        });
+        this.#logger.info(
+          `[FastMCP info] server is running on HTTP Stream at http://${httpConfig.host}:${httpConfig.port}${httpConfig.endpoint}`
+        );
+        this.#logger.info(
+          `[FastMCP info] Transport type: httpStream (Streamable HTTP, not SSE)`
+        );
+      }
+    } else {
+      throw new Error("Invalid transport type");
+    }
+  }
+  /**
+   * Stops the server.
+   */
+  async stop() {
+    if (this.#httpStreamServer) {
+      await this.#httpStreamServer.close();
+    }
+  }
+  async #authenticateRequest(request) {
+    if (!this.#authenticate) {
+      return void 0;
+    }
+    try {
+      return await this.#authenticate(request);
+    } catch (error) {
+      const response = this.#createOAuthChallengeResponse(error);
+      if (response) {
+        throw response;
+      }
+      throw error;
+    }
+  }
+  #createOAuthChallengeResponse(error) {
+    if (error instanceof Response) {
+      return void 0;
+    }
+    const resourceMetadataUrl = this.#options.oauth?.protectedResourceMetadataUrl;
+    if (!this.#options.oauth?.enabled || !resourceMetadataUrl) {
+      return void 0;
+    }
+    const errorMessage = error instanceof Error ? error.message : String(error || "Unauthorized");
+    const wwwAuthenticate = [
+      `resource_metadata="${escapeWWWAuthenticateValue(resourceMetadataUrl)}"`,
+      `error="invalid_token"`,
+      `error_description="${escapeWWWAuthenticateValue(errorMessage)}"`
+    ].join(", ");
+    return new Response(
+      JSON.stringify({
+        error: "invalid_token",
+        error_description: errorMessage
+      }),
+      {
+        headers: {
+          "Content-Type": "application/json",
+          "WWW-Authenticate": `Bearer ${wwwAuthenticate}`
+        },
+        status: 401
+      }
+    );
+  }
+  /**
+   * Creates a new FastMCPSession instance with the current configuration.
+   * Used both for regular sessions and stateless requests.
+   */
+  #createSession(auth) {
+    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,
+      ping: this.#options.ping,
+      prompts: this.#prompts,
+      resources: this.#resources,
+      resourcesTemplates: this.#resourcesTemplates,
+      roots: this.#options.roots,
+      tools: allowedTools,
+      transportType: "httpStream",
+      utils: this.#options.utils,
+      version: this.#options.version
+    });
+  }
+  /**
+   * Handles unhandled HTTP requests with health, readiness, and OAuth endpoints
+   */
+  #handleUnhandledRequest = async (req, res, isStateless = false, host) => {
+    const url = new URL(req.url || "", `http://${host}`);
+    if (url.pathname === "/messages") {
+      return;
+    }
+    const healthConfig = this.#options.health ?? {};
+    const enabled = healthConfig.enabled === void 0 ? true : healthConfig.enabled;
+    if (enabled) {
+      const path2 = healthConfig.path ?? "/health";
+      try {
+        if (req.method === "GET" && url.pathname === path2) {
+          res.writeHead(healthConfig.status ?? 200, {
+            "Content-Type": "text/plain"
+          }).end(healthConfig.message ?? "\u2713 Ok");
+          return;
+        }
+        if (req.method === "GET" && url.pathname === "/ready") {
+          if (isStateless) {
+            const response = {
+              mode: "stateless",
+              ready: 1,
+              status: "ready",
+              total: 1
+            };
+            res.writeHead(200, {
+              "Content-Type": "application/json"
+            }).end(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(JSON.stringify(response));
+          }
+          return;
+        }
+      } catch (error) {
+        this.#logger.error("[FastMCP error] health endpoint error", error);
+      }
+    }
+    const openaiAppsChallengeConfig = this.#options.openaiAppsChallenge;
+    const openaiAppsChallengeToken = openaiAppsChallengeConfig?.token?.trim();
+    const openaiAppsChallengeEnabled = openaiAppsChallengeConfig?.enabled !== false && !!openaiAppsChallengeToken;
+    if (openaiAppsChallengeEnabled && req.method === "GET") {
+      const path2 = openaiAppsChallengeConfig?.path ?? "/.well-known/openai-apps-challenge";
+      if (url.pathname === path2) {
+        res.writeHead(200, {
+          "Content-Type": "text/plain"
+        }).end(openaiAppsChallengeToken);
+        return;
+      }
+    }
+    const oauthConfig = this.#options.oauth;
+    if (oauthConfig?.enabled && req.method === "GET") {
+      if (url.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 (url.pathname === "/.well-known/oauth-protected-resource" && oauthConfig.protectedResource) {
+        const metadata = convertObjectToSnakeCase(
+          oauthConfig.protectedResource
+        );
+        res.writeHead(200, {
+          "Content-Type": "application/json"
+        }).end(JSON.stringify(metadata));
+        return;
+      }
+    }
+    res.writeHead(404).end();
+  };
+  #parseRuntimeConfig(overrides) {
+    const args2 = process.argv.slice(2);
+    const getArg = (name) => {
+      const index = args2.findIndex((arg) => arg === `--${name}`);
+      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;
+      return {
+        httpStream: {
+          enableJsonResponse,
+          endpoint,
+          host,
+          port,
+          stateless
+        },
+        transportType: "httpStream"
+      };
+    }
+    return { transportType: "stdio" };
+  }
+  #removeSession(session) {
+    const sessionIndex = this.#sessions.indexOf(session);
+    if (sessionIndex !== -1) {
+      this.#sessions.splice(sessionIndex, 1);
+      this.emit("disconnect", {
+        session
+      });
+    }
+  }
+};
+
+// src/monitor.ts
+import { z as z2 } from "zod";
+var DEFAULT_API_URL = "https://api.firecrawl.dev";
+function resolveAuth(session) {
+  const apiKey = session?.firecrawlApiKey ?? process.env.FIRECRAWL_API_KEY;
+  const baseUrl = (process.env.FIRECRAWL_API_URL ?? DEFAULT_API_URL).replace(
+    /\/$/,
+    ""
+  );
+  return { apiKey, baseUrl };
+}
+async function monitorRequest(session, path2, init = {}) {
+  const { apiKey, baseUrl } = resolveAuth(session);
+  if (!apiKey && !process.env.FIRECRAWL_API_URL) {
+    throw new Error("Unauthorized: API key is required for monitor requests");
+  }
+  let url = `${baseUrl}/v2${path2}`;
+  if (init.query) {
+    const qs = new URLSearchParams();
+    for (const [k, v] of Object.entries(init.query)) {
+      if (v !== void 0 && v !== null && v !== "") qs.set(k, String(v));
+    }
+    const s = qs.toString();
+    if (s) url += `?${s}`;
+  }
+  const headers = { "X-Origin": "mcp" };
+  if (apiKey) headers.Authorization = `Bearer ${apiKey}`;
+  if (init.body !== void 0) headers["Content-Type"] = "application/json";
+  const response = await fetch(url, {
+    method: init.method ?? "GET",
+    headers,
+    body: init.body !== void 0 ? JSON.stringify(init.body) : void 0
+  });
+  const payload = await response.json().catch(() => ({}));
+  if (!response.ok || payload?.success === false) {
+    const message = payload?.error || `HTTP ${response.status}: ${response.statusText || "Request failed"}`;
+    throw new Error(message);
+  }
+  return payload;
+}
+function asText(data) {
+  return JSON.stringify(data, null, 2);
+}
+var pageStatusSchema = z2.enum(["same", "new", "changed", "removed", "error"]);
+var checkStatusSchema = z2.enum([
+  "queued",
+  "running",
+  "completed",
+  "failed",
+  "partial",
+  "skipped_overlap"
+]);
+function splitPages(page, pages) {
+  return [page, ...pages ?? []].filter((url) => typeof url === "string").map((url) => url.trim()).filter(Boolean);
+}
+function buildMonitorCreateBody(args2) {
+  if (args2.body && typeof args2.body === "object" && !Array.isArray(args2.body)) {
+    return args2.body;
+  }
+  const urls = splitPages(
+    args2.page,
+    args2.pages
+  );
+  if (urls.length === 0) {
+    throw new Error(
+      "firecrawl_monitor_create requires either `body`, `page`, or `pages`."
+    );
+  }
+  const goal = typeof args2.goal === "string" ? args2.goal.trim() : "";
+  if (!goal) {
+    throw new Error(
+      "firecrawl_monitor_create shorthand requires `goal`. Use `body` for advanced requests without a goal."
+    );
+  }
+  const webhookUrl = typeof args2.webhookUrl === "string" ? args2.webhookUrl.trim() : "";
+  const email = typeof args2.email === "string" && args2.email.trim() ? {
+    email: {
+      enabled: true,
+      recipients: [args2.email.trim()],
+      includeDiffs: Boolean(args2.includeDiffs)
+    }
+  } : void 0;
+  return {
+    name: typeof args2.name === "string" && args2.name.trim() ? args2.name.trim() : `Monitor ${urls[0]}`,
+    schedule: {
+      text: typeof args2.scheduleText === "string" && args2.scheduleText.trim() ? args2.scheduleText.trim() : "every 30 minutes",
+      timezone: typeof args2.timezone === "string" && args2.timezone.trim() ? args2.timezone.trim() : "UTC"
+    },
+    goal,
+    targets: [{ type: "scrape", urls }],
+    ...email ? { notification: email } : {},
+    ...webhookUrl ? {
+      webhook: {
+        url: webhookUrl,
+        events: ["monitor.page", "monitor.check.completed"]
+      }
+    } : {}
+  };
+}
+function registerMonitorTools(server2) {
+  server2.addTool({
+    name: "firecrawl_monitor_create",
+    annotations: {
+      title: "Create monitor",
+      readOnlyHint: false,
+      // Creates a new recurring monitor configuration on the Firecrawl API.
+      openWorldHint: true,
+      // Monitors user-specified URLs on the public web on a recurring schedule.
+      destructiveHint: false
+      // Additive; creates a new monitor without deleting existing monitors or external content.
+    },
+    description: `
+Create a Firecrawl monitor \u2014 a recurring scrape or crawl that diffs each result against the last retained snapshot.
+
+Prefer the simple path: pass \`page\` or \`pages\` plus \`goal\`. The tool will create a scrape monitor with a 30-minute schedule and meaningful-change judging enabled by the API. Use \`body\` only for advanced requests such as crawl targets, JSON change tracking, custom retention, or manual \`judgeEnabled\` control.
+
+Meaningful-change judge: set \`goal\` to a plain-language description of what the user actually cares about. \`judgeEnabled\` defaults to true when \`goal\` is set, so providing \`goal\` is enough. Page webhooks expose \`isMeaningful\` and \`judgment\` on \`monitor.page\` events.
+
+Simple fields:
+- \`page\`: one page URL to monitor.
+- \`pages\`: multiple page URLs to monitor.
+- \`goal\`: plain-English instruction for what changes matter. Required for the simple path.
+- \`scheduleText\`: optional natural-language schedule, default \`every 30 minutes\`.
+- \`email\`: optional email recipient for summaries.
+- \`webhookUrl\`: optional webhook URL. Configures \`monitor.page\` and \`monitor.check.completed\`.
+
+Goal guidance:
+- Expand the user's one-line monitoring intent into a concise 2-3 sentence monitor goal.
+- State what should trigger an alert, restate any scope the user gave, and include intent-specific exclusions only when obvious from the user's request.
+- Generic noise such as whitespace, formatting-only changes, request IDs, tracking params, generic metadata, and unrelated page chrome is already handled by the judge; do not repeat it in every goal.
+- If the user is vague, keep the goal broad rather than guessing exclusions. If the user asks for broad monitoring or "any change", preserve that and do not add exclusions that hide changes.
+- If the user says they do not care about something, include that explicitly. It is okay to ask whether they want to ignore specific noise when it is likely to matter.
+- Do not invent page-specific sections, thresholds, entities, or business rules unless the user mentioned them.
+
+Full \`body\` requests require: \`name\`, \`schedule\` (with \`cron\` or \`text\`), and \`targets\` (one or more \`{ type: 'scrape', urls: [...] }\` or \`{ type: 'crawl', url: '...' }\`). Optional: \`goal\`, \`judgeEnabled\`, \`webhook\`, \`notification\`, \`retentionDays\`.
+
+**Markdown-mode (default):** Each check produces a unified text diff of the page's markdown. No extra configuration needed.
+
+\`\`\`json
+{
+  "name": "firecrawl_monitor_create",
+  "arguments": {
+    "page": "https://example.com/blog",
+    "goal": "Alert when a new blog post is published or an existing headline changes.",
+    "email": "alerts@example.com"
+  }
+}
+\`\`\`
+
+**Multiple pages:**
+
+\`\`\`json
+{
+  "name": "firecrawl_monitor_create",
+  "arguments": {
+    "pages": ["https://example.com/pricing", "https://example.com/changelog"],
+    "goal": "Alert when pricing, packaging, or launch messaging changes.",
+    "webhookUrl": "https://example.com/webhooks/firecrawl"
+  }
+}
+\`\`\`
+
+**JSON-mode change tracking:** To detect changes in **specific structured fields** (price, headline, in-stock flag, list items) instead of the whole page, add a \`changeTracking\` format with \`modes: ["json"]\` and a JSON schema to the target's \`scrapeOptions.formats\`. The check response will then carry a per-field diff (keyed by JSON path, e.g. \`plans[0].price\`) and a \`snapshot.json\` with the full current extraction. See \`firecrawl_monitor_check\` for the response shape.
+
+\`\`\`json
+{
+  "name": "firecrawl_monitor_create",
+  "arguments": {
+    "body": {
+      "name": "Pricing watch",
+      "schedule": { "text": "hourly", "timezone": "UTC" },
+      "goal": "Alert when a pricing tier, price, billing period, limit, or headline feature changes. Ignore unrelated marketing copy unless it changes the pricing offer.",
+      "targets": [{
+        "type": "scrape",
+        "urls": ["https://example.com/pricing"],
+        "scrapeOptions": {
+          "formats": [{
+            "type": "changeTracking",
+            "modes": ["json"],
+            "prompt": "Extract pricing tiers and headline features for each plan.",
+            "schema": {
+              "type": "object",
+              "properties": {
+                "plans": {
+                  "type": "array",
+                  "items": {
+                    "type": "object",
+                    "properties": {
+                      "name":     { "type": "string" },
+                      "price":    { "type": "string" },
+                      "features": { "type": "array", "items": { "type": "string" } }
+                    }
+                  }
+                }
+              }
+            }
+          }]
+        }
+      }]
+    }
+  }
+}
+\`\`\`
+
+**Mixed mode (JSON + git-diff):** Use \`modes: ["json", "git-diff"]\` to get both per-field diffs and a markdown sidecar. The page is marked \`changed\` whenever either surface changed.
+`,
+    parameters: z2.object({
+      body: z2.record(z2.string(), z2.any()).optional(),
+      page: z2.string().optional(),
+      pages: z2.array(z2.string()).optional(),
+      goal: z2.string().optional(),
+      name: z2.string().optional(),
+      scheduleText: z2.string().optional(),
+      timezone: z2.string().optional(),
+      email: z2.string().optional(),
+      includeDiffs: z2.boolean().optional(),
+      webhookUrl: z2.string().optional()
+    }),
+    execute: async (args2, { session, log }) => {
+      const body = buildMonitorCreateBody(args2);
+      log.info("Creating monitor", { name: String(body.name) });
+      const res = await monitorRequest(session, "/monitor", {
+        method: "POST",
+        body
+      });
+      return asText(res);
+    }
+  });
+  server2.addTool({
+    name: "firecrawl_monitor_list",
+    annotations: {
+      title: "List monitors",
+      readOnlyHint: true,
+      // Lists monitors for the authenticated account; no mutations.
+      openWorldHint: false,
+      // Returns only the user's Firecrawl monitor records, not arbitrary web content.
+      destructiveHint: false
+      // Read-only listing.
+    },
+    description: `
+List all Firecrawl monitors for the authenticated account.
+
+**Usage Example:**
+\`\`\`json
+{ "name": "firecrawl_monitor_list", "arguments": { "limit": 20 } }
+\`\`\`
+`,
+    parameters: z2.object({
+      limit: z2.number().int().positive().optional(),
+      offset: z2.number().int().nonnegative().optional()
+    }),
+    execute: async (args2, { session, log }) => {
+      const { limit, offset } = args2;
+      const res = await monitorRequest(session, "/monitor", {
+        query: { limit, offset }
+      });
+      return asText(res);
+    }
+  });
+  server2.addTool({
+    name: "firecrawl_monitor_get",
+    annotations: {
+      title: "Get monitor",
+      readOnlyHint: true,
+      // Fetches a single monitor by ID; no mutations.
+      openWorldHint: false,
+      // Reads a specific monitor resource in the user's Firecrawl account.
+      destructiveHint: false
+      // Read-only retrieval.
+    },
+    description: `
+Get a single monitor by ID.
+
+**Usage Example:**
+\`\`\`json
+{ "name": "firecrawl_monitor_get", "arguments": { "id": "mon_abc123" } }
+\`\`\`
+`,
+    parameters: z2.object({ id: z2.string() }),
+    execute: async (args2, { session, log }) => {
+      const { id } = args2;
+      const res = await monitorRequest(
+        session,
+        `/monitor/${encodeURIComponent(id)}`
+      );
+      return asText(res);
+    }
+  });
+  server2.addTool({
+    name: "firecrawl_monitor_update",
+    annotations: {
+      title: "Update monitor",
+      readOnlyHint: false,
+      // PATCHes an existing monitor (status, schedule, targets, webhooks, etc.).
+      openWorldHint: true,
+      // Can change which external URLs are monitored and how recurring scrapes run.
+      destructiveHint: true
+      // Can pause, replace, or remove monitor configuration; changes overwrite prior settings.
+    },
+    description: `
+Update a monitor. Pass any subset of fields to patch: \`name\`, \`status\` ("active" | "paused"), \`schedule\`, \`targets\`, \`goal\`, \`judgeEnabled\`, \`webhook\`, \`notification\`, \`retentionDays\`.
+
+**Usage Example:**
+\`\`\`json
+{
+  "name": "firecrawl_monitor_update",
+  "arguments": {
+    "id": "mon_abc123",
+    "body": { "status": "paused" }
+  }
+}
+\`\`\`
+`,
+    parameters: z2.object({
+      id: z2.string(),
+      body: z2.record(z2.string(), z2.any())
+    }),
+    execute: async (args2, { session, log }) => {
+      const { id, body } = args2;
+      const res = await monitorRequest(
+        session,
+        `/monitor/${encodeURIComponent(id)}`,
+        { method: "PATCH", body }
+      );
+      return asText(res);
+    }
+  });
+  server2.addTool({
+    name: "firecrawl_monitor_delete",
+    annotations: {
+      title: "Delete monitor",
+      readOnlyHint: false,
+      // Permanently deletes a monitor via DELETE on the API.
+      openWorldHint: true,
+      // Deletes a monitor that tracked open-web URLs.
+      destructiveHint: true
+      // Irreversibly removes the monitor and stops its schedule.
+    },
+    description: `
+Permanently delete a monitor and stop its schedule. This cannot be undone.
+
+**Usage Example:**
+\`\`\`json
+{ "name": "firecrawl_monitor_delete", "arguments": { "id": "mon_abc123" } }
+\`\`\`
+`,
+    parameters: z2.object({ id: z2.string() }),
+    execute: async (args2, { session, log }) => {
+      const { id } = args2;
+      log.info("Deleting monitor", { id });
+      const res = await monitorRequest(
+        session,
+        `/monitor/${encodeURIComponent(id)}`,
+        { method: "DELETE" }
+      );
+      return asText(res);
+    }
+  });
+  server2.addTool({
+    name: "firecrawl_monitor_run",
+    annotations: {
+      title: "Run monitor now",
+      readOnlyHint: false,
+      // Triggers an immediate monitor check, queueing a new scrape/diff run.
+      openWorldHint: true,
+      // The triggered check scrapes external URLs configured on the monitor.
+      destructiveHint: false
+      // Starts a read-only check job; does not delete the monitor or external sites.
+    },
+    description: `
+Trigger a monitor check immediately, outside its normal schedule. Returns the queued check.
+
+**Usage Example:**
+\`\`\`json
+{ "name": "firecrawl_monitor_run", "arguments": { "id": "mon_abc123" } }
+\`\`\`
+`,
+    parameters: z2.object({ id: z2.string() }),
+    execute: async (args2, { session, log }) => {
+      const { id } = args2;
+      const res = await monitorRequest(
+        session,
+        `/monitor/${encodeURIComponent(id)}/run`,
+        { method: "POST" }
+      );
+      return asText(res);
+    }
+  });
+  server2.addTool({
+    name: "firecrawl_monitor_checks",
+    annotations: {
+      title: "List monitor checks",
+      readOnlyHint: true,
+      // Lists historical check runs for a monitor; no mutations.
+      openWorldHint: false,
+      // Returns check history for a known monitor ID within the user's account.
+      destructiveHint: false
+      // Read-only listing.
+    },
+    description: `
+List historical checks for a monitor.
+
+**Usage Example:**
+\`\`\`json
+{ "name": "firecrawl_monitor_checks", "arguments": { "id": "mon_abc123", "limit": 10, "status": "completed" } }
+\`\`\`
+`,
+    parameters: z2.object({
+      id: z2.string(),
+      limit: z2.number().int().positive().optional(),
+      offset: z2.number().int().nonnegative().optional(),
+      status: checkStatusSchema.optional()
+    }),
+    execute: async (args2, { session, log }) => {
+      const { id, limit, offset, status } = args2;
+      const res = await monitorRequest(
+        session,
+        `/monitor/${encodeURIComponent(id)}/checks`,
+        { query: { limit, offset, status } }
+      );
+      return asText(res);
+    }
+  });
+  server2.addTool({
+    name: "firecrawl_monitor_check",
+    annotations: {
+      title: "Get monitor check",
+      readOnlyHint: true,
+      // Retrieves a single check run with page-level diff results; no mutations.
+      openWorldHint: false,
+      // Reads stored check results for a known monitor/check ID in the user's account.
+      destructiveHint: false
+      // Read-only retrieval of diff snapshots and judgments.
+    },
+    description: `
+Get a single check with page-level diff results. Filter \`pageStatus\` to surface only the pages that changed (or were new, removed, etc.).
+
+Each entry in \`data.pages[]\` has \`url\`, \`status\` (\`same\` | \`new\` | \`changed\` | \`removed\` | \`error\`), optional \`judgment\` when goal-based judging ran, and \u2014 when changed \u2014 a \`diff\` and possibly a \`snapshot\`. The shape of \`diff\` depends on the monitor's \`formats\` configuration:
+
+- **Markdown mode (default).** \`diff.text\` is the unified markdown diff; \`diff.json\` is a parse-diff AST (\`{ files: [...] }\`). No \`snapshot\`.
+- **JSON mode** (\`changeTracking\` with \`modes: ["json"]\`). \`diff.json\` is a per-field map keyed by JSON path into the extraction, e.g. \`plans[0].price\`, with each value being \`{ previous, current }\`. \`snapshot.json\` is the full current extraction. No \`diff.text\`.
+- **Mixed mode** (\`modes: ["json", "git-diff"]\`). Both \`diff.text\` (markdown sidecar) AND \`diff.json\` (per-field map) are present, plus \`snapshot.json\`.
+
+**Example JSON-mode response \`pages[]\` entry:**
+
+\`\`\`json
+{
+  "url": "https://example.com/pricing",
+  "status": "changed",
+  "diff": {
+    "json": {
+      "plans[0].price":       { "previous": "$19/mo",        "current": "$24/mo" },
+      "plans[1].features[2]": { "previous": "10 GB storage", "current": "25 GB storage" }
+    }
+  },
+  "snapshot": { "json": { "plans": [/* current full extraction matching the monitor's schema */] } },
+  "judgment": {
+    "meaningful": true,
+    "confidence": "high",
+    "reason": "The pricing changed, which matches the monitor goal.",
+    "meaningfulChanges": [
+      {
+        "type": "changed",
+        "before": "$19/mo",
+        "after": "$24/mo",
+        "reason": "The tracked plan price changed."
+      }
+    ]
+  }
+}
+\`\`\`
+
+When summarizing a check for the user, prefer \`diff.json\` paths (e.g. "plans[0].price changed from $19/mo to $24/mo") over re-printing the markdown diff \u2014 it's more concise and grounded in the schema fields they asked for.
+
+When \`judgment\` is present, use it to decide what to surface. \`judgment.meaningful: false\` means the change was classified as noise for the monitor's goal. When \`judgment.meaningfulChanges\` is present, prefer those goal-relevant changes over raw diff hunks; each item includes \`type\`, \`before\`, \`after\`, and \`reason\`.
+
+The endpoint paginates via a top-level \`next\` URL; this tool returns one page at a time. Increase \`limit\` (max 100) to fetch fewer pages.
+
+**Usage Example:**
+\`\`\`json
+{
+  "name": "firecrawl_monitor_check",
+  "arguments": {
+    "id": "mon_abc123",
+    "checkId": "chk_xyz",
+    "pageStatus": "changed"
+  }
+}
+\`\`\`
+`,
+    parameters: z2.object({
+      id: z2.string(),
+      checkId: z2.string(),
+      limit: z2.number().int().positive().optional(),
+      skip: z2.number().int().nonnegative().optional(),
+      pageStatus: pageStatusSchema.optional()
+    }),
+    execute: async (args2, { session, log }) => {
+      const { id, checkId, limit, skip, pageStatus } = args2;
+      const res = await monitorRequest(
+        session,
+        `/monitor/${encodeURIComponent(id)}/checks/${encodeURIComponent(checkId)}`,
+        { query: { limit, skip, status: pageStatus } }
+      );
+      return asText(res);
+    }
+  });
+}
+
+// src/research.ts
+import { z as z3 } from "zod";
+var BASE = "/v2/search/research";
+var ORIGIN_HEADERS = { "X-Origin": "mcp-fastmcp" };
+function appendParam(params, key, value) {
+  if (value == null) return;
+  if (Array.isArray(value)) {
+    for (const v of value) {
+      if (v != null && String(v).length > 0) params.append(key, String(v));
+    }
+  } else {
+    params.append(key, String(value));
+  }
+}
+function withQuery(path2, params) {
+  const qs = params.toString();
+  return qs ? `${path2}?${qs}` : path2;
+}
+var MAX_AUTHORS = 15;
+var MAX_ABSTRACT_CHARS = 600;
+var MAX_AFFIL_CHARS = 60;
+var MAX_AUTHORS_LINE_CHARS = 400;
+function displayId(p) {
+  return p.primaryId ?? "missing-primary-id";
+}
+function fmtAuthors(authors) {
+  if (!authors) return null;
+  let shown;
+  let total;
+  if (typeof authors === "string") {
+    const names = authors.split(",").map((s) => s.trim()).filter(Boolean);
+    if (names.length === 0) return null;
+    total = names.length;
+    shown = names.slice(0, MAX_AUTHORS);
+  } else {
+    if (authors.length === 0) return null;
+    total = authors.length;
+    shown = authors.slice(0, MAX_AUTHORS).map((a) => {
+      const aff = a.affiliation?.trim();
+      return aff ? `${a.name} (${aff.slice(0, MAX_AFFIL_CHARS)})` : a.name;
+    });
+  }
+  const extra = total > MAX_AUTHORS ? `; +${total - MAX_AUTHORS} more` : "";
+  return ("Authors: " + shown.join("; ") + extra).slice(
+    0,
+    MAX_AUTHORS_LINE_CHARS
+  );
+}
+function fmtHits(results) {
+  if (!results || results.length === 0) return "(no results)";
+  return results.map((r) => {
+    const lines = [`## [${displayId(r)}] ${r.title ?? "(untitled)"}`];
+    const authors = fmtAuthors(r.authors);
+    if (authors) lines.push(authors);
+    lines.push(
+      (r.abstract || "(no abstract)").replace(/\s+/g, " ").slice(0, MAX_ABSTRACT_CHARS)
+    );
+    return lines.join("\n");
+  }).join("\n\n");
+}
+function fmtPaperMetadata(paper) {
+  if (!paper) return "(paper not found)";
+  const lines = [`# ${paper.title ?? "(untitled)"}`];
+  lines.push("");
+  lines.push(`Paper ID: ${paper.paperId ?? "?"}`);
+  const ids = Object.entries(paper.ids ?? {}).flatMap(
+    ([namespace, values]) => values.map((value) => `${namespace}:${value}`)
+  ).join(", ");
+  if (ids) lines.push(`IDs: ${ids}`);
+  const authors = fmtAuthors(paper.authors);
+  if (authors) lines.push(authors);
+  if (paper.categories?.length) {
+    lines.push(`Categories: ${paper.categories.join(", ")}`);
+  }
+  const dates = [
+    paper.createdDate ? `created ${paper.createdDate}` : "",
+    paper.updateDate ? `updated ${paper.updateDate}` : ""
+  ].filter(Boolean).join("; ");
+  if (dates) lines.push(`Dates: ${dates}`);
+  lines.push("");
+  lines.push("## Abstract");
+  lines.push((paper.abstract || "(no abstract)").replace(/\s+/g, " "));
+  return lines.join("\n");
+}
+var MAX_GITHUB_CONTENT_CHARS = 1200;
+function fmtGithub(results) {
+  if (!results || results.length === 0) return "(no results)";
+  return results.map((r) => {
+    const lines = [];
+    if (r.resultType === "repo_readme") {
+      lines.push(`[${r.repo ?? "?"}] README`);
+    } else {
+      const ref = r.number != null ? `#${r.number}` : "";
+      const meta = [
+        r.pageType,
+        r.segmentCount ? `${r.segmentCount} segments` : ""
+      ].filter(Boolean).join(", ");
+      lines.push(`[${r.repo ?? "?"}${ref}]${meta ? ` (${meta})` : ""}`);
+    }
+    const url = r.readmeUrl ?? r.url;
+    if (url) lines.push(url);
+    const body = (r.contentMd || r.snippet || "").trim();
+    lines.push(
+      body ? body.slice(0, MAX_GITHUB_CONTENT_CHARS) : "(no content)"
+    );
+    return lines.join("\n");
+  }).join("\n\n");
+}
+function registerResearchTools(server2, getClient2) {
+  server2.addTool({
+    name: "firecrawl_research_search_papers",
+    annotations: {
+      title: "Search arXiv papers",
+      readOnlyHint: true,
+      // Semantic search over indexed arXiv metadata; returns ranked results only.
+      openWorldHint: true,
+      // Searches the public arXiv research corpus.
+      destructiveHint: false
+      // Query-only; no writes to arXiv or the research index.
+    },
+    description: "Primary entry point for finding arXiv papers by topic. Semantic (HyDE) search over arXiv abstracts; returns ranked papers with arXiv id, title, and abstract. The query should be a natural-language description of what you want. Run SEVERAL distinct framings of the question (sibling domains, rival methods, dataset/benchmark names) rather than one query \u2014 recall improves markedly with diverse framings. Returns up to `k` results (default 40).",
+    parameters: z3.object({
+      query: z3.string().min(1),
+      k: z3.number().int().min(1).max(500).optional(),
+      authors: z3.array(z3.string()).optional().describe(
+        "Author substring filter(s); ALL must match (case-insensitive)."
+      ),
+      categories: z3.array(z3.string()).optional().describe("arXiv category filter(s) (e.g. `cs.LG`); ALL must match."),
+      from: z3.string().optional().describe(
+        "Inclusive lower bound on created/updated date (`YYYY-MM-DD`)."
+      ),
+      to: z3.string().optional().describe(
+        "Inclusive upper bound on created/updated date (`YYYY-MM-DD`)."
+      )
+    }),
+    execute: async (args2, { session }) => {
+      const { query, k, authors, categories, from, to } = args2;
+      const params = new URLSearchParams();
+      appendParam(params, "query", query);
+      appendParam(params, "k", k);
+      appendParam(params, "authors", authors);
+      appendParam(params, "categories", categories);
+      appendParam(params, "from", from);
+      appendParam(params, "to", to);
+      const client = getClient2(session);
+      const res = await client.http.get(
+        withQuery(`${BASE}/papers`, params),
+        ORIGIN_HEADERS
+      );
+      return fmtHits(res.data?.results);
+    }
+  });
+  server2.addTool({
+    name: "firecrawl_research_inspect_paper",
+    annotations: {
+      title: "Inspect a paper",
+      readOnlyHint: true,
+      // Fetches canonical metadata (title, abstract, authors) for one paper by ID.
+      openWorldHint: true,
+      // Retrieves metadata for papers in public indexes (arXiv, PMC, DOI, etc.).
+      destructiveHint: false
+      // Read-only metadata lookup.
+    },
+    description: "Fetch canonical metadata for one paper by primaryId or canonical paperId. Use this after search/related results when you need the full title, abstract, authors, categories, source ids, and dates rendered as markdown.",
+    parameters: z3.object({
+      paperId: z3.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`."
+      )
+    }),
+    execute: async (args2, { session }) => {
+      const { paperId } = args2;
+      const client = getClient2(session);
+      const res = await client.http.get(
+        `${BASE}/papers/${encodeURIComponent(paperId)}`,
+        ORIGIN_HEADERS
+      );
+      return fmtPaperMetadata(res.data?.paper);
+    }
+  });
+  server2.addTool({
+    name: "firecrawl_research_related_papers",
+    annotations: {
+      title: "Find related arXiv papers",
+      readOnlyHint: true,
+      // Finds related papers via citation graph expansion; returns candidates only.
+      openWorldHint: true,
+      // Traverses relationships across the public research paper corpus.
+      destructiveHint: false
+      // Read-only graph query; no modifications.
+    },
+    description: "Expand from anchor papers you have already found, via the citation graph, ranked and filtered to a natural-language `intent`. Pass arXiv ids of your strongest hits as `seed_ids`. Modes: `similar` (cocitation/coupling \u2014 papers in the same niche; the default), `citers` (papers that cite the anchors), `references` (papers the anchors cite). This reaches relevant papers that plain search misses, so use it on your best hits before finishing. A `similar` call already runs a DEEP multi-round expansion internally (re-seeding from each round\u2019s best finds), so one call reaches the wider neighborhood \u2014 no need to chain many. Returns the candidates plus the pool size.",
+    parameters: z3.object({
+      seed_ids: z3.array(z3.string()).min(1).max(10),
+      intent: z3.string().min(1),
+      mode: z3.enum(["similar", "citers", "references"]).optional(),
+      k: z3.number().int().min(1).max(500).optional(),
+      rerank: z3.boolean().optional().describe("Apply an additional rerank over the fused candidates.")
+    }),
+    execute: async (args2, { session }) => {
+      const { seed_ids, intent, mode, k, rerank } = args2;
+      const [primary, ...anchors] = seed_ids;
+      const params = new URLSearchParams();
+      appendParam(params, "intent", intent);
+      appendParam(params, "mode", mode);
+      appendParam(params, "k", k);
+      if (rerank != null) appendParam(params, "rerank", rerank);
+      appendParam(params, "anchor", anchors);
+      const client = getClient2(session);
+      const res = await client.http.get(
+        withQuery(
+          `${BASE}/papers/${encodeURIComponent(primary)}/similar`,
+          params
+        ),
+        ORIGIN_HEADERS
+      );
+      const note = res.data?.note ? `
+note: ${res.data.note}` : "";
+      return `${fmtHits(res.data?.results)}
+(poolSize=${res.data?.poolSize ?? 0})${note}`;
+    }
+  });
+  server2.addTool({
+    name: "firecrawl_research_read_paper",
+    annotations: {
+      title: "Read a paper",
+      readOnlyHint: true,
+      // Retrieves relevant full-text passages from a paper; does not modify the paper.
+      openWorldHint: true,
+      // Reads from publicly indexed paper full text when available.
+      destructiveHint: false
+      // Read-only passage retrieval.
+    },
+    description: "Read the most relevant in-body (full-text) passages of ONE specific paper for a question. Use this to VERIFY whether a candidate actually satisfies a constraint before you include or reject it (e.g. 'does this paper actually use technique X / report a score on benchmark Y'). Returns the best-matching passages, or a notice if the paper's full text is unavailable.",
+    parameters: z3.object({
+      paperId: z3.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: z3.string().min(1),
+      k: z3.number().int().min(1).max(50).optional().describe("Number of passages to return (default 4).")
+    }),
+    execute: async (args2, { session }) => {
+      const { paperId, question, k } = args2;
+      const params = new URLSearchParams();
+      appendParam(params, "query", question);
+      appendParam(params, "k", k);
+      const client = getClient2(session);
+      const res = await client.http.get(
+        withQuery(`${BASE}/papers/${encodeURIComponent(paperId)}`, params),
+        ORIGIN_HEADERS
+      );
+      const passages = res.data?.passages ?? [];
+      return passages.length ? passages.map((p) => p.text).join("\n---\n") : "(no full-text passages available for this paper)";
+    }
+  });
+  server2.addTool({
+    name: "firecrawl_research_search_github",
+    annotations: {
+      title: "Search GitHub history",
+      readOnlyHint: true,
+      // Searches indexed GitHub issue/PR history and READMEs; returns matches only.
+      openWorldHint: true,
+      // Searches public GitHub content.
+      destructiveHint: false
+      // Query-only; does not create issues, PRs, or modify repositories.
+    },
+    description: "Search GitHub issue/PR history and repository readmes. Returns ranked matches with repo, url, a short snippet, and (when available) the full matched content in markdown.",
+    parameters: z3.object({
+      query: z3.string().min(1),
+      k: z3.number().int().min(1).max(100).optional()
+    }),
+    execute: async (args2, { session }) => {
+      const { query, k } = args2;
+      const params = new URLSearchParams();
+      appendParam(params, "query", query);
+      appendParam(params, "k", k);
+      const client = getClient2(session);
+      const res = await client.http.get(
+        withQuery(`${BASE}/github`, params),
+        ORIGIN_HEADERS
+      );
+      return fmtGithub(res.data?.results);
+    }
+  });
+}
+
+// src/index.ts
+dotenv.config({ debug: false, quiet: true });
+var require2 = createRequire(import.meta.url);
+var { version: packageVersion } = require2("../package.json");
 function normalizeHeader(value) {
-    if (value == null)
-        return undefined;
-    const v = Array.isArray(value) ? value[0] : value;
-    const trimmed = typeof v === 'string' ? v.trim() : '';
-    return trimmed || undefined;
+  if (value == null) return void 0;
+  const v = Array.isArray(value) ? value[0] : value;
+  const trimmed = typeof v === "string" ? v.trim() : "";
+  return trimmed || void 0;
 }
 function extractBearerToken(headers) {
-    const headerAuth = normalizeHeader(headers['authorization']);
-    if (!headerAuth?.toLowerCase().startsWith('bearer '))
-        return undefined;
-    const raw = headerAuth.slice(7).trim();
-    return raw || undefined;
+  const headerAuth = normalizeHeader(headers["authorization"]);
+  if (!headerAuth?.toLowerCase().startsWith("bearer ")) return void 0;
+  const raw = headerAuth.slice(7).trim();
+  return raw || void 0;
 }
-/** OAuth access tokens minted by Firecrawl (Authorization Server). */
 function isFirecrawlOAuthAccessToken(token) {
-    return token.startsWith('fco_');
+  return token.startsWith("fco_");
 }
 function resolveCredentialFromEnv() {
-    return (normalizeHeader(process.env.FIRECRAWL_OAUTH_TOKEN) ??
-        normalizeHeader(process.env.FIRECRAWL_API_KEY));
+  return normalizeHeader(process.env.FIRECRAWL_OAUTH_TOKEN) ?? normalizeHeader(process.env.FIRECRAWL_API_KEY);
 }
 function isHttpStreamingTransport() {
-    return (process.env.HTTP_STREAMABLE_SERVER === 'true' ||
-        process.env.SSE_LOCAL === 'true');
+  return process.env.HTTP_STREAMABLE_SERVER === "true" || process.env.SSE_LOCAL === "true";
 }
-const DEFAULT_OAUTH_ISSUER = 'https://www.firecrawl.dev';
-const DEFAULT_MCP_RESOURCE_URL = 'https://mcp.firecrawl.dev/v2/mcp';
+var DEFAULT_OAUTH_ISSUER = "https://www.firecrawl.dev";
+var DEFAULT_MCP_RESOURCE_URL = "https://mcp.firecrawl.dev/v2/mcp";
 function withoutTrailingSlash(value) {
-    return value.replace(/\/+$/, '');
+  return value.replace(/\/+$/, "");
 }
 function getOAuthIssuer() {
-    return withoutTrailingSlash(normalizeHeader(process.env.FIRECRAWL_OAUTH_ISSUER) ?? DEFAULT_OAUTH_ISSUER);
+  return withoutTrailingSlash(
+    normalizeHeader(process.env.FIRECRAWL_OAUTH_ISSUER) ?? DEFAULT_OAUTH_ISSUER
+  );
 }
 function getMcpResourceUrl() {
-    return (normalizeHeader(process.env.FIRECRAWL_MCP_RESOURCE_URL) ??
-        DEFAULT_MCP_RESOURCE_URL);
+  return normalizeHeader(process.env.FIRECRAWL_MCP_RESOURCE_URL) ?? DEFAULT_MCP_RESOURCE_URL;
 }
-// PRM lives at the MCP origin per RFC 9728 (one PRM per resource). firecrawl-fastmcp
-// auto-serves it at the standard /.well-known/oauth-protected-resource path from the
-// protectedResource config, so the URL is fully derived from the MCP resource.
 function getOAuthProtectedResourceMetadataUrl() {
-    return `${new URL(getMcpResourceUrl()).origin}/.well-known/oauth-protected-resource`;
+  return `${new URL(getMcpResourceUrl()).origin}/.well-known/oauth-protected-resource`;
 }
 function getOAuthIntrospectionEndpoint() {
-    return `${getOAuthIssuer()}/api/oauth/introspect`;
+  return `${getOAuthIssuer()}/api/oauth/introspect`;
 }
 function getOAuthIntrospectionSecret() {
-    return normalizeHeader(process.env.FIRECRAWL_OAUTH_INTROSPECT_SECRET);
+  return normalizeHeader(process.env.FIRECRAWL_OAUTH_INTROSPECT_SECRET);
 }
 function isMcpOAuthEnabled() {
-    return process.env.CLOUD_SERVICE === 'true';
+  return process.env.CLOUD_SERVICE === "true";
 }
 async function introspectOAuthAccessToken(token) {
-    const introspectionSecret = getOAuthIntrospectionSecret();
-    if (!introspectionSecret) {
-        throw new Error('OAuth token introspection is not configured');
-    }
-    const response = await fetch(getOAuthIntrospectionEndpoint(), {
-        method: 'POST',
-        headers: {
-            'Content-Type': 'application/x-www-form-urlencoded',
-            Authorization: `Bearer ${introspectionSecret}`,
-        },
-        body: new URLSearchParams({
-            token,
-            token_type_hint: 'access_token',
-        }),
-    });
-    if (!response.ok) {
-        throw new Error(`OAuth token introspection failed: ${response.status}`);
-    }
-    const data = (await response.json());
-    if (!data.active || !data.api_key) {
-        throw new Error('Invalid OAuth access token');
-    }
-    return data.api_key;
+  const introspectionSecret = getOAuthIntrospectionSecret();
+  if (!introspectionSecret) {
+    throw new Error("OAuth token introspection is not configured");
+  }
+  const response = await fetch(getOAuthIntrospectionEndpoint(), {
+    method: "POST",
+    headers: {
+      "Content-Type": "application/x-www-form-urlencoded",
+      Authorization: `Bearer ${introspectionSecret}`
+    },
+    body: new URLSearchParams({
+      token,
+      token_type_hint: "access_token"
+    })
+  });
+  if (!response.ok) {
+    throw new Error(`OAuth token introspection failed: ${response.status}`);
+  }
+  const data = await response.json();
+  if (!data.active || !data.api_key) {
+    throw new Error("Invalid OAuth access token");
+  }
+  return data.api_key;
 }
 async function resolveCredentialFromHeaders(headers) {
-    const bearer = extractBearerToken(headers);
-    const headerApiKey = normalizeHeader(headers['x-firecrawl-api-key'] ?? headers['x-api-key']);
-    if (bearer && isFirecrawlOAuthAccessToken(bearer)) {
-        return introspectOAuthAccessToken(bearer);
-    }
-    if (headerApiKey) {
-        return headerApiKey;
-    }
-    if (bearer) {
-        return bearer;
-    }
-    return undefined;
+  const bearer = extractBearerToken(headers);
+  const headerApiKey = normalizeHeader(
+    headers["x-firecrawl-api-key"] ?? headers["x-api-key"]
+  );
+  if (bearer && isFirecrawlOAuthAccessToken(bearer)) {
+    return introspectOAuthAccessToken(bearer);
+  }
+  if (headerApiKey) {
+    return headerApiKey;
+  }
+  if (bearer) {
+    return bearer;
+  }
+  return void 0;
 }
 function removeEmptyTopLevel(obj) {
-    const out = {};
-    for (const [k, v] of Object.entries(obj)) {
-        if (v == null)
-            continue;
-        if (typeof v === 'string' && v.trim() === '')
-            continue;
-        if (Array.isArray(v) && v.length === 0)
-            continue;
-        if (typeof v === 'object' &&
-            !Array.isArray(v) &&
-            Object.keys(v).length === 0)
-            continue;
-        // @ts-expect-error dynamic assignment
-        out[k] = v;
-    }
-    return out;
-}
-const searchDomainSchema = z
-    .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');
+  const out = {};
+  for (const [k, v] of Object.entries(obj)) {
+    if (v == null) continue;
+    if (typeof v === "string" && v.trim() === "") continue;
+    if (Array.isArray(v) && v.length === 0) continue;
+    if (typeof v === "object" && !Array.isArray(v) && Object.keys(v).length === 0)
+      continue;
+    out[k] = v;
+  }
+  return out;
+}
+var searchDomainSchema = z4.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"
+);
 function buildSearchQueryWithDomains(query, includeDomains, excludeDomains) {
-    if (includeDomains?.length) {
-        return `${query} (${includeDomains
-            .map((domain) => `site:${domain}`)
-            .join(' OR ')})`;
-    }
-    if (excludeDomains?.length) {
-        return `${query} ${excludeDomains
-            .map((domain) => `-site:${domain}`)
-            .join(' ')}`;
-    }
-    return query;
-}
-class ConsoleLogger {
-    shouldLog = process.env.CLOUD_SERVICE === 'true' ||
-        process.env.SSE_LOCAL === 'true' ||
-        process.env.HTTP_STREAMABLE_SERVER === 'true';
-    debug(...args) {
-        if (this.shouldLog) {
-            console.debug('[DEBUG]', new Date().toISOString(), ...args);
-        }
+  if (includeDomains?.length) {
+    return `${query} (${includeDomains.map((domain) => `site:${domain}`).join(" OR ")})`;
+  }
+  if (excludeDomains?.length) {
+    return `${query} ${excludeDomains.map((domain) => `-site:${domain}`).join(" ")}`;
+  }
+  return query;
+}
+var ConsoleLogger = class {
+  shouldLog = process.env.CLOUD_SERVICE === "true" || process.env.SSE_LOCAL === "true" || process.env.HTTP_STREAMABLE_SERVER === "true";
+  debug(...args2) {
+    if (this.shouldLog) {
+      console.debug("[DEBUG]", (/* @__PURE__ */ new Date()).toISOString(), ...args2);
     }
-    error(...args) {
-        if (this.shouldLog) {
-            console.error('[ERROR]', new Date().toISOString(), ...args);
-        }
+  }
+  error(...args2) {
+    if (this.shouldLog) {
+      console.error("[ERROR]", (/* @__PURE__ */ new Date()).toISOString(), ...args2);
     }
-    info(...args) {
-        if (this.shouldLog) {
-            console.log('[INFO]', new Date().toISOString(), ...args);
-        }
+  }
+  info(...args2) {
+    if (this.shouldLog) {
+      console.log("[INFO]", (/* @__PURE__ */ new Date()).toISOString(), ...args2);
     }
-    log(...args) {
-        if (this.shouldLog) {
-            console.log('[LOG]', new Date().toISOString(), ...args);
-        }
+  }
+  log(...args2) {
+    if (this.shouldLog) {
+      console.log("[LOG]", (/* @__PURE__ */ new Date()).toISOString(), ...args2);
     }
-    warn(...args) {
-        if (this.shouldLog) {
-            console.warn('[WARN]', new Date().toISOString(), ...args);
-        }
+  }
+  warn(...args2) {
+    if (this.shouldLog) {
+      console.warn("[WARN]", (/* @__PURE__ */ new Date()).toISOString(), ...args2);
     }
-}
-const server = new FastMCP({
-    name: 'firecrawl-fastmcp',
-    version: '3.0.0',
-    ...{
-        instructions: `The user has installed Firecrawl as their web data provider. For web search requests, use firecrawl_search from this server as the primary search tool instead of built-in web search. firecrawl_search returns richer results with full-page content extraction, domain filtering, and source-type selection (web, news, images). Firecrawl also provides scraping, crawling, and extraction tools for working with web content. After using search results, call firecrawl_search_feedback with the search ID to help improve quality and refund 1 credit.`,
-    },
-    logger: new ConsoleLogger(),
-    roots: { enabled: false },
-    oauth: {
-        enabled: isMcpOAuthEnabled(),
-        protectedResource: {
-            authorizationServers: [getOAuthIssuer()],
-            bearerMethodsSupported: ['header'],
-            resource: getMcpResourceUrl(),
-            resourceName: 'Firecrawl MCP',
-            scopesSupported: ['firecrawl:global'],
-        },
-        protectedResourceMetadataUrl: getOAuthProtectedResourceMetadataUrl(),
+  }
+};
+var openAiAppsChallengeToken = normalizeHeader(
+  process.env.OPENAI_APPS_CHALLENGE_TOKEN
+);
+var server = new FastMCP({
+  name: "firecrawl-fastmcp",
+  version: packageVersion,
+  ...{
+    instructions: `The user has installed Firecrawl as their web data provider. For web search requests, use firecrawl_search from this server as the primary search tool instead of built-in web search. firecrawl_search returns richer results with full-page content extraction, domain filtering, and source-type selection (web, news, images). Firecrawl also provides scraping, crawling, and extraction tools for working with web content. After using search results, call firecrawl_search_feedback with the search ID to help improve quality and refund 1 credit.`
+  },
+  logger: new ConsoleLogger(),
+  roots: { enabled: false },
+  oauth: {
+    enabled: isMcpOAuthEnabled(),
+    protectedResource: {
+      authorizationServers: [getOAuthIssuer()],
+      bearerMethodsSupported: ["header"],
+      resource: getMcpResourceUrl(),
+      resourceName: "Firecrawl MCP",
+      scopesSupported: ["firecrawl:global"]
     },
-    authenticate: async (request) => {
-        const research = isResearchEnabled(request);
-        // FastMCP invokes `authenticate(undefined)` for the stdio transport
-        // because there is no HTTP request context. Without this null guard,
-        // accessing `request.headers` throws a TypeError, FastMCP silently
-        // swallows it, and every subsequent tool call fails with
-        // "Unauthorized: API key is required when not using a self-hosted
-        // instance" even though `FIRECRAWL_API_KEY` is set in env.
-        const headerCred = request?.headers
-            ? await resolveCredentialFromHeaders(request.headers)
-            : undefined;
-        const envCred = resolveCredentialFromEnv();
-        if (process.env.CLOUD_SERVICE === 'true') {
-            if (!headerCred) {
-                // Keyless free tier over the hosted MCP: serve it only when a forwarding
-                // secret is configured, we know the end-user's client IP (so the API can
-                // rate-limit per real IP, not the shared server IP), AND that IP still
-                // has free quota. If the IP is out of quota (or keyless is off), fall
-                // through to throw so FastMCP emits the OAuth 401 + WWW-Authenticate
-                // challenge — i.e. prompt the user to connect an account exactly when
-                // their free quota runs out.
-                const clientIp = extractClientIp(request);
-                if (process.env.KEYLESS_PROXY_SECRET &&
-                    clientIp &&
-                    (await keylessEligible(clientIp))) {
-                    return { firecrawlApiKey: undefined, research, keylessClientIp: clientIp };
-                }
-                throw new Error('Firecrawl credentials required: OAuth access token (Authorization: Bearer fco_...) or API key (x-firecrawl-api-key)');
-            }
-            return { firecrawlApiKey: headerCred, research };
-        }
-        const credential = headerCred ?? envCred;
-        // Self-hosted / stdio / HTTP streamable — headers supply MCP OAuth token when present
-        const httpStreaming = isHttpStreamingTransport();
-        if (!httpStreaming &&
-            !process.env.FIRECRAWL_API_KEY &&
-            !process.env.FIRECRAWL_API_URL) {
-            // No credential and no self-hosted URL: run in keyless mode. scrape and
-            // search work for free (rate-limited per IP) against the Firecrawl cloud;
-            // every other tool needs an API key and will return Unauthorized.
-            console.error('No FIRECRAWL_API_KEY or FIRECRAWL_API_URL set — running in keyless mode. ' +
-                'firecrawl_scrape and firecrawl_search are free (rate-limited per IP) against the Firecrawl cloud; ' +
-                'other tools require an API key (get one free at https://firecrawl.dev).');
-        }
-        if (httpStreaming && !credential && !process.env.FIRECRAWL_API_URL) {
-            console.error('HTTP MCP transport requires FIRECRAWL_API_URL and/or credentials (OAuth: Authorization Bearer fco_..., or FIRECRAWL_API_KEY / FIRECRAWL_OAUTH_TOKEN)');
-            process.exit(1);
+    protectedResourceMetadataUrl: getOAuthProtectedResourceMetadataUrl()
+  },
+  authenticate: async (request) => {
+    const headerCred = request?.headers ? await resolveCredentialFromHeaders(request.headers) : void 0;
+    const envCred = resolveCredentialFromEnv();
+    if (process.env.CLOUD_SERVICE === "true") {
+      if (!headerCred) {
+        const clientIp = extractClientIp(request);
+        if (process.env.KEYLESS_PROXY_SECRET && clientIp && await keylessEligible(clientIp)) {
+          return { firecrawlApiKey: void 0, keylessClientIp: clientIp };
         }
-        return { firecrawlApiKey: credential, research };
-    },
-    // Lightweight health endpoint for LB checks
-    health: {
-        enabled: true,
-        message: 'ok',
-        path: '/health',
-        status: 200,
-    },
+        throw new Error(
+          "Firecrawl credentials required: OAuth access token (Authorization: Bearer fco_...) or API key (x-firecrawl-api-key)"
+        );
+      }
+      return { firecrawlApiKey: headerCred };
+    }
+    const credential = headerCred ?? envCred;
+    const httpStreaming = isHttpStreamingTransport();
+    if (!httpStreaming && !process.env.FIRECRAWL_API_KEY && !process.env.FIRECRAWL_API_URL) {
+      console.error(
+        "No FIRECRAWL_API_KEY or FIRECRAWL_API_URL set \u2014 running in keyless mode. firecrawl_scrape and firecrawl_search are free (rate-limited per IP) against the Firecrawl cloud; other tools require an API key (get one free at https://firecrawl.dev)."
+      );
+    }
+    if (httpStreaming && !credential && !process.env.FIRECRAWL_API_URL) {
+      console.error(
+        "HTTP MCP transport requires FIRECRAWL_API_URL and/or credentials (OAuth: Authorization Bearer fco_..., or FIRECRAWL_API_KEY / FIRECRAWL_OAUTH_TOKEN)"
+      );
+      process.exit(1);
+    }
+    return { firecrawlApiKey: credential };
+  },
+  // Lightweight health endpoint for LB checks
+  health: {
+    enabled: true,
+    message: "ok",
+    path: "/health",
+    status: 200
+  },
+  ...openAiAppsChallengeToken ? { openaiAppsChallenge: { token: openAiAppsChallengeToken } } : {}
 });
 function createClient(apiKey) {
-    const config = {
-        ...(process.env.FIRECRAWL_API_URL && {
-            apiUrl: process.env.FIRECRAWL_API_URL,
-        }),
-    };
-    // Only add apiKey if it's provided (required for cloud, optional for self-hosted)
-    if (apiKey) {
-        config.apiKey = apiKey;
+  const config = {
+    ...process.env.FIRECRAWL_API_URL && {
+      apiUrl: process.env.FIRECRAWL_API_URL
     }
-    return new FirecrawlApp(config);
+  };
+  if (apiKey) {
+    config.apiKey = apiKey;
+  }
+  return new FirecrawlApp(config);
 }
-const ORIGIN = 'mcp-fastmcp';
-// Safe mode is enabled by default for cloud service to comply with ChatGPT safety requirements
-const SAFE_MODE = process.env.CLOUD_SERVICE === 'true';
+var ORIGIN = "mcp-fastmcp";
+var SAFE_MODE = process.env.CLOUD_SERVICE === "true";
 function getClient(session) {
-    // For cloud service, API key is required
-    if (process.env.CLOUD_SERVICE === 'true') {
-        if (!session || !session.firecrawlApiKey) {
-            throw new Error('Unauthorized');
-        }
-        return createClient(session.firecrawlApiKey);
-    }
-    // For self-hosted instances, API key is optional if FIRECRAWL_API_URL is provided
-    if (!process.env.FIRECRAWL_API_URL &&
-        (!session || !session.firecrawlApiKey)) {
-        throw new Error('Unauthorized: API key is required when not using a self-hosted instance');
+  if (process.env.CLOUD_SERVICE === "true") {
+    if (!session || !session.firecrawlApiKey) {
+      throw new Error("Unauthorized");
     }
-    return createClient(session?.firecrawlApiKey);
+    return createClient(session.firecrawlApiKey);
+  }
+  if (!process.env.FIRECRAWL_API_URL && (!session || !session.firecrawlApiKey)) {
+    throw new Error(
+      "Unauthorized: API key is required when not using a self-hosted instance"
+    );
+  }
+  return createClient(session?.firecrawlApiKey);
 }
-function asText(data) {
-    return JSON.stringify(data, null, 2);
-}
-// scrape tool (v2 semantics, minimal args)
-// Centralized scrape params (used by scrape, and referenced in search/crawl scrapeOptions)
-// Define safe action types
-const safeActionTypes = ['wait', 'screenshot', 'scroll', 'scrape'];
-const otherActions = [
-    'click',
-    'write',
-    'press',
-    'executeJavascript',
-    'generatePDF',
+function asText2(data) {
+  return JSON.stringify(data, null, 2);
+}
+var safeActionTypes = ["wait", "screenshot", "scroll", "scrape"];
+var otherActions = [
+  "click",
+  "write",
+  "press",
+  "executeJavascript",
+  "generatePDF"
 ];
-const allActionTypes = [...safeActionTypes, ...otherActions];
-// Use appropriate action types based on safe mode
-const allowedActionTypes = SAFE_MODE ? safeActionTypes : allActionTypes;
-function buildFormatsArray(args) {
-    const formats = args.formats;
-    if (!formats || formats.length === 0)
-        return undefined;
-    const result = [];
-    for (const fmt of formats) {
-        if (fmt === 'json') {
-            const jsonOpts = args.jsonOptions;
-            result.push({ type: 'json', ...jsonOpts });
-        }
-        else if (fmt === 'query') {
-            const queryOpts = args.queryOptions;
-            result.push({ type: 'query', ...queryOpts });
-        }
-        else if (fmt === 'screenshot' && args.screenshotOptions) {
-            const ssOpts = args.screenshotOptions;
-            result.push({ type: 'screenshot', ...ssOpts });
-        }
-        else {
-            result.push(fmt);
-        }
+var allActionTypes = [...safeActionTypes, ...otherActions];
+var allowedActionTypes = SAFE_MODE ? safeActionTypes : allActionTypes;
+function buildFormatsArray(args2) {
+  const formats = args2.formats;
+  if (!formats || formats.length === 0) return void 0;
+  const result = [];
+  for (const fmt of formats) {
+    if (fmt === "json") {
+      const jsonOpts = args2.jsonOptions;
+      result.push({ type: "json", ...jsonOpts });
+    } else if (fmt === "query") {
+      const queryOpts = args2.queryOptions;
+      result.push({ type: "query", ...queryOpts });
+    } else if (fmt === "screenshot" && args2.screenshotOptions) {
+      const ssOpts = args2.screenshotOptions;
+      result.push({ type: "screenshot", ...ssOpts });
+    } else {
+      result.push(fmt);
     }
-    return result;
-}
-function buildParsersArray(args) {
-    const parsers = args.parsers;
-    if (!parsers || parsers.length === 0)
-        return undefined;
-    const result = [];
-    for (const p of parsers) {
-        if (p === 'pdf' && args.pdfOptions) {
-            const pdfOpts = args.pdfOptions;
-            result.push({ type: 'pdf', ...pdfOpts });
-        }
-        else {
-            result.push(p);
-        }
+  }
+  return result;
+}
+function buildParsersArray(args2) {
+  const parsers = args2.parsers;
+  if (!parsers || parsers.length === 0) return void 0;
+  const result = [];
+  for (const p of parsers) {
+    if (p === "pdf" && args2.pdfOptions) {
+      const pdfOpts = args2.pdfOptions;
+      result.push({ type: "pdf", ...pdfOpts });
+    } else {
+      result.push(p);
     }
-    return result;
-}
-function buildWebhook(args) {
-    const webhook = args.webhook;
-    if (!webhook)
-        return undefined;
-    const headers = args.webhookHeaders;
-    if (headers && Object.keys(headers).length > 0) {
-        return { url: webhook, headers };
-    }
-    return webhook;
-}
-function transformScrapeParams(args) {
-    const out = { ...args };
-    const formats = buildFormatsArray(out);
-    if (formats)
-        out.formats = formats;
-    const parsers = buildParsersArray(out);
-    if (parsers)
-        out.parsers = parsers;
-    delete out.jsonOptions;
-    delete out.queryOptions;
-    delete out.screenshotOptions;
-    delete out.pdfOptions;
-    return out;
-}
-const scrapeParamsSchema = z.object({
-    url: z.string().url(),
-    formats: z
-        .array(z.enum([
-        'markdown',
-        'html',
-        'rawHtml',
-        'screenshot',
-        'links',
-        'summary',
-        'changeTracking',
-        'branding',
-        'json',
-        'query',
-        'audio',
-    ]))
-        .optional(),
-    jsonOptions: z
-        .object({
-        prompt: z.string().optional(),
-        schema: z.record(z.string(), z.any()).optional(),
-    })
-        .optional(),
-    queryOptions: z
-        .object({
-        prompt: z.string().max(10000),
-        mode: z.enum(['directQuote', 'freeform']).default('freeform'),
-    })
-        .optional(),
-    screenshotOptions: z
-        .object({
-        fullPage: z.boolean().optional(),
-        quality: z.number().optional(),
-        viewport: z.object({ width: z.number(), height: z.number() }).optional(),
-    })
-        .optional(),
-    parsers: z.array(z.enum(['pdf'])).optional(),
-    pdfOptions: z
-        .object({
-        maxPages: z.number().int().min(1).max(10000).optional(),
-    })
-        .optional(),
-    onlyMainContent: z.boolean().optional(),
-    redactPII: z.boolean().optional(),
-    includeTags: z.array(z.string()).optional(),
-    excludeTags: z.array(z.string()).optional(),
-    waitFor: z.number().optional(),
-    ...(SAFE_MODE
-        ? {}
-        : {
-            actions: z
-                .array(z.object({
-                type: z.enum(allowedActionTypes),
-                selector: z.string().optional(),
-                milliseconds: z.number().optional(),
-                text: z.string().optional(),
-                key: z.string().optional(),
-                direction: z.enum(['up', 'down']).optional(),
-                script: z.string().optional(),
-                fullPage: z.boolean().optional(),
-            }))
-                .optional(),
-        }),
-    mobile: z.boolean().optional(),
-    skipTlsVerification: z.boolean().optional(),
-    removeBase64Images: z.boolean().optional(),
-    location: z
-        .object({
-        country: z.string().optional(),
-        languages: z.array(z.string()).optional(),
-    })
-        .optional(),
-    storeInCache: z.boolean().optional(),
-    zeroDataRetention: z.boolean().optional(),
-    maxAge: z.number().optional(),
-    lockdown: z.boolean().optional(),
-    proxy: z.enum(['basic', 'stealth', 'enhanced', 'auto']).optional(),
-    profile: z
-        .object({
-        name: z.string(),
-        saveChanges: z.boolean().optional(),
-    })
-        .optional(),
+  }
+  return result;
+}
+function buildWebhook(args2) {
+  const webhook = args2.webhook;
+  if (!webhook) return void 0;
+  const headers = args2.webhookHeaders;
+  if (headers && Object.keys(headers).length > 0) {
+    return { url: webhook, headers };
+  }
+  return webhook;
+}
+function transformScrapeParams(args2) {
+  const out = { ...args2 };
+  const formats = buildFormatsArray(out);
+  if (formats) out.formats = formats;
+  const parsers = buildParsersArray(out);
+  if (parsers) out.parsers = parsers;
+  delete out.jsonOptions;
+  delete out.queryOptions;
+  delete out.screenshotOptions;
+  delete out.pdfOptions;
+  return out;
+}
+var scrapeParamsSchema = z4.object({
+  url: z4.string().url(),
+  formats: z4.array(
+    z4.enum([
+      "markdown",
+      "html",
+      "rawHtml",
+      "screenshot",
+      "links",
+      "summary",
+      "changeTracking",
+      "branding",
+      "json",
+      "query",
+      "audio"
+    ])
+  ).optional(),
+  jsonOptions: z4.object({
+    prompt: z4.string().optional(),
+    schema: z4.record(z4.string(), z4.any()).optional()
+  }).optional(),
+  queryOptions: z4.object({
+    prompt: z4.string().max(1e4),
+    mode: z4.enum(["directQuote", "freeform"]).default("freeform")
+  }).optional(),
+  screenshotOptions: z4.object({
+    fullPage: z4.boolean().optional(),
+    quality: z4.number().optional(),
+    viewport: z4.object({ width: z4.number(), height: z4.number() }).optional()
+  }).optional(),
+  parsers: z4.array(z4.enum(["pdf"])).optional(),
+  pdfOptions: z4.object({
+    maxPages: z4.number().int().min(1).max(1e4).optional()
+  }).optional(),
+  onlyMainContent: z4.boolean().optional(),
+  redactPII: z4.boolean().optional(),
+  includeTags: z4.array(z4.string()).optional(),
+  excludeTags: z4.array(z4.string()).optional(),
+  waitFor: z4.number().optional(),
+  ...SAFE_MODE ? {} : {
+    actions: z4.array(
+      z4.object({
+        type: z4.enum(allowedActionTypes),
+        selector: z4.string().optional(),
+        milliseconds: z4.number().optional(),
+        text: z4.string().optional(),
+        key: z4.string().optional(),
+        direction: z4.enum(["up", "down"]).optional(),
+        script: z4.string().optional(),
+        fullPage: z4.boolean().optional()
+      })
+    ).optional()
+  },
+  mobile: z4.boolean().optional(),
+  skipTlsVerification: z4.boolean().optional(),
+  removeBase64Images: z4.boolean().optional(),
+  location: z4.object({
+    country: z4.string().optional(),
+    languages: z4.array(z4.string()).optional()
+  }).optional(),
+  storeInCache: z4.boolean().optional(),
+  zeroDataRetention: z4.boolean().optional(),
+  maxAge: z4.number().optional(),
+  lockdown: z4.boolean().optional(),
+  proxy: z4.enum(["basic", "stealth", "enhanced", "auto"]).optional(),
+  profile: z4.object({
+    name: z4.string(),
+    saveChanges: z4.boolean().optional()
+  }).optional()
 });
 server.addTool({
-    name: 'firecrawl_scrape',
-    annotations: {
-        title: 'Scrape a URL',
-        readOnlyHint: SAFE_MODE,
-        openWorldHint: true,
-    },
-    description: `
+  name: "firecrawl_scrape",
+  annotations: {
+    title: "Scrape a URL",
+    readOnlyHint: SAFE_MODE,
+    // Fetches page content only; in cloud/safe mode interactive browser actions are disabled.
+    openWorldHint: true,
+    // Accepts any user-supplied URL on the public web.
+    destructiveHint: false
+    // Does not modify, delete, or write to external websites.
+  },
+  description: `
 Scrape content from a single URL with advanced options.
 This is the most powerful, fastest and most reliable scraper tool, if available you should always default to using this tool for any web scraping needs.
 
@@ -532,7 +2560,7 @@ If JSON extraction returns empty, minimal, or just navigation content, the page
 }
 \`\`\`
 
-**Prefer markdown format by default.** You can read and reason over the full page content directly — no need for an intermediate query step. Use markdown for questions about page content, factual lookups, and any task where you need to understand the page.
+**Prefer markdown format by default.** You can read and reason over the full page content directly \u2014 no need for an intermediate query step. Use markdown for questions about page content, factual lookups, and any task where you need to understand the page.
 
 **Use JSON format when user needs:**
 - Structured data with specific fields (extract all products with name, price, description)
@@ -569,45 +2597,52 @@ If JSON extraction returns empty, minimal, or just navigation content, the page
 **Lockdown mode:** Set \`lockdown: true\` to serve the request only from the existing index/cache without any outbound network request. For air-gapped or compliance-constrained use where the request URL itself is considered sensitive. Errors on cache miss. Billed at 5 credits.
 **Privacy:** Set \`redactPII: true\` to return content with personally identifiable information redacted.
 **Returns:** JSON structured data, markdown, branding profile, or other formats as specified.
-${SAFE_MODE
-        ? '**Safe Mode:** Read-only content extraction. Interactive actions (click, write, executeJavascript) are disabled for security.'
-        : ''}
+${SAFE_MODE ? "**Safe Mode:** Read-only content extraction. Interactive actions (click, write, executeJavascript) are disabled for security." : ""}
 `,
-    parameters: scrapeParamsSchema,
-    execute: async (args, { session, log }) => {
-        const { url, ...options } = args;
-        const transformed = transformScrapeParams(options);
-        const cleaned = removeEmptyTopLevel(transformed);
-        if (cleaned.lockdown) {
-            log.info('Scraping URL (lockdown)');
-        }
-        else {
-            log.info('Scraping URL', { url: String(url) });
-        }
-        if (isKeylessMode(session)) {
-            const json = await keylessPost('/v2/scrape', {
-                url: String(url),
-                ...cleaned,
-                origin: ORIGIN,
-            }, session);
-            return asText(json?.data ?? json);
-        }
-        const client = getClient(session);
-        const res = await client.scrape(String(url), {
-            ...cleaned,
-            origin: ORIGIN,
-        });
-        return asText(res);
-    },
+  parameters: scrapeParamsSchema,
+  execute: async (args2, { session, log }) => {
+    const { url, ...options } = args2;
+    const transformed = transformScrapeParams(
+      options
+    );
+    const cleaned = removeEmptyTopLevel(transformed);
+    if (cleaned.lockdown) {
+      log.info("Scraping URL (lockdown)");
+    } else {
+      log.info("Scraping URL", { url: String(url) });
+    }
+    if (isKeylessMode(session)) {
+      const json = await keylessPost(
+        "/v2/scrape",
+        {
+          url: String(url),
+          ...cleaned,
+          origin: ORIGIN
+        },
+        session
+      );
+      return asText2(json?.data ?? json);
+    }
+    const client = getClient(session);
+    const res = await client.scrape(String(url), {
+      ...cleaned,
+      origin: ORIGIN
+    });
+    return asText2(res);
+  }
 });
 server.addTool({
-    name: 'firecrawl_map',
-    annotations: {
-        title: 'Map a website',
-        readOnlyHint: true,
-        openWorldHint: true,
-    },
-    description: `
+  name: "firecrawl_map",
+  annotations: {
+    title: "Map a website",
+    readOnlyHint: true,
+    // Discovers and returns indexed URLs; does not modify the target site.
+    openWorldHint: true,
+    // Operates against arbitrary user-supplied web domains.
+    destructiveHint: false
+    // Read-only discovery; no deletion or destructive updates.
+  },
+  description: `
 Map a website to discover all indexed URLs on the site.
 
 **Best for:** Discovering URLs on a website before deciding what to scrape; finding specific sections or pages within a large site; locating the correct page when scrape returns empty or incomplete results.
@@ -638,40 +2673,44 @@ Map a website to discover all indexed URLs on the site.
 \`\`\`
 **Returns:** Array of URLs found on the site, filtered by search query if provided.
 `,
-    parameters: z.object({
-        url: z.string().url(),
-        search: z.string().optional(),
-        sitemap: z.enum(['include', 'skip', 'only']).optional(),
-        includeSubdomains: z.boolean().optional(),
-        limit: z.number().optional(),
-        ignoreQueryParameters: z.boolean().optional(),
-    }),
-    execute: async (args, { session, log }) => {
-        const { url, ...options } = args;
-        const client = getClient(session);
-        const cleaned = removeEmptyTopLevel(options);
-        log.info('Mapping URL', { url: String(url) });
-        const res = await client.map(String(url), {
-            ...cleaned,
-            origin: ORIGIN,
-        });
-        return asText(res);
-    },
+  parameters: z4.object({
+    url: z4.string().url(),
+    search: z4.string().optional(),
+    sitemap: z4.enum(["include", "skip", "only"]).optional(),
+    includeSubdomains: z4.boolean().optional(),
+    limit: z4.number().optional(),
+    ignoreQueryParameters: z4.boolean().optional()
+  }),
+  execute: async (args2, { session, log }) => {
+    const { url, ...options } = args2;
+    const client = getClient(session);
+    const cleaned = removeEmptyTopLevel(options);
+    log.info("Mapping URL", { url: String(url) });
+    const res = await client.map(String(url), {
+      ...cleaned,
+      origin: ORIGIN
+    });
+    return asText2(res);
+  }
 });
 server.addTool({
-    name: 'firecrawl_search',
-    annotations: {
-        title: 'Search the web',
-        readOnlyHint: true,
-        openWorldHint: true,
-    },
-    description: `
+  name: "firecrawl_search",
+  annotations: {
+    title: "Search the web",
+    readOnlyHint: true,
+    // Runs a web search and returns results; does not modify external sites.
+    openWorldHint: true,
+    // Searches the open web across arbitrary domains and sources.
+    destructiveHint: false
+    // Query-only; no destructive side effects on external entities.
+  },
+  description: `
 Search the web and optionally extract content from search results. This is the most powerful web search tool available, and if available you should always default to using this tool for any web search needs.
 
 The query also supports search operators, that you can use if needed to refine the search:
 | Operator | Functionality | Examples |
 ---|-|-|
-| \`"\"\` | Non-fuzzy matches a string of text | \`"Firecrawl"\`
+| \`""\` | Non-fuzzy matches a string of text | \`"Firecrawl"\`
 | \`-\` | Excludes certain keywords or negates other operators | \`-bad\`, \`-site:firecrawl.dev\`
 | \`site:\` | Only returns results from a specified website | \`site:firecrawl.dev\`
 | \`inurl:\` | Only returns results that include a word in the URL | \`inurl:firecrawl\`
@@ -729,187 +2768,182 @@ The query also supports search operators, that you can use if needed to refine t
 \`\`\`
 **Returns:** A JSON envelope of the form \`{ success, data: { web?, images?, news? }, id, creditsUsed }\`. Each result array contains the search results (with optional scraped content). Pass the top-level \`id\` to \`firecrawl_search_feedback\` after you've used the results.
 `,
-    parameters: z
-        .object({
-        query: z.string().min(1),
-        limit: z.number().optional(),
-        tbs: z.string().optional(),
-        filter: z.string().optional(),
-        location: z.string().optional(),
-        includeDomains: z.array(searchDomainSchema).optional(),
-        excludeDomains: z.array(searchDomainSchema).optional(),
-        sources: z
-            .array(z.object({ type: z.enum(['web', 'images', 'news']) }))
-            .optional(),
-        scrapeOptions: scrapeParamsSchema
-            .omit({ url: true })
-            .partial()
-            .optional(),
-        enterprise: z.array(z.enum(['default', 'anon', 'zdr'])).optional(),
-    })
-        .refine((args) => !(args.includeDomains?.length && args.excludeDomains?.length), 'includeDomains and excludeDomains cannot both be specified'),
-    execute: async (args, { session, log }) => {
-        const { query, ...opts } = args;
-        const searchOpts = { ...opts };
-        const includeDomains = searchOpts.includeDomains;
-        const excludeDomains = searchOpts.excludeDomains;
-        delete searchOpts.includeDomains;
-        delete searchOpts.excludeDomains;
-        if (searchOpts.scrapeOptions) {
-            searchOpts.scrapeOptions = transformScrapeParams(searchOpts.scrapeOptions);
-        }
-        const cleaned = removeEmptyTopLevel(searchOpts);
-        const searchQuery = buildSearchQueryWithDomains(query, includeDomains, excludeDomains);
-        log.info('Searching', { query: searchQuery });
-        const searchBody = {
-            query: searchQuery,
-            ...cleaned,
-            origin: ORIGIN,
-        };
-        if (isKeylessMode(session)) {
-            const json = await keylessPost('/v2/search', searchBody, session);
-            return asText(json ?? {});
-        }
-        // Call /v2/search through the SDK's HTTP layer (auth + retries) instead
-        // of `client.search()` so we preserve the full response envelope. The
-        // high-level `search()` helper strips `id` and `creditsUsed`, which
-        // breaks the `firecrawl_search_feedback` workflow that this server
-        // explicitly tells the LLM to use after every search.
-        const client = getClient(session);
-        const httpRes = await client.http.post('/v2/search', searchBody);
-        return asText(httpRes?.data ?? {});
-    },
+  parameters: z4.object({
+    query: z4.string().min(1),
+    limit: z4.number().optional(),
+    tbs: z4.string().optional(),
+    filter: z4.string().optional(),
+    location: z4.string().optional(),
+    includeDomains: z4.array(searchDomainSchema).optional(),
+    excludeDomains: z4.array(searchDomainSchema).optional(),
+    sources: z4.array(z4.object({ type: z4.enum(["web", "images", "news"]) })).optional(),
+    scrapeOptions: scrapeParamsSchema.omit({ url: true }).partial().optional(),
+    enterprise: z4.array(z4.enum(["default", "anon", "zdr"])).optional()
+  }).refine(
+    (args2) => !(args2.includeDomains?.length && args2.excludeDomains?.length),
+    "includeDomains and excludeDomains cannot both be specified"
+  ),
+  execute: async (args2, { session, log }) => {
+    const { query, ...opts } = args2;
+    const searchOpts = { ...opts };
+    const includeDomains = searchOpts.includeDomains;
+    const excludeDomains = searchOpts.excludeDomains;
+    delete searchOpts.includeDomains;
+    delete searchOpts.excludeDomains;
+    if (searchOpts.scrapeOptions) {
+      searchOpts.scrapeOptions = transformScrapeParams(
+        searchOpts.scrapeOptions
+      );
+    }
+    const cleaned = removeEmptyTopLevel(searchOpts);
+    const searchQuery = buildSearchQueryWithDomains(
+      query,
+      includeDomains,
+      excludeDomains
+    );
+    log.info("Searching", { query: searchQuery });
+    const searchBody = {
+      query: searchQuery,
+      ...cleaned,
+      origin: ORIGIN
+    };
+    if (isKeylessMode(session)) {
+      const json = await keylessPost("/v2/search", searchBody, session);
+      return asText2(json ?? {});
+    }
+    const client = getClient(session);
+    const httpRes = await client.http.post("/v2/search", searchBody);
+    return asText2(httpRes?.data ?? {});
+  }
 });
-const DEFAULT_CLOUD_API_URL = 'https://api.firecrawl.dev';
+var DEFAULT_CLOUD_API_URL = "https://api.firecrawl.dev";
 function resolveApiBaseUrl() {
-    return (process.env.FIRECRAWL_API_URL || DEFAULT_CLOUD_API_URL).replace(/\/$/, '');
-}
-// Keyless free tier: when no credential is configured and we're targeting the
-// Firecrawl cloud (not self-hosted via FIRECRAWL_API_URL, not the multi-tenant
-// CLOUD_SERVICE deployment), scrape and search are free, rate-limited per IP.
-// The cloud only grants this when NO Authorization header is sent, so we bypass
-// the SDK — which always attaches a Bearer header — and post directly.
-/** Best-effort end-user client IP from the incoming MCP request headers. */
+  return (process.env.FIRECRAWL_API_URL || DEFAULT_CLOUD_API_URL).replace(
+    /\/$/,
+    ""
+  );
+}
 function extractClientIp(request) {
-    const xff = request?.headers?.['x-forwarded-for'];
-    const raw = Array.isArray(xff) ? xff[0] : xff;
-    const first = typeof raw === 'string' ? raw.split(',')[0].trim() : undefined;
-    return first || undefined;
-}
-/**
- * Read-only check (no quota consumed) of whether a client IP can still use the
- * keyless free tier, via the API's secret-gated eligibility endpoint. Fails
- * closed: anything other than a clear "eligible: true" means fall through to the
- * OAuth challenge rather than silently granting keyless.
- */
+  const xff = request?.headers?.["x-forwarded-for"];
+  const raw = Array.isArray(xff) ? xff[0] : xff;
+  const first = typeof raw === "string" ? raw.split(",")[0].trim() : void 0;
+  return first || void 0;
+}
 async function keylessEligible(clientIp) {
-    const secret = process.env.KEYLESS_PROXY_SECRET;
-    if (!secret)
-        return false;
-    try {
-        const response = await fetch(`${resolveApiBaseUrl()}/v2/keyless/eligibility`, {
-            headers: {
-                'x-firecrawl-keyless-ip': clientIp,
-                'x-firecrawl-keyless-secret': secret,
-            },
-        });
-        if (!response.ok)
-            return false;
-        const json = await response.json().catch(() => ({}));
-        return json?.eligible === true;
-    }
-    catch {
-        return false;
-    }
+  const secret = process.env.KEYLESS_PROXY_SECRET;
+  if (!secret) return false;
+  try {
+    const response = await fetch(
+      `${resolveApiBaseUrl()}/v2/keyless/eligibility`,
+      {
+        headers: {
+          "x-firecrawl-keyless-ip": clientIp,
+          "x-firecrawl-keyless-secret": secret
+        }
+      }
+    );
+    if (!response.ok) return false;
+    const json = await response.json().catch(() => ({}));
+    return json?.eligible === true;
+  } catch {
+    return false;
+  }
 }
 function isKeylessMode(session) {
-    if (session?.firecrawlApiKey)
-        return false;
-    if (process.env.CLOUD_SERVICE === 'true') {
-        // Hosted: keyless only for secret-gated sessions carrying the forwarded
-        // client IP (so the per-IP cap is meaningful, not the shared server IP).
-        return !!session?.keylessClientIp;
-    }
-    // Local/stdio against the cloud (not a self-hosted FIRECRAWL_API_URL).
-    return !process.env.FIRECRAWL_API_URL;
-}
-async function keylessPost(path, body, session) {
-    const headers = { 'Content-Type': 'application/json' };
-    // Forward the real client IP (secret-authenticated) when proxying keyless
-    // requests through the hosted MCP, so the API rate-limits per real IP.
-    if (session?.keylessClientIp && process.env.KEYLESS_PROXY_SECRET) {
-        headers['x-firecrawl-keyless-ip'] = session.keylessClientIp;
-        headers['x-firecrawl-keyless-secret'] = process.env.KEYLESS_PROXY_SECRET;
-    }
-    const response = await fetch(`${resolveApiBaseUrl()}${path}`, {
-        method: 'POST',
-        headers,
-        body: JSON.stringify(body),
-    });
-    const json = await response.json().catch(() => ({}));
-    if (!response.ok) {
-        throw new Error(json?.error || `Firecrawl request failed (HTTP ${response.status})`);
-    }
-    return json;
-}
-const feedbackIssueSchema = z
-    .string()
-    .trim()
-    .min(1)
-    .max(80)
-    .regex(/^[a-z0-9][a-z0-9_-]*$/, 'Issue codes must use lowercase letters, numbers, underscores, or hyphens');
-const valuableSourceSchema = z.object({
-    url: z.string().url(),
-    reason: z.string().max(1000).optional(),
+  if (session?.firecrawlApiKey) return false;
+  if (process.env.CLOUD_SERVICE === "true") {
+    return !!session?.keylessClientIp;
+  }
+  return !process.env.FIRECRAWL_API_URL;
+}
+async function keylessPost(path2, body, session) {
+  const headers = {
+    "Content-Type": "application/json"
+  };
+  if (session?.keylessClientIp && process.env.KEYLESS_PROXY_SECRET) {
+    headers["x-firecrawl-keyless-ip"] = session.keylessClientIp;
+    headers["x-firecrawl-keyless-secret"] = process.env.KEYLESS_PROXY_SECRET;
+  }
+  const response = await fetch(`${resolveApiBaseUrl()}${path2}`, {
+    method: "POST",
+    headers,
+    body: JSON.stringify(body)
+  });
+  const json = await response.json().catch(() => ({}));
+  if (!response.ok) {
+    throw new Error(
+      json?.error || `Firecrawl request failed (HTTP ${response.status})`
+    );
+  }
+  return json;
+}
+var feedbackIssueSchema = z4.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 = z4.object({
+  url: z4.string().url(),
+  reason: z4.string().max(1e3).optional()
 });
-const missingContentSchema = z.object({
-    topic: z
-        .string()
-        .min(1, 'topic must not be empty')
-        .max(200, 'topic must be 200 characters or fewer'),
-    description: z.string().max(2000).optional(),
+var missingContentSchema = z4.object({
+  topic: z4.string().min(1, "topic must not be empty").max(200, "topic must be 200 characters or fewer"),
+  description: z4.string().max(2e3).optional()
 });
-const FEEDBACK_DISABLED_VALUES = new Set(['1', 'true', 'yes', 'on']);
+var FEEDBACK_DISABLED_VALUES = /* @__PURE__ */ new Set(["1", "true", "yes", "on"]);
 function feedbackEnvEnabled(...keys) {
-    return keys.some((key) => FEEDBACK_DISABLED_VALUES.has((process.env[key] || '').trim().toLowerCase()));
+  return keys.some(
+    (key) => FEEDBACK_DISABLED_VALUES.has((process.env[key] || "").trim().toLowerCase())
+  );
 }
-const SEARCH_FEEDBACK_DISABLED = feedbackEnvEnabled('FIRECRAWL_NO_SEARCH_FEEDBACK', 'FIRECRAWL_DISABLE_SEARCH_FEEDBACK');
-const ENDPOINT_FEEDBACK_DISABLED = feedbackEnvEnabled('FIRECRAWL_NO_ENDPOINT_FEEDBACK', 'FIRECRAWL_DISABLE_ENDPOINT_FEEDBACK');
+var SEARCH_FEEDBACK_DISABLED = feedbackEnvEnabled(
+  "FIRECRAWL_NO_SEARCH_FEEDBACK",
+  "FIRECRAWL_DISABLE_SEARCH_FEEDBACK"
+);
+var ENDPOINT_FEEDBACK_DISABLED = feedbackEnvEnabled(
+  "FIRECRAWL_NO_ENDPOINT_FEEDBACK",
+  "FIRECRAWL_DISABLE_ENDPOINT_FEEDBACK"
+);
 if (SEARCH_FEEDBACK_DISABLED) {
-    console.error('[firecrawl-mcp] Search feedback tool disabled by FIRECRAWL_NO_SEARCH_FEEDBACK; firecrawl_search_feedback will not be registered.');
+  console.error(
+    "[firecrawl-mcp] Search feedback tool disabled by FIRECRAWL_NO_SEARCH_FEEDBACK; firecrawl_search_feedback will not be registered."
+  );
 }
 if (!SEARCH_FEEDBACK_DISABLED) {
-    server.addTool({
-        name: 'firecrawl_search_feedback',
-        annotations: {
-            title: 'Send feedback on a search result',
-            readOnlyHint: false,
-            openWorldHint: true,
-        },
-        description: `
+  server.addTool({
+    name: "firecrawl_search_feedback",
+    annotations: {
+      title: "Send feedback on a search result",
+      readOnlyHint: false,
+      // POSTs structured feedback to the API, creating a server-side record.
+      openWorldHint: true,
+      // Feedback references open-web search results and external URLs.
+      destructiveHint: false
+      // Additive only; records feedback and may refund credits, does not delete data.
+    },
+    description: `
 Send structured feedback on a previous \`firecrawl_search\` result. **Call this immediately after a search where you used the results** so we can improve search quality and refund 1 credit (search costs 2).
 
 Pass the \`searchId\` returned by \`firecrawl_search\` (the \`id\` field on the response) and tell us:
 
-- **rating** — overall result quality: \`good\`, \`partial\`, or \`bad\`.
-- **valuableSources** — which result URLs were actually useful, and a short reason why.
-- **missingContent** — **the most important field.** An ARRAY of specific pieces of content you expected to find but didn't. One entry per missing piece, each with a short \`topic\` and an optional longer \`description\`. Examples: \`{"topic":"enterprise pricing","description":"no pricing tier table for the Enterprise plan was returned"}\`, \`{"topic":"API rate limits"}\`, \`{"topic":"comparison vs competitors"}\`. **Be specific** — these aggregate across teams and tell us what to index next. Do not pack multiple topics into one entry.
-- **querySuggestions** — how the query or response shape could be improved (e.g. "would have liked official docs first", "should boost github.com").
+- **rating** \u2014 overall result quality: \`good\`, \`partial\`, or \`bad\`.
+- **valuableSources** \u2014 which result URLs were actually useful, and a short reason why.
+- **missingContent** \u2014 **the most important field.** An ARRAY of specific pieces of content you expected to find but didn't. One entry per missing piece, each with a short \`topic\` and an optional longer \`description\`. Examples: \`{"topic":"enterprise pricing","description":"no pricing tier table for the Enterprise plan was returned"}\`, \`{"topic":"API rate limits"}\`, \`{"topic":"comparison vs competitors"}\`. **Be specific** \u2014 these aggregate across teams and tell us what to index next. Do not pack multiple topics into one entry.
+- **querySuggestions** \u2014 how the query or response shape could be improved (e.g. "would have liked official docs first", "should boost github.com").
 
 **Substantive-feedback requirement** (zero-effort feedback is rejected with HTTP 400):
-- \`good\` — must include at least one \`valuableSources\` entry
-- \`partial\` — must include \`valuableSources\` or at least one \`missingContent\` entry
-- \`bad\` — must include at least one \`missingContent\` entry or \`querySuggestions\`
+- \`good\` \u2014 must include at least one \`valuableSources\` entry
+- \`partial\` \u2014 must include \`valuableSources\` or at least one \`missingContent\` entry
+- \`bad\` \u2014 must include at least one \`missingContent\` entry or \`querySuggestions\`
 
-**Time window:** Feedback must be submitted within ~2 minutes of the search. Beyond that, the call returns HTTP 409 with \`feedbackErrorCode: "FEEDBACK_WINDOW_EXPIRED"\` — do not retry, just move on. Same goes for any 4xx response: do not retry-loop.
+**Time window:** Feedback must be submitted within ~2 minutes of the search. Beyond that, the call returns HTTP 409 with \`feedbackErrorCode: "FEEDBACK_WINDOW_EXPIRED"\` \u2014 do not retry, just move on. Same goes for any 4xx response: do not retry-loop.
 
 **Behaviors:**
 - Idempotent per \`searchId\`. Re-submitting for the same id returns \`alreadySubmitted: true\` with \`creditsRefunded: 0\`.
 - Refund only applies to billable searches; preview teams are blocked.
 - Failed searches cannot receive feedback (the search itself already returned an error you can act on).
-- **Daily refund cap (per team, per UTC day, default 100 credits).** Once a team's \`creditsRefundedToday\` reaches \`dailyRefundCap\`, the response returns \`dailyCapReached: true\` with \`creditsRefunded: 0\`. The feedback is still recorded for search-quality improvement — only the credit refund is gated. **Stop calling this tool for the rest of the UTC day** when you see \`dailyCapReached: true\`.
+- **Daily refund cap (per team, per UTC day, default 100 credits).** Once a team's \`creditsRefundedToday\` reaches \`dailyRefundCap\`, the response returns \`dailyCapReached: true\` with \`creditsRefunded: 0\`. The feedback is still recorded for search-quality improvement \u2014 only the credit refund is gated. **Stop calling this tool for the rest of the UTC day** when you see \`dailyCapReached: true\`.
 
-**When to call:** Right after processing a search result. If the result didn't help, send rating \`bad\` with a clear \`missingContent\` — that is just as valuable as a \`good\` rating.
+**When to call:** Right after processing a search result. If the result didn't help, send rating \`bad\` with a clear \`missingContent\` \u2014 that is just as valuable as a \`good\` rating.
 
 **Usage Example (good rating with valuable sources + missing content):**
 \`\`\`json
@@ -947,203 +2981,217 @@ Pass the \`searchId\` returned by \`firecrawl_search\` (the \`id\` field on the
 
 **Returns:** \`{ success, feedbackId, creditsRefunded, creditsRefundedToday, dailyRefundCap, dailyCapReached?, alreadySubmitted?, warning? }\` JSON.
 `,
-        parameters: z.object({
-            searchId: z
-                .string()
-                .uuid('searchId must be the UUID returned by firecrawl_search'),
-            rating: z.enum(['good', 'bad', 'partial']),
-            valuableSources: z
-                .array(z.object({
-                url: z.string().url(),
-                reason: z.string().max(1000).optional(),
-            }))
-                .max(50)
-                .optional(),
-            missingContent: z
-                .array(z.object({
-                topic: z
-                    .string()
-                    .min(1, 'topic must not be empty')
-                    .max(200, 'topic must be 200 characters or fewer'),
-                description: z.string().max(2000).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: z.string().max(2000).optional(),
-        }),
-        execute: async (args, { session, log }) => {
-            const { searchId, rating, valuableSources, missingContent, querySuggestions, } = args;
-            const apiBase = resolveApiBaseUrl();
-            const endpoint = `${apiBase}/v2/search/${encodeURIComponent(searchId)}/feedback`;
-            const body = {
-                rating,
-                origin: ORIGIN,
-            };
-            if (valuableSources && valuableSources.length > 0) {
-                body.valuableSources = valuableSources;
-            }
-            if (missingContent && missingContent.length > 0) {
-                body.missingContent = missingContent;
-            }
-            if (querySuggestions)
-                body.querySuggestions = querySuggestions;
-            const headers = {
-                'Content-Type': 'application/json',
-            };
-            const apiKey = session?.firecrawlApiKey;
-            if (apiKey) {
-                headers['Authorization'] = `Bearer ${apiKey}`;
-            }
-            else if (process.env.CLOUD_SERVICE === 'true') {
-                throw new Error('Unauthorized: missing API key for search feedback.');
-            }
-            log.info('Submitting search feedback', { searchId, rating });
-            const response = await fetch(endpoint, {
-                method: 'POST',
-                headers,
-                body: JSON.stringify(body),
-            });
-            const responseText = await response.text();
-            let parsed;
-            try {
-                parsed = JSON.parse(responseText);
-            }
-            catch {
-                parsed = { raw: responseText };
-            }
-            // 4xx is terminal; surface a structured payload (with retryable=false)
-            // so agents do not retry-loop on substantive-feedback rejections,
-            // expired windows, etc.
-            if (!response.ok) {
-                log.warn('Search feedback rejected', {
-                    status: response.status,
-                    feedbackErrorCode: parsed?.feedbackErrorCode,
-                });
-                return asText({
-                    success: false,
-                    status: response.status,
-                    feedbackErrorCode: parsed?.feedbackErrorCode,
-                    error: parsed?.error ?? `HTTP ${response.status}`,
-                    retryable: response.status >= 500,
-                });
-            }
-            return asText(parsed);
-        },
-    });
+    parameters: z4.object({
+      searchId: z4.string().uuid("searchId must be the UUID returned by firecrawl_search"),
+      rating: z4.enum(["good", "bad", "partial"]),
+      valuableSources: z4.array(
+        z4.object({
+          url: z4.string().url(),
+          reason: z4.string().max(1e3).optional()
+        })
+      ).max(50).optional(),
+      missingContent: z4.array(
+        z4.object({
+          topic: z4.string().min(1, "topic must not be empty").max(200, "topic must be 200 characters or fewer"),
+          description: z4.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: z4.string().max(2e3).optional()
+    }),
+    execute: async (args2, { session, log }) => {
+      const {
+        searchId,
+        rating,
+        valuableSources,
+        missingContent,
+        querySuggestions
+      } = args2;
+      const apiBase = resolveApiBaseUrl();
+      const endpoint = `${apiBase}/v2/search/${encodeURIComponent(
+        searchId
+      )}/feedback`;
+      const body = {
+        rating,
+        origin: ORIGIN
+      };
+      if (valuableSources && valuableSources.length > 0) {
+        body.valuableSources = valuableSources;
+      }
+      if (missingContent && missingContent.length > 0) {
+        body.missingContent = missingContent;
+      }
+      if (querySuggestions) body.querySuggestions = querySuggestions;
+      const headers = {
+        "Content-Type": "application/json"
+      };
+      const apiKey = session?.firecrawlApiKey;
+      if (apiKey) {
+        headers["Authorization"] = `Bearer ${apiKey}`;
+      } else if (process.env.CLOUD_SERVICE === "true") {
+        throw new Error("Unauthorized: missing API key for search feedback.");
+      }
+      log.info("Submitting search feedback", { searchId, rating });
+      const response = await fetch(endpoint, {
+        method: "POST",
+        headers,
+        body: JSON.stringify(body)
+      });
+      const responseText = await response.text();
+      let parsed;
+      try {
+        parsed = JSON.parse(responseText);
+      } catch {
+        parsed = { raw: responseText };
+      }
+      if (!response.ok) {
+        log.warn("Search feedback rejected", {
+          status: response.status,
+          feedbackErrorCode: parsed?.feedbackErrorCode
+        });
+        return asText2({
+          success: false,
+          status: response.status,
+          feedbackErrorCode: parsed?.feedbackErrorCode,
+          error: parsed?.error ?? `HTTP ${response.status}`,
+          retryable: response.status >= 500
+        });
+      }
+      return asText2(parsed);
+    }
+  });
 }
 if (ENDPOINT_FEEDBACK_DISABLED) {
-    console.error('[firecrawl-mcp] Endpoint feedback tool disabled by FIRECRAWL_NO_ENDPOINT_FEEDBACK; firecrawl_feedback will not be registered.');
+  console.error(
+    "[firecrawl-mcp] Endpoint feedback tool disabled by FIRECRAWL_NO_ENDPOINT_FEEDBACK; firecrawl_feedback will not be registered."
+  );
 }
 if (!ENDPOINT_FEEDBACK_DISABLED) {
-    server.addTool({
-        name: 'firecrawl_feedback',
-        annotations: {
-            title: 'Send feedback on a Firecrawl job',
-            readOnlyHint: false,
-            openWorldHint: true,
-        },
-        description: `
+  server.addTool({
+    name: "firecrawl_feedback",
+    annotations: {
+      title: "Send feedback on a Firecrawl job",
+      readOnlyHint: false,
+      // POSTs structured feedback for a completed job to /v2/feedback.
+      openWorldHint: true,
+      // Feedback is tied to jobs that processed open-web URLs.
+      destructiveHint: false
+      // Additive only; submits ratings and notes, does not delete jobs or external content.
+    },
+    description: `
 Send structured feedback for a completed Firecrawl v2 job. Use this for endpoint-level feedback on \`scrape\`, \`parse\`, \`map\`, or \`search\` jobs when the job result was useful, partially useful, or failed to meet expectations.
 
 For search-result quality specifically, prefer \`firecrawl_search_feedback\` when available because it has search-focused guidance. This generic tool posts to \`/v2/feedback\` and accepts endpoint-wide signals:
 
-- **endpoint** — one of \`search\`, \`scrape\`, \`parse\`, or \`map\`.
-- **jobId** — the id returned by that endpoint.
-- **rating** — overall result quality: \`good\`, \`partial\`, or \`bad\`.
-- **issues** — stable lowercase issue codes such as \`missing_markdown\`, \`bad_pdf_parse\`, or \`wrong_links\`.
-- **tags** — optional lowercase tags for grouping feedback.
-- **note** — short human-readable context. Do not include huge page contents or raw scrape results.
-- **url**, **pageNumbers**, and **metadata** — small contextual fields that identify what the feedback refers to.
+- **endpoint** \u2014 one of \`search\`, \`scrape\`, \`parse\`, or \`map\`.
+- **jobId** \u2014 the id returned by that endpoint.
+- **rating** \u2014 overall result quality: \`good\`, \`partial\`, or \`bad\`.
+- **issues** \u2014 stable lowercase issue codes such as \`missing_markdown\`, \`bad_pdf_parse\`, or \`wrong_links\`.
+- **tags** \u2014 optional lowercase tags for grouping feedback.
+- **note** \u2014 short human-readable context. Do not include huge page contents or raw scrape results.
+- **url**, **pageNumbers**, and **metadata** \u2014 small contextual fields that identify what the feedback refers to.
 
 Do not store multi-MB outputs in feedback. Use concise notes, issue codes, URLs, and page numbers.
 
 **Returns:** \`{ success, feedbackId, creditsRefunded, creditsRefundedToday?, dailyRefundCap?, dailyCapReached?, alreadySubmitted?, warning? }\` JSON.
 `,
-        parameters: z.object({
-            endpoint: z.enum(['search', 'scrape', 'parse', 'map']),
-            jobId: z.string().uuid('jobId must be the UUID returned by Firecrawl'),
-            rating: z.enum(['good', 'bad', 'partial']),
-            issues: z.array(feedbackIssueSchema).max(20).optional(),
-            tags: z.array(feedbackIssueSchema).max(20).optional(),
-            note: z.string().max(4000).optional(),
-            valuableSources: z.array(valuableSourceSchema).max(50).optional(),
-            missingContent: z.array(missingContentSchema).max(50).optional(),
-            querySuggestions: z.string().max(2000).optional(),
-            url: z.string().url().optional(),
-            pageNumbers: z.array(z.number().int().positive()).max(100).optional(),
-            metadata: z.record(z.string(), z.unknown()).optional(),
-        }),
-        execute: async (args, { session, log }) => {
-            const { endpoint, jobId, rating, issues, tags, note, valuableSources, missingContent, querySuggestions, url, pageNumbers, metadata, } = args;
-            const apiBase = resolveApiBaseUrl();
-            const headers = {
-                'Content-Type': 'application/json',
-            };
-            const apiKey = session?.firecrawlApiKey;
-            if (apiKey) {
-                headers['Authorization'] = `Bearer ${apiKey}`;
-            }
-            else if (process.env.CLOUD_SERVICE === 'true') {
-                throw new Error('Unauthorized: missing API key for feedback.');
-            }
-            const body = removeEmptyTopLevel({
-                endpoint,
-                jobId,
-                rating,
-                issues,
-                tags,
-                note,
-                valuableSources,
-                missingContent,
-                querySuggestions,
-                url,
-                pageNumbers,
-                metadata,
-                origin: ORIGIN,
-            });
-            log.info('Submitting endpoint feedback', { endpoint, jobId, rating });
-            const response = await fetch(`${apiBase}/v2/feedback`, {
-                method: 'POST',
-                headers,
-                body: JSON.stringify(body),
-            });
-            const responseText = await response.text();
-            let parsed;
-            try {
-                parsed = JSON.parse(responseText);
-            }
-            catch {
-                parsed = { raw: responseText };
-            }
-            if (!response.ok) {
-                log.warn('Endpoint feedback rejected', {
-                    status: response.status,
-                    feedbackErrorCode: parsed?.feedbackErrorCode,
-                });
-                return asText({
-                    success: false,
-                    status: response.status,
-                    feedbackErrorCode: parsed?.feedbackErrorCode,
-                    error: parsed?.error ?? `HTTP ${response.status}`,
-                    retryable: response.status >= 500,
-                });
-            }
-            return asText(parsed);
-        },
-    });
+    parameters: z4.object({
+      endpoint: z4.enum(["search", "scrape", "parse", "map"]),
+      jobId: z4.string().uuid("jobId must be the UUID returned by Firecrawl"),
+      rating: z4.enum(["good", "bad", "partial"]),
+      issues: z4.array(feedbackIssueSchema).max(20).optional(),
+      tags: z4.array(feedbackIssueSchema).max(20).optional(),
+      note: z4.string().max(4e3).optional(),
+      valuableSources: z4.array(valuableSourceSchema).max(50).optional(),
+      missingContent: z4.array(missingContentSchema).max(50).optional(),
+      querySuggestions: z4.string().max(2e3).optional(),
+      url: z4.string().url().optional(),
+      pageNumbers: z4.array(z4.number().int().positive()).max(100).optional(),
+      metadata: z4.record(z4.string(), z4.unknown()).optional()
+    }),
+    execute: async (args2, { session, log }) => {
+      const {
+        endpoint,
+        jobId,
+        rating,
+        issues,
+        tags,
+        note,
+        valuableSources,
+        missingContent,
+        querySuggestions,
+        url,
+        pageNumbers,
+        metadata
+      } = args2;
+      const apiBase = resolveApiBaseUrl();
+      const headers = {
+        "Content-Type": "application/json"
+      };
+      const apiKey = session?.firecrawlApiKey;
+      if (apiKey) {
+        headers["Authorization"] = `Bearer ${apiKey}`;
+      } else if (process.env.CLOUD_SERVICE === "true") {
+        throw new Error("Unauthorized: missing API key for feedback.");
+      }
+      const body = removeEmptyTopLevel({
+        endpoint,
+        jobId,
+        rating,
+        issues,
+        tags,
+        note,
+        valuableSources,
+        missingContent,
+        querySuggestions,
+        url,
+        pageNumbers,
+        metadata,
+        origin: ORIGIN
+      });
+      log.info("Submitting endpoint feedback", { endpoint, jobId, rating });
+      const response = await fetch(`${apiBase}/v2/feedback`, {
+        method: "POST",
+        headers,
+        body: JSON.stringify(body)
+      });
+      const responseText = await response.text();
+      let parsed;
+      try {
+        parsed = JSON.parse(responseText);
+      } catch {
+        parsed = { raw: responseText };
+      }
+      if (!response.ok) {
+        log.warn("Endpoint feedback rejected", {
+          status: response.status,
+          feedbackErrorCode: parsed?.feedbackErrorCode
+        });
+        return asText2({
+          success: false,
+          status: response.status,
+          feedbackErrorCode: parsed?.feedbackErrorCode,
+          error: parsed?.error ?? `HTTP ${response.status}`,
+          retryable: response.status >= 500
+        });
+      }
+      return asText2(parsed);
+    }
+  });
 }
 server.addTool({
-    name: 'firecrawl_crawl',
-    annotations: {
-        title: 'Start a site crawl',
-        readOnlyHint: false,
-        openWorldHint: true,
-        destructiveHint: false,
-    },
-    description: `
+  name: "firecrawl_crawl",
+  annotations: {
+    title: "Start a site crawl",
+    readOnlyHint: false,
+    // Starts an asynchronous crawl job, creating a persistent server-side job.
+    openWorldHint: true,
+    // Crawls user-specified URLs across the public web.
+    destructiveHint: false
+    // Reads pages from target sites; does not delete or alter external websites.
+  },
+  description: `
  Starts a crawl job on a website and extracts content from all pages.
  
  **Best for:** Extracting content from multiple related pages, when you need comprehensive coverage.
@@ -1166,61 +3214,62 @@ server.addTool({
  }
  \`\`\`
  **Returns:** Operation ID for status checking; use firecrawl_check_crawl_status to check progress.
- ${SAFE_MODE
-        ? '**Safe Mode:** Read-only crawling. Webhooks and interactive actions are disabled for security.'
-        : ''}
+ ${SAFE_MODE ? "**Safe Mode:** Read-only crawling. Webhooks and interactive actions are disabled for security." : ""}
  `,
-    parameters: z.object({
-        url: z.string(),
-        prompt: z.string().optional(),
-        excludePaths: z.array(z.string()).optional(),
-        includePaths: z.array(z.string()).optional(),
-        maxDiscoveryDepth: z.number().optional(),
-        sitemap: z.enum(['skip', 'include', 'only']).optional(),
-        limit: z.number().optional(),
-        allowExternalLinks: z.boolean().optional(),
-        allowSubdomains: z.boolean().optional(),
-        crawlEntireDomain: z.boolean().optional(),
-        delay: z.number().optional(),
-        maxConcurrency: z.number().optional(),
-        ...(SAFE_MODE
-            ? {}
-            : {
-                webhook: z.string().optional(),
-                webhookHeaders: z.record(z.string(), z.string()).optional(),
-            }),
-        deduplicateSimilarURLs: z.boolean().optional(),
-        ignoreQueryParameters: z.boolean().optional(),
-        scrapeOptions: scrapeParamsSchema.omit({ url: true }).partial().optional(),
-    }),
-    execute: async (args, { session, log }) => {
-        const { url, ...options } = args;
-        const client = getClient(session);
-        const opts = { ...options };
-        if (opts.scrapeOptions) {
-            opts.scrapeOptions = transformScrapeParams(opts.scrapeOptions);
-        }
-        const webhook = buildWebhook(opts);
-        if (webhook)
-            opts.webhook = webhook;
-        delete opts.webhookHeaders;
-        const cleaned = removeEmptyTopLevel(opts);
-        log.info('Starting crawl', { url: String(url) });
-        const res = await client.crawl(String(url), {
-            ...cleaned,
-            origin: ORIGIN,
-        });
-        return asText(res);
+  parameters: z4.object({
+    url: z4.string(),
+    prompt: z4.string().optional(),
+    excludePaths: z4.array(z4.string()).optional(),
+    includePaths: z4.array(z4.string()).optional(),
+    maxDiscoveryDepth: z4.number().optional(),
+    sitemap: z4.enum(["skip", "include", "only"]).optional(),
+    limit: z4.number().optional(),
+    allowExternalLinks: z4.boolean().optional(),
+    allowSubdomains: z4.boolean().optional(),
+    crawlEntireDomain: z4.boolean().optional(),
+    delay: z4.number().optional(),
+    maxConcurrency: z4.number().optional(),
+    ...SAFE_MODE ? {} : {
+      webhook: z4.string().optional(),
+      webhookHeaders: z4.record(z4.string(), z4.string()).optional()
     },
+    deduplicateSimilarURLs: z4.boolean().optional(),
+    ignoreQueryParameters: z4.boolean().optional(),
+    scrapeOptions: scrapeParamsSchema.omit({ url: true }).partial().optional()
+  }),
+  execute: async (args2, { session, log }) => {
+    const { url, ...options } = args2;
+    const client = getClient(session);
+    const opts = { ...options };
+    if (opts.scrapeOptions) {
+      opts.scrapeOptions = transformScrapeParams(
+        opts.scrapeOptions
+      );
+    }
+    const webhook = buildWebhook(opts);
+    if (webhook) opts.webhook = webhook;
+    delete opts.webhookHeaders;
+    const cleaned = removeEmptyTopLevel(opts);
+    log.info("Starting crawl", { url: String(url) });
+    const res = await client.crawl(String(url), {
+      ...cleaned,
+      origin: ORIGIN
+    });
+    return asText2(res);
+  }
 });
 server.addTool({
-    name: 'firecrawl_check_crawl_status',
-    annotations: {
-        title: 'Get crawl status',
-        readOnlyHint: true,
-        openWorldHint: false,
-    },
-    description: `
+  name: "firecrawl_check_crawl_status",
+  annotations: {
+    title: "Get crawl status",
+    readOnlyHint: true,
+    // Retrieves status and results for an existing crawl job by ID; no mutations.
+    openWorldHint: false,
+    // Queries only Firecrawl job state within the authenticated account.
+    destructiveHint: false
+    // Status lookup only; no deletes or updates.
+  },
+  description: `
 Check the status of a crawl job.
 
 **Usage Example:**
@@ -1234,21 +3283,25 @@ Check the status of a crawl job.
 \`\`\`
 **Returns:** Status and progress of the crawl job, including results if available.
 `,
-    parameters: z.object({ id: z.string() }),
-    execute: async (args, { session }) => {
-        const client = getClient(session);
-        const res = await client.getCrawlStatus(args.id);
-        return asText(res);
-    },
+  parameters: z4.object({ id: z4.string() }),
+  execute: async (args2, { session }) => {
+    const client = getClient(session);
+    const res = await client.getCrawlStatus(args2.id);
+    return asText2(res);
+  }
 });
 server.addTool({
-    name: 'firecrawl_extract',
-    annotations: {
-        title: 'Extract structured data',
-        readOnlyHint: true,
-        openWorldHint: true,
-    },
-    description: `
+  name: "firecrawl_extract",
+  annotations: {
+    title: "Extract structured data",
+    readOnlyHint: true,
+    // Uses LLM extraction to pull structured data from URLs without modifying those sites.
+    openWorldHint: true,
+    // Accepts arbitrary user-supplied URLs on the public web.
+    destructiveHint: false
+    // Read-only extraction; no destructive changes to external content.
+  },
+  description: `
 Extract structured information from web pages using LLM capabilities. Supports both cloud AI and self-hosted LLM extraction.
 
 **Best for:** Extracting specific structured data like prices, names, details from web pages.
@@ -1285,48 +3338,51 @@ Extract structured information from web pages using LLM capabilities. Supports b
 \`\`\`
 **Returns:** Extracted structured data as defined by your schema.
 `,
-    parameters: z.object({
-        urls: z.array(z.string()),
-        prompt: z.string().optional(),
-        schema: z.record(z.string(), z.any()).optional(),
-        allowExternalLinks: z.boolean().optional(),
-        enableWebSearch: z.boolean().optional(),
-        includeSubdomains: z.boolean().optional(),
-    }),
-    execute: async (args, { session, log }) => {
-        const client = getClient(session);
-        const a = args;
-        log.info('Extracting from URLs', {
-            count: Array.isArray(a.urls) ? a.urls.length : 0,
-        });
-        const extractBody = removeEmptyTopLevel({
-            urls: a.urls,
-            prompt: a.prompt,
-            schema: a.schema || undefined,
-            allowExternalLinks: a.allowExternalLinks,
-            enableWebSearch: a.enableWebSearch,
-            includeSubdomains: a.includeSubdomains,
-            origin: ORIGIN,
-        });
-        const res = await client.extract(extractBody);
-        return asText(res);
-    },
+  parameters: z4.object({
+    urls: z4.array(z4.string()),
+    prompt: z4.string().optional(),
+    schema: z4.record(z4.string(), z4.any()).optional(),
+    allowExternalLinks: z4.boolean().optional(),
+    enableWebSearch: z4.boolean().optional(),
+    includeSubdomains: z4.boolean().optional()
+  }),
+  execute: async (args2, { session, log }) => {
+    const client = getClient(session);
+    const a = args2;
+    log.info("Extracting from URLs", {
+      count: Array.isArray(a.urls) ? a.urls.length : 0
+    });
+    const extractBody = removeEmptyTopLevel({
+      urls: a.urls,
+      prompt: a.prompt,
+      schema: a.schema || void 0,
+      allowExternalLinks: a.allowExternalLinks,
+      enableWebSearch: a.enableWebSearch,
+      includeSubdomains: a.includeSubdomains,
+      origin: ORIGIN
+    });
+    const res = await client.extract(extractBody);
+    return asText2(res);
+  }
 });
 server.addTool({
-    name: 'firecrawl_agent',
-    annotations: {
-        title: 'Start a research agent',
-        readOnlyHint: false,
-        openWorldHint: true,
-        destructiveHint: false,
-    },
-    description: `
+  name: "firecrawl_agent",
+  annotations: {
+    title: "Start a research agent",
+    readOnlyHint: false,
+    // Starts an autonomous research agent job on the Firecrawl API.
+    openWorldHint: true,
+    // The agent browses and searches the open web to fulfill the prompt.
+    destructiveHint: false
+    // Gathers information only; does not delete external data or user resources.
+  },
+  description: `
 Autonomous web research agent. This is a separate AI agent layer that independently browses the internet, searches for information, navigates through pages, and extracts structured data based on your query. You describe what you need, and the agent figures out where to find it.
 
 **How it works:** The agent performs web searches, follows links, reads pages, and gathers data autonomously. This runs **asynchronously** - it returns a job ID immediately, and you poll \`firecrawl_agent_status\` to check when complete and retrieve results.
 
 **IMPORTANT - Async workflow with patient polling:**
-1. Call \`firecrawl_agent\` with your prompt/schema → returns job ID immediately
+1. Call \`firecrawl_agent\` with your prompt/schema \u2192 returns job ID immediately
 2. Poll \`firecrawl_agent_status\` with the job ID to check progress
 3. **Keep polling for at least 2-3 minutes** - agent research typically takes 1-5 minutes for complex queries
 4. Poll every 15-30 seconds until status is "completed" or "failed"
@@ -1389,38 +3445,42 @@ Then poll with \`firecrawl_agent_status\` every 15-30 seconds for at least 2-3 m
 \`\`\`
 **Returns:** Job ID for status checking. Use \`firecrawl_agent_status\` to poll for results.
 `,
-    parameters: z.object({
-        prompt: z.string().min(1).max(10000),
-        urls: z.array(z.string().url()).optional(),
-        schema: z.record(z.string(), z.any()).optional(),
-    }),
-    execute: async (args, { session, log }) => {
-        const client = getClient(session);
-        const a = args;
-        log.info('Starting agent', {
-            prompt: a.prompt.substring(0, 100),
-            urlCount: Array.isArray(a.urls) ? a.urls.length : 0,
-        });
-        const agentBody = removeEmptyTopLevel({
-            prompt: a.prompt,
-            urls: a.urls,
-            schema: a.schema || undefined,
-        });
-        const res = await client.startAgent({
-            ...agentBody,
-            origin: ORIGIN,
-        });
-        return asText(res);
-    },
+  parameters: z4.object({
+    prompt: z4.string().min(1).max(1e4),
+    urls: z4.array(z4.string().url()).optional(),
+    schema: z4.record(z4.string(), z4.any()).optional()
+  }),
+  execute: async (args2, { session, log }) => {
+    const client = getClient(session);
+    const a = args2;
+    log.info("Starting agent", {
+      prompt: a.prompt.substring(0, 100),
+      urlCount: Array.isArray(a.urls) ? a.urls.length : 0
+    });
+    const agentBody = removeEmptyTopLevel({
+      prompt: a.prompt,
+      urls: a.urls,
+      schema: a.schema || void 0
+    });
+    const res = await client.startAgent({
+      ...agentBody,
+      origin: ORIGIN
+    });
+    return asText2(res);
+  }
 });
 server.addTool({
-    name: 'firecrawl_agent_status',
-    annotations: {
-        title: 'Get agent job status',
-        readOnlyHint: true,
-        openWorldHint: false,
-    },
-    description: `
+  name: "firecrawl_agent_status",
+  annotations: {
+    title: "Get agent job status",
+    readOnlyHint: true,
+    // Polls an existing agent job by ID for progress and results; no mutations.
+    openWorldHint: false,
+    // Queries only Firecrawl job state by job ID within the user's account.
+    destructiveHint: false
+    // Read-only status check.
+  },
+  description: `
 Check the status of an agent job and retrieve results when complete. Use this to poll for results after starting an agent with \`firecrawl_agent\`.
 
 **IMPORTANT - Be patient with polling:**
@@ -1445,28 +3505,30 @@ Check the status of an agent job and retrieve results when complete. Use this to
 
 **Returns:** Status, progress, and results (if completed) of the agent job.
 `,
-    parameters: z.object({ id: z.string() }),
-    execute: async (args, { session, log }) => {
-        const client = getClient(session);
-        const { id } = args;
-        log.info('Checking agent status', { id });
-        const res = await client.getAgentStatus(id);
-        return asText(res);
-    },
+  parameters: z4.object({ id: z4.string() }),
+  execute: async (args2, { session, log }) => {
+    const client = getClient(session);
+    const { id } = args2;
+    log.info("Checking agent status", { id });
+    const res = await client.getAgentStatus(id);
+    return asText2(res);
+  }
 });
-// Interact tools (scrape-bound browser sessions)
 server.addTool({
-    name: 'firecrawl_interact',
-    annotations: {
-        title: 'Interact with a scraped page',
-        readOnlyHint: false,
-        openWorldHint: true,
-        destructiveHint: false,
-    },
-    description: `
+  name: "firecrawl_interact",
+  annotations: {
+    title: "Interact with a scraped page",
+    readOnlyHint: false,
+    // Executes browser interactions (clicks, form input, scripts) in a live session.
+    openWorldHint: true,
+    // Interacts with pages on the public web via the scraped session.
+    destructiveHint: false
+    // Transient page interactions only; does not delete monitors, jobs, or external sites.
+  },
+  description: `
 Interact with a previously scraped page in a live browser session. Scrape a page first with firecrawl_scrape, then use the returned scrapeId to click buttons, fill forms, extract dynamic content, or navigate deeper.
 
-**Best for:** Multi-step workflows on a single page — searching a site, clicking through results, filling forms, extracting data that requires interaction.
+**Best for:** Multi-step workflows on a single page \u2014 searching a site, clicking through results, filling forms, extracting data that requires interaction.
 **Requires:** A scrapeId from a previous firecrawl_scrape call (found in the metadata of the scrape response).
 
 **Arguments:**
@@ -1500,43 +3562,40 @@ Interact with a previously scraped page in a live browser session. Scrape a page
 \`\`\`
 **Returns:** Execution result including output, stdout, stderr, exit code, and live view URLs.
 `,
-    parameters: z
-        .object({
-        scrapeId: z.string(),
-        prompt: z.string().optional(),
-        code: z.string().optional(),
-        language: z.enum(['bash', 'python', 'node']).optional(),
-        timeout: z.number().min(1).max(300).optional(),
-    })
-        .refine((data) => data.code || data.prompt, {
-        message: "Either 'code' or 'prompt' must be provided.",
-    }),
-    execute: async (args, { session, log }) => {
-        const client = getClient(session);
-        const { scrapeId, prompt, code, language, timeout } = args;
-        log.info('Interacting with scraped page', { scrapeId });
-        const interactArgs = { origin: ORIGIN };
-        if (prompt)
-            interactArgs.prompt = prompt;
-        if (code)
-            interactArgs.code = code;
-        if (language)
-            interactArgs.language = language;
-        if (timeout != null)
-            interactArgs.timeout = timeout;
-        const res = await client.interact(scrapeId, interactArgs);
-        return asText(res);
-    },
+  parameters: z4.object({
+    scrapeId: z4.string(),
+    prompt: z4.string().optional(),
+    code: z4.string().optional(),
+    language: z4.enum(["bash", "python", "node"]).optional(),
+    timeout: z4.number().min(1).max(300).optional()
+  }).refine((data) => data.code || data.prompt, {
+    message: "Either 'code' or 'prompt' must be provided."
+  }),
+  execute: async (args2, { session, log }) => {
+    const client = getClient(session);
+    const { scrapeId, prompt, code, language, timeout } = args2;
+    log.info("Interacting with scraped page", { scrapeId });
+    const interactArgs = { origin: ORIGIN };
+    if (prompt) interactArgs.prompt = prompt;
+    if (code) interactArgs.code = code;
+    if (language) interactArgs.language = language;
+    if (timeout != null) interactArgs.timeout = timeout;
+    const res = await client.interact(scrapeId, interactArgs);
+    return asText2(res);
+  }
 });
 server.addTool({
-    name: 'firecrawl_interact_stop',
-    annotations: {
-        title: 'Stop interact session',
-        readOnlyHint: false,
-        openWorldHint: false,
-        destructiveHint: true,
-    },
-    description: `
+  name: "firecrawl_interact_stop",
+  annotations: {
+    title: "Stop interact session",
+    readOnlyHint: false,
+    // Calls the API to stop and tear down an active interact session.
+    openWorldHint: false,
+    // Operates only on a known Firecrawl scrape/interact session ID.
+    destructiveHint: true
+    // Terminates the live browser session; this end state cannot be resumed.
+  },
+  description: `
 Stop an interact session for a scraped page. Call this when you are done interacting to free resources.
 
 **Usage Example:**
@@ -1550,99 +3609,93 @@ Stop an interact session for a scraped page. Call this when you are done interac
 \`\`\`
 **Returns:** Success confirmation.
 `,
-    parameters: z.object({
-        scrapeId: z.string(),
-    }),
-    execute: async (args, { session, log }) => {
-        const client = getClient(session);
-        const { scrapeId } = args;
-        log.info('Stopping interact session', { scrapeId });
-        const res = await client.stopInteraction(scrapeId);
-        return asText(res);
-    },
+  parameters: z4.object({
+    scrapeId: z4.string()
+  }),
+  execute: async (args2, { session, log }) => {
+    const client = getClient(session);
+    const { scrapeId } = args2;
+    log.info("Stopping interact session", { scrapeId });
+    const res = await client.stopInteraction(scrapeId);
+    return asText2(res);
+  }
 });
-// Local-only: parse a local file via the self-hosted Firecrawl /v2/parse endpoint.
-// The parse endpoint is only exposed on self-hosted/local Firecrawl API deployments,
-// so this tool is registered only when the MCP is NOT running in cloud mode.
-if (process.env.CLOUD_SERVICE !== 'true') {
-    const parseParamsSchema = z.object({
-        filePath: z
-            .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: z
-            .string()
-            .optional()
-            .describe('Optional MIME type override. If omitted, the server infers the file kind from the extension.'),
-        formats: z
-            .array(z.enum([
-            'markdown',
-            'html',
-            'rawHtml',
-            'links',
-            'summary',
-            'json',
-            'query',
-        ]))
-            .optional(),
-        jsonOptions: z
-            .object({
-            prompt: z.string().optional(),
-            schema: z.record(z.string(), z.any()).optional(),
-        })
-            .optional(),
-        queryOptions: z
-            .object({
-            prompt: z.string().max(10000),
-            mode: z.enum(['directQuote', 'freeform']).default('freeform'),
-        })
-            .optional(),
-        parsers: z.array(z.enum(['pdf'])).optional(),
-        pdfOptions: z
-            .object({
-            maxPages: z.number().int().min(1).max(10000).optional(),
-        })
-            .optional(),
-        onlyMainContent: z.boolean().optional(),
-        redactPII: z.boolean().optional(),
-        includeTags: z.array(z.string()).optional(),
-        excludeTags: z.array(z.string()).optional(),
-        removeBase64Images: z.boolean().optional(),
-        skipTlsVerification: z.boolean().optional(),
-        storeInCache: z.boolean().optional(),
-        zeroDataRetention: z.boolean().optional(),
-        maxAge: z.number().optional(),
-        proxy: z.enum(['basic', 'auto']).optional(),
-    });
-    const EXTENSION_CONTENT_TYPES = {
-        '.html': 'text/html',
-        '.htm': 'text/html',
-        '.pdf': 'application/pdf',
-        '.docx': 'application/vnd.openxmlformats-officedocument.wordprocessingml.document',
-        '.doc': 'application/msword',
-        '.odt': 'application/vnd.oasis.opendocument.text',
-        '.rtf': 'application/rtf',
-        '.xlsx': 'application/vnd.openxmlformats-officedocument.spreadsheetml.sheet',
-        '.xls': 'application/vnd.ms-excel',
-    };
-    function inferContentType(filename) {
-        const ext = path.extname(filename).toLowerCase();
-        return EXTENSION_CONTENT_TYPES[ext] ?? 'application/octet-stream';
-    }
-    server.addTool({
-        name: 'firecrawl_parse',
-        annotations: {
-            title: 'Parse a local file',
-            readOnlyHint: true,
-            openWorldHint: false,
-        },
-        description: `
+if (process.env.CLOUD_SERVICE !== "true") {
+  let inferContentType = function(filename) {
+    const ext = path.extname(filename).toLowerCase();
+    return EXTENSION_CONTENT_TYPES[ext] ?? "application/octet-stream";
+  };
+  inferContentType2 = inferContentType;
+  const parseParamsSchema = z4.object({
+    filePath: z4.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: z4.string().optional().describe(
+      "Optional MIME type override. If omitted, the server infers the file kind from the extension."
+    ),
+    formats: z4.array(
+      z4.enum([
+        "markdown",
+        "html",
+        "rawHtml",
+        "links",
+        "summary",
+        "json",
+        "query"
+      ])
+    ).optional(),
+    jsonOptions: z4.object({
+      prompt: z4.string().optional(),
+      schema: z4.record(z4.string(), z4.any()).optional()
+    }).optional(),
+    queryOptions: z4.object({
+      prompt: z4.string().max(1e4),
+      mode: z4.enum(["directQuote", "freeform"]).default("freeform")
+    }).optional(),
+    parsers: z4.array(z4.enum(["pdf"])).optional(),
+    pdfOptions: z4.object({
+      maxPages: z4.number().int().min(1).max(1e4).optional()
+    }).optional(),
+    onlyMainContent: z4.boolean().optional(),
+    redactPII: z4.boolean().optional(),
+    includeTags: z4.array(z4.string()).optional(),
+    excludeTags: z4.array(z4.string()).optional(),
+    removeBase64Images: z4.boolean().optional(),
+    skipTlsVerification: z4.boolean().optional(),
+    storeInCache: z4.boolean().optional(),
+    zeroDataRetention: z4.boolean().optional(),
+    maxAge: z4.number().optional(),
+    proxy: z4.enum(["basic", "auto"]).optional()
+  });
+  const EXTENSION_CONTENT_TYPES = {
+    ".html": "text/html",
+    ".htm": "text/html",
+    ".pdf": "application/pdf",
+    ".docx": "application/vnd.openxmlformats-officedocument.wordprocessingml.document",
+    ".doc": "application/msword",
+    ".odt": "application/vnd.oasis.opendocument.text",
+    ".rtf": "application/rtf",
+    ".xlsx": "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet",
+    ".xls": "application/vnd.ms-excel"
+  };
+  server.addTool({
+    name: "firecrawl_parse",
+    annotations: {
+      title: "Parse a local file",
+      readOnlyHint: true,
+      // Reads and parses a local file; does not modify the file on disk.
+      openWorldHint: false,
+      // Operates on a local filesystem path, not the open web.
+      destructiveHint: false
+      // Read-only parsing; no deletion or writes to the source file.
+    },
+    description: `
 Parse a file from the local filesystem using a self-hosted Firecrawl API's /v2/parse endpoint.
-This is the fastest and most reliable way to extract content from a document on disk — if the file lives locally and the MCP is pointed at a self-hosted Firecrawl instance, you should always prefer this tool over uploading the file elsewhere and then scraping it.
+This is the fastest and most reliable way to extract content from a document on disk \u2014 if the file lives locally and the MCP is pointed at a self-hosted Firecrawl instance, you should always prefer this tool over uploading the file elsewhere and then scraping it.
 
 **Best for:** Extracting content from a local document (PDF, Word, Excel, HTML, etc.) when you don't want to host it on the public web first; pulling structured data out of a file with JSON format; converting binary documents into markdown for downstream reasoning.
-**Not recommended for:** Remote URLs (use firecrawl_scrape); multiple files at once (call parse multiple times); documents that require interactive actions, screenshots, or change tracking — those aren't supported by the parse endpoint.
-**Common mistakes:** Passing a URL instead of a local file path; requesting an unsupported format (screenshot, branding, changeTracking); setting waitFor, location, mobile, or a non-basic/auto proxy — parse uploads reject all of those.
+**Not recommended for:** Remote URLs (use firecrawl_scrape); multiple files at once (call parse multiple times); documents that require interactive actions, screenshots, or change tracking \u2014 those aren't supported by the parse endpoint.
+**Common mistakes:** Passing a URL instead of a local file path; requesting an unsupported format (screenshot, branding, changeTracking); setting waitFor, location, mobile, or a non-basic/auto proxy \u2014 parse uploads reject all of those.
 
 **Supported file types:** .html, .htm, .xhtml, .pdf, .docx, .doc, .odt, .rtf, .xlsx, .xls
 **Unsupported options:** actions, screenshot/branding/changeTracking formats, waitFor > 0, location, mobile, proxy values other than "auto" or "basic".
@@ -1708,93 +3761,82 @@ Add \`"parsers": ["pdf"]\` (optionally with \`pdfOptions.maxPages\`) when parsin
 \`\`\`
 **Returns:** A parsed document with markdown, html, links, summary, json, or query results depending on the requested formats.
 `,
-        parameters: parseParamsSchema,
-        execute: async (args, { session, log }) => {
-            const apiUrl = process.env.FIRECRAWL_API_URL;
-            if (!apiUrl) {
-                throw new Error('firecrawl_parse requires FIRECRAWL_API_URL to be set to a self-hosted Firecrawl API instance.');
-            }
-            const { filePath, contentType: overrideContentType, ...options } = args;
-            const absPath = path.resolve(filePath);
-            const buffer = await readFile(absPath);
-            const filename = path.basename(absPath);
-            const fileContentType = overrideContentType && overrideContentType.length > 0
-                ? overrideContentType
-                : inferContentType(filename);
-            const transformed = transformScrapeParams(options);
-            const cleaned = removeEmptyTopLevel(transformed);
-            const optionsPayload = { origin: ORIGIN, ...cleaned };
-            const form = new FormData();
-            const blob = new Blob([new Uint8Array(buffer)], {
-                type: fileContentType,
-            });
-            form.append('file', blob, filename);
-            form.append('options', JSON.stringify(optionsPayload));
-            const headers = {};
-            const apiKey = session?.firecrawlApiKey;
-            if (apiKey) {
-                headers['Authorization'] = `Bearer ${apiKey}`;
-            }
-            const endpoint = `${apiUrl.replace(/\/$/, '')}/v2/parse`;
-            log.info('Parsing local file', {
-                endpoint,
-                filename,
-                size: buffer.length,
-            });
-            const response = await fetch(endpoint, {
-                method: 'POST',
-                headers,
-                body: form,
-            });
-            const responseText = await response.text();
-            if (!response.ok) {
-                throw new Error(`Parse request failed with status ${response.status}: ${responseText}`);
-            }
-            try {
-                return asText(JSON.parse(responseText));
-            }
-            catch {
-                return responseText;
-            }
-        },
-    });
-}
-const PORT = Number(process.env.PORT || 3000);
-const HOST = process.env.CLOUD_SERVICE === 'true'
-    ? '0.0.0.0'
-    : process.env.HOST || 'localhost';
-let args;
-if (process.env.CLOUD_SERVICE === 'true' ||
-    process.env.SSE_LOCAL === 'true' ||
-    process.env.HTTP_STREAMABLE_SERVER === 'true') {
-    args = {
-        transportType: 'httpStream',
-        httpStream: {
-            port: PORT,
-            host: HOST,
-            stateless: true,
-        },
-    };
+    parameters: parseParamsSchema,
+    execute: async (args2, { session, log }) => {
+      const apiUrl = process.env.FIRECRAWL_API_URL;
+      if (!apiUrl) {
+        throw new Error(
+          "firecrawl_parse requires FIRECRAWL_API_URL to be set to a self-hosted Firecrawl API instance."
+        );
+      }
+      const {
+        filePath,
+        contentType: overrideContentType,
+        ...options
+      } = args2;
+      const absPath = path.resolve(filePath);
+      const buffer = await readFile(absPath);
+      const filename = path.basename(absPath);
+      const fileContentType = overrideContentType && overrideContentType.length > 0 ? overrideContentType : inferContentType(filename);
+      const transformed = transformScrapeParams(
+        options
+      );
+      const cleaned = removeEmptyTopLevel(transformed);
+      const optionsPayload = { origin: ORIGIN, ...cleaned };
+      const form = new FormData();
+      const blob = new Blob([new Uint8Array(buffer)], {
+        type: fileContentType
+      });
+      form.append("file", blob, filename);
+      form.append("options", JSON.stringify(optionsPayload));
+      const headers = {};
+      const apiKey = session?.firecrawlApiKey;
+      if (apiKey) {
+        headers["Authorization"] = `Bearer ${apiKey}`;
+      }
+      const endpoint = `${apiUrl.replace(/\/$/, "")}/v2/parse`;
+      log.info("Parsing local file", {
+        endpoint,
+        filename,
+        size: buffer.length
+      });
+      const response = await fetch(endpoint, {
+        method: "POST",
+        headers,
+        body: form
+      });
+      const responseText = await response.text();
+      if (!response.ok) {
+        throw new Error(
+          `Parse request failed with status ${response.status}: ${responseText}`
+        );
+      }
+      try {
+        return asText2(JSON.parse(responseText));
+      } catch {
+        return responseText;
+      }
+    }
+  });
 }
-else {
-    // default: stdio
-    args = {
-        transportType: 'stdio',
-    };
+var inferContentType2;
+var PORT = Number(process.env.PORT || 3e3);
+var HOST = process.env.CLOUD_SERVICE === "true" ? "0.0.0.0" : process.env.HOST || "localhost";
+var args;
+if (process.env.CLOUD_SERVICE === "true" || process.env.SSE_LOCAL === "true" || process.env.HTTP_STREAMABLE_SERVER === "true") {
+  args = {
+    transportType: "httpStream",
+    httpStream: {
+      port: PORT,
+      host: HOST,
+      stateless: true
+    }
+  };
+} else {
+  args = {
+    transportType: "stdio"
+  };
 }
 registerMonitorTools(server);
-// Research tools gating. FastMCP's `canAccess` is only honored on the HTTP
-// transport (the stdio path exposes every registered tool regardless), so we
-// split the two cases:
-//   - HTTP (cloud / SSE_LOCAL / HTTP_STREAMABLE_SERVER): always register; each
-//     tool's `canAccess` hides it unless the session has research enabled
-//     (`FIRECRAWL_RESEARCH=true` env or `?research=true` on the request).
-//   - stdio (local): register only when `FIRECRAWL_RESEARCH=true`, since
-//     `canAccess` cannot hide them there.
-const isHttpTransport = process.env.CLOUD_SERVICE === 'true' ||
-    process.env.SSE_LOCAL === 'true' ||
-    process.env.HTTP_STREAMABLE_SERVER === 'true';
-if (isHttpTransport || process.env.FIRECRAWL_RESEARCH === 'true') {
-    registerResearchTools(server, getClient);
-}
+registerResearchTools(server, getClient);
 await server.start(args);