@mendable/firecrawl 4.11.2 → 4.11.3

package/dist/{chunk-GVCNL5KA.js → chunk-TLAC3APA.js}

@@ -8,7 +8,7 @@ var require_package = __commonJS({
   "package.json"(exports, module) {
     module.exports = {
       name: "@mendable/firecrawl-js",
-      version: "4.11.2",
+      version: "4.11.3",
       description: "JavaScript SDK for Firecrawl API",
       main: "dist/index.js",
       types: "dist/index.d.ts",

package/dist/index.cjs

@@ -35,7 +35,7 @@ var require_package = __commonJS({
   "package.json"(exports2, module2) {
     module2.exports = {
       name: "@mendable/firecrawl-js",
-      version: "4.11.2",
+      version: "4.11.3",
       description: "JavaScript SDK for Firecrawl API",
       main: "dist/index.js",
       types: "dist/index.d.ts",
@@ -249,14 +249,54 @@ var JobTimeoutError = class extends SdkError {
   }
 };
 
-// src/v2/utils/validation.ts
+// src/utils/zodSchemaToJson.ts
 var import_zod_to_json_schema = require("zod-to-json-schema");
+function isZodSchema(value) {
+  if (!value || typeof value !== "object") return false;
+  const schema = value;
+  const hasV3Markers = "_def" in schema && (typeof schema.safeParse === "function" || typeof schema.parse === "function");
+  const hasV4Markers = "_zod" in schema && typeof schema._zod === "object";
+  return hasV3Markers || hasV4Markers;
+}
+function isZodV4Schema(schema) {
+  if (!schema || typeof schema !== "object") return false;
+  return "_zod" in schema && typeof schema._zod === "object";
+}
+function tryZodV4Conversion(schema) {
+  if (!isZodV4Schema(schema)) return null;
+  try {
+    const zodModule = schema.constructor?.prototype?.constructor;
+    if (zodModule && typeof zodModule.toJSONSchema === "function") {
+      return zodModule.toJSONSchema(schema);
+    }
+  } catch {
+  }
+  return null;
+}
+function zodSchemaToJsonSchema(schema) {
+  if (!isZodSchema(schema)) {
+    return schema;
+  }
+  const v4Result = tryZodV4Conversion(schema);
+  if (v4Result) {
+    return v4Result;
+  }
+  try {
+    return (0, import_zod_to_json_schema.zodToJsonSchema)(schema);
+  } catch {
+    return schema;
+  }
+}
 function looksLikeZodShape(obj) {
   if (!obj || typeof obj !== "object" || Array.isArray(obj)) return false;
   const values = Object.values(obj);
   if (values.length === 0) return false;
-  return values.some((v) => v && typeof v === "object" && v._def && typeof v.safeParse === "function");
+  return values.some(
+    (v) => v && typeof v === "object" && v._def && typeof v.safeParse === "function"
+  );
 }
+
+// src/v2/utils/validation.ts
 function ensureValidFormats(formats) {
   if (!formats) return;
   for (const fmt of formats) {
@@ -272,12 +312,8 @@ function ensureValidFormats(formats) {
         throw new Error("json format requires either 'prompt' or 'schema' (or both)");
       }
       const maybeSchema = j.schema;
-      const isZod = !!maybeSchema && (typeof maybeSchema.safeParse === "function" || typeof maybeSchema.parse === "function") && !!maybeSchema._def;
-      if (isZod) {
-        try {
-          j.schema = (0, import_zod_to_json_schema.zodToJsonSchema)(maybeSchema);
-        } catch {
-        }
+      if (isZodSchema(maybeSchema)) {
+        j.schema = zodSchemaToJsonSchema(maybeSchema);
       } else if (looksLikeZodShape(maybeSchema)) {
         throw new Error(
           "json format schema appears to be a Zod schema's .shape property. Pass the Zod schema directly (e.g., `schema: MySchema`) instead of `schema: MySchema.shape`. The SDK will automatically convert Zod schemas to JSON Schema format."
@@ -288,12 +324,8 @@ function ensureValidFormats(formats) {
     if (fmt.type === "changeTracking") {
       const ct = fmt;
       const maybeSchema = ct.schema;
-      const isZod = !!maybeSchema && (typeof maybeSchema.safeParse === "function" || typeof maybeSchema.parse === "function") && !!maybeSchema._def;
-      if (isZod) {
-        try {
-          ct.schema = (0, import_zod_to_json_schema.zodToJsonSchema)(maybeSchema);
-        } catch {
-        }
+      if (isZodSchema(maybeSchema)) {
+        ct.schema = zodSchemaToJsonSchema(maybeSchema);
       } else if (looksLikeZodShape(maybeSchema)) {
         throw new Error(
           "changeTracking format schema appears to be a Zod schema's .shape property. Pass the Zod schema directly (e.g., `schema: MySchema`) instead of `schema: MySchema.shape`. The SDK will automatically convert Zod schemas to JSON Schema format."
@@ -780,15 +812,12 @@ async function batchScrape(http, urls, opts = {}) {
 }
 
 // src/v2/methods/extract.ts
-var import_zod_to_json_schema2 = require("zod-to-json-schema");
 function prepareExtractPayload(args) {
   const body = {};
   if (args.urls) body.urls = args.urls;
   if (args.prompt != null) body.prompt = args.prompt;
   if (args.schema != null) {
-    const s = args.schema;
-    const isZod = s && (typeof s.safeParse === "function" || typeof s.parse === "function") && s._def;
-    body.schema = isZod ? (0, import_zod_to_json_schema2.zodToJsonSchema)(s) : args.schema;
+    body.schema = isZodSchema(args.schema) ? zodSchemaToJsonSchema(args.schema) : args.schema;
   }
   if (args.systemPrompt != null) body.systemPrompt = args.systemPrompt;
   if (args.allowExternalLinks != null) body.allowExternalLinks = args.allowExternalLinks;
@@ -841,15 +870,12 @@ async function extract(http, args) {
 }
 
 // src/v2/methods/agent.ts
-var import_zod_to_json_schema3 = require("zod-to-json-schema");
 function prepareAgentPayload(args) {
   const body = {};
   if (args.urls) body.urls = args.urls;
   body.prompt = args.prompt;
   if (args.schema != null) {
-    const s = args.schema;
-    const isZod = s && (typeof s.safeParse === "function" || typeof s.parse === "function") && s._def;
-    body.schema = isZod ? (0, import_zod_to_json_schema3.zodToJsonSchema)(s) : args.schema;
+    body.schema = isZodSchema(args.schema) ? zodSchemaToJsonSchema(args.schema) : args.schema;
   }
   if (args.integration && args.integration.trim()) body.integration = args.integration.trim();
   if (args.maxCredits !== null && args.maxCredits !== void 0) body.maxCredits = args.maxCredits;
@@ -1437,7 +1463,6 @@ var FirecrawlClient = class {
 // src/v1/index.ts
 var import_axios3 = __toESM(require("axios"), 1);
 var zt2 = require("zod");
-var import_zod_to_json_schema4 = require("zod-to-json-schema");
 
 // node_modules/.pnpm/typescript-event-target@1.1.1/node_modules/typescript-event-target/dist/index.mjs
 var e = class extends EventTarget {
@@ -1507,30 +1532,20 @@ var FirecrawlApp = class {
     };
     let jsonData = { url, ...params, origin: typeof params.origin === "string" && params.origin.includes("mcp") ? params.origin : `js-sdk@${this.version}` };
     if (jsonData?.extract?.schema) {
-      let schema = jsonData.extract.schema;
-      try {
-        schema = (0, import_zod_to_json_schema4.zodToJsonSchema)(schema);
-      } catch (error) {
-      }
       jsonData = {
         ...jsonData,
         extract: {
           ...jsonData.extract,
-          schema
+          schema: zodSchemaToJsonSchema(jsonData.extract.schema)
         }
       };
     }
     if (jsonData?.jsonOptions?.schema) {
-      let schema = jsonData.jsonOptions.schema;
-      try {
-        schema = (0, import_zod_to_json_schema4.zodToJsonSchema)(schema);
-      } catch (error) {
-      }
       jsonData = {
         ...jsonData,
         jsonOptions: {
           ...jsonData.jsonOptions,
-          schema
+          schema: zodSchemaToJsonSchema(jsonData.jsonOptions.schema)
         }
       };
     }
@@ -1584,18 +1599,13 @@ var FirecrawlApp = class {
       scrapeOptions: params?.scrapeOptions ?? { formats: [] }
     };
     if (jsonData?.scrapeOptions?.extract?.schema) {
-      let schema = jsonData.scrapeOptions.extract.schema;
-      try {
-        schema = (0, import_zod_to_json_schema4.zodToJsonSchema)(schema);
-      } catch (error) {
-      }
       jsonData = {
         ...jsonData,
         scrapeOptions: {
           ...jsonData.scrapeOptions,
           extract: {
             ...jsonData.scrapeOptions.extract,
-            schema
+            schema: zodSchemaToJsonSchema(jsonData.scrapeOptions.extract.schema)
           }
         }
       };
@@ -1853,30 +1863,20 @@ var FirecrawlApp = class {
     const headers = this.prepareHeaders(idempotencyKey);
     let jsonData = { urls, webhook, ignoreInvalidURLs, maxConcurrency, ...params, origin: typeof params.origin === "string" && params.origin.includes("mcp") ? params.origin : `js-sdk@${this.version}` };
     if (jsonData?.extract?.schema) {
-      let schema = jsonData.extract.schema;
-      try {
-        schema = (0, import_zod_to_json_schema4.zodToJsonSchema)(schema);
-      } catch (error) {
-      }
       jsonData = {
         ...jsonData,
         extract: {
           ...jsonData.extract,
-          schema
+          schema: zodSchemaToJsonSchema(jsonData.extract.schema)
         }
       };
     }
     if (jsonData?.jsonOptions?.schema) {
-      let schema = jsonData.jsonOptions.schema;
-      try {
-        schema = (0, import_zod_to_json_schema4.zodToJsonSchema)(schema);
-      } catch (error) {
-      }
       jsonData = {
         ...jsonData,
         jsonOptions: {
           ...jsonData.jsonOptions,
-          schema
+          schema: zodSchemaToJsonSchema(jsonData.jsonOptions.schema)
         }
       };
     }
@@ -2042,20 +2042,7 @@ var FirecrawlApp = class {
   async extract(urls, params) {
     const headers = this.prepareHeaders();
     let jsonData = { urls, ...params };
-    let jsonSchema;
-    try {
-      if (!params?.schema) {
-        jsonSchema = void 0;
-      } else {
-        try {
-          jsonSchema = (0, import_zod_to_json_schema4.zodToJsonSchema)(params.schema);
-        } catch (_) {
-          jsonSchema = params.schema;
-        }
-      }
-    } catch (error) {
-      throw new FirecrawlError("Invalid schema. Schema must be either a valid Zod schema or JSON schema object.", 400);
-    }
+    const jsonSchema = params?.schema ? zodSchemaToJsonSchema(params.schema) : void 0;
     try {
       const response = await this.postRequest(
         this.apiUrl + `/v1/extract`,
@@ -2105,21 +2092,8 @@ var FirecrawlApp = class {
    */
   async asyncExtract(urls, params, idempotencyKey) {
     const headers = this.prepareHeaders(idempotencyKey);
-    let jsonData = { urls, ...params };
-    let jsonSchema;
-    try {
-      if (!params?.schema) {
-        jsonSchema = void 0;
-      } else {
-        try {
-          jsonSchema = (0, import_zod_to_json_schema4.zodToJsonSchema)(params.schema);
-        } catch (_) {
-          jsonSchema = params.schema;
-        }
-      }
-    } catch (error) {
-      throw new FirecrawlError("Invalid schema. Schema must be either a valid Zod schema or JSON schema object.", 400);
-    }
+    const jsonData = { urls, ...params };
+    const jsonSchema = params?.schema ? zodSchemaToJsonSchema(params.schema) : void 0;
     try {
       const response = await this.postRequest(
         this.apiUrl + `/v1/extract`,
@@ -2401,16 +2375,11 @@ var FirecrawlApp = class {
     const headers = this.prepareHeaders();
     let jsonData = { query, ...params, origin: typeof params.origin === "string" && params.origin.includes("mcp") ? params.origin : `js-sdk@${this.version}` };
     if (jsonData?.jsonOptions?.schema) {
-      let schema = jsonData.jsonOptions.schema;
-      try {
-        schema = (0, import_zod_to_json_schema4.zodToJsonSchema)(schema);
-      } catch (error) {
-      }
       jsonData = {
         ...jsonData,
         jsonOptions: {
           ...jsonData.jsonOptions,
-          schema
+          schema: zodSchemaToJsonSchema(jsonData.jsonOptions.schema)
         }
       };
     }

package/dist/index.js

@@ -1,6 +1,6 @@
 import {
   require_package
-} from "./chunk-GVCNL5KA.js";
+} from "./chunk-TLAC3APA.js";
 
 // src/v2/utils/httpClient.ts
 import axios from "axios";
@@ -130,14 +130,54 @@ var JobTimeoutError = class extends SdkError {
   }
 };
 
-// src/v2/utils/validation.ts
-import { zodToJsonSchema } from "zod-to-json-schema";
+// src/utils/zodSchemaToJson.ts
+import { zodToJsonSchema as zodToJsonSchemaLib } from "zod-to-json-schema";
+function isZodSchema(value) {
+  if (!value || typeof value !== "object") return false;
+  const schema = value;
+  const hasV3Markers = "_def" in schema && (typeof schema.safeParse === "function" || typeof schema.parse === "function");
+  const hasV4Markers = "_zod" in schema && typeof schema._zod === "object";
+  return hasV3Markers || hasV4Markers;
+}
+function isZodV4Schema(schema) {
+  if (!schema || typeof schema !== "object") return false;
+  return "_zod" in schema && typeof schema._zod === "object";
+}
+function tryZodV4Conversion(schema) {
+  if (!isZodV4Schema(schema)) return null;
+  try {
+    const zodModule = schema.constructor?.prototype?.constructor;
+    if (zodModule && typeof zodModule.toJSONSchema === "function") {
+      return zodModule.toJSONSchema(schema);
+    }
+  } catch {
+  }
+  return null;
+}
+function zodSchemaToJsonSchema(schema) {
+  if (!isZodSchema(schema)) {
+    return schema;
+  }
+  const v4Result = tryZodV4Conversion(schema);
+  if (v4Result) {
+    return v4Result;
+  }
+  try {
+    return zodToJsonSchemaLib(schema);
+  } catch {
+    return schema;
+  }
+}
 function looksLikeZodShape(obj) {
   if (!obj || typeof obj !== "object" || Array.isArray(obj)) return false;
   const values = Object.values(obj);
   if (values.length === 0) return false;
-  return values.some((v) => v && typeof v === "object" && v._def && typeof v.safeParse === "function");
+  return values.some(
+    (v) => v && typeof v === "object" && v._def && typeof v.safeParse === "function"
+  );
 }
+
+// src/v2/utils/validation.ts
 function ensureValidFormats(formats) {
   if (!formats) return;
   for (const fmt of formats) {
@@ -153,12 +193,8 @@ function ensureValidFormats(formats) {
         throw new Error("json format requires either 'prompt' or 'schema' (or both)");
       }
       const maybeSchema = j.schema;
-      const isZod = !!maybeSchema && (typeof maybeSchema.safeParse === "function" || typeof maybeSchema.parse === "function") && !!maybeSchema._def;
-      if (isZod) {
-        try {
-          j.schema = zodToJsonSchema(maybeSchema);
-        } catch {
-        }
+      if (isZodSchema(maybeSchema)) {
+        j.schema = zodSchemaToJsonSchema(maybeSchema);
       } else if (looksLikeZodShape(maybeSchema)) {
         throw new Error(
           "json format schema appears to be a Zod schema's .shape property. Pass the Zod schema directly (e.g., `schema: MySchema`) instead of `schema: MySchema.shape`. The SDK will automatically convert Zod schemas to JSON Schema format."
@@ -169,12 +205,8 @@ function ensureValidFormats(formats) {
     if (fmt.type === "changeTracking") {
       const ct = fmt;
       const maybeSchema = ct.schema;
-      const isZod = !!maybeSchema && (typeof maybeSchema.safeParse === "function" || typeof maybeSchema.parse === "function") && !!maybeSchema._def;
-      if (isZod) {
-        try {
-          ct.schema = zodToJsonSchema(maybeSchema);
-        } catch {
-        }
+      if (isZodSchema(maybeSchema)) {
+        ct.schema = zodSchemaToJsonSchema(maybeSchema);
       } else if (looksLikeZodShape(maybeSchema)) {
         throw new Error(
           "changeTracking format schema appears to be a Zod schema's .shape property. Pass the Zod schema directly (e.g., `schema: MySchema`) instead of `schema: MySchema.shape`. The SDK will automatically convert Zod schemas to JSON Schema format."
@@ -661,15 +693,12 @@ async function batchScrape(http, urls, opts = {}) {
 }
 
 // src/v2/methods/extract.ts
-import { zodToJsonSchema as zodToJsonSchema2 } from "zod-to-json-schema";
 function prepareExtractPayload(args) {
   const body = {};
   if (args.urls) body.urls = args.urls;
   if (args.prompt != null) body.prompt = args.prompt;
   if (args.schema != null) {
-    const s = args.schema;
-    const isZod = s && (typeof s.safeParse === "function" || typeof s.parse === "function") && s._def;
-    body.schema = isZod ? zodToJsonSchema2(s) : args.schema;
+    body.schema = isZodSchema(args.schema) ? zodSchemaToJsonSchema(args.schema) : args.schema;
   }
   if (args.systemPrompt != null) body.systemPrompt = args.systemPrompt;
   if (args.allowExternalLinks != null) body.allowExternalLinks = args.allowExternalLinks;
@@ -722,15 +751,12 @@ async function extract(http, args) {
 }
 
 // src/v2/methods/agent.ts
-import { zodToJsonSchema as zodToJsonSchema3 } from "zod-to-json-schema";
 function prepareAgentPayload(args) {
   const body = {};
   if (args.urls) body.urls = args.urls;
   body.prompt = args.prompt;
   if (args.schema != null) {
-    const s = args.schema;
-    const isZod = s && (typeof s.safeParse === "function" || typeof s.parse === "function") && s._def;
-    body.schema = isZod ? zodToJsonSchema3(s) : args.schema;
+    body.schema = isZodSchema(args.schema) ? zodSchemaToJsonSchema(args.schema) : args.schema;
   }
   if (args.integration && args.integration.trim()) body.integration = args.integration.trim();
   if (args.maxCredits !== null && args.maxCredits !== void 0) body.maxCredits = args.maxCredits;
@@ -1318,7 +1344,6 @@ var FirecrawlClient = class {
 // src/v1/index.ts
 import axios2, { AxiosError } from "axios";
 import "zod";
-import { zodToJsonSchema as zodToJsonSchema4 } from "zod-to-json-schema";
 
 // node_modules/.pnpm/typescript-event-target@1.1.1/node_modules/typescript-event-target/dist/index.mjs
 var e = class extends EventTarget {
@@ -1349,7 +1374,7 @@ var FirecrawlApp = class {
       if (typeof process !== "undefined" && process.env && process.env.npm_package_version) {
         return process.env.npm_package_version;
       }
-      const packageJson = await import("./package-LU5XQZAL.js");
+      const packageJson = await import("./package-3BZQ6TAW.js");
       return packageJson.default.version;
     } catch (error) {
       const isTest = typeof process !== "undefined" && (process.env.JEST_WORKER_ID != null || false);
@@ -1388,30 +1413,20 @@ var FirecrawlApp = class {
     };
     let jsonData = { url, ...params, origin: typeof params.origin === "string" && params.origin.includes("mcp") ? params.origin : `js-sdk@${this.version}` };
     if (jsonData?.extract?.schema) {
-      let schema = jsonData.extract.schema;
-      try {
-        schema = zodToJsonSchema4(schema);
-      } catch (error) {
-      }
       jsonData = {
         ...jsonData,
         extract: {
           ...jsonData.extract,
-          schema
+          schema: zodSchemaToJsonSchema(jsonData.extract.schema)
         }
       };
     }
     if (jsonData?.jsonOptions?.schema) {
-      let schema = jsonData.jsonOptions.schema;
-      try {
-        schema = zodToJsonSchema4(schema);
-      } catch (error) {
-      }
       jsonData = {
         ...jsonData,
         jsonOptions: {
           ...jsonData.jsonOptions,
-          schema
+          schema: zodSchemaToJsonSchema(jsonData.jsonOptions.schema)
         }
       };
     }
@@ -1465,18 +1480,13 @@ var FirecrawlApp = class {
       scrapeOptions: params?.scrapeOptions ?? { formats: [] }
     };
     if (jsonData?.scrapeOptions?.extract?.schema) {
-      let schema = jsonData.scrapeOptions.extract.schema;
-      try {
-        schema = zodToJsonSchema4(schema);
-      } catch (error) {
-      }
       jsonData = {
         ...jsonData,
         scrapeOptions: {
           ...jsonData.scrapeOptions,
           extract: {
             ...jsonData.scrapeOptions.extract,
-            schema
+            schema: zodSchemaToJsonSchema(jsonData.scrapeOptions.extract.schema)
           }
         }
       };
@@ -1734,30 +1744,20 @@ var FirecrawlApp = class {
     const headers = this.prepareHeaders(idempotencyKey);
     let jsonData = { urls, webhook, ignoreInvalidURLs, maxConcurrency, ...params, origin: typeof params.origin === "string" && params.origin.includes("mcp") ? params.origin : `js-sdk@${this.version}` };
     if (jsonData?.extract?.schema) {
-      let schema = jsonData.extract.schema;
-      try {
-        schema = zodToJsonSchema4(schema);
-      } catch (error) {
-      }
       jsonData = {
         ...jsonData,
         extract: {
           ...jsonData.extract,
-          schema
+          schema: zodSchemaToJsonSchema(jsonData.extract.schema)
         }
       };
     }
     if (jsonData?.jsonOptions?.schema) {
-      let schema = jsonData.jsonOptions.schema;
-      try {
-        schema = zodToJsonSchema4(schema);
-      } catch (error) {
-      }
       jsonData = {
         ...jsonData,
         jsonOptions: {
           ...jsonData.jsonOptions,
-          schema
+          schema: zodSchemaToJsonSchema(jsonData.jsonOptions.schema)
         }
       };
     }
@@ -1923,20 +1923,7 @@ var FirecrawlApp = class {
   async extract(urls, params) {
     const headers = this.prepareHeaders();
     let jsonData = { urls, ...params };
-    let jsonSchema;
-    try {
-      if (!params?.schema) {
-        jsonSchema = void 0;
-      } else {
-        try {
-          jsonSchema = zodToJsonSchema4(params.schema);
-        } catch (_) {
-          jsonSchema = params.schema;
-        }
-      }
-    } catch (error) {
-      throw new FirecrawlError("Invalid schema. Schema must be either a valid Zod schema or JSON schema object.", 400);
-    }
+    const jsonSchema = params?.schema ? zodSchemaToJsonSchema(params.schema) : void 0;
     try {
       const response = await this.postRequest(
         this.apiUrl + `/v1/extract`,
@@ -1986,21 +1973,8 @@ var FirecrawlApp = class {
    */
   async asyncExtract(urls, params, idempotencyKey) {
     const headers = this.prepareHeaders(idempotencyKey);
-    let jsonData = { urls, ...params };
-    let jsonSchema;
-    try {
-      if (!params?.schema) {
-        jsonSchema = void 0;
-      } else {
-        try {
-          jsonSchema = zodToJsonSchema4(params.schema);
-        } catch (_) {
-          jsonSchema = params.schema;
-        }
-      }
-    } catch (error) {
-      throw new FirecrawlError("Invalid schema. Schema must be either a valid Zod schema or JSON schema object.", 400);
-    }
+    const jsonData = { urls, ...params };
+    const jsonSchema = params?.schema ? zodSchemaToJsonSchema(params.schema) : void 0;
     try {
       const response = await this.postRequest(
         this.apiUrl + `/v1/extract`,
@@ -2282,16 +2256,11 @@ var FirecrawlApp = class {
     const headers = this.prepareHeaders();
     let jsonData = { query, ...params, origin: typeof params.origin === "string" && params.origin.includes("mcp") ? params.origin : `js-sdk@${this.version}` };
     if (jsonData?.jsonOptions?.schema) {
-      let schema = jsonData.jsonOptions.schema;
-      try {
-        schema = zodToJsonSchema4(schema);
-      } catch (error) {
-      }
       jsonData = {
         ...jsonData,
         jsonOptions: {
           ...jsonData.jsonOptions,
-          schema
+          schema: zodSchemaToJsonSchema(jsonData.jsonOptions.schema)
         }
       };
     }

package/dist/{package-LU5XQZAL.js → package-3BZQ6TAW.js}

@@ -1,4 +1,4 @@
 import {
   require_package
-} from "./chunk-GVCNL5KA.js";
+} from "./chunk-TLAC3APA.js";
 export default require_package();

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mendable/firecrawl",
-  "version": "4.11.2",
+  "version": "4.11.3",
   "description": "JavaScript SDK for Firecrawl API",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",

package/src/__tests__/unit/v2/zodSchemaToJson.test.ts

@@ -0,0 +1,107 @@
+import { describe, test, expect } from "@jest/globals";
+import { z } from "zod";
+import {
+  isZodSchema,
+  zodSchemaToJsonSchema,
+  looksLikeZodShape,
+} from "../../../utils/zodSchemaToJson";
+
+describe("zodSchemaToJson utility", () => {
+  test("isZodSchema detects Zod schemas and rejects non-Zod values", () => {
+    expect(isZodSchema(z.object({ name: z.string() }))).toBe(true);
+    expect(isZodSchema(z.string())).toBe(true);
+    expect(isZodSchema(z.number())).toBe(true);
+    expect(isZodSchema(z.array(z.string()))).toBe(true);
+    expect(isZodSchema(z.enum(["A", "B"]))).toBe(true);
+    expect(isZodSchema(z.union([z.string(), z.number()]))).toBe(true);
+    expect(isZodSchema(z.string().optional())).toBe(true);
+    expect(isZodSchema(z.string().nullable())).toBe(true);
+
+    expect(isZodSchema(null)).toBe(false);
+    expect(isZodSchema(undefined)).toBe(false);
+    expect(isZodSchema({ name: "test" })).toBe(false);
+    expect(isZodSchema({ type: "object", properties: {} })).toBe(false);
+    expect(isZodSchema("string")).toBe(false);
+    expect(isZodSchema(42)).toBe(false);
+    expect(isZodSchema([1, 2, 3])).toBe(false);
+  });
+
+  test("zodSchemaToJsonSchema converts Zod schemas to JSON Schema", () => {
+    const simpleSchema = z.object({ name: z.string() });
+    const simpleResult = zodSchemaToJsonSchema(simpleSchema) as Record<string, unknown>;
+    expect(simpleResult.type).toBe("object");
+    expect(simpleResult.properties).toBeDefined();
+    expect((simpleResult.properties as Record<string, unknown>).name).toBeDefined();
+
+    const complexSchema = z.object({
+      id: z.string().uuid(),
+      name: z.string().min(1).max(100),
+      age: z.number().min(0).max(150).optional(),
+      tags: z.array(z.string()),
+      status: z.enum(["active", "inactive"]),
+      metadata: z.object({
+        createdAt: z.string(),
+        nested: z.object({ value: z.number() }),
+      }),
+    });
+    const complexResult = zodSchemaToJsonSchema(complexSchema) as Record<string, unknown>;
+    expect(complexResult.type).toBe("object");
+    expect(complexResult.properties).toBeDefined();
+    expect(complexResult.required).toContain("id");
+    expect(complexResult.required).not.toContain("age");
+
+    const enumResult = zodSchemaToJsonSchema(z.enum(["a", "b", "c"])) as Record<string, unknown>;
+    expect(enumResult.enum).toEqual(["a", "b", "c"]);
+
+    const arrayResult = zodSchemaToJsonSchema(z.array(z.number())) as Record<string, unknown>;
+    expect(arrayResult.type).toBe("array");
+    expect(arrayResult.items).toBeDefined();
+  });
+
+  test("zodSchemaToJsonSchema passes through non-Zod values unchanged", () => {
+    const jsonSchema = { type: "object", properties: { name: { type: "string" } } };
+    expect(zodSchemaToJsonSchema(jsonSchema)).toEqual(jsonSchema);
+    expect(zodSchemaToJsonSchema(null)).toBe(null);
+    expect(zodSchemaToJsonSchema(undefined)).toBe(undefined);
+    expect(zodSchemaToJsonSchema("string")).toBe("string");
+    expect(zodSchemaToJsonSchema(42)).toBe(42);
+    expect(zodSchemaToJsonSchema({ foo: "bar" })).toEqual({ foo: "bar" });
+  });
+
+  test("looksLikeZodShape detects .shape property misuse", () => {
+    const schema = z.object({ title: z.string(), count: z.number() });
+    expect(looksLikeZodShape(schema.shape)).toBe(true);
+    expect(looksLikeZodShape(schema)).toBe(false);
+    expect(looksLikeZodShape(null)).toBe(false);
+    expect(looksLikeZodShape(undefined)).toBe(false);
+    expect(looksLikeZodShape({ name: "test" })).toBe(false);
+    expect(looksLikeZodShape({})).toBe(false);
+    expect(looksLikeZodShape([1, 2, 3])).toBe(false);
+    expect(looksLikeZodShape({ type: "object", properties: {} })).toBe(false);
+  });
+
+  test("SDK-like usage: convert Zod schema or pass through JSON schema", () => {
+    const zodSchema = z.object({
+      name: z.string(),
+      email: z.string().email(),
+      age: z.number().min(0),
+    });
+
+    if (isZodSchema(zodSchema)) {
+      const result = zodSchemaToJsonSchema(zodSchema) as Record<string, unknown>;
+      expect(result.type).toBe("object");
+      expect(result.properties).toBeDefined();
+    } else {
+      throw new Error("Should detect Zod schema");
+    }
+
+    const existingJsonSchema = {
+      type: "object" as const,
+      properties: { title: { type: "string" as const } },
+      required: ["title"] as string[],
+    };
+
+    expect(isZodSchema(existingJsonSchema)).toBe(false);
+    expect(zodSchemaToJsonSchema(existingJsonSchema)).toEqual(existingJsonSchema);
+  });
+});

package/src/utils/zodSchemaToJson.ts

@@ -0,0 +1,67 @@
+import { zodToJsonSchema as zodToJsonSchemaLib } from "zod-to-json-schema";
+
+type SchemaConverter = (schema: unknown) => unknown;
+
+export function isZodSchema(value: unknown): boolean {
+  if (!value || typeof value !== "object") return false;
+  const schema = value as Record<string, unknown>;
+
+  const hasV3Markers =
+    "_def" in schema &&
+    (typeof schema.safeParse === "function" ||
+      typeof schema.parse === "function");
+
+  const hasV4Markers = "_zod" in schema && typeof schema._zod === "object";
+
+  return hasV3Markers || hasV4Markers;
+}
+
+function isZodV4Schema(schema: unknown): boolean {
+  if (!schema || typeof schema !== "object") return false;
+  return "_zod" in schema && typeof (schema as Record<string, unknown>)._zod === "object";
+}
+
+function tryZodV4Conversion(schema: unknown): Record<string, unknown> | null {
+  if (!isZodV4Schema(schema)) return null;
+
+  try {
+    const zodModule = (schema as Record<string, unknown>).constructor?.prototype?.constructor;
+    if (zodModule && typeof (zodModule as Record<string, unknown>).toJSONSchema === "function") {
+      return (zodModule as { toJSONSchema: SchemaConverter }).toJSONSchema(schema) as Record<string, unknown>;
+    }
+  } catch {
+    // V4 conversion not available
+  }
+
+  return null;
+}
+
+export function zodSchemaToJsonSchema(schema: unknown): Record<string, unknown> | unknown {
+  if (!isZodSchema(schema)) {
+    return schema;
+  }
+
+  const v4Result = tryZodV4Conversion(schema);
+  if (v4Result) {
+    return v4Result;
+  }
+
+  try {
+    return zodToJsonSchemaLib(schema as Parameters<typeof zodToJsonSchemaLib>[0]) as Record<string, unknown>;
+  } catch {
+    return schema;
+  }
+}
+
+export function looksLikeZodShape(obj: unknown): boolean {
+  if (!obj || typeof obj !== "object" || Array.isArray(obj)) return false;
+  const values = Object.values(obj);
+  if (values.length === 0) return false;
+  return values.some(
+    (v) =>
+      v &&
+      typeof v === "object" &&
+      (v as Record<string, unknown>)._def &&
+      typeof (v as Record<string, unknown>).safeParse === "function"
+  );
+}

package/src/v1/index.ts

@@ -1,6 +1,6 @@
 import axios, { type AxiosResponse, type AxiosRequestHeaders, AxiosError } from "axios";
 import * as zt from "zod";
-import { zodToJsonSchema } from "zod-to-json-schema";
+import { zodSchemaToJsonSchema } from "../utils/zodSchemaToJson";
 import { TypedEventTarget } from "typescript-event-target";
 
 /**
@@ -707,36 +707,21 @@ export default class FirecrawlApp {
     } as AxiosRequestHeaders;
     let jsonData: any = { url, ...params, origin: typeof (params as any).origin === "string" && (params as any).origin.includes("mcp") ? (params as any).origin : `js-sdk@${this.version}` };
     if (jsonData?.extract?.schema) {
-      let schema = jsonData.extract.schema;
-
-      // Try parsing the schema as a Zod schema
-      try {
-        schema = zodToJsonSchema(schema);
-      } catch (error) {
-        
-      }
       jsonData = {
         ...jsonData,
         extract: {
           ...jsonData.extract,
-          schema: schema,
+          schema: zodSchemaToJsonSchema(jsonData.extract.schema),
         },
       };
     }
 
     if (jsonData?.jsonOptions?.schema) {
-      let schema = jsonData.jsonOptions.schema;
-      // Try parsing the schema as a Zod schema
-      try {
-        schema = zodToJsonSchema(schema);
-      } catch (error) {
-        
-      }
       jsonData = {
         ...jsonData,
         jsonOptions: {
           ...jsonData.jsonOptions,
-          schema: schema,
+          schema: zodSchemaToJsonSchema(jsonData.jsonOptions.schema),
         },
       };
     }
@@ -793,21 +778,13 @@ export default class FirecrawlApp {
     };
 
     if (jsonData?.scrapeOptions?.extract?.schema) {
-      let schema = jsonData.scrapeOptions.extract.schema;
-
-      // Try parsing the schema as a Zod schema
-      try {
-        schema = zodToJsonSchema(schema);
-      } catch (error) {
-        
-      }
       jsonData = {
         ...jsonData,
         scrapeOptions: {
           ...jsonData.scrapeOptions,
           extract: {
             ...jsonData.scrapeOptions.extract,
-            schema: schema,
+            schema: zodSchemaToJsonSchema(jsonData.scrapeOptions.extract.schema),
           },
         },
       };
@@ -1105,36 +1082,20 @@ export default class FirecrawlApp {
     const headers = this.prepareHeaders(idempotencyKey);
     let jsonData: any = { urls, webhook, ignoreInvalidURLs, maxConcurrency, ...params, origin: typeof (params as any).origin === "string" && (params as any).origin.includes("mcp") ? (params as any).origin : `js-sdk@${this.version}` };
     if (jsonData?.extract?.schema) {
-      let schema = jsonData.extract.schema;
-
-      // Try parsing the schema as a Zod schema
-      try {
-        schema = zodToJsonSchema(schema);
-      } catch (error) {
-        
-      }
       jsonData = {
         ...jsonData,
         extract: {
           ...jsonData.extract,
-          schema: schema,
+          schema: zodSchemaToJsonSchema(jsonData.extract.schema),
         },
       };
     }
     if (jsonData?.jsonOptions?.schema) {
-      let schema = jsonData.jsonOptions.schema;
-
-      // Try parsing the schema as a Zod schema
-      try {
-        schema = zodToJsonSchema(schema);
-      } catch (error) {
-        
-      }
       jsonData = {
         ...jsonData,
         jsonOptions: {
           ...jsonData.jsonOptions,
-          schema: schema,
+          schema: zodSchemaToJsonSchema(jsonData.jsonOptions.schema),
         },
       };
     }
@@ -1326,20 +1287,7 @@ export default class FirecrawlApp {
     const headers = this.prepareHeaders();
 
     let jsonData: { urls?: string[] } & ExtractParams<T> = { urls: urls,  ...params };
-    let jsonSchema: any;
-    try {
-      if (!params?.schema) {
-        jsonSchema = undefined;
-      } else {
-        try {
-          jsonSchema = zodToJsonSchema(params.schema as zt.ZodType);
-        } catch (_) {
-          jsonSchema = params.schema;
-        }
-      }
-    } catch (error: any) {
-      throw new FirecrawlError("Invalid schema. Schema must be either a valid Zod schema or JSON schema object.", 400);
-    }
+    const jsonSchema = params?.schema ? zodSchemaToJsonSchema(params.schema) : undefined;
     
     try {
       const response: AxiosResponse = await this.postRequest(
@@ -1396,22 +1344,8 @@ export default class FirecrawlApp {
     idempotencyKey?: string
   ): Promise<ExtractResponse | ErrorResponse> {
     const headers = this.prepareHeaders(idempotencyKey);
-    let jsonData: any = { urls, ...params };
-    let jsonSchema: any;
-
-    try {
-      if (!params?.schema) {
-        jsonSchema = undefined;
-      } else {
-        try {
-          jsonSchema = zodToJsonSchema(params.schema as zt.ZodType);
-        } catch (_) {
-          jsonSchema = params.schema;
-        }
-      }
-    } catch (error: any) {
-      throw new FirecrawlError("Invalid schema. Schema must be either a valid Zod schema or JSON schema object.", 400);
-    }
+    const jsonData: any = { urls, ...params };
+    const jsonSchema = params?.schema ? zodSchemaToJsonSchema(params.schema) : undefined;
 
     try {
       const response: AxiosResponse = await this.postRequest(
@@ -1780,18 +1714,11 @@ export default class FirecrawlApp {
     let jsonData: any = { query, ...params, origin: typeof (params as any).origin === "string" && (params as any).origin.includes("mcp") ? (params as any).origin : `js-sdk@${this.version}` };
 
     if (jsonData?.jsonOptions?.schema) {
-      let schema = jsonData.jsonOptions.schema;
-      // Try parsing the schema as a Zod schema
-      try {
-        schema = zodToJsonSchema(schema);
-      } catch (error) {
-        // Ignore error if schema can't be parsed as Zod
-      }
       jsonData = {
         ...jsonData,
         jsonOptions: {
           ...jsonData.jsonOptions,
-          schema: schema,
+          schema: zodSchemaToJsonSchema(jsonData.jsonOptions.schema),
         },
       };
     }

package/src/v2/methods/agent.ts

@@ -1,7 +1,7 @@
 import { type AgentResponse, type AgentStatusResponse, type AgentWebhookConfig } from "../types";
 import { HttpClient } from "../utils/httpClient";
 import { normalizeAxiosError, throwForBadResponse } from "../utils/errorHandler";
-import { zodToJsonSchema } from "zod-to-json-schema";
+import { isZodSchema, zodSchemaToJsonSchema } from "../../utils/zodSchemaToJson";
 import type { ZodTypeAny } from "zod";
 
 function prepareAgentPayload(args: {
@@ -18,9 +18,7 @@ function prepareAgentPayload(args: {
   if (args.urls) body.urls = args.urls;
   body.prompt = args.prompt;
   if (args.schema != null) {
-    const s: any = args.schema;
-    const isZod = s && (typeof s.safeParse === "function" || typeof s.parse === "function") && s._def;
-    body.schema = isZod ? zodToJsonSchema(s) : args.schema;
+    body.schema = isZodSchema(args.schema) ? zodSchemaToJsonSchema(args.schema) : args.schema;
   }
   if (args.integration && args.integration.trim()) body.integration = args.integration.trim();
   if (args.maxCredits !== null && args.maxCredits !== undefined) body.maxCredits = args.maxCredits;

package/src/v2/methods/extract.ts

@@ -2,7 +2,7 @@ import { type ExtractResponse, type ScrapeOptions, type AgentOptions } from "../
 import { HttpClient } from "../utils/httpClient";
 import { ensureValidScrapeOptions } from "../utils/validation";
 import { normalizeAxiosError, throwForBadResponse } from "../utils/errorHandler";
-import { zodToJsonSchema } from "zod-to-json-schema";
+import { isZodSchema, zodSchemaToJsonSchema } from "../../utils/zodSchemaToJson";
 import type { ZodTypeAny } from "zod";
 
 function prepareExtractPayload(args: {
@@ -22,9 +22,7 @@ function prepareExtractPayload(args: {
   if (args.urls) body.urls = args.urls;
   if (args.prompt != null) body.prompt = args.prompt;
   if (args.schema != null) {
-    const s: any = args.schema;
-    const isZod = s && (typeof s.safeParse === "function" || typeof s.parse === "function") && s._def;
-    body.schema = isZod ? zodToJsonSchema(s) : args.schema;
+    body.schema = isZodSchema(args.schema) ? zodSchemaToJsonSchema(args.schema) : args.schema;
   }
   if (args.systemPrompt != null) body.systemPrompt = args.systemPrompt;
   if (args.allowExternalLinks != null) body.allowExternalLinks = args.allowExternalLinks;

package/src/v2/utils/validation.ts

@@ -1,18 +1,5 @@
 import { type FormatOption, type JsonFormat, type ScrapeOptions, type ScreenshotFormat, type ChangeTrackingFormat } from "../types";
-import { zodToJsonSchema } from "zod-to-json-schema";
-
-/**
- * Detects if an object looks like a Zod schema's `.shape` property.
- * When users mistakenly pass `schema.shape` instead of `schema`, the object
- * will have Zod types as values but won't be a Zod schema itself.
- */
-function looksLikeZodShape(obj: unknown): boolean {
-  if (!obj || typeof obj !== "object" || Array.isArray(obj)) return false;
-  const values = Object.values(obj);
-  if (values.length === 0) return false;
-  // Check if at least one value looks like a Zod type
-  return values.some((v: any) => v && typeof v === "object" && v._def && typeof v.safeParse === "function");
-}
+import { isZodSchema, zodSchemaToJsonSchema, looksLikeZodShape } from "../../utils/zodSchemaToJson";
 
 export function ensureValidFormats(formats?: FormatOption[]): void {
   if (!formats) return;
@@ -28,17 +15,10 @@ export function ensureValidFormats(formats?: FormatOption[]): void {
       if (!j.prompt && !j.schema) {
         throw new Error("json format requires either 'prompt' or 'schema' (or both)");
       }
-      // Flexibility: allow passing a Zod schema. Convert to JSON schema internally.
-      const maybeSchema: any = j.schema as any;
-      const isZod = !!maybeSchema && (typeof maybeSchema.safeParse === "function" || typeof maybeSchema.parse === "function") && !!maybeSchema._def;
-      if (isZod) {
-        try {
-          (j as any).schema = zodToJsonSchema(maybeSchema);
-        } catch {
-          // If conversion fails, leave as-is; server-side may still handle, or request will fail explicitly
-        }
+      const maybeSchema = j.schema;
+      if (isZodSchema(maybeSchema)) {
+        (j as any).schema = zodSchemaToJsonSchema(maybeSchema);
       } else if (looksLikeZodShape(maybeSchema)) {
-        // User likely passed schema.shape instead of the schema itself
         throw new Error(
           "json format schema appears to be a Zod schema's .shape property. " +
           "Pass the Zod schema directly (e.g., `schema: MySchema`) instead of `schema: MySchema.shape`. " +
@@ -49,14 +29,9 @@ export function ensureValidFormats(formats?: FormatOption[]): void {
     }
     if ((fmt as ChangeTrackingFormat).type === "changeTracking") {
       const ct = fmt as ChangeTrackingFormat;
-      const maybeSchema: any = ct.schema as any;
-      const isZod = !!maybeSchema && (typeof maybeSchema.safeParse === "function" || typeof maybeSchema.parse === "function") && !!maybeSchema._def;
-      if (isZod) {
-        try {
-          (ct as any).schema = zodToJsonSchema(maybeSchema);
-        } catch {
-          // Best-effort conversion; if it fails, leave original value
-        }
+      const maybeSchema = ct.schema;
+      if (isZodSchema(maybeSchema)) {
+        (ct as any).schema = zodSchemaToJsonSchema(maybeSchema);
       } else if (looksLikeZodShape(maybeSchema)) {
         throw new Error(
           "changeTracking format schema appears to be a Zod schema's .shape property. " +