firecrawl-aisdk 0.7.1

package/README.md

@@ -0,0 +1,181 @@
+# Firecrawl AI SDK Tools
+
+Firecrawl tools for Vercel AI SDK v5. Web scraping, search, crawling, and data extraction for AI applications.
+
+## Install
+
+```bash
+npm install @developersdigest/fc-ai-sdk ai @ai-sdk/openai
+```
+
+Set environment variables:
+```bash
+FIRECRAWL_API_KEY=fc-your-key
+OPENAI_API_KEY=sk-your-key
+```
+
+## Quick Start
+
+```typescript
+import { generateText } from 'ai';
+import { openai } from '@ai-sdk/openai';
+import { scrapeTool } from '@developersdigest/fc-ai-sdk';
+
+const { text } = await generateText({
+  model: openai('gpt-5-mini'),
+  prompt: 'Scrape https://firecrawl.dev and summarize what it does',
+  tools: { scrape: scrapeTool },
+});
+```
+
+## Available Tools
+
+```typescript
+import {
+  scrapeTool,         // Scrape single URL
+  searchTool,         // Search the web
+  mapTool,            // Discover URLs on a site
+  crawlTool,          // Crawl multiple pages
+  batchScrapeTool,    // Scrape multiple URLs
+  extractTool,        // Extract structured data
+  pollTool,           // Poll async jobs
+  statusTool,         // Check job status
+  cancelTool,         // Cancel jobs
+} from '@developersdigest/fc-ai-sdk';
+```
+
+## Examples
+
+**Scrape**
+```typescript
+import { generateText } from 'ai';
+import { openai } from '@ai-sdk/openai';
+import { scrapeTool } from '@developersdigest/fc-ai-sdk';
+
+const { text } = await generateText({
+  model: openai('gpt-5-mini'),
+  prompt: 'Scrape https://firecrawl.dev and summarize what it does',
+  tools: { scrape: scrapeTool },
+});
+
+console.log(text);
+```
+
+**Search**
+```typescript
+import { generateText } from 'ai';
+import { openai } from '@ai-sdk/openai';
+import { searchTool } from '@developersdigest/fc-ai-sdk';
+
+const { text } = await generateText({
+  model: openai('gpt-5-mini'),
+  prompt: 'Search for Firecrawl and summarize what you find',
+  tools: { search: searchTool },
+});
+
+console.log(text);
+```
+
+**Map**
+```typescript
+import { generateText } from 'ai';
+import { openai } from '@ai-sdk/openai';
+import { mapTool } from '@developersdigest/fc-ai-sdk';
+
+const { text } = await generateText({
+  model: openai('gpt-5-mini'),
+  prompt: 'Map https://docs.firecrawl.dev and list the main sections',
+  tools: { map: mapTool },
+});
+
+console.log(text);
+```
+
+**Crawl** (async - requires polling)
+```typescript
+import { generateText } from 'ai';
+import { openai } from '@ai-sdk/openai';
+import { crawlTool, pollTool } from '@developersdigest/fc-ai-sdk';
+
+const { text } = await generateText({
+  model: openai('gpt-5-mini'),
+  prompt: 'Crawl https://docs.firecrawl.dev (limit 3 pages) and summarize',
+  tools: { crawl: crawlTool, poll: pollTool },
+});
+
+console.log(text);
+```
+
+**Batch** (async - requires polling)
+```typescript
+import { generateText } from 'ai';
+import { openai } from '@ai-sdk/openai';
+import { batchScrapeTool, pollTool } from '@developersdigest/fc-ai-sdk';
+
+const { text } = await generateText({
+  model: openai('gpt-5-mini'),
+  prompt: 'Scrape https://firecrawl.dev and https://docs.firecrawl.dev, then compare',
+  tools: { batchScrape: batchScrapeTool, poll: pollTool },
+});
+
+console.log(text);
+```
+
+**Extract** (async - requires polling)
+```typescript
+import { generateText } from 'ai';
+import { openai } from '@ai-sdk/openai';
+import { extractTool, pollTool } from '@developersdigest/fc-ai-sdk';
+
+const { text } = await generateText({
+  model: openai('gpt-5-mini'),
+  prompt: 'Extract the main features from https://firecrawl.dev',
+  tools: { extract: extractTool, poll: pollTool },
+});
+
+console.log(text);
+```
+
+**Search + Scrape**
+```typescript
+import { generateText } from 'ai';
+import { openai } from '@ai-sdk/openai';
+import { searchTool, scrapeTool } from '@developersdigest/fc-ai-sdk';
+
+const { text } = await generateText({
+  model: openai('gpt-5-mini'),
+  prompt: 'Search for Firecrawl, scrape the top result, and explain what it does',
+  tools: { search: searchTool, scrape: scrapeTool },
+});
+
+console.log(text);
+```
+
+**Stream**
+```typescript
+import { streamText } from 'ai';
+import { openai } from '@ai-sdk/openai';
+import { scrapeTool } from '@developersdigest/fc-ai-sdk';
+
+const result = streamText({
+  model: openai('gpt-5-mini'),
+  prompt: 'Scrape https://firecrawl.dev and explain what it does',
+  tools: { scrape: scrapeTool },
+});
+
+for await (const chunk of result.textStream) {
+  process.stdout.write(chunk);
+}
+```
+
+## Development
+
+Run tests:
+```bash
+pnpm test          # Run all tests
+pnpm test:watch    # Watch mode
+```
+
+## License
+
+MIT

package/dist/index.d.ts

@@ -0,0 +1,603 @@
+import * as ai from 'ai';
+import * as _mendable_firecrawl_js from '@mendable/firecrawl-js';
+import { z } from 'zod';
+
+declare const scrapeTool: ai.Tool<{
+    url: string;
+    formats?: ("markdown" | "html" | "rawHtml" | "screenshot" | "links" | "summary" | "changeTracking" | "branding" | {
+        type: "json";
+        prompt?: string | undefined;
+        schema?: Record<string, any> | undefined;
+    } | {
+        type: "screenshot";
+        fullPage?: boolean | undefined;
+        quality?: number | undefined;
+        viewport?: {
+            width: number;
+            height: number;
+        } | undefined;
+    })[] | undefined;
+    parsers?: ("pdf" | {
+        type: "pdf";
+        maxPages?: number | undefined;
+    })[] | undefined;
+    onlyMainContent?: boolean | undefined;
+    includeTags?: string[] | undefined;
+    excludeTags?: string[] | undefined;
+    waitFor?: number | undefined;
+    actions?: {
+        type: "screenshot" | "wait" | "scroll" | "scrape" | "click" | "write" | "press" | "executeJavascript" | "generatePDF";
+        fullPage?: boolean | undefined;
+        selector?: string | undefined;
+        milliseconds?: number | undefined;
+        text?: string | undefined;
+        key?: string | undefined;
+        direction?: "up" | "down" | undefined;
+        script?: string | undefined;
+    }[] | undefined;
+    mobile?: boolean | undefined;
+    skipTlsVerification?: boolean | undefined;
+    removeBase64Images?: boolean | undefined;
+    location?: {
+        country?: string | undefined;
+        languages?: string[] | undefined;
+    } | undefined;
+    storeInCache?: boolean | undefined;
+    maxAge?: number | undefined;
+    headers?: Record<string, string> | undefined;
+    blockAds?: boolean | undefined;
+    proxy?: "basic" | "stealth" | "auto" | undefined;
+    zeroDataRetention?: boolean | undefined;
+    timeout?: number | undefined;
+}, Omit<_mendable_firecrawl_js.Document, "json"> & {
+    json?: unknown;
+}>;
+
+declare const searchTool: ai.Tool<{
+    query: string;
+    country?: string | undefined;
+    location?: string | undefined;
+    timeout?: number | undefined;
+    limit?: number | undefined;
+    sources?: {
+        type: "web" | "images" | "news";
+    }[] | undefined;
+    categories?: {
+        type: "pdf" | "github" | "research";
+    }[] | undefined;
+    tbs?: string | undefined;
+    ignoreInvalidURLs?: boolean | undefined;
+    scrapeOptions?: {
+        formats?: ("markdown" | "html" | "rawHtml")[] | undefined;
+        onlyMainContent?: boolean | undefined;
+    } | undefined;
+}, _mendable_firecrawl_js.SearchData>;
+
+declare const mapTool: ai.Tool<{
+    url: string;
+    limit?: number | undefined;
+    search?: string | undefined;
+    includeSubdomains?: boolean | undefined;
+    ignoreSitemap?: boolean | undefined;
+}, _mendable_firecrawl_js.MapData>;
+
+declare const extractTool: ai.Tool<{
+    urls: string[];
+    prompt?: string | undefined;
+    schema?: Record<string, any> | undefined;
+    ignoreInvalidURLs?: boolean | undefined;
+    scrapeOptions?: {
+        formats?: ("markdown" | "html" | "rawHtml")[] | undefined;
+        onlyMainContent?: boolean | undefined;
+        includeTags?: string[] | undefined;
+        excludeTags?: string[] | undefined;
+        waitFor?: number | undefined;
+        mobile?: boolean | undefined;
+    } | undefined;
+    systemPrompt?: string | undefined;
+    allowExternalLinks?: boolean | undefined;
+    enableWebSearch?: boolean | undefined;
+    showSources?: boolean | undefined;
+}, _mendable_firecrawl_js.ExtractResponse>;
+
+declare const batchScrapeTool: ai.Tool<{
+    urls: string[];
+    formats?: ("markdown" | "html" | "rawHtml" | "screenshot" | "links")[] | undefined;
+    onlyMainContent?: boolean | undefined;
+}, _mendable_firecrawl_js.BatchScrapeJob>;
+
+declare const crawlTool: ai.Tool<{
+    url: string;
+    limit?: number | undefined;
+    scrapeOptions?: {
+        formats?: ("markdown" | "html" | "rawHtml")[] | undefined;
+        onlyMainContent?: boolean | undefined;
+    } | undefined;
+    allowExternalLinks?: boolean | undefined;
+    maxDepth?: number | undefined;
+    allowBackwardLinks?: boolean | undefined;
+    includePaths?: string[] | undefined;
+    excludePaths?: string[] | undefined;
+}, _mendable_firecrawl_js.CrawlResponse>;
+
+declare const pollTool: ai.Tool<{
+    jobType: "crawl" | "batchScrape" | "extract";
+    jobId: string;
+    pollInterval?: number | undefined;
+    maxWaitTime?: number | undefined;
+}, {
+    success: boolean;
+    status: string;
+    data: any;
+    total?: undefined;
+    creditsUsed?: undefined;
+    error?: undefined;
+} | {
+    success: boolean;
+    status: string;
+    data: any;
+    total: any;
+    creditsUsed: any;
+    error?: undefined;
+} | {
+    success: boolean;
+    status: string;
+    error: any;
+    data?: undefined;
+    total?: undefined;
+    creditsUsed?: undefined;
+}>;
+declare const statusTool: ai.Tool<{
+    id: string;
+    jobType?: "crawl" | "batchScrape" | "extract" | undefined;
+}, _mendable_firecrawl_js.ExtractResponse | _mendable_firecrawl_js.BatchScrapeJob | undefined>;
+declare const cancelTool: ai.Tool<{
+    jobType: "crawl" | "batchScrape";
+    jobId: string;
+}, {
+    success: boolean;
+    jobId: string;
+    jobType: "crawl" | "batchScrape";
+    message: string;
+}>;
+
+interface PollOptions {
+    pollInterval?: number;
+    timeout?: number;
+    onProgress?: (status: any) => void;
+}
+declare function pollCrawlJob(jobId: string, options?: PollOptions): Promise<any>;
+declare function pollBatchScrapeJob(jobId: string, options?: PollOptions): Promise<any>;
+declare function pollExtractJob(jobId: string, options?: PollOptions): Promise<any>;
+
+declare const scrapeSchema: z.ZodObject<{
+    url: z.ZodString;
+    formats: z.ZodOptional<z.ZodArray<z.ZodUnion<[z.ZodEnum<["markdown", "html", "rawHtml", "screenshot", "links", "summary", "changeTracking", "branding"]>, z.ZodObject<{
+        type: z.ZodLiteral<"json">;
+        prompt: z.ZodOptional<z.ZodString>;
+        schema: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodAny>>;
+    }, "strip", z.ZodTypeAny, {
+        type: "json";
+        prompt?: string | undefined;
+        schema?: Record<string, any> | undefined;
+    }, {
+        type: "json";
+        prompt?: string | undefined;
+        schema?: Record<string, any> | undefined;
+    }>, z.ZodObject<{
+        type: z.ZodLiteral<"screenshot">;
+        fullPage: z.ZodOptional<z.ZodBoolean>;
+        quality: z.ZodOptional<z.ZodNumber>;
+        viewport: z.ZodOptional<z.ZodObject<{
+            width: z.ZodNumber;
+            height: z.ZodNumber;
+        }, "strip", z.ZodTypeAny, {
+            width: number;
+            height: number;
+        }, {
+            width: number;
+            height: number;
+        }>>;
+    }, "strip", z.ZodTypeAny, {
+        type: "screenshot";
+        fullPage?: boolean | undefined;
+        quality?: number | undefined;
+        viewport?: {
+            width: number;
+            height: number;
+        } | undefined;
+    }, {
+        type: "screenshot";
+        fullPage?: boolean | undefined;
+        quality?: number | undefined;
+        viewport?: {
+            width: number;
+            height: number;
+        } | undefined;
+    }>]>, "many">>;
+    parsers: z.ZodOptional<z.ZodArray<z.ZodUnion<[z.ZodEnum<["pdf"]>, z.ZodObject<{
+        type: z.ZodEnum<["pdf"]>;
+        maxPages: z.ZodOptional<z.ZodNumber>;
+    }, "strip", z.ZodTypeAny, {
+        type: "pdf";
+        maxPages?: number | undefined;
+    }, {
+        type: "pdf";
+        maxPages?: number | undefined;
+    }>]>, "many">>;
+    onlyMainContent: z.ZodOptional<z.ZodBoolean>;
+    includeTags: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+    excludeTags: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+    waitFor: z.ZodOptional<z.ZodNumber>;
+    actions: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        type: z.ZodEnum<["wait", "screenshot", "scroll", "scrape", "click", "write", "press", "executeJavascript", "generatePDF"]>;
+        selector: z.ZodOptional<z.ZodString>;
+        milliseconds: z.ZodOptional<z.ZodNumber>;
+        text: z.ZodOptional<z.ZodString>;
+        key: z.ZodOptional<z.ZodString>;
+        direction: z.ZodOptional<z.ZodEnum<["up", "down"]>>;
+        script: z.ZodOptional<z.ZodString>;
+        fullPage: z.ZodOptional<z.ZodBoolean>;
+    }, "strip", z.ZodTypeAny, {
+        type: "screenshot" | "wait" | "scroll" | "scrape" | "click" | "write" | "press" | "executeJavascript" | "generatePDF";
+        fullPage?: boolean | undefined;
+        selector?: string | undefined;
+        milliseconds?: number | undefined;
+        text?: string | undefined;
+        key?: string | undefined;
+        direction?: "up" | "down" | undefined;
+        script?: string | undefined;
+    }, {
+        type: "screenshot" | "wait" | "scroll" | "scrape" | "click" | "write" | "press" | "executeJavascript" | "generatePDF";
+        fullPage?: boolean | undefined;
+        selector?: string | undefined;
+        milliseconds?: number | undefined;
+        text?: string | undefined;
+        key?: string | undefined;
+        direction?: "up" | "down" | undefined;
+        script?: string | undefined;
+    }>, "many">>;
+    mobile: z.ZodOptional<z.ZodBoolean>;
+    skipTlsVerification: z.ZodOptional<z.ZodBoolean>;
+    removeBase64Images: z.ZodOptional<z.ZodBoolean>;
+    location: z.ZodOptional<z.ZodObject<{
+        country: z.ZodOptional<z.ZodString>;
+        languages: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+    }, "strip", z.ZodTypeAny, {
+        country?: string | undefined;
+        languages?: string[] | undefined;
+    }, {
+        country?: string | undefined;
+        languages?: string[] | undefined;
+    }>>;
+    storeInCache: z.ZodOptional<z.ZodBoolean>;
+    maxAge: z.ZodOptional<z.ZodNumber>;
+    headers: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+    blockAds: z.ZodOptional<z.ZodBoolean>;
+    proxy: z.ZodOptional<z.ZodEnum<["basic", "stealth", "auto"]>>;
+    zeroDataRetention: z.ZodOptional<z.ZodBoolean>;
+    timeout: z.ZodOptional<z.ZodNumber>;
+}, "strip", z.ZodTypeAny, {
+    url: string;
+    formats?: ("markdown" | "html" | "rawHtml" | "screenshot" | "links" | "summary" | "changeTracking" | "branding" | {
+        type: "json";
+        prompt?: string | undefined;
+        schema?: Record<string, any> | undefined;
+    } | {
+        type: "screenshot";
+        fullPage?: boolean | undefined;
+        quality?: number | undefined;
+        viewport?: {
+            width: number;
+            height: number;
+        } | undefined;
+    })[] | undefined;
+    parsers?: ("pdf" | {
+        type: "pdf";
+        maxPages?: number | undefined;
+    })[] | undefined;
+    onlyMainContent?: boolean | undefined;
+    includeTags?: string[] | undefined;
+    excludeTags?: string[] | undefined;
+    waitFor?: number | undefined;
+    actions?: {
+        type: "screenshot" | "wait" | "scroll" | "scrape" | "click" | "write" | "press" | "executeJavascript" | "generatePDF";
+        fullPage?: boolean | undefined;
+        selector?: string | undefined;
+        milliseconds?: number | undefined;
+        text?: string | undefined;
+        key?: string | undefined;
+        direction?: "up" | "down" | undefined;
+        script?: string | undefined;
+    }[] | undefined;
+    mobile?: boolean | undefined;
+    skipTlsVerification?: boolean | undefined;
+    removeBase64Images?: boolean | undefined;
+    location?: {
+        country?: string | undefined;
+        languages?: string[] | undefined;
+    } | undefined;
+    storeInCache?: boolean | undefined;
+    maxAge?: number | undefined;
+    headers?: Record<string, string> | undefined;
+    blockAds?: boolean | undefined;
+    proxy?: "basic" | "stealth" | "auto" | undefined;
+    zeroDataRetention?: boolean | undefined;
+    timeout?: number | undefined;
+}, {
+    url: string;
+    formats?: ("markdown" | "html" | "rawHtml" | "screenshot" | "links" | "summary" | "changeTracking" | "branding" | {
+        type: "json";
+        prompt?: string | undefined;
+        schema?: Record<string, any> | undefined;
+    } | {
+        type: "screenshot";
+        fullPage?: boolean | undefined;
+        quality?: number | undefined;
+        viewport?: {
+            width: number;
+            height: number;
+        } | undefined;
+    })[] | undefined;
+    parsers?: ("pdf" | {
+        type: "pdf";
+        maxPages?: number | undefined;
+    })[] | undefined;
+    onlyMainContent?: boolean | undefined;
+    includeTags?: string[] | undefined;
+    excludeTags?: string[] | undefined;
+    waitFor?: number | undefined;
+    actions?: {
+        type: "screenshot" | "wait" | "scroll" | "scrape" | "click" | "write" | "press" | "executeJavascript" | "generatePDF";
+        fullPage?: boolean | undefined;
+        selector?: string | undefined;
+        milliseconds?: number | undefined;
+        text?: string | undefined;
+        key?: string | undefined;
+        direction?: "up" | "down" | undefined;
+        script?: string | undefined;
+    }[] | undefined;
+    mobile?: boolean | undefined;
+    skipTlsVerification?: boolean | undefined;
+    removeBase64Images?: boolean | undefined;
+    location?: {
+        country?: string | undefined;
+        languages?: string[] | undefined;
+    } | undefined;
+    storeInCache?: boolean | undefined;
+    maxAge?: number | undefined;
+    headers?: Record<string, string> | undefined;
+    blockAds?: boolean | undefined;
+    proxy?: "basic" | "stealth" | "auto" | undefined;
+    zeroDataRetention?: boolean | undefined;
+    timeout?: number | undefined;
+}>;
+declare const searchSchema: z.ZodObject<{
+    query: z.ZodString;
+    limit: z.ZodOptional<z.ZodNumber>;
+    sources: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        type: z.ZodEnum<["web", "images", "news"]>;
+    }, "strip", z.ZodTypeAny, {
+        type: "web" | "images" | "news";
+    }, {
+        type: "web" | "images" | "news";
+    }>, "many">>;
+    categories: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        type: z.ZodEnum<["github", "research", "pdf"]>;
+    }, "strip", z.ZodTypeAny, {
+        type: "pdf" | "github" | "research";
+    }, {
+        type: "pdf" | "github" | "research";
+    }>, "many">>;
+    tbs: z.ZodOptional<z.ZodString>;
+    location: z.ZodOptional<z.ZodString>;
+    country: z.ZodOptional<z.ZodString>;
+    timeout: z.ZodOptional<z.ZodNumber>;
+    ignoreInvalidURLs: z.ZodOptional<z.ZodBoolean>;
+    scrapeOptions: z.ZodOptional<z.ZodObject<{
+        formats: z.ZodOptional<z.ZodArray<z.ZodEnum<["markdown", "html", "rawHtml"]>, "many">>;
+        onlyMainContent: z.ZodOptional<z.ZodBoolean>;
+    }, "strip", z.ZodTypeAny, {
+        formats?: ("markdown" | "html" | "rawHtml")[] | undefined;
+        onlyMainContent?: boolean | undefined;
+    }, {
+        formats?: ("markdown" | "html" | "rawHtml")[] | undefined;
+        onlyMainContent?: boolean | undefined;
+    }>>;
+}, "strip", z.ZodTypeAny, {
+    query: string;
+    country?: string | undefined;
+    location?: string | undefined;
+    timeout?: number | undefined;
+    limit?: number | undefined;
+    sources?: {
+        type: "web" | "images" | "news";
+    }[] | undefined;
+    categories?: {
+        type: "pdf" | "github" | "research";
+    }[] | undefined;
+    tbs?: string | undefined;
+    ignoreInvalidURLs?: boolean | undefined;
+    scrapeOptions?: {
+        formats?: ("markdown" | "html" | "rawHtml")[] | undefined;
+        onlyMainContent?: boolean | undefined;
+    } | undefined;
+}, {
+    query: string;
+    country?: string | undefined;
+    location?: string | undefined;
+    timeout?: number | undefined;
+    limit?: number | undefined;
+    sources?: {
+        type: "web" | "images" | "news";
+    }[] | undefined;
+    categories?: {
+        type: "pdf" | "github" | "research";
+    }[] | undefined;
+    tbs?: string | undefined;
+    ignoreInvalidURLs?: boolean | undefined;
+    scrapeOptions?: {
+        formats?: ("markdown" | "html" | "rawHtml")[] | undefined;
+        onlyMainContent?: boolean | undefined;
+    } | undefined;
+}>;
+declare const mapSchema: z.ZodObject<{
+    url: z.ZodString;
+    search: z.ZodOptional<z.ZodString>;
+    limit: z.ZodOptional<z.ZodNumber>;
+    includeSubdomains: z.ZodOptional<z.ZodBoolean>;
+    ignoreSitemap: z.ZodOptional<z.ZodBoolean>;
+}, "strip", z.ZodTypeAny, {
+    url: string;
+    limit?: number | undefined;
+    search?: string | undefined;
+    includeSubdomains?: boolean | undefined;
+    ignoreSitemap?: boolean | undefined;
+}, {
+    url: string;
+    limit?: number | undefined;
+    search?: string | undefined;
+    includeSubdomains?: boolean | undefined;
+    ignoreSitemap?: boolean | undefined;
+}>;
+declare const extractSchema: z.ZodObject<{
+    urls: z.ZodArray<z.ZodString, "many">;
+    prompt: z.ZodOptional<z.ZodString>;
+    schema: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodAny>>;
+    systemPrompt: z.ZodOptional<z.ZodString>;
+    allowExternalLinks: z.ZodOptional<z.ZodBoolean>;
+    enableWebSearch: z.ZodOptional<z.ZodBoolean>;
+    showSources: z.ZodOptional<z.ZodBoolean>;
+    ignoreInvalidURLs: z.ZodOptional<z.ZodBoolean>;
+    scrapeOptions: z.ZodOptional<z.ZodObject<{
+        formats: z.ZodOptional<z.ZodArray<z.ZodEnum<["markdown", "html", "rawHtml"]>, "many">>;
+        onlyMainContent: z.ZodOptional<z.ZodBoolean>;
+        includeTags: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+        excludeTags: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+        waitFor: z.ZodOptional<z.ZodNumber>;
+        mobile: z.ZodOptional<z.ZodBoolean>;
+    }, "strip", z.ZodTypeAny, {
+        formats?: ("markdown" | "html" | "rawHtml")[] | undefined;
+        onlyMainContent?: boolean | undefined;
+        includeTags?: string[] | undefined;
+        excludeTags?: string[] | undefined;
+        waitFor?: number | undefined;
+        mobile?: boolean | undefined;
+    }, {
+        formats?: ("markdown" | "html" | "rawHtml")[] | undefined;
+        onlyMainContent?: boolean | undefined;
+        includeTags?: string[] | undefined;
+        excludeTags?: string[] | undefined;
+        waitFor?: number | undefined;
+        mobile?: boolean | undefined;
+    }>>;
+}, "strip", z.ZodTypeAny, {
+    urls: string[];
+    prompt?: string | undefined;
+    schema?: Record<string, any> | undefined;
+    ignoreInvalidURLs?: boolean | undefined;
+    scrapeOptions?: {
+        formats?: ("markdown" | "html" | "rawHtml")[] | undefined;
+        onlyMainContent?: boolean | undefined;
+        includeTags?: string[] | undefined;
+        excludeTags?: string[] | undefined;
+        waitFor?: number | undefined;
+        mobile?: boolean | undefined;
+    } | undefined;
+    systemPrompt?: string | undefined;
+    allowExternalLinks?: boolean | undefined;
+    enableWebSearch?: boolean | undefined;
+    showSources?: boolean | undefined;
+}, {
+    urls: string[];
+    prompt?: string | undefined;
+    schema?: Record<string, any> | undefined;
+    ignoreInvalidURLs?: boolean | undefined;
+    scrapeOptions?: {
+        formats?: ("markdown" | "html" | "rawHtml")[] | undefined;
+        onlyMainContent?: boolean | undefined;
+        includeTags?: string[] | undefined;
+        excludeTags?: string[] | undefined;
+        waitFor?: number | undefined;
+        mobile?: boolean | undefined;
+    } | undefined;
+    systemPrompt?: string | undefined;
+    allowExternalLinks?: boolean | undefined;
+    enableWebSearch?: boolean | undefined;
+    showSources?: boolean | undefined;
+}>;
+declare const batchScrapeSchema: z.ZodObject<{
+    urls: z.ZodArray<z.ZodString, "many">;
+    formats: z.ZodOptional<z.ZodArray<z.ZodEnum<["markdown", "html", "rawHtml", "screenshot", "links"]>, "many">>;
+    onlyMainContent: z.ZodOptional<z.ZodBoolean>;
+}, "strip", z.ZodTypeAny, {
+    urls: string[];
+    formats?: ("markdown" | "html" | "rawHtml" | "screenshot" | "links")[] | undefined;
+    onlyMainContent?: boolean | undefined;
+}, {
+    urls: string[];
+    formats?: ("markdown" | "html" | "rawHtml" | "screenshot" | "links")[] | undefined;
+    onlyMainContent?: boolean | undefined;
+}>;
+declare const crawlSchema: z.ZodObject<{
+    url: z.ZodString;
+    limit: z.ZodOptional<z.ZodNumber>;
+    maxDepth: z.ZodOptional<z.ZodNumber>;
+    allowExternalLinks: z.ZodOptional<z.ZodBoolean>;
+    allowBackwardLinks: z.ZodOptional<z.ZodBoolean>;
+    includePaths: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+    excludePaths: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+    scrapeOptions: z.ZodOptional<z.ZodObject<{
+        formats: z.ZodOptional<z.ZodArray<z.ZodEnum<["markdown", "html", "rawHtml"]>, "many">>;
+        onlyMainContent: z.ZodOptional<z.ZodBoolean>;
+    }, "strip", z.ZodTypeAny, {
+        formats?: ("markdown" | "html" | "rawHtml")[] | undefined;
+        onlyMainContent?: boolean | undefined;
+    }, {
+        formats?: ("markdown" | "html" | "rawHtml")[] | undefined;
+        onlyMainContent?: boolean | undefined;
+    }>>;
+}, "strip", z.ZodTypeAny, {
+    url: string;
+    limit?: number | undefined;
+    scrapeOptions?: {
+        formats?: ("markdown" | "html" | "rawHtml")[] | undefined;
+        onlyMainContent?: boolean | undefined;
+    } | undefined;
+    allowExternalLinks?: boolean | undefined;
+    maxDepth?: number | undefined;
+    allowBackwardLinks?: boolean | undefined;
+    includePaths?: string[] | undefined;
+    excludePaths?: string[] | undefined;
+}, {
+    url: string;
+    limit?: number | undefined;
+    scrapeOptions?: {
+        formats?: ("markdown" | "html" | "rawHtml")[] | undefined;
+        onlyMainContent?: boolean | undefined;
+    } | undefined;
+    allowExternalLinks?: boolean | undefined;
+    maxDepth?: number | undefined;
+    allowBackwardLinks?: boolean | undefined;
+    includePaths?: string[] | undefined;
+    excludePaths?: string[] | undefined;
+}>;
+declare const checkStatusSchema: z.ZodObject<{
+    id: z.ZodString;
+    jobType: z.ZodOptional<z.ZodEnum<["crawl", "batchScrape", "extract"]>>;
+}, "strip", z.ZodTypeAny, {
+    id: string;
+    jobType?: "crawl" | "batchScrape" | "extract" | undefined;
+}, {
+    id: string;
+    jobType?: "crawl" | "batchScrape" | "extract" | undefined;
+}>;
+type ScrapeParams = z.infer<typeof scrapeSchema>;
+type SearchParams = z.infer<typeof searchSchema>;
+type MapParams = z.infer<typeof mapSchema>;
+type ExtractParams = z.infer<typeof extractSchema>;
+type BatchScrapeParams = z.infer<typeof batchScrapeSchema>;
+type CrawlParams = z.infer<typeof crawlSchema>;
+type CheckStatusParams = z.infer<typeof checkStatusSchema>;
+
+export { type BatchScrapeParams, type CheckStatusParams, type CrawlParams, type ExtractParams, type MapParams, type PollOptions, type ScrapeParams, type SearchParams, batchScrapeSchema, batchScrapeTool, cancelTool, checkStatusSchema, crawlSchema, crawlTool, extractSchema, extractTool, mapSchema, mapTool, pollBatchScrapeJob, pollCrawlJob, pollExtractJob, pollTool, scrapeSchema, scrapeTool, searchSchema, searchTool, statusTool };

package/dist/index.js

@@ -0,0 +1,539 @@
+// src/tools/scrape.ts
+import { tool } from "ai";
+import Firecrawl from "@mendable/firecrawl-js";
+
+// src/schemas/firecrawl.ts
+import { z } from "zod";
+var scrapeSchema = z.object({
+  url: z.string().url().describe("The URL to scrape content from"),
+  formats: z.array(
+    z.union([
+      z.enum([
+        "markdown",
+        "html",
+        "rawHtml",
+        "screenshot",
+        "links",
+        "summary",
+        "changeTracking",
+        "branding"
+      ]),
+      z.object({
+        type: z.literal("json"),
+        prompt: z.string().optional(),
+        schema: z.record(z.string(), z.any()).optional()
+      }),
+      z.object({
+        type: z.literal("screenshot"),
+        fullPage: z.boolean().optional(),
+        quality: z.number().optional(),
+        viewport: z.object({ width: z.number(), height: z.number() }).optional()
+      })
+    ])
+  ).optional().describe("Output formats for the scraped content"),
+  parsers: z.array(
+    z.union([
+      z.enum(["pdf"]),
+      z.object({
+        type: z.enum(["pdf"]),
+        maxPages: z.number().int().min(1).max(1e4).optional()
+      })
+    ])
+  ).optional().describe("Parsers to use for processing content (e.g., PDF parsing)"),
+  onlyMainContent: z.boolean().optional().describe("Extract only the main content, removing headers, footers, and navigation"),
+  includeTags: z.array(z.string()).optional().describe("HTML tags to include in the output"),
+  excludeTags: z.array(z.string()).optional().describe("HTML tags to exclude from the output"),
+  waitFor: z.number().optional().describe("Time in milliseconds to wait before scraping"),
+  actions: z.array(
+    z.object({
+      type: z.enum(["wait", "screenshot", "scroll", "scrape", "click", "write", "press", "executeJavascript", "generatePDF"]),
+      selector: z.string().optional(),
+      milliseconds: z.number().optional(),
+      text: z.string().optional(),
+      key: z.string().optional(),
+      direction: z.enum(["up", "down"]).optional(),
+      script: z.string().optional(),
+      fullPage: z.boolean().optional()
+    })
+  ).optional().describe("Browser actions to perform before scraping (click, scroll, type, wait, etc.)"),
+  mobile: z.boolean().optional().describe("Emulate mobile device"),
+  skipTlsVerification: z.boolean().optional().describe("Skip TLS certificate verification"),
+  removeBase64Images: z.boolean().optional().describe("Remove base64 encoded images from the output"),
+  location: z.object({
+    country: z.string().optional(),
+    languages: z.array(z.string()).optional()
+  }).optional().describe("Location settings for the scraping request"),
+  storeInCache: z.boolean().optional().describe("Store the scraped content in cache"),
+  maxAge: z.number().optional().describe("Maximum age of cached content in milliseconds. Default: 172800000 (2 days)"),
+  headers: z.record(z.string()).optional().describe("Custom headers to send with the request (cookies, user-agent, etc.)"),
+  blockAds: z.boolean().optional().describe("Enable ad-blocking and cookie popup blocking. Default: true"),
+  proxy: z.enum(["basic", "stealth", "auto"]).optional().describe("Proxy type: basic (fast), stealth (reliable, 5 credits), auto (retry with stealth). Default: auto"),
+  zeroDataRetention: z.boolean().optional().describe("Enable zero data retention. Contact help@firecrawl.dev to enable this feature"),
+  timeout: z.number().optional().describe("Timeout in milliseconds. Default: 60000")
+});
+var searchSchema = z.object({
+  query: z.string().min(1).describe("The search query. Supports operators like site:, inurl:, intitle:, etc."),
+  limit: z.number().int().min(1).max(100).optional().describe("Maximum number of search results to return. Default: 5"),
+  sources: z.array(z.object({ type: z.enum(["web", "images", "news"]) })).optional().describe("Sources to search: web, images, news"),
+  categories: z.array(z.object({ type: z.enum(["github", "research", "pdf"]) })).optional().describe("Filter by categories: github (repositories), research (academic), pdf (PDFs)"),
+  tbs: z.string().optional().describe("Time-based search: qdr:h (hour), qdr:d (day), qdr:w (week), qdr:m (month), qdr:y (year)"),
+  location: z.string().optional().describe('Location for search results (e.g., "San Francisco,California,United States")'),
+  country: z.string().optional().describe('ISO country code for geo-targeting (e.g., "US", "DE"). Default: "US"'),
+  timeout: z.number().optional().describe("Timeout in milliseconds. Default: 60000"),
+  ignoreInvalidURLs: z.boolean().optional().describe("Exclude invalid URLs from results. Default: false"),
+  scrapeOptions: z.object({
+    formats: z.array(z.enum(["markdown", "html", "rawHtml"])).optional(),
+    onlyMainContent: z.boolean().optional()
+  }).optional().describe("Options for scraping the search results")
+});
+var mapSchema = z.object({
+  url: z.string().url().describe("The website URL to map and discover URLs from"),
+  search: z.string().optional().describe("Filter URLs containing this keyword"),
+  limit: z.number().int().positive().optional().describe("Maximum number of URLs to discover"),
+  includeSubdomains: z.boolean().optional().describe("Include URLs from subdomains"),
+  ignoreSitemap: z.boolean().optional().describe("Ignore the sitemap and crawl the site directly")
+});
+var extractSchema = z.object({
+  urls: z.array(z.string().url()).min(1).describe("Array of URLs to extract structured data from"),
+  prompt: z.string().optional().describe("Custom prompt to guide the LLM extraction"),
+  schema: z.record(z.any()).optional().describe("JSON schema defining the structure of data to extract"),
+  systemPrompt: z.string().optional().describe("System prompt to guide the extraction behavior"),
+  allowExternalLinks: z.boolean().optional().describe("Allow extraction from external links found on the page"),
+  enableWebSearch: z.boolean().optional().describe("Enable web search to enrich results"),
+  showSources: z.boolean().optional().describe("Include source URLs in the response"),
+  ignoreInvalidURLs: z.boolean().optional().describe("Continue extraction even if some URLs are invalid. Default: true"),
+  scrapeOptions: z.object({
+    formats: z.array(z.enum(["markdown", "html", "rawHtml"])).optional(),
+    onlyMainContent: z.boolean().optional(),
+    includeTags: z.array(z.string()).optional(),
+    excludeTags: z.array(z.string()).optional(),
+    waitFor: z.number().optional(),
+    mobile: z.boolean().optional()
+  }).optional().describe("Advanced scraping options for extraction")
+});
+var batchScrapeSchema = z.object({
+  urls: z.array(z.string().url()).min(1).max(10).describe("Array of URLs to scrape (max 10)"),
+  formats: z.array(z.enum(["markdown", "html", "rawHtml", "screenshot", "links"])).optional().describe("Output formats for the scraped content"),
+  onlyMainContent: z.boolean().optional().describe("Extract only the main content from each URL")
+});
+var crawlSchema = z.object({
+  url: z.string().url().describe("The starting URL to crawl from"),
+  limit: z.number().int().positive().optional().describe("Maximum number of pages to crawl"),
+  maxDepth: z.number().int().positive().optional().describe("Maximum depth of crawling from the starting URL"),
+  allowExternalLinks: z.boolean().optional().describe("Allow crawling external links"),
+  allowBackwardLinks: z.boolean().optional().describe("Allow crawling backward links"),
+  includePaths: z.array(z.string()).optional().describe("Only crawl URLs matching these path patterns"),
+  excludePaths: z.array(z.string()).optional().describe("Exclude URLs matching these path patterns"),
+  scrapeOptions: z.object({
+    formats: z.array(z.enum(["markdown", "html", "rawHtml"])).optional(),
+    onlyMainContent: z.boolean().optional()
+  }).optional().describe("Options for scraping crawled pages")
+});
+var checkStatusSchema = z.object({
+  id: z.string().describe("The job ID to check status for"),
+  jobType: z.enum(["crawl", "batchScrape", "extract"]).optional().describe("Type of job (crawl, batchScrape, or extract). Optional but recommended.")
+});
+
+// src/tools/scrape.ts
+var scrapeTool = tool({
+  description: `Scrape content from a single URL with advanced options.
+
+    Best for: Single page content extraction when you know the exact URL.
+    Returns: Content in specified formats (markdown, html, rawHtml, screenshot, or links).
+
+    Example use cases:
+    - Extract article content from a blog post
+    - Get product information from an e-commerce page
+    - Scrape documentation from a specific page`,
+  inputSchema: scrapeSchema,
+  execute: async function(args) {
+    const apiKey = process.env.FIRECRAWL_API_KEY;
+    if (!apiKey) {
+      throw new Error("FIRECRAWL_API_KEY environment variable is required");
+    }
+    const firecrawl = new Firecrawl({ apiKey });
+    const result = await firecrawl.scrape(args.url, {
+      formats: args.formats || ["markdown"],
+      onlyMainContent: args.onlyMainContent,
+      includeTags: args.includeTags,
+      excludeTags: args.excludeTags,
+      waitFor: args.waitFor,
+      timeout: args.timeout
+    });
+    return result;
+  }
+});
+
+// src/tools/search.ts
+import { tool as tool2 } from "ai";
+import Firecrawl2 from "@mendable/firecrawl-js";
+var searchTool = tool2({
+  description: `Search the web and optionally scrape content from search results.
+
+    Best for: Finding information across multiple websites when you don't know the exact URL.
+    Supports search operators: site:, inurl:, intitle:, related:, etc.
+
+    Example use cases:
+    - Find the latest news about a topic
+    - Search for specific information across multiple sources
+    - Discover content related to a query`,
+  inputSchema: searchSchema,
+  execute: async (args) => {
+    const apiKey = process.env.FIRECRAWL_API_KEY;
+    if (!apiKey) {
+      throw new Error("FIRECRAWL_API_KEY environment variable is required");
+    }
+    const firecrawl = new Firecrawl2({ apiKey });
+    const result = await firecrawl.search(args.query, {
+      limit: args.limit || 5,
+      sources: args.sources,
+      categories: args.categories,
+      tbs: args.tbs,
+      location: args.location,
+      timeout: args.timeout,
+      ignoreInvalidURLs: args.ignoreInvalidURLs,
+      scrapeOptions: args.scrapeOptions
+    });
+    return result;
+  }
+});
+
+// src/tools/map.ts
+import { tool as tool3 } from "ai";
+import Firecrawl3 from "@mendable/firecrawl-js";
+var mapTool = tool3({
+  description: `Map a website to discover all indexed URLs.
+
+    Best for: Discovering URLs on a website before deciding what to scrape or analyzing site structure.
+
+    Example use cases:
+    - Find all pages on a website
+    - Discover blog posts or articles
+    - Analyze website structure
+    - Find specific sections of a website`,
+  inputSchema: mapSchema,
+  execute: async (args) => {
+    const apiKey = process.env.FIRECRAWL_API_KEY;
+    if (!apiKey) {
+      throw new Error("FIRECRAWL_API_KEY environment variable is required");
+    }
+    const firecrawl = new Firecrawl3({ apiKey });
+    const result = await firecrawl.map(args.url, {
+      search: args.search,
+      limit: args.limit,
+      includeSubdomains: args.includeSubdomains
+    });
+    return result;
+  }
+});
+
+// src/tools/extract.ts
+import { tool as tool4 } from "ai";
+import Firecrawl4 from "@mendable/firecrawl-js";
+var extractTool = tool4({
+  description: `Extract structured information from web pages using LLM.
+
+    Best for: Extracting specific structured data like prices, names, details from web pages.
+    
+    Returns:
+    - Immediately returns data for small requests.
+    - Returns a job ID for larger requests (use pollTool with the ID to get results).
+
+    Example use cases:
+    - Extract product information (name, price, description)
+    - Get contact details from company websites
+    - Parse event information (date, location, speakers)
+    - Scrape job listings with structured fields`,
+  inputSchema: extractSchema,
+  execute: async (args) => {
+    const apiKey = process.env.FIRECRAWL_API_KEY;
+    if (!apiKey) {
+      throw new Error("FIRECRAWL_API_KEY environment variable is required");
+    }
+    const firecrawl = new Firecrawl4({ apiKey });
+    const result = await firecrawl.startExtract({
+      urls: args.urls,
+      prompt: args.prompt,
+      schema: args.schema,
+      systemPrompt: args.systemPrompt,
+      allowExternalLinks: args.allowExternalLinks,
+      enableWebSearch: args.enableWebSearch,
+      showSources: args.showSources,
+      ignoreInvalidURLs: args.ignoreInvalidURLs,
+      scrapeOptions: args.scrapeOptions
+    });
+    return result;
+  }
+});
+
+// src/tools/batch.ts
+import { tool as tool5 } from "ai";
+import Firecrawl5 from "@mendable/firecrawl-js";
+var batchScrapeTool = tool5({
+  description: `Scrape multiple URLs in a single request (max 10 URLs).
+
+    Best for: Scraping content from multiple known URLs efficiently.
+
+    Example use cases:
+    - Scrape multiple articles from a list of URLs
+    - Get product pages in bulk
+    - Extract content from several documentation pages
+    - Batch process a list of web pages`,
+  inputSchema: batchScrapeSchema,
+  execute: async (args) => {
+    const apiKey = process.env.FIRECRAWL_API_KEY;
+    if (!apiKey) {
+      throw new Error("FIRECRAWL_API_KEY environment variable is required");
+    }
+    const firecrawl = new Firecrawl5({ apiKey });
+    const result = await firecrawl.batchScrape(args.urls);
+    return result;
+  }
+});
+
+// src/tools/crawl.ts
+import { tool as tool6 } from "ai";
+import Firecrawl6 from "@mendable/firecrawl-js";
+var crawlTool = tool6({
+  description: `Start a crawl job to extract content from multiple related pages on a website.
+
+    Best for: Comprehensive content extraction from multiple pages with depth control.
+    Note: This is an asynchronous operation that returns a job ID. Use checkCrawlStatusTool to monitor progress.
+
+    Example use cases:
+    - Crawl an entire blog section
+    - Extract all documentation pages
+    - Scrape product catalog with pagination
+    - Comprehensive site analysis`,
+  inputSchema: crawlSchema,
+  execute: async (args) => {
+    const apiKey = process.env.FIRECRAWL_API_KEY;
+    if (!apiKey) {
+      throw new Error("FIRECRAWL_API_KEY environment variable is required");
+    }
+    const firecrawl = new Firecrawl6({ apiKey });
+    const result = await firecrawl.startCrawl(args.url, {
+      limit: args.limit,
+      allowExternalLinks: args.allowExternalLinks,
+      includePaths: args.includePaths,
+      excludePaths: args.excludePaths,
+      scrapeOptions: args.scrapeOptions
+    });
+    return result;
+  }
+});
+
+// src/tools/job-management.ts
+import { tool as tool7 } from "ai";
+import { z as z2 } from "zod";
+import Firecrawl8 from "@mendable/firecrawl-js";
+
+// src/helpers/poll-job.ts
+import Firecrawl7 from "@mendable/firecrawl-js";
+async function pollCrawlJob(jobId, options = {}) {
+  const { pollInterval = 2e3, timeout = 6e4, onProgress } = options;
+  const apiKey = process.env.FIRECRAWL_API_KEY;
+  if (!apiKey) {
+    throw new Error("FIRECRAWL_API_KEY environment variable is required");
+  }
+  const firecrawl = new Firecrawl7({ apiKey });
+  const startTime = Date.now();
+  while (Date.now() - startTime < timeout) {
+    const status = await firecrawl.getCrawlStatus(jobId);
+    if (onProgress) {
+      onProgress(status);
+    }
+    if (status.status === "completed") {
+      return status;
+    }
+    if (status.status === "failed" || status.status === "cancelled") {
+      const errorStatus = status;
+      throw new Error(`Crawl job ${status.status}: ${errorStatus.error || "Unknown error"}`);
+    }
+    await new Promise((resolve) => setTimeout(resolve, pollInterval));
+  }
+  throw new Error(`Crawl job timed out after ${timeout}ms`);
+}
+async function pollBatchScrapeJob(jobId, options = {}) {
+  const { pollInterval = 2e3, timeout = 6e4, onProgress } = options;
+  const apiKey = process.env.FIRECRAWL_API_KEY;
+  if (!apiKey) {
+    throw new Error("FIRECRAWL_API_KEY environment variable is required");
+  }
+  const firecrawl = new Firecrawl7({ apiKey });
+  const startTime = Date.now();
+  while (Date.now() - startTime < timeout) {
+    const status = await firecrawl.getBatchScrapeStatus(jobId);
+    if (onProgress) {
+      onProgress(status);
+    }
+    if (status.status === "completed") {
+      return status;
+    }
+    if (status.status === "failed" || status.status === "cancelled") {
+      const errorStatus = status;
+      throw new Error(`Batch scrape job ${status.status}: ${errorStatus.error || "Unknown error"}`);
+    }
+    await new Promise((resolve) => setTimeout(resolve, pollInterval));
+  }
+  throw new Error(`Batch scrape job timed out after ${timeout}ms`);
+}
+async function pollExtractJob(jobId, options = {}) {
+  const { pollInterval = 2e3, timeout = 12e4, onProgress } = options;
+  const apiKey = process.env.FIRECRAWL_API_KEY;
+  if (!apiKey) {
+    throw new Error("FIRECRAWL_API_KEY environment variable is required");
+  }
+  const firecrawl = new Firecrawl7({ apiKey });
+  const startTime = Date.now();
+  while (Date.now() - startTime < timeout) {
+    const status = await firecrawl.getExtractStatus(jobId);
+    if (onProgress) {
+      onProgress(status);
+    }
+    if (status.status === "completed") {
+      return status;
+    }
+    if (status.status === "failed" || status.status === "cancelled") {
+      const errorStatus = status;
+      throw new Error(`Extract job ${status.status}: ${errorStatus.error || "Unknown error"}`);
+    }
+    await new Promise((resolve) => setTimeout(resolve, pollInterval));
+  }
+  throw new Error(`Extract job timed out after ${timeout}ms`);
+}
+
+// src/tools/job-management.ts
+var pollResultsSchema = z2.object({
+  jobId: z2.string().describe("The job ID returned from crawl, batchScrape, or extract operations"),
+  jobType: z2.enum(["crawl", "batchScrape", "extract"]).describe("Type of job to poll for"),
+  pollInterval: z2.number().optional().describe("How often to check status in seconds (default: 2)"),
+  maxWaitTime: z2.number().optional().describe("Maximum time to wait in seconds (default: 60)")
+});
+var pollTool = tool7({
+  description: `Poll for results from async Firecrawl jobs (crawl, batchScrape, or extract).
+
+    Use this tool after starting a crawl, batchScrape, or extract job to wait for completion and get results.
+
+    Best for: Getting results from async operations you've already started.
+
+    Example workflow:
+    1. Use crawlTool to start a crawl \u2192 get job ID
+    2. Use pollTool with that job ID \u2192 get completed results`,
+  inputSchema: pollResultsSchema,
+  execute: async function(args) {
+    const options = {
+      pollInterval: (args.pollInterval || 2) * 1e3,
+      timeout: (args.maxWaitTime || 60) * 1e3
+    };
+    try {
+      let result;
+      if (args.jobType === "crawl") {
+        result = await pollCrawlJob(args.jobId, options);
+      } else if (args.jobType === "batchScrape") {
+        result = await pollBatchScrapeJob(args.jobId, options);
+      } else if (args.jobType === "extract") {
+        result = await pollExtractJob(args.jobId, options);
+      }
+      if (args.jobType === "extract") {
+        return {
+          success: true,
+          status: "completed",
+          data: result.data
+        };
+      }
+      return {
+        success: true,
+        status: "completed",
+        data: result.data,
+        total: result.total,
+        creditsUsed: result.creditsUsed
+      };
+    } catch (error) {
+      return {
+        success: false,
+        status: "failed",
+        error: error.message
+      };
+    }
+  }
+});
+var statusTool = tool7({
+  description: `Check the status of a Firecrawl job (crawl, batch, or extract).
+
+    Use this tool to check the current progress of any async job.
+    Returns the status and partial/complete results if available.
+
+    Possible statuses: pending, scraping, completed, failed`,
+  inputSchema: checkStatusSchema,
+  execute: async (args) => {
+    const apiKey = process.env.FIRECRAWL_API_KEY;
+    if (!apiKey) {
+      throw new Error("FIRECRAWL_API_KEY environment variable is required");
+    }
+    const firecrawl = new Firecrawl8({ apiKey });
+    let result;
+    const jobType = args.jobType || "crawl";
+    if (jobType === "crawl") {
+      result = await firecrawl.getCrawlStatus(args.id);
+    } else if (jobType === "batchScrape") {
+      result = await firecrawl.getBatchScrapeStatus(args.id);
+    } else if (jobType === "extract") {
+      result = await firecrawl.getExtractStatus(args.id);
+    }
+    return result;
+  }
+});
+var cancelJobSchema = z2.object({
+  jobId: z2.string().describe("The job ID to cancel"),
+  jobType: z2.enum(["crawl", "batchScrape"]).describe("The type of job to cancel")
+});
+var cancelTool = tool7({
+  description: `Cancel a running Firecrawl job (crawl or batch scrape).
+
+    Use this tool to stop a long-running operation that is no longer needed.
+    Note: Extraction jobs cannot be cancelled via this API.
+
+    Returns the cancellation status.`,
+  inputSchema: cancelJobSchema,
+  execute: async function(args) {
+    const apiKey = process.env.FIRECRAWL_API_KEY;
+    if (!apiKey) {
+      throw new Error("FIRECRAWL_API_KEY environment variable is required");
+    }
+    const firecrawl = new Firecrawl8({ apiKey });
+    let result = false;
+    if (args.jobType === "crawl") {
+      result = await firecrawl.cancelCrawl(args.jobId);
+    } else if (args.jobType === "batchScrape") {
+      result = await firecrawl.cancelBatchScrape(args.jobId);
+    }
+    return {
+      success: result,
+      jobId: args.jobId,
+      jobType: args.jobType,
+      message: result ? `${args.jobType} cancelled successfully` : `Failed to cancel ${args.jobType}`
+    };
+  }
+});
+export {
+  batchScrapeSchema,
+  batchScrapeTool,
+  cancelTool,
+  checkStatusSchema,
+  crawlSchema,
+  crawlTool,
+  extractSchema,
+  extractTool,
+  mapSchema,
+  mapTool,
+  pollBatchScrapeJob,
+  pollCrawlJob,
+  pollExtractJob,
+  pollTool,
+  scrapeSchema,
+  scrapeTool,
+  searchSchema,
+  searchTool,
+  statusTool
+};

package/package.json

@@ -0,0 +1,53 @@
+{
+  "name": "firecrawl-aisdk",
+  "version": "0.7.1",
+  "description": "Firecrawl tools for Vercel AI SDK - Web scraping and search capabilities for AI applications",
+  "type": "module",
+  "main": "./dist/index.js",
+  "module": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "import": "./dist/index.js",
+      "types": "./dist/index.d.ts"
+    }
+  },
+  "files": [
+    "dist"
+  ],
+  "keywords": [
+    "ai",
+    "ai-sdk",
+    "vercel",
+    "firecrawl",
+    "web-scraping",
+    "web-search",
+    "tools",
+    "llm"
+  ],
+  "author": "firecrawl",
+  "license": "MIT",
+  "engines": {
+    "node": ">=18.0.0"
+  },
+  "dependencies": {
+    "@mendable/firecrawl-js": "^4.6.1",
+    "ai": "^5.0.0",
+    "zod": "^3.0.0"
+  },
+  "devDependencies": {
+    "@ai-sdk/openai": "^2.0.69",
+    "@types/node": "^20.0.0",
+    "@vitest/ui": "^2.1.8",
+    "dotenv": "^17.2.3",
+    "tsup": "^8.5.0",
+    "tsx": "^4.20.6",
+    "typescript": "^5.9.3",
+    "vitest": "^2.1.8"
+  },
+  "scripts": {
+    "build": "tsup src/index.ts --format esm --dts",
+    "test": "vitest run",
+    "test:watch": "vitest"
+  }
+}