@mendable/firecrawl 4.11.1 → 4.11.3

package/dist/{chunk-SHZTLDEM.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.1",
+      version: "4.11.3",
       description: "JavaScript SDK for Firecrawl API",
       main: "dist/index.js",
       types: "dist/index.d.ts",
@@ -22,8 +22,8 @@ var require_package = __commonJS({
       type: "module",
       scripts: {
         build: "tsup",
-        "build-and-publish": "npm run build && npm publish --access public",
-        "publish-beta": "npm run build && npm publish --access public --tag beta",
+        "build-and-publish": "pnpm run build && pnpm publish --access public",
+        "publish-beta": "pnpm run build && pnpm publish --access public --tag beta",
         test: "NODE_OPTIONS=--experimental-vm-modules jest --verbose src/__tests__/e2e/v2/*.test.ts --detectOpenHandles",
         "test:unit": "NODE_OPTIONS=--experimental-vm-modules jest --verbose src/__tests__/unit/v2/*.test.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.1",
+      version: "4.11.3",
       description: "JavaScript SDK for Firecrawl API",
       main: "dist/index.js",
       types: "dist/index.d.ts",
@@ -49,8 +49,8 @@ var require_package = __commonJS({
       type: "module",
       scripts: {
         build: "tsup",
-        "build-and-publish": "npm run build && npm publish --access public",
-        "publish-beta": "npm run build && npm publish --access public --tag beta",
+        "build-and-publish": "pnpm run build && pnpm publish --access public",
+        "publish-beta": "pnpm run build && pnpm publish --access public --tag beta",
         test: "NODE_OPTIONS=--experimental-vm-modules jest --verbose src/__tests__/e2e/v2/*.test.ts --detectOpenHandles",
         "test:unit": "NODE_OPTIONS=--experimental-vm-modules jest --verbose src/__tests__/unit/v2/*.test.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,20 +870,18 @@ 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;
   if (args.strictConstrainToURLs !== null && args.strictConstrainToURLs !== void 0) body.strictConstrainToURLs = args.strictConstrainToURLs;
   if (args.model !== null && args.model !== void 0) body.model = args.model;
+  if (args.webhook != null) body.webhook = args.webhook;
   return body;
 }
 async function startAgent(http, args) {
@@ -1436,9 +1463,8 @@ 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/typescript-event-target/dist/index.mjs
+// node_modules/.pnpm/typescript-event-target@1.1.1/node_modules/typescript-event-target/dist/index.mjs
 var e = class extends EventTarget {
   dispatchTypedEvent(s, t) {
     return super.dispatchEvent(t);
@@ -1506,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)
         }
       };
     }
@@ -1583,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)
           }
         }
       };
@@ -1852,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)
         }
       };
     }
@@ -2041,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`,
@@ -2104,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`,
@@ -2400,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.d.cts

@@ -122,6 +122,13 @@ interface WebhookConfig {
     metadata?: Record<string, string>;
     events?: Array<'completed' | 'failed' | 'page' | 'started'>;
 }
+type AgentWebhookEvent = 'started' | 'action' | 'completed' | 'failed' | 'cancelled';
+interface AgentWebhookConfig {
+    url: string;
+    headers?: Record<string, string>;
+    metadata?: Record<string, string>;
+    events?: AgentWebhookEvent[];
+}
 interface BrandingProfile {
     colorScheme?: 'light' | 'dark';
     logo?: string | null;
@@ -594,6 +601,7 @@ declare function prepareAgentPayload(args: {
     maxCredits?: number;
     strictConstrainToURLs?: boolean;
     model?: "spark-1-pro" | "spark-1-mini";
+    webhook?: string | AgentWebhookConfig;
 }): Record<string, unknown>;
 declare function startAgent(http: HttpClient, args: Parameters<typeof prepareAgentPayload>[0]): Promise<AgentResponse>;
 
@@ -1727,4 +1735,4 @@ declare class Firecrawl extends FirecrawlClient {
     get v1(): FirecrawlApp;
 }
 
-export { type ActionOption, type ActiveCrawl, type ActiveCrawlsResponse, type AgentOptions$1 as AgentOptions, type AgentResponse, type AgentStatusResponse, type AttributesFormat, type BatchScrapeJob, type BatchScrapeOptions, type BatchScrapeResponse$1 as BatchScrapeResponse, type BrandingProfile, type CategoryOption, type ChangeTrackingFormat, type ClickAction, type ConcurrencyCheck, type CrawlErrorsResponse$1 as CrawlErrorsResponse, type CrawlJob, type CrawlOptions, type CrawlResponse$1 as CrawlResponse, type CreditUsage, type CreditUsageHistoricalPeriod, type CreditUsageHistoricalResponse, type Document, type DocumentMetadata, type ErrorDetails, type ExecuteJavascriptAction, type ExtractResponse$1 as ExtractResponse, Firecrawl, FirecrawlApp as FirecrawlAppV1, FirecrawlClient, type FirecrawlClientOptions, type Format, type FormatOption, type FormatString, JobTimeoutError, type JsonFormat, type LocationConfig$1 as LocationConfig, type MapData, type MapOptions, type PDFAction, type PaginationConfig, type PressAction, type QueueStatusResponse$1 as QueueStatusResponse, type ScrapeAction, type ScrapeOptions, type ScreenshotAction, type ScreenshotFormat, type ScrollAction, SdkError, type SearchData, type SearchRequest, type SearchResultImages, type SearchResultNews, type SearchResultWeb, type TokenUsage, type TokenUsageHistoricalPeriod, type TokenUsageHistoricalResponse, type Viewport, type WaitAction, type WebhookConfig, type WriteAction, Firecrawl as default };
+export { type ActionOption, type ActiveCrawl, type ActiveCrawlsResponse, type AgentOptions$1 as AgentOptions, type AgentResponse, type AgentStatusResponse, type AgentWebhookConfig, type AgentWebhookEvent, type AttributesFormat, type BatchScrapeJob, type BatchScrapeOptions, type BatchScrapeResponse$1 as BatchScrapeResponse, type BrandingProfile, type CategoryOption, type ChangeTrackingFormat, type ClickAction, type ConcurrencyCheck, type CrawlErrorsResponse$1 as CrawlErrorsResponse, type CrawlJob, type CrawlOptions, type CrawlResponse$1 as CrawlResponse, type CreditUsage, type CreditUsageHistoricalPeriod, type CreditUsageHistoricalResponse, type Document, type DocumentMetadata, type ErrorDetails, type ExecuteJavascriptAction, type ExtractResponse$1 as ExtractResponse, Firecrawl, FirecrawlApp as FirecrawlAppV1, FirecrawlClient, type FirecrawlClientOptions, type Format, type FormatOption, type FormatString, JobTimeoutError, type JsonFormat, type LocationConfig$1 as LocationConfig, type MapData, type MapOptions, type PDFAction, type PaginationConfig, type PressAction, type QueueStatusResponse$1 as QueueStatusResponse, type ScrapeAction, type ScrapeOptions, type ScreenshotAction, type ScreenshotFormat, type ScrollAction, SdkError, type SearchData, type SearchRequest, type SearchResultImages, type SearchResultNews, type SearchResultWeb, type TokenUsage, type TokenUsageHistoricalPeriod, type TokenUsageHistoricalResponse, type Viewport, type WaitAction, type WebhookConfig, type WriteAction, Firecrawl as default };

package/dist/index.d.ts

@@ -122,6 +122,13 @@ interface WebhookConfig {
     metadata?: Record<string, string>;
     events?: Array<'completed' | 'failed' | 'page' | 'started'>;
 }
+type AgentWebhookEvent = 'started' | 'action' | 'completed' | 'failed' | 'cancelled';
+interface AgentWebhookConfig {
+    url: string;
+    headers?: Record<string, string>;
+    metadata?: Record<string, string>;
+    events?: AgentWebhookEvent[];
+}
 interface BrandingProfile {
     colorScheme?: 'light' | 'dark';
     logo?: string | null;
@@ -594,6 +601,7 @@ declare function prepareAgentPayload(args: {
     maxCredits?: number;
     strictConstrainToURLs?: boolean;
     model?: "spark-1-pro" | "spark-1-mini";
+    webhook?: string | AgentWebhookConfig;
 }): Record<string, unknown>;
 declare function startAgent(http: HttpClient, args: Parameters<typeof prepareAgentPayload>[0]): Promise<AgentResponse>;
 
@@ -1727,4 +1735,4 @@ declare class Firecrawl extends FirecrawlClient {
     get v1(): FirecrawlApp;
 }
 
-export { type ActionOption, type ActiveCrawl, type ActiveCrawlsResponse, type AgentOptions$1 as AgentOptions, type AgentResponse, type AgentStatusResponse, type AttributesFormat, type BatchScrapeJob, type BatchScrapeOptions, type BatchScrapeResponse$1 as BatchScrapeResponse, type BrandingProfile, type CategoryOption, type ChangeTrackingFormat, type ClickAction, type ConcurrencyCheck, type CrawlErrorsResponse$1 as CrawlErrorsResponse, type CrawlJob, type CrawlOptions, type CrawlResponse$1 as CrawlResponse, type CreditUsage, type CreditUsageHistoricalPeriod, type CreditUsageHistoricalResponse, type Document, type DocumentMetadata, type ErrorDetails, type ExecuteJavascriptAction, type ExtractResponse$1 as ExtractResponse, Firecrawl, FirecrawlApp as FirecrawlAppV1, FirecrawlClient, type FirecrawlClientOptions, type Format, type FormatOption, type FormatString, JobTimeoutError, type JsonFormat, type LocationConfig$1 as LocationConfig, type MapData, type MapOptions, type PDFAction, type PaginationConfig, type PressAction, type QueueStatusResponse$1 as QueueStatusResponse, type ScrapeAction, type ScrapeOptions, type ScreenshotAction, type ScreenshotFormat, type ScrollAction, SdkError, type SearchData, type SearchRequest, type SearchResultImages, type SearchResultNews, type SearchResultWeb, type TokenUsage, type TokenUsageHistoricalPeriod, type TokenUsageHistoricalResponse, type Viewport, type WaitAction, type WebhookConfig, type WriteAction, Firecrawl as default };
+export { type ActionOption, type ActiveCrawl, type ActiveCrawlsResponse, type AgentOptions$1 as AgentOptions, type AgentResponse, type AgentStatusResponse, type AgentWebhookConfig, type AgentWebhookEvent, type AttributesFormat, type BatchScrapeJob, type BatchScrapeOptions, type BatchScrapeResponse$1 as BatchScrapeResponse, type BrandingProfile, type CategoryOption, type ChangeTrackingFormat, type ClickAction, type ConcurrencyCheck, type CrawlErrorsResponse$1 as CrawlErrorsResponse, type CrawlJob, type CrawlOptions, type CrawlResponse$1 as CrawlResponse, type CreditUsage, type CreditUsageHistoricalPeriod, type CreditUsageHistoricalResponse, type Document, type DocumentMetadata, type ErrorDetails, type ExecuteJavascriptAction, type ExtractResponse$1 as ExtractResponse, Firecrawl, FirecrawlApp as FirecrawlAppV1, FirecrawlClient, type FirecrawlClientOptions, type Format, type FormatOption, type FormatString, JobTimeoutError, type JsonFormat, type LocationConfig$1 as LocationConfig, type MapData, type MapOptions, type PDFAction, type PaginationConfig, type PressAction, type QueueStatusResponse$1 as QueueStatusResponse, type ScrapeAction, type ScrapeOptions, type ScreenshotAction, type ScreenshotFormat, type ScrollAction, SdkError, type SearchData, type SearchRequest, type SearchResultImages, type SearchResultNews, type SearchResultWeb, type TokenUsage, type TokenUsageHistoricalPeriod, type TokenUsageHistoricalResponse, type Viewport, type WaitAction, type WebhookConfig, type WriteAction, Firecrawl as default };

package/dist/index.js

@@ -1,6 +1,6 @@
 import {
   require_package
-} from "./chunk-SHZTLDEM.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,20 +751,18 @@ 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;
   if (args.strictConstrainToURLs !== null && args.strictConstrainToURLs !== void 0) body.strictConstrainToURLs = args.strictConstrainToURLs;
   if (args.model !== null && args.model !== void 0) body.model = args.model;
+  if (args.webhook != null) body.webhook = args.webhook;
   return body;
 }
 async function startAgent(http, args) {
@@ -1317,9 +1344,8 @@ 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/typescript-event-target/dist/index.mjs
+// node_modules/.pnpm/typescript-event-target@1.1.1/node_modules/typescript-event-target/dist/index.mjs
 var e = class extends EventTarget {
   dispatchTypedEvent(s, t) {
     return super.dispatchEvent(t);
@@ -1348,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-LM7L2L66.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);
@@ -1387,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)
         }
       };
     }
@@ -1464,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)
           }
         }
       };
@@ -1733,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)
         }
       };
     }
@@ -1922,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`,
@@ -1985,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`,
@@ -2281,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-LM7L2L66.js → package-3BZQ6TAW.js}

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

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mendable/firecrawl",
-  "version": "4.11.1",
+  "version": "4.11.3",
   "description": "JavaScript SDK for Firecrawl API",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
@@ -12,13 +12,6 @@
     }
   },
   "type": "module",
-  "scripts": {
-    "build": "tsup",
-    "build-and-publish": "npm run build && npm publish --access public",
-    "publish-beta": "npm run build && npm publish --access public --tag beta",
-    "test": "NODE_OPTIONS=--experimental-vm-modules jest --verbose src/__tests__/e2e/v2/*.test.ts --detectOpenHandles",
-    "test:unit": "NODE_OPTIONS=--experimental-vm-modules jest --verbose src/__tests__/unit/v2/*.test.ts"
-  },
   "repository": {
     "type": "git",
     "url": "git+https://github.com/firecrawl/firecrawl.git"
@@ -61,13 +54,11 @@
   "engines": {
     "node": ">=22.0.0"
   },
-  "pnpm": {
-    "overrides": {
-      "@babel/helpers@<7.26.10": ">=7.26.10",
-      "brace-expansion@>=1.0.0 <=1.1.11": ">=1.1.12",
-      "brace-expansion@>=2.0.0 <=2.0.1": ">=2.0.2",
-      "js-yaml@<3.14.2": ">=3.14.2",
-      "glob@>=10.2.0 <10.5.0": ">=10.5.0"
-    }
+  "scripts": {
+    "build": "tsup",
+    "build-and-publish": "pnpm run build && pnpm publish --access public",
+    "publish-beta": "pnpm run build && pnpm publish --access public --tag beta",
+    "test": "NODE_OPTIONS=--experimental-vm-modules jest --verbose src/__tests__/e2e/v2/*.test.ts --detectOpenHandles",
+    "test:unit": "NODE_OPTIONS=--experimental-vm-modules jest --verbose src/__tests__/unit/v2/*.test.ts"
   }
-}
+}

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

@@ -0,0 +1,80 @@
+import { describe, test, expect } from "@jest/globals";
+
+// We need to test the prepareAgentPayload function, but it's not exported.
+// Since the function is internal, we'll test the behavior through type checking
+// and verify the types are properly exported.
+
+import type { AgentWebhookConfig, AgentWebhookEvent } from "../../../v2/types";
+
+describe("v2 types: Agent webhook types", () => {
+  test("AgentWebhookConfig accepts string webhook", () => {
+    // Type check - this should compile without errors
+    const webhook: string | AgentWebhookConfig = "https://example.com/webhook";
+    expect(typeof webhook).toBe("string");
+  });
+
+  test("AgentWebhookConfig accepts config object", () => {
+    const config: AgentWebhookConfig = {
+      url: "https://example.com/webhook",
+      headers: { Authorization: "Bearer token" },
+      events: ["completed", "failed"],
+    };
+    expect(config.url).toBe("https://example.com/webhook");
+    expect(config.headers).toEqual({ Authorization: "Bearer token" });
+    expect(config.events).toEqual(["completed", "failed"]);
+  });
+
+  test("AgentWebhookConfig accepts minimal config", () => {
+    const config: AgentWebhookConfig = {
+      url: "https://example.com/webhook",
+    };
+    expect(config.url).toBe("https://example.com/webhook");
+    expect(config.headers).toBeUndefined();
+    expect(config.metadata).toBeUndefined();
+    expect(config.events).toBeUndefined();
+  });
+
+  test("AgentWebhookEvent includes agent-specific events", () => {
+    const events: AgentWebhookEvent[] = [
+      "started",
+      "action",
+      "completed",
+      "failed",
+      "cancelled",
+    ];
+    expect(events).toContain("action");
+    expect(events).toContain("cancelled");
+    expect(events.length).toBe(5);
+  });
+
+  test("AgentWebhookConfig accepts all fields", () => {
+    const config: AgentWebhookConfig = {
+      url: "https://example.com/webhook",
+      headers: {
+        Authorization: "Bearer token",
+        "X-Custom-Header": "value",
+      },
+      metadata: {
+        project: "test",
+        environment: "staging",
+      },
+      events: ["started", "action", "completed", "failed", "cancelled"],
+    };
+    expect(config.url).toBe("https://example.com/webhook");
+    expect(Object.keys(config.headers!).length).toBe(2);
+    expect(config.metadata!.project).toBe("test");
+    expect(config.events!.length).toBe(5);
+  });
+
+  test("AgentWebhookConfig events are agent-specific (not crawl)", () => {
+    // Agent has 'action' and 'cancelled', but not 'page'
+    const config: AgentWebhookConfig = {
+      url: "https://example.com/webhook",
+      events: ["action", "cancelled"],
+    };
+    expect(config.events).toContain("action");
+    expect(config.events).toContain("cancelled");
+    // 'page' is a crawl-specific event, not valid for agent
+    // This is enforced at the type level
+  });
+});

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 } from "../types";
+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: {
@@ -12,19 +12,19 @@ function prepareAgentPayload(args: {
   maxCredits?: number;
   strictConstrainToURLs?: boolean;
   model?: "spark-1-pro" | "spark-1-mini";
+  webhook?: string | AgentWebhookConfig;
 }): Record<string, unknown> {
   const body: Record<string, unknown> = {};
   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;
   if (args.strictConstrainToURLs !== null && args.strictConstrainToURLs !== undefined) body.strictConstrainToURLs = args.strictConstrainToURLs;
   if (args.model !== null && args.model !== undefined) body.model = args.model;
+  if (args.webhook != null) body.webhook = args.webhook;
   return body;
 }
 

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/types.ts

@@ -167,6 +167,16 @@ export interface WebhookConfig {
   events?: Array<'completed' | 'failed' | 'page' | 'started'>;
 }
 
+// Agent webhook events differ from crawl: has 'action' and 'cancelled', no 'page'
+export type AgentWebhookEvent = 'started' | 'action' | 'completed' | 'failed' | 'cancelled';
+
+export interface AgentWebhookConfig {
+  url: string;
+  headers?: Record<string, string>;
+  metadata?: Record<string, string>;
+  events?: AgentWebhookEvent[];
+}
+
 export interface BrandingProfile {
   colorScheme?: 'light' | 'dark';
   logo?: string | null;

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. " +