@openclaw/firecrawl-plugin 0.0.0 → 2026.6.9-beta.1

package/dist/index.js

@@ -0,0 +1,121 @@
+import { n as runFirecrawlScrape, r as runFirecrawlSearch } from "./firecrawl-client-DcIDkg-C.js";
+import { t as createFirecrawlWebFetchProvider } from "./firecrawl-fetch-provider-XTUD9NBF.js";
+import { t as createFirecrawlWebSearchProvider } from "./firecrawl-search-provider-CpEdMkT_.js";
+import { definePluginEntry } from "openclaw/plugin-sdk/plugin-entry";
+import { optionalStringEnum } from "openclaw/plugin-sdk/channel-actions";
+import { jsonResult, readNonNegativeIntegerParam, readPositiveIntegerParam, readStringArrayParam, readStringParam } from "openclaw/plugin-sdk/provider-web-search";
+import { Type } from "typebox";
+//#region extensions/firecrawl/src/firecrawl-scrape-tool.ts
+const FirecrawlScrapeToolSchema = Type.Object({
+	url: Type.String({ description: "HTTP or HTTPS URL to scrape via Firecrawl." }),
+	extractMode: optionalStringEnum(["markdown", "text"], { description: "Extraction mode (\"markdown\" or \"text\"). Default: markdown." }),
+	maxChars: Type.Optional(Type.Integer({
+		description: "Maximum characters to return.",
+		minimum: 100
+	})),
+	onlyMainContent: Type.Optional(Type.Boolean({ description: "Keep only main content when Firecrawl supports it." })),
+	maxAgeMs: Type.Optional(Type.Integer({
+		description: "Maximum Firecrawl cache age in milliseconds.",
+		minimum: 0
+	})),
+	proxy: optionalStringEnum([
+		"auto",
+		"basic",
+		"stealth"
+	], { description: "Firecrawl proxy mode (\"auto\", \"basic\", or \"stealth\")." }),
+	storeInCache: Type.Optional(Type.Boolean({ description: "Whether Firecrawl should store the scrape in its cache." })),
+	timeoutSeconds: Type.Optional(Type.Integer({
+		description: "Timeout in seconds for the Firecrawl scrape request.",
+		minimum: 1
+	}))
+}, { additionalProperties: false });
+function createFirecrawlScrapeTool(api) {
+	return {
+		name: "firecrawl_scrape",
+		label: "Firecrawl Scrape",
+		description: "Scrape a page using Firecrawl v2/scrape. Useful for JS-heavy or bot-protected pages where plain web_fetch is weak.",
+		parameters: FirecrawlScrapeToolSchema,
+		execute: async (_toolCallId, rawParams) => {
+			const url = readStringParam(rawParams, "url", { required: true });
+			const extractMode = readStringParam(rawParams, "extractMode") === "text" ? "text" : "markdown";
+			const maxChars = readPositiveIntegerParam(rawParams, "maxChars");
+			const maxAgeMs = readNonNegativeIntegerParam(rawParams, "maxAgeMs");
+			const timeoutSeconds = readPositiveIntegerParam(rawParams, "timeoutSeconds");
+			const proxyRaw = readStringParam(rawParams, "proxy");
+			const proxy = proxyRaw === "basic" || proxyRaw === "stealth" || proxyRaw === "auto" ? proxyRaw : void 0;
+			const onlyMainContent = typeof rawParams.onlyMainContent === "boolean" ? rawParams.onlyMainContent : void 0;
+			const storeInCache = typeof rawParams.storeInCache === "boolean" ? rawParams.storeInCache : void 0;
+			return jsonResult(await runFirecrawlScrape({
+				cfg: api.config,
+				url,
+				extractMode,
+				maxChars,
+				onlyMainContent,
+				maxAgeMs,
+				proxy,
+				storeInCache,
+				timeoutSeconds
+			}));
+		}
+	};
+}
+//#endregion
+//#region extensions/firecrawl/src/firecrawl-search-tool.ts
+const FirecrawlSearchToolSchema = Type.Object({
+	query: Type.String({ description: "Search query string." }),
+	count: Type.Optional(Type.Integer({
+		description: "Number of results to return (1-10).",
+		minimum: 1,
+		maximum: 10
+	})),
+	sources: Type.Optional(Type.Array(Type.String(), { description: "Optional sources list, for example [\"web\"], [\"news\"], or [\"images\"]." })),
+	categories: Type.Optional(Type.Array(Type.String(), { description: "Optional Firecrawl categories, for example [\"github\"] or [\"research\"]." })),
+	scrapeResults: Type.Optional(Type.Boolean({ description: "Include scraped result content when Firecrawl returns it." })),
+	timeoutSeconds: Type.Optional(Type.Integer({
+		description: "Timeout in seconds for the Firecrawl Search request.",
+		minimum: 1
+	}))
+}, { additionalProperties: false });
+function createFirecrawlSearchTool(api) {
+	return {
+		name: "firecrawl_search",
+		label: "Firecrawl Search",
+		description: "Search the web using Firecrawl v2/search. Can optionally include scraped content from result pages.",
+		parameters: FirecrawlSearchToolSchema,
+		execute: async (_toolCallId, rawParams) => {
+			const query = readStringParam(rawParams, "query", { required: true });
+			const count = readPositiveIntegerParam(rawParams, "count", {
+				max: 10,
+				message: "count must be an integer from 1 to 10"
+			});
+			const timeoutSeconds = readPositiveIntegerParam(rawParams, "timeoutSeconds");
+			const sources = readStringArrayParam(rawParams, "sources");
+			const categories = readStringArrayParam(rawParams, "categories");
+			const scrapeResults = rawParams.scrapeResults === true;
+			return jsonResult(await runFirecrawlSearch({
+				cfg: api.config,
+				query,
+				count,
+				timeoutSeconds,
+				sources,
+				categories,
+				scrapeResults
+			}));
+		}
+	};
+}
+//#endregion
+//#region extensions/firecrawl/index.ts
+var firecrawl_default = definePluginEntry({
+	id: "firecrawl",
+	name: "Firecrawl Plugin",
+	description: "Bundled Firecrawl search and scrape plugin",
+	register(api) {
+		api.registerWebFetchProvider(createFirecrawlWebFetchProvider());
+		api.registerWebSearchProvider(createFirecrawlWebSearchProvider());
+		api.registerTool(createFirecrawlSearchTool(api));
+		api.registerTool(createFirecrawlScrapeTool(api));
+	}
+});
+//#endregion
+export { firecrawl_default as default };

package/dist/web-fetch-contract-api.js

@@ -0,0 +1,12 @@
+import { t as FIRECRAWL_WEB_FETCH_PROVIDER_SHARED } from "./firecrawl-fetch-provider-shared-BQUWpKAv.js";
+import { enablePluginInConfig } from "openclaw/plugin-sdk/provider-web-fetch-contract";
+//#region extensions/firecrawl/web-fetch-contract-api.ts
+function createFirecrawlWebFetchProvider() {
+	return {
+		...FIRECRAWL_WEB_FETCH_PROVIDER_SHARED,
+		applySelectionConfig: (config) => enablePluginInConfig(config, "firecrawl").config,
+		createTool: () => null
+	};
+}
+//#endregion
+export { createFirecrawlWebFetchProvider };

package/dist/web-fetch-provider.js

@@ -0,0 +1,2 @@
+import { t as createFirecrawlWebFetchProvider } from "./firecrawl-fetch-provider-XTUD9NBF.js";
+export { createFirecrawlWebFetchProvider };

package/dist/web-search-contract-api.js

@@ -0,0 +1,10 @@
+import { buildFirecrawlWebSearchProviderBase } from "./web-search-shared.js";
+//#region extensions/firecrawl/web-search-contract-api.ts
+function createFirecrawlWebSearchProvider() {
+	return {
+		...buildFirecrawlWebSearchProviderBase(),
+		createTool: () => null
+	};
+}
+//#endregion
+export { createFirecrawlWebSearchProvider };

package/dist/web-search-provider.js

@@ -0,0 +1,2 @@
+import { t as createFirecrawlWebSearchProvider } from "./firecrawl-search-provider-CpEdMkT_.js";
+export { createFirecrawlWebSearchProvider };

package/dist/web-search-shared.js

@@ -0,0 +1,54 @@
+import { createWebSearchProviderContractFields, enablePluginInConfig } from "openclaw/plugin-sdk/provider-web-search-contract";
+//#region extensions/firecrawl/web-search-shared.ts
+const FIRECRAWL_CREDENTIAL_PATH = "plugins.entries.firecrawl.config.webSearch.apiKey";
+const FIRECRAWL_FETCH_CREDENTIAL_PATH = "plugins.entries.firecrawl.config.webFetch.apiKey";
+function getConfiguredFirecrawlFetchCredentialFallback(config) {
+	const apiKey = (config?.plugins?.entries?.firecrawl?.config)?.webFetch?.apiKey;
+	return apiKey === void 0 ? void 0 : {
+		path: FIRECRAWL_FETCH_CREDENTIAL_PATH,
+		value: apiKey
+	};
+}
+function buildFirecrawlWebSearchProviderBase() {
+	return {
+		id: "firecrawl",
+		label: "Firecrawl Search",
+		hint: "Structured results with optional result scraping",
+		onboardingScopes: ["text-inference"],
+		credentialLabel: "Firecrawl API key",
+		envVars: ["FIRECRAWL_API_KEY"],
+		placeholder: "fc-...",
+		signupUrl: "https://www.firecrawl.dev/",
+		docsUrl: "https://docs.openclaw.ai/tools/firecrawl",
+		autoDetectOrder: 60,
+		credentialPath: FIRECRAWL_CREDENTIAL_PATH,
+		...createWebSearchProviderContractFields({
+			credentialPath: FIRECRAWL_CREDENTIAL_PATH,
+			searchCredential: {
+				type: "scoped",
+				scopeId: "firecrawl"
+			},
+			configuredCredential: { pluginId: "firecrawl" }
+		}),
+		applySelectionConfig: (config) => {
+			const enabled = enablePluginInConfig(config, "firecrawl");
+			if (!enabled.enabled || enabled.config.tools?.web?.fetch?.provider) return enabled.config;
+			return {
+				...enabled.config,
+				tools: {
+					...enabled.config.tools,
+					web: {
+						...enabled.config.tools?.web,
+						fetch: {
+							...enabled.config.tools?.web?.fetch,
+							provider: "firecrawl"
+						}
+					}
+				}
+			};
+		},
+		getConfiguredCredentialFallback: getConfiguredFirecrawlFetchCredentialFallback
+	};
+}
+//#endregion
+export { FIRECRAWL_CREDENTIAL_PATH, FIRECRAWL_FETCH_CREDENTIAL_PATH, buildFirecrawlWebSearchProviderBase, getConfiguredFirecrawlFetchCredentialFallback };

package/node_modules/typebox/build/compile/code.d.mts

@@ -0,0 +1,12 @@
+import { type TProperties, type TSchema } from '../type/index.mjs';
+import { type TExternal } from '../schema/index.mjs';
+export interface CodeResult {
+    /** External Variables  */
+    External: TExternal;
+    /** Generated Esm module. */
+    Code: string;
+}
+/** Creates a standalone ESM validation module for the given type. */
+export declare function Code<Type extends TSchema>(type: Type): CodeResult;
+/** Creates a standalone ESM validation module for the given type. */
+export declare function Code<Context extends TProperties, Type extends TSchema>(context: Context, type: Type): CodeResult;

package/node_modules/typebox/build/compile/code.mjs

@@ -0,0 +1,65 @@
+// deno-fmt-ignore-file
+import { Arguments } from '../system/arguments/index.mjs';
+import { Build } from '../schema/index.mjs';
+// ------------------------------------------------------------------
+// Comments and Formatting
+// ------------------------------------------------------------------
+function TsIgnore() {
+    return `// @ts-ignore`;
+}
+function Separator() {
+    return ``;
+}
+// ------------------------------------------------------------------
+// ImportSection
+// ------------------------------------------------------------------
+function ImportSection(build) {
+    const context = build.UseUnevaluated() ? [`import { CheckContext } from "typebox/schema"`] : [];
+    const hashing = `import { Hashing } from "typebox/system"`;
+    const format = `import { Format } from "typebox/format"`;
+    const guard = `import { Guard } from "typebox/guard"`;
+    return [...context, hashing, format, guard];
+}
+// ------------------------------------------------------------------
+// ExternalSection
+// ------------------------------------------------------------------
+function ExternalSection(build) {
+    const { identifier } = build.External();
+    return [
+        Separator(),
+        TsIgnore(),
+        `let ${identifier} = []`,
+        Separator(),
+        TsIgnore(),
+        `export function SetExternal(external) { ${identifier} = external.variables }`
+    ];
+}
+// ------------------------------------------------------------------
+// FunctionSection
+// ------------------------------------------------------------------
+function FunctionSection(build) {
+    return build.Functions().map((func) => [Separator(), TsIgnore(), `${func};`].join('\n'));
+}
+// ------------------------------------------------------------------
+// ExportSection
+// ------------------------------------------------------------------
+function ExportSection(build) {
+    const body = build.UseUnevaluated()
+        ? `const context = new CheckContext({}, {}); return ${build.Entry()}`
+        : `return ${build.Entry()}`;
+    return [
+        Separator(),
+        TsIgnore(),
+        `export function Check(value) { ${body} }`
+    ];
+}
+/** Creates a standalone ESM validation module for the given type. */
+export function Code(...args) {
+    const [context, type] = Arguments.Match(args, {
+        2: (context, type) => [context, type],
+        1: (type) => [{}, type]
+    });
+    const build = Build(context, type);
+    const code = [...ImportSection(build), ...ExternalSection(build), ...FunctionSection(build), ...ExportSection(build)].join('\n');
+    return { External: build.External(), Code: code };
+}

package/node_modules/typebox/build/compile/compile.d.mts

@@ -0,0 +1,6 @@
+import { type TProperties, type TSchema } from '../type/index.mjs';
+import { Validator } from './validator.mjs';
+/** Compiles a type into a high performance Validator */
+export declare function Compile<const Type extends TSchema, Result extends Validator = Validator<{}, Type>>(type: Type): Result;
+/** Compiles a type into a high performance Validator */
+export declare function Compile<Context extends TProperties, const Type extends TSchema, Result extends Validator = Validator<Context, Type>>(context: Context, type: Type): Result;

package/node_modules/typebox/build/compile/compile.mjs

@@ -0,0 +1,12 @@
+// deno-lint-ignore-file ban-types
+// deno-fmt-ignore-file
+import { Arguments } from '../system/arguments/index.mjs';
+import { Validator } from './validator.mjs';
+/** Compiles a type into a high performance Validator */
+export function Compile(...args) {
+    const [context, type] = Arguments.Match(args, {
+        2: (context, type) => [context, type],
+        1: (type) => [{}, type]
+    });
+    return new Validator(context, type);
+}

package/node_modules/typebox/build/compile/index.d.mts

@@ -0,0 +1,8 @@
+export * from './code.mjs';
+export * from './compile.mjs';
+export * from './validator.mjs';
+import { Code } from './code.mjs';
+import { Compile } from './compile.mjs';
+import { Validator } from './validator.mjs';
+export { Code, Compile, Validator };
+export default Compile;

package/node_modules/typebox/build/compile/index.mjs

@@ -0,0 +1,14 @@
+// ------------------------------------------------------------------
+// Barrel
+// ------------------------------------------------------------------
+export * from './code.mjs';
+export * from './compile.mjs';
+export * from './validator.mjs';
+// ------------------------------------------------------------------
+// Default
+// ------------------------------------------------------------------
+import { Code } from './code.mjs';
+import { Compile } from './compile.mjs';
+import { Validator } from './validator.mjs';
+export { Code, Compile, Validator };
+export default Compile;

package/node_modules/typebox/build/compile/validator.d.mts

@@ -0,0 +1,43 @@
+import { type TLocalizedValidationError } from '../error/index.mjs';
+import { type StaticDecode, type StaticEncode, type TProperties, type TSchema, Base } from '../type/index.mjs';
+import { BuildResult, EvaluateResult } from '../schema/index.mjs';
+export declare class Validator<Context extends TProperties = TProperties, Type extends TSchema = TSchema, Encode extends unknown = StaticEncode<Type, Context>, Decode extends unknown = StaticDecode<Type, Context>> extends Base<Encode> {
+    private readonly hasCodec;
+    private readonly buildResult;
+    private readonly evaluateResult;
+    /** Constructs a Validator with the given Context and Type. */
+    constructor(context: Context, type: Type);
+    /** Constructs a Validator with the given arguments. */
+    constructor(hasCodec: boolean, buildResult: BuildResult, evaluateResult: EvaluateResult);
+    /** Returns true if this Validator is using JIT acceleration. */
+    IsAccelerated(): boolean;
+    /** Returns the Context for this validator. */
+    Context(): Context;
+    /** Returns the underlying Type used to construct this Validator. */
+    Type(): Type;
+    /** Returns the generated code for this validator. */
+    Code(): string;
+    /** Performs a type-guard check on the provided value. */
+    Check(value: unknown): value is Encode;
+    /** Validates a value and returns it. Will throw if invalid. */
+    Parse(value: unknown): Encode;
+    /** Inspects a value and returns a detailed list of validation errors. */
+    Errors(value: unknown): TLocalizedValidationError[];
+    /** Cleans a value using the Validator type. */
+    Clean(value: unknown): unknown;
+    /** Converts a value using the Validator type. */
+    Convert(value: unknown): unknown;
+    /** Creates a value using the Validator type. */
+    Create(): Encode;
+    /** Creates defaults using the Validator type. */
+    Default(value: unknown): unknown;
+    /** Decodes a value */
+    Decode(value: unknown): Decode;
+    /** Encodes a value */
+    Encode(value: unknown): Encode;
+    /**
+     * @deprecated Validator instances should not support Clone because they are owners of JIT evaluated functions. This function will be
+     * removed in the next version of TypeBox (relates to Type.Base deprecation)
+     */
+    Clone(): Validator<Context, Type>;
+}

package/node_modules/typebox/build/compile/validator.mjs

@@ -0,0 +1,121 @@
+// deno-fmt-ignore-file
+import { Settings } from '../system/settings/index.mjs';
+import { Arguments } from '../system/arguments/index.mjs';
+import { Base } from '../type/index.mjs';
+import { Errors, Clean, Convert, Create, Default, Decode, Encode, HasCodec, Parser, ParseError } from '../value/index.mjs';
+import { Build, BuildResult, EvaluateResult } from '../schema/index.mjs';
+// ------------------------------------------------------------------
+// Validator<...>
+// ------------------------------------------------------------------
+export class Validator extends Base {
+    /** Constructs a Validator. */
+    constructor(...args) {
+        super();
+        const matched = Arguments.Match(args, {
+            3: (hasCodec, buildResult, evaluateResult) => [hasCodec, buildResult, evaluateResult],
+            2: (context, type) => [context, type]
+        });
+        // Note: The Base type requires this Validator to be Clone, but where we cannot safely clone
+        // the BuildResult or the EvaluateResult. For now we pass the Validator constructor a shared 
+        // reference of BuildResult and EvaluateResult to mitigate re-compile on Clone. We must remove 
+        // this overload when Base is removed (memory-gc-ref)
+        if (matched.length === 3 && matched[1] instanceof BuildResult && matched[2] instanceof EvaluateResult) {
+            const [hasCodec, buildResult, evaluateResult] = matched;
+            this.hasCodec = hasCodec;
+            this.buildResult = buildResult;
+            this.evaluateResult = evaluateResult;
+        }
+        else {
+            const [context, type] = matched;
+            this.hasCodec = HasCodec(context, type);
+            this.buildResult = Build(context, type);
+            this.evaluateResult = this.buildResult.Evaluate();
+        }
+    }
+    // ----------------------------------------------------------------
+    // IsAccelerated
+    // ----------------------------------------------------------------
+    /** Returns true if this Validator is using JIT acceleration. */
+    IsAccelerated() {
+        return this.evaluateResult.IsAccelerated();
+    }
+    // ----------------------------------------------------------------
+    // Context & Type
+    // ----------------------------------------------------------------
+    /** Returns the Context for this validator. */
+    Context() {
+        return this.buildResult.Context();
+    }
+    /** Returns the underlying Type used to construct this Validator. */
+    Type() {
+        return this.buildResult.Schema();
+    }
+    // ----------------------------------------------------------------
+    // Code
+    // ----------------------------------------------------------------
+    /** Returns the generated code for this validator. */
+    Code() {
+        return this.evaluateResult.Code();
+    }
+    // ----------------------------------------------------------------
+    // Standard Validator
+    // ----------------------------------------------------------------
+    /** Performs a type-guard check on the provided value. */
+    Check(value) {
+        return this.evaluateResult.Check(value);
+    }
+    /** Validates a value and returns it. Will throw if invalid. */
+    Parse(value) {
+        const checked = this.Check(value);
+        if (checked)
+            return value;
+        if (Settings.Get().correctiveParse)
+            return Parser(this.Context(), this.Type(), value);
+        throw new ParseError(value, this.Errors(value));
+    }
+    /** Inspects a value and returns a detailed list of validation errors. */
+    Errors(value) {
+        if (this.IsAccelerated() && this.Check(value))
+            return [];
+        return Errors(this.Context(), this.Type(), value);
+    }
+    // ----------------------------------------------------------------
+    // Value.* Operations
+    // ----------------------------------------------------------------
+    /** Cleans a value using the Validator type. */
+    Clean(value) {
+        return Clean(this.Context(), this.Type(), value);
+    }
+    /** Converts a value using the Validator type. */
+    Convert(value) {
+        return Convert(this.Context(), this.Type(), value);
+    }
+    /** Creates a value using the Validator type. */
+    Create() {
+        return Create(this.Context(), this.Type());
+    }
+    /** Creates defaults using the Validator type. */
+    Default(value) {
+        return Default(this.Context(), this.Type(), value);
+    }
+    /** Decodes a value */
+    Decode(value) {
+        const result = this.hasCodec ? Decode(this.Context(), this.Type(), value) : this.Parse(value);
+        return result;
+    }
+    /** Encodes a value */
+    Encode(value) {
+        const result = this.hasCodec ? Encode(this.Context(), this.Type(), value) : this.Parse(value);
+        return result;
+    }
+    // ----------------------------------------------------------------
+    // Deprecations
+    // ----------------------------------------------------------------
+    /**
+     * @deprecated Validator instances should not support Clone because they are owners of JIT evaluated functions. This function will be
+     * removed in the next version of TypeBox (relates to Type.Base deprecation)
+     */
+    Clone() {
+        return new Validator(this.hasCodec, this.buildResult, this.evaluateResult);
+    }
+}