firecrawl 4.44.1 → 4.46.0

package/src/__tests__/e2e/v2/search.test.ts

@@ -6,7 +6,7 @@ import type { Document, SearchResultWeb, SearchResultNews, SearchResultImages }
 import { config } from "dotenv";
 import { getIdentity, getApiUrl } from "./utils/idmux";
 import { testTimeoutMs, withRateLimitRetry } from "./utils/rateLimit";
-import { describe, test, expect, beforeAll } from "@jest/globals";
+import { describe, test, expect, beforeAll } from "vitest";
 
 config();
 

package/src/__tests__/e2e/v2/usage.test.ts

@@ -5,7 +5,7 @@ import Firecrawl from "../../../index";
 import { config } from "dotenv";
 import { getIdentity, getApiUrl } from "./utils/idmux";
 import { testTimeoutMs, withRateLimitRetry } from "./utils/rateLimit";
-import { describe, test, expect, beforeAll } from "@jest/globals";
+import { describe, test, expect, beforeAll } from "vitest";
 
 config();
 

package/src/__tests__/e2e/v2/utils/rateLimit.ts

@@ -52,7 +52,7 @@ export const RETRY_BUDGET_MS = (MAX_ATTEMPTS - 1) * MAX_WAIT_MS;
  *
  * Every caller now passes its own timeout, sized to the work it waits for.
  * This value is only a backstop for a new caller that forgets one. Without a
- * bound the poll loop runs until the jest timeout, which hides the reason.
+ * bound the poll loop runs until the test timeout, which hides the reason.
  *
  * The value stays short because it cannot know the work. It fits the smallest
  * base any suite passes to testTimeoutMs, which is 60_000 ms:
@@ -69,7 +69,7 @@ export const RETRY_BUDGET_MS = (MAX_ATTEMPTS - 1) * MAX_WAIT_MS;
 export const DEFAULT_JOB_TIMEOUT_MS = 45_000;
 
 /**
- * Jest timeout for a test that calls a wrapped client.
+ * Vitest timeout for a test that calls a wrapped client.
  *
  * Pass the base: the time the test needs when the API answers at once. The
  * result adds one retry budget on top, so a test whose single call hits the

package/src/__tests__/e2e/v2/watcher.test.ts

@@ -1,6 +1,6 @@
 import Firecrawl from "../../../index";
 import { config } from "dotenv";
-import { describe, test, expect, beforeAll } from "@jest/globals";
+import { describe, test, expect, beforeAll } from "vitest";
 import { getIdentity } from "./utils/idmux";
 import { testTimeoutMs, withRateLimitRetry } from "./utils/rateLimit";
 

package/src/__tests__/unit/v1/batch-scrape-poll.test.ts

@@ -1,4 +1,4 @@
-import { describe, test, expect, jest, afterEach, beforeEach } from "@jest/globals";
+import { describe, test, expect, vi, afterEach, beforeEach } from "vitest";
 import axios from "axios";
 import FirecrawlApp from "../../../v1";
 
@@ -20,7 +20,7 @@ const lastPage = () => ({ success: true, status: "completed", data: [{ markdown:
 function mockPoll(path: string, nextOrigin = API_URL) {
   const sent: string[] = [];
   let polls = 0;
-  jest.spyOn(axios, "get").mockImplementation(async (url: string) => {
+  vi.spyOn(axios, "get").mockImplementation(async (url: string) => {
     sent.push(url);
     if (new URL(url).searchParams.has("skip")) return { status: 200, data: lastPage() };
     polls++;
@@ -33,18 +33,18 @@ describe("v1 batch scrape waits on the batch scrape status endpoint", () => {
   const app = new FirecrawlApp({ apiKey: API_KEY, apiUrl: API_URL });
 
   beforeEach(() => {
-    jest.spyOn(global, "setTimeout").mockImplementation(((fn: () => void) => {
+    vi.spyOn(global, "setTimeout").mockImplementation(((fn: () => void) => {
       fn();
       return 0;
     }) as any);
   });
 
   afterEach(() => {
-    jest.restoreAllMocks();
+    vi.restoreAllMocks();
   });
 
   test("batchScrapeUrls polls /v1/batch/scrape/{id} and follows pinned next pages", async () => {
-    const post = jest.spyOn(axios, "post").mockResolvedValue({ status: 200, data: { success: true, id: "abc" } });
+    const post = vi.spyOn(axios, "post").mockResolvedValue({ status: 200, data: { success: true, id: "abc" } });
     const path = "/v1/batch/scrape/abc";
     const sent = mockPoll(path, "https://evil.example");
 
@@ -58,9 +58,9 @@ describe("v1 batch scrape waits on the batch scrape status endpoint", () => {
   });
 
   test("batchScrapeUrls reports batch scrape failures as batch scrape errors", async () => {
-    jest.spyOn(axios, "post").mockResolvedValue({ status: 200, data: { success: true, id: "abc" } });
+    vi.spyOn(axios, "post").mockResolvedValue({ status: 200, data: { success: true, id: "abc" } });
     const sent: string[] = [];
-    jest.spyOn(axios, "get").mockImplementation(async (url: string) => {
+    vi.spyOn(axios, "get").mockImplementation(async (url: string) => {
       sent.push(url);
       return { status: 200, data: { success: true, status: "failed", data: [] } };
     });

package/src/__tests__/unit/v1/monitor-job-status-retry.test.ts

@@ -1,5 +1,5 @@
 import FirecrawlApp from '../../../v1';
-import { describe, test, expect, jest, beforeEach, afterEach } from '@jest/globals';
+import { describe, test, expect, vi, beforeEach, afterEach } from 'vitest';
 
 const successResponse = {
   status: 200,
@@ -21,17 +21,17 @@ describe('monitorJobStatus retry logic', () => {
   beforeEach(() => {
     app = new FirecrawlApp({ apiKey: 'test-key', apiUrl: 'https://test.com' });
     delays = [];
-    jest.useFakeTimers();
+    vi.useFakeTimers();
     const fakeSetTimeout = globalThis.setTimeout;
-    jest.spyOn(globalThis, 'setTimeout').mockImplementation(((fn: () => void, ms?: number) => {
+    vi.spyOn(globalThis, 'setTimeout').mockImplementation(((fn: () => void, ms?: number) => {
       delays.push(ms ?? 0);
       return fakeSetTimeout(fn, ms);
     }) as any);
   });
 
   afterEach(() => {
-    jest.restoreAllMocks();
-    jest.useRealTimers();
+    vi.restoreAllMocks();
+    vi.useRealTimers();
   });
 
   function failFirst(n: number, error: Error, statuses: string[] = []) {
@@ -48,7 +48,7 @@ describe('monitorJobStatus retry logic', () => {
   async function monitor() {
     const result = app.monitorJobStatus('test-id', {} as any, 1);
     result.catch(() => {});
-    await jest.runAllTimersAsync();
+    await vi.runAllTimersAsync();
     return result;
   }
 

package/src/__tests__/unit/v1/next-url-pinning.test.ts

@@ -1,4 +1,4 @@
-import { describe, test, expect, jest, afterEach } from "@jest/globals";
+import { describe, test, expect, vi, afterEach } from "vitest";
 import axios from "axios";
 import FirecrawlApp from "../../../v1";
 
@@ -16,7 +16,7 @@ const origins: Array<[string, string]> = [
 
 function mockGet(respond: (url: URL) => unknown) {
   const sent: Array<{ url: string; authorization: unknown }> = [];
-  jest.spyOn(axios, "get").mockImplementation(async (url: string, config?: any) => {
+  vi.spyOn(axios, "get").mockImplementation(async (url: string, config?: any) => {
     sent.push({ url, authorization: config?.headers?.Authorization });
     return { status: 200, data: respond(new URL(url)) };
   });
@@ -45,7 +45,7 @@ const lastPage = () => ({ success: true, status: "completed", data: [{ markdown:
 
 describe("v1 pins next URLs to the api_url origin", () => {
   afterEach(() => {
-    jest.restoreAllMocks();
+    vi.restoreAllMocks();
   });
 
   describe.each(origins)("%s next", (_label, origin) => {

package/src/__tests__/unit/v1/optional-params.test.ts

@@ -1,4 +1,4 @@
-import { describe, test, expect, jest, beforeEach, afterEach } from "@jest/globals";
+import { describe, test, expect, vi, beforeEach, afterEach } from "vitest";
 import axios from "axios";
 import FirecrawlApp from "../../../v1";
 
@@ -20,11 +20,11 @@ describe("v1 methods work without params", () => {
   beforeEach(() => {
     app = new FirecrawlApp({ apiKey: "fc-test", apiUrl: API_URL });
     posts = [];
-    jest.spyOn(axios, "post").mockImplementation(async (url: string, data?: any) => {
+    vi.spyOn(axios, "post").mockImplementation(async (url: string, data?: any) => {
       posts.push({ url, data });
       return { status: 200, data: { success: true, id: "job-1", data: [], links: [] } };
     });
-    jest.spyOn(axios, "get").mockImplementation(async () => ({
+    vi.spyOn(axios, "get").mockImplementation(async () => ({
       status: 200,
       data: { success: true, status: "completed", data: [{ markdown: "ok" }] },
     }));
@@ -32,7 +32,7 @@ describe("v1 methods work without params", () => {
   });
 
   afterEach(() => {
-    jest.restoreAllMocks();
+    vi.restoreAllMocks();
     (globalThis as any).WebSocket = originalWebSocket;
   });
 

package/src/__tests__/unit/v2/agent-effort-trace.unit.test.ts

@@ -1,4 +1,4 @@
-import { describe, expect, jest, test } from "@jest/globals";
+import { describe, expect, vi, test } from "vitest";
 import {
   startAgent,
   getAgentTrace,
@@ -8,7 +8,7 @@ import type { AgentTraceEvent } from "../../../v2/types";
 
 describe("v2.agent unit", () => {
   test("startAgent forwards effort in request payload", async () => {
-    const post = jest.fn().mockResolvedValue({
+    const post = vi.fn().mockResolvedValue({
       status: 200,
       data: { success: true, id: "agent-job" },
     });
@@ -25,7 +25,7 @@ describe("v2.agent unit", () => {
   });
 
   test("startAgent omits effort when unset", async () => {
-    const post = jest.fn().mockResolvedValue({
+    const post = vi.fn().mockResolvedValue({
       status: 200,
       data: { success: true, id: "agent-job" },
     });
@@ -70,7 +70,7 @@ describe("v2.agent unit", () => {
         change: "partial",
       },
     };
-    const get = jest.fn().mockResolvedValue({
+    const get = vi.fn().mockResolvedValue({
       status: 200,
       data: {
         success: true,
@@ -95,7 +95,7 @@ describe("v2.agent unit", () => {
   });
 
   test("getAgentTrace appends liveView query param when requested", async () => {
-    const get = jest.fn().mockResolvedValue({
+    const get = vi.fn().mockResolvedValue({
       status: 200,
       data: {
         success: true,
@@ -122,7 +122,7 @@ describe("v2.agent unit", () => {
   });
 
   test("getAgentSnapshot hits the snapshot endpoint", async () => {
-    const get = jest.fn().mockResolvedValue({
+    const get = vi.fn().mockResolvedValue({
       status: 200,
       data: {
         success: true,

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

@@ -1,4 +1,4 @@
-import { describe, expect, it, jest } from "@jest/globals";
+import { describe, expect, it, vi } from "vitest";
 import { search } from "../../../v2/methods/search";
 import { scrape } from "../../../v2/methods/scrape";
 import { parse } from "../../../v2/methods/parse";
@@ -14,8 +14,8 @@ const hints = [
 ];
 function httpFor(body: object) {
   return {
-    post: jest.fn<any>().mockResolvedValue({ status: 200, data: body }),
-    postMultipart: jest
+    post: vi.fn<any>().mockResolvedValue({ status: 200, data: body }),
+    postMultipart: vi
       .fn<any>()
       .mockResolvedValue({ status: 200, data: body }),
   } as any;

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

@@ -1,4 +1,4 @@
-import { describe, expect, jest, test } from "@jest/globals";
+import { describe, expect, vi, test } from "vitest";
 import { listAgents } from "../../../v2/methods/agent";
 
 describe("v2.agent listAgents unit", () => {
@@ -17,7 +17,7 @@ describe("v2.agent listAgents unit", () => {
   };
 
   test("hits GET /v2/agent without query by default", async () => {
-    const get = jest.fn().mockResolvedValue({
+    const get = vi.fn().mockResolvedValue({
       status: 200,
       data: { success: true, agents: [sampleAgent] },
     });
@@ -33,7 +33,7 @@ describe("v2.agent listAgents unit", () => {
   });
 
   test("passes before as a query param", async () => {
-    const get = jest.fn().mockResolvedValue({
+    const get = vi.fn().mockResolvedValue({
       status: 200,
       data: {
         success: true,
@@ -51,7 +51,7 @@ describe("v2.agent listAgents unit", () => {
   });
 
   test("does not auto-paginate when next is present", async () => {
-    const get = jest.fn().mockResolvedValue({
+    const get = vi.fn().mockResolvedValue({
       status: 200,
       data: {
         success: true,

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

@@ -1,4 +1,4 @@
-import { describe, expect, jest, test } from "@jest/globals";
+import { describe, expect, vi, test } from "vitest";
 import {
   getAgentStatus,
   getAgentThread,
@@ -6,7 +6,7 @@ import {
 } from "../../../v2/methods/agent";
 
 const okPost = () =>
-  jest.fn().mockResolvedValue({
+  vi.fn().mockResolvedValue({
     status: 200,
     data: { success: true, id: "agent-job", threadId: "thread-1", threadTurn: 2 },
   });
@@ -51,7 +51,7 @@ describe("v2.agent threads unit", () => {
   });
 
   test("getAgentStatus parses a chat-mode status payload", async () => {
-    const get = jest.fn().mockResolvedValue({
+    const get = vi.fn().mockResolvedValue({
       status: 200,
       data: {
         success: true,
@@ -95,7 +95,7 @@ describe("v2.agent threads unit", () => {
   });
 
   test("getAgentStatus parses a status payload without the thread fields", async () => {
-    const get = jest.fn().mockResolvedValue({
+    const get = vi.fn().mockResolvedValue({
       status: 200,
       data: {
         success: true,
@@ -116,7 +116,7 @@ describe("v2.agent threads unit", () => {
   });
 
   test("getAgentThread hits the thread endpoint", async () => {
-    const get = jest.fn().mockResolvedValue({
+    const get = vi.fn().mockResolvedValue({
       status: 200,
       data: {
         success: true,
@@ -150,7 +150,7 @@ describe("v2.agent threads unit", () => {
   });
 
   test("getAgentThread appends includeData when requested", async () => {
-    const get = jest.fn().mockResolvedValue({
+    const get = vi.fn().mockResolvedValue({
       status: 200,
       data: { success: true, thread: { id: "thread-1", runs: [] } },
     });
@@ -197,7 +197,7 @@ describe("v2.agent threads unit", () => {
 
   test("getAgentStatus parses skippedProviders, requiresAction and a terms approval", async () => {
     const approvalId = "0199aaaa-0000-7000-8000-000000000000";
-    const get = jest.fn().mockResolvedValue({
+    const get = vi.fn().mockResolvedValue({
       status: 200,
       data: {
         success: true,

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

@@ -1,4 +1,4 @@
-import { describe, test, expect } from "@jest/globals";
+import { describe, test, expect } from "vitest";
 
 // 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

package/src/__tests__/unit/v2/audit-metadata.unit.test.ts

@@ -1,4 +1,4 @@
-import { describe, test, expect, jest } from "@jest/globals";
+import { describe, test, expect, vi } from "vitest";
 import { scrape } from "../../../v2/methods/scrape";
 import { startBatchScrape } from "../../../v2/methods/batch";
 import { startCrawl } from "../../../v2/methods/crawl";
@@ -10,10 +10,10 @@ import { startAgent } from "../../../v2/methods/agent";
 const auditMetadata = { username: "alice@example.com" };
 
 function makeHttp(data: Record<string, unknown>) {
-  const post = jest.fn(async () => ({ status: 200, data }));
+  const post = vi.fn(async () => ({ status: 200, data }));
   return {
     post,
-    prepareHeaders: jest.fn(() => undefined),
+    prepareHeaders: vi.fn(() => undefined),
   } as any;
 }
 

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

@@ -1,9 +1,9 @@
-import { describe, test, expect, jest } from "@jest/globals";
+import { describe, test, expect, vi } from "vitest";
 import { scrape } from "../../../v2/methods/scrape";
 
 describe("JS SDK v2 branding format", () => {
   function makeHttp(postImpl: (url: string, data: any) => any) {
-    return { post: jest.fn(async (u: string, d: any) => postImpl(u, d)) } as any;
+    return { post: vi.fn(async (u: string, d: any) => postImpl(u, d)) } as any;
   }
 
   test("scrape with branding format returns branding data", async () => {

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

@@ -1,3 +1,4 @@
+import { describe, it, expect } from 'vitest';
 import { Firecrawl, FirecrawlClient, type FirecrawlClientOptions } from '../../../index';
 
 describe('Firecrawl v2 Client Options', () => {

package/src/__tests__/unit/v2/crawl-cancel-abort.unit.test.ts

@@ -0,0 +1,189 @@
+import { describe, test, expect } from "vitest";
+import axios, { type AxiosAdapter } from "axios";
+import { FirecrawlClient } from "../../../v2/client";
+import { HttpClient } from "../../../v2/utils/httpClient";
+import { waitForCrawlCompletion } from "../../../v2/methods/crawl";
+import { SdkError } from "../../../v2/types";
+
+const API_URL = "https://api.firecrawl.dev";
+const JOB_ID = "job-123";
+
+type Sent = { method: string; path: string };
+type Reply = { status: number; data: unknown };
+
+function withAdapter<T extends { defaults: any }>(instance: T, route: (req: Sent) => Reply): Sent[] {
+  const sent: Sent[] = [];
+  const adapter: AxiosAdapter = async (config) => {
+    const req = {
+      method: (config.method || "get").toLowerCase(),
+      path: new URL(axios.getUri(config)).pathname,
+    };
+    sent.push(req);
+    const { status, data } = route(req);
+    const response = { data, status, statusText: String(status), headers: {}, config };
+    const validate = config.validateStatus;
+    if (validate && !validate(status)) {
+      throw new axios.AxiosError(`Request failed with status code ${status}`, undefined, config, null, response);
+    }
+    return response;
+  };
+  instance.defaults.adapter = adapter;
+  return sent;
+}
+
+function makeClient(route: (req: Sent) => Reply) {
+  const client = new FirecrawlClient({ apiKey: "fc-test", apiUrl: API_URL });
+  const sent = withAdapter((client as any).http.instance, route);
+  return { client, sent };
+}
+
+// The cancel runs in the background, so let its request reach the adapter.
+const flush = () => new Promise((r) => setTimeout(r, 0));
+
+const running: Reply = { status: 200, data: { success: true, status: "scraping", completed: 0, total: 1, data: [] } };
+const started: Reply = { status: 200, data: { success: true, id: JOB_ID, url: "https://example.com" } };
+
+describe("v2 cancelCrawl", () => {
+  test("returns false when the crawl is already completed (409)", async () => {
+    const { client, sent } = makeClient(() => ({ status: 409, data: { error: "Crawl is already completed" } }));
+    await expect(client.cancelCrawl(JOB_ID)).resolves.toBe(false);
+    expect(sent).toEqual([{ method: "delete", path: `/v2/crawl/${JOB_ID}` }]);
+  });
+
+  test("returns false on 409 when the transport does not throw for 4xx", async () => {
+    const { client } = makeClient(() => ({ status: 409, data: { error: "Crawl is already completed" } }));
+    (client as any).http.instance.defaults.validateStatus = () => true;
+    await expect(client.cancelCrawl(JOB_ID)).resolves.toBe(false);
+  });
+
+  test("returns true when the crawl is cancelled", async () => {
+    const { client } = makeClient(() => ({ status: 200, data: { status: "cancelled" } }));
+    await expect(client.cancelCrawl(JOB_ID)).resolves.toBe(true);
+  });
+
+  test("still throws for other errors", async () => {
+    const { client } = makeClient(() => ({ status: 404, data: { error: "Job not found" } }));
+    const err = await client.cancelCrawl(JOB_ID).catch((e) => e);
+    expect(err).toBeInstanceOf(SdkError);
+    expect(err.status).toBe(404);
+  });
+});
+
+describe("v2 crawl with an AbortSignal", () => {
+  test("abort during polling stops polling, cancels the job, and rejects with the abort reason", async () => {
+    const controller = new AbortController();
+    let polls = 0;
+    const { client, sent } = makeClient((req) => {
+      if (req.method === "post") return started;
+      if (req.method === "delete") return { status: 200, data: { status: "cancelled" } };
+      polls += 1;
+      if (polls === 1) setTimeout(() => controller.abort(), 10);
+      return running;
+    });
+
+    const t0 = Date.now();
+    const err = await client.crawl("https://example.com", { pollInterval: 30, signal: controller.signal }).catch((e) => e);
+
+    expect(Date.now() - t0).toBeLessThan(5000);
+    expect(err).toBe(controller.signal.reason);
+    expect((err as Error).name).toBe("AbortError");
+    await flush();
+    expect(sent.map((r) => r.method)).toEqual(["post", "get", "delete"]);
+    expect(sent[2]!.path).toBe(`/v2/crawl/${JOB_ID}`);
+  });
+
+  test("rejects with a custom abort reason and ignores a failing cancel", async () => {
+    const controller = new AbortController();
+    const reason = new Error("caller gave up");
+    const { client, sent } = makeClient((req) => {
+      if (req.method === "post") return started;
+      if (req.method === "delete") return { status: 500, data: { error: "boom" } };
+      setTimeout(() => controller.abort(reason), 10);
+      return running;
+    });
+
+    await expect(client.crawl("https://example.com", { pollInterval: 30, signal: controller.signal })).rejects.toBe(reason);
+    await flush();
+    expect(sent.some((r) => r.method === "delete")).toBe(true);
+  });
+
+  test("a hanging cancel does not delay the rejection", async () => {
+    const controller = new AbortController();
+    const client = new FirecrawlClient({ apiKey: "fc-test", apiUrl: API_URL });
+    const methods: string[] = [];
+    (client as any).http.instance.defaults.adapter = (async (config) => {
+      methods.push(config.method!);
+      if (config.method === "delete") return new Promise(() => {});
+      if (config.method === "get") setTimeout(() => controller.abort(), 10);
+      const data = config.method === "post" ? started.data : running.data;
+      return { data, status: 200, statusText: "OK", headers: {}, config };
+    }) as AxiosAdapter;
+
+    // Read the reason after the abort: before it, signal.reason is undefined.
+    const err = await client.crawl("https://example.com", { pollInterval: 30, signal: controller.signal }).catch((e) => e);
+    expect(err).toBe(controller.signal.reason);
+    expect((err as Error).name).toBe("AbortError");
+    await flush();
+    expect(methods).toEqual(["post", "get", "delete"]);
+  });
+
+  test("abort while the start request is in flight cancels the job once the id arrives", async () => {
+    const controller = new AbortController();
+    const { client, sent } = makeClient((req) => {
+      if (req.method === "post") {
+        controller.abort();
+        return started;
+      }
+      if (req.method === "delete") return { status: 200, data: { status: "cancelled" } };
+      return running;
+    });
+
+    const err = await client.crawl("https://example.com", { signal: controller.signal }).catch((e) => e);
+    expect(err).toBe(controller.signal.reason);
+    expect((err as Error).name).toBe("AbortError");
+    await flush();
+    expect(sent.map((r) => r.method)).toEqual(["post", "delete"]);
+  });
+
+  test("an already aborted signal sends no request", async () => {
+    const controller = new AbortController();
+    controller.abort();
+    const { client, sent } = makeClient(() => started);
+
+    await expect(client.crawl("https://example.com", { signal: controller.signal })).rejects.toBe(controller.signal.reason);
+    expect(sent).toHaveLength(0);
+  });
+
+  test("the signal is not sent in the crawl request body", async () => {
+    const controller = new AbortController();
+    const client = new FirecrawlClient({ apiKey: "fc-test", apiUrl: API_URL });
+    const bodies: unknown[] = [];
+    (client as any).http.instance.defaults.adapter = (async (config) => {
+      if (config.method === "post") bodies.push(JSON.parse(config.data as string));
+      const data = config.method === "post" ? started.data : { success: true, status: "completed", completed: 1, total: 1, data: [] };
+      return { data, status: 200, statusText: "OK", headers: {}, config };
+    }) as AxiosAdapter;
+
+    const job = await client.crawl("https://example.com", { limit: 1, signal: controller.signal });
+    expect(job.status).toBe("completed");
+    expect(bodies[0]).toMatchObject({ url: "https://example.com", limit: 1 });
+    expect(Object.keys(bodies[0] as object)).not.toContain("signal");
+  });
+});
+
+describe("v2 waitForCrawlCompletion with an AbortSignal", () => {
+  test("stops polling and rejects without cancelling the job", async () => {
+    const http = new HttpClient({ apiKey: "fc-test", apiUrl: API_URL });
+    const controller = new AbortController();
+    const sent = withAdapter((http as any).instance, () => {
+      setTimeout(() => controller.abort(), 10);
+      return running;
+    });
+
+    const err = await waitForCrawlCompletion(http, JOB_ID, 30, undefined, controller.signal).catch((e) => e);
+    expect(err).toBe(controller.signal.reason);
+    expect((err as Error).name).toBe("AbortError");
+    await new Promise((r) => setTimeout(r, 50));
+    expect(sent.map((r) => r.method)).toEqual(["get"]);
+  });
+});

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

@@ -1,4 +1,4 @@
-import { describe, expect, jest, test } from "@jest/globals";
+import { describe, expect, vi, test } from "vitest";
 import { FirecrawlClient } from "../../../v2/client";
 import { SdkError } from "../../../v2/types";
 
@@ -31,7 +31,7 @@ const response = {
 describe("developerSearch", () => {
   test("forwards every dedicated developer filter", async () => {
     const http = {
-      post: jest.fn(async () => ({ status: 200, data: response })),
+      post: vi.fn(async () => ({ status: 200, data: response })),
     } as any;
 
     const client = new FirecrawlClient({
@@ -77,7 +77,7 @@ describe("developerSearch", () => {
 
   test("normalizes transport errors to SdkError", async () => {
     const http = {
-      post: jest.fn(async () => {
+      post: vi.fn(async () => {
         throw {
           isAxiosError: true,
           code: "ECONNABORTED",
@@ -102,7 +102,7 @@ describe("developerSearch", () => {
       results: [{ ...response.results[0], license: "MIT" }],
     };
     const http = {
-      post: jest.fn(async () => ({ status: 200, data: flattened })),
+      post: vi.fn(async () => ({ status: 200, data: flattened })),
     } as any;
 
     const client = new FirecrawlClient({