unbrowse 8.3.0-preview.2 → 8.3.0-preview.4

package/dist-sdk/adapters/firecrawl.d.ts

@@ -0,0 +1,57 @@
+/**
+ * src/sdk/adapters/firecrawl.ts — drop-in replacement for the `@mendable/firecrawl-js`
+ * client.
+ *
+ * Same construction (`new FirecrawlApp({ apiKey })`) and the same method shapes
+ * (`scrapeUrl`, `search`, `mapUrl`, `crawlUrl`) returning firecrawl-shaped results — but
+ * every call routes through the wallet-sealed unbrowse hole instead of Firecrawl's API.
+ * Swap the import, keep your code. Where Firecrawl bills a flat monthly plan, the hole
+ * settles each call via x402 — you pay per request, only for what you actually fetch.
+ * Inject a `transport`/`wallet` (HoleOptions) for tests or to bind the hole to a wallet.
+ */
+import { type HoleOptions } from "../hole.js";
+export interface FirecrawlMetadata {
+    sourceURL?: string;
+    title?: string;
+    description?: string;
+    [key: string]: unknown;
+}
+export interface FirecrawlDocument {
+    url?: string;
+    markdown?: string;
+    html?: string;
+    metadata?: FirecrawlMetadata;
+}
+export interface ScrapeResponse extends FirecrawlDocument {
+    success: boolean;
+}
+export interface SearchResponse {
+    success: boolean;
+    data: FirecrawlDocument[];
+}
+export interface MapResponse {
+    success: boolean;
+    links: string[];
+}
+export interface CrawlResponse {
+    success: boolean;
+    status: string;
+    completed: number;
+    total: number;
+    data: FirecrawlDocument[];
+}
+export declare class FirecrawlApp {
+    private readonly hole;
+    constructor(opts?: {
+        apiKey?: string;
+    } & HoleOptions);
+    scrapeUrl(url: string, _params?: Record<string, unknown>): Promise<ScrapeResponse>;
+    search(query: string, params?: {
+        limit?: number;
+    } & Record<string, unknown>): Promise<SearchResponse>;
+    mapUrl(url: string, _params?: Record<string, unknown>): Promise<MapResponse>;
+    crawlUrl(url: string, params?: {
+        limit?: number;
+    } & Record<string, unknown>): Promise<CrawlResponse>;
+}
+export default FirecrawlApp;

package/dist-sdk/adapters/firecrawl.js

@@ -0,0 +1,51 @@
+/**
+ * src/sdk/adapters/firecrawl.ts — drop-in replacement for the `@mendable/firecrawl-js`
+ * client.
+ *
+ * Same construction (`new FirecrawlApp({ apiKey })`) and the same method shapes
+ * (`scrapeUrl`, `search`, `mapUrl`, `crawlUrl`) returning firecrawl-shaped results — but
+ * every call routes through the wallet-sealed unbrowse hole instead of Firecrawl's API.
+ * Swap the import, keep your code. Where Firecrawl bills a flat monthly plan, the hole
+ * settles each call via x402 — you pay per request, only for what you actually fetch.
+ * Inject a `transport`/`wallet` (HoleOptions) for tests or to bind the hole to a wallet.
+ */
+import { createHole } from "../hole.js";
+function toDoc(it) {
+    const url = it.url ?? "";
+    return {
+        url,
+        markdown: typeof it.text === "string" ? it.text : undefined,
+        metadata: { sourceURL: url, title: it.title ?? undefined },
+    };
+}
+export class FirecrawlApp {
+    hole;
+    constructor(opts = {}) {
+        // apiKey is accepted for drop-in compatibility but unused — the hole is
+        // wallet-sealed and settles per call via x402, not a Firecrawl key.
+        const { apiKey: _apiKey, ...holeOpts } = opts;
+        this.hole = createHole(holeOpts);
+    }
+    async scrapeUrl(url, _params = {}) {
+        const r = await this.hole.fill({ intent: `contents of ${url}`, url });
+        const first = r.items[0];
+        const doc = toDoc(first ? { ...first, url } : { url });
+        return { success: true, ...doc };
+    }
+    async search(query, params = {}) {
+        const r = await this.hole.fill({ intent: query, params });
+        const n = params.limit ?? r.items.length;
+        return { success: true, data: r.items.slice(0, n).map(toDoc) };
+    }
+    async mapUrl(url, _params = {}) {
+        const r = await this.hole.fill({ intent: `links on ${url}`, url });
+        return { success: true, links: r.items.map((it) => it.url ?? "").filter(Boolean) };
+    }
+    async crawlUrl(url, params = {}) {
+        const r = await this.hole.fill({ intent: `crawl ${url}`, url, params });
+        const n = params.limit ?? r.items.length;
+        const data = r.items.slice(0, n).map(toDoc);
+        return { success: true, status: "completed", completed: data.length, total: data.length, data };
+    }
+}
+export default FirecrawlApp;

package/dist-sdk/adapters/index.d.ts

@@ -6,11 +6,14 @@
  *
  *   import Exa from "@unbrowse/sdk/adapters/exa";          // was: import Exa from "exa-js"
  *   import { tavily } from "@unbrowse/sdk/adapters/tavily"; // was: from "@tavily/core"
+ *   import FirecrawlApp from "@unbrowse/sdk/adapters/firecrawl"; // was: from "@mendable/firecrawl-js"
  *   import { Agent } from "@unbrowse/sdk/adapters/browser-use";
  *
- * All of them wrap the same wallet-sealed streaming hole (`../hole.ts`).
+ * All of them wrap the same wallet-sealed streaming hole (`../hole.ts`), so each call
+ * settles per request via x402 — you pay only for what you fetch, not a flat plan.
  */
 export { Exa, type ExaResult, type ExaSearchResponse, type ExaSearchOptions } from "./exa.js";
 export { tavily, type TavilyClient, type TavilyResult, type TavilySearchResponse } from "./tavily.js";
+export { FirecrawlApp, type FirecrawlDocument, type ScrapeResponse, type SearchResponse, type MapResponse, type CrawlResponse, } from "./firecrawl.js";
 export { Agent, type AgentOptions, type AgentResult } from "./browser-use.js";
 export { createHole, Hole, type HoleRequest, type HoleResult, type HoleItem, type HoleOptions, type HoleTransport, type WalletSeal, } from "../hole.js";

package/dist-sdk/adapters/index.js

@@ -6,11 +6,14 @@
  *
  *   import Exa from "@unbrowse/sdk/adapters/exa";          // was: import Exa from "exa-js"
  *   import { tavily } from "@unbrowse/sdk/adapters/tavily"; // was: from "@tavily/core"
+ *   import FirecrawlApp from "@unbrowse/sdk/adapters/firecrawl"; // was: from "@mendable/firecrawl-js"
  *   import { Agent } from "@unbrowse/sdk/adapters/browser-use";
  *
- * All of them wrap the same wallet-sealed streaming hole (`../hole.ts`).
+ * All of them wrap the same wallet-sealed streaming hole (`../hole.ts`), so each call
+ * settles per request via x402 — you pay only for what you fetch, not a flat plan.
  */
 export { Exa } from "./exa.js";
 export { tavily } from "./tavily.js";
+export { FirecrawlApp, } from "./firecrawl.js";
 export { Agent } from "./browser-use.js";
 export { createHole, Hole, } from "../hole.js";

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "unbrowse",
-  "version": "8.3.0-preview.2",
+  "version": "8.3.0-preview.4",
   "description": "Reverse-engineer any website into reusable API skills. Zero-dep single binary with embedded browser engine.",
   "mcpName": "io.github.unbrowse-ai/unbrowse",
   "type": "module",