@brightdata/brightdata-plugin 1.0.0

package/src/brightdata-scrape-tool.ts

@@ -0,0 +1,69 @@
+import { Type } from "@sinclair/typebox";
+import { jsonResult, readNumberParam, readStringParam } from "openclaw/plugin-sdk/agent-runtime";
+import type { OpenClawPluginApi } from "openclaw/plugin-sdk/plugin-runtime";
+import { runBrightDataScrape } from "./brightdata-client.js";
+
+function optionalStringEnum<const T extends readonly string[]>(
+  values: T,
+  options: { description?: string } = {},
+) {
+  return Type.Optional(
+    Type.Unsafe<T[number]>({
+      type: "string",
+      enum: [...values],
+      ...options,
+    }),
+  );
+}
+
+const BrightDataScrapeToolSchema = Type.Object(
+  {
+    url: Type.String({ description: "HTTP or HTTPS URL to scrape via Bright Data." }),
+    extractMode: optionalStringEnum(["markdown", "text", "html"] as const, {
+      description: 'Extraction mode ("markdown", "text", or "html"). Default: markdown.',
+    }),
+    maxChars: Type.Optional(
+      Type.Number({
+        description: "Maximum characters to return.",
+        minimum: 100,
+      }),
+    ),
+    timeoutSeconds: Type.Optional(
+      Type.Number({
+        description: "Timeout in seconds for the Bright Data scrape request.",
+        minimum: 1,
+      }),
+    ),
+  },
+  { additionalProperties: false },
+);
+
+export function createBrightDataScrapeTool(api: OpenClawPluginApi) {
+  return {
+    name: "brightdata_scrape",
+    label: "Bright Data Scrape",
+    description:
+      "Fetch and extract a page directly through Bright Data Web Unlocker. Use this tool when you specifically want Bright Data-backed web fetching, including bot-protected pages.",
+    parameters: BrightDataScrapeToolSchema,
+    execute: async (_toolCallId: string, rawParams: Record<string, unknown>) => {
+      const url = readStringParam(rawParams, "url", { required: true });
+      const extractModeRaw = readStringParam(rawParams, "extractMode");
+      const extractMode =
+        extractModeRaw === "text" || extractModeRaw === "html" ? extractModeRaw : "markdown";
+      const maxChars = readNumberParam(rawParams, "maxChars", { integer: true });
+      const timeoutSeconds = readNumberParam(rawParams, "timeoutSeconds", {
+        integer: true,
+      });
+
+      return jsonResult(
+        await runBrightDataScrape({
+          pluginConfig: api.pluginConfig,
+          url,
+          extractMode,
+          maxChars,
+          timeoutSeconds,
+        }),
+      );
+    },
+  };
+}

package/src/brightdata-search-provider.ts

@@ -0,0 +1,76 @@
+import { Type } from "@sinclair/typebox";
+import {
+  enablePluginInConfig,
+  resolveProviderWebSearchPluginConfig,
+  setProviderWebSearchPluginConfigValue,
+  type WebSearchProviderPlugin,
+} from "openclaw/plugin-sdk/provider-web-search";
+import { runBrightDataSearch } from "./brightdata-client.js";
+
+const GenericBrightDataSearchSchema = Type.Object(
+  {
+    query: Type.String({ description: "Search query string." }),
+    count: Type.Optional(
+      Type.Number({
+        description: "Number of results to return (1-10).",
+        minimum: 1,
+        maximum: 10,
+      }),
+    ),
+  },
+  { additionalProperties: false },
+);
+
+function getScopedCredentialValue(searchConfig?: Record<string, unknown>): unknown {
+  const scoped = searchConfig?.brightdata;
+  if (!scoped || typeof scoped !== "object" || Array.isArray(scoped)) {
+    return undefined;
+  }
+  return (scoped as Record<string, unknown>).apiKey;
+}
+
+function setScopedCredentialValue(
+  searchConfigTarget: Record<string, unknown>,
+  value: unknown,
+): void {
+  const scoped = searchConfigTarget.brightdata;
+  if (!scoped || typeof scoped !== "object" || Array.isArray(scoped)) {
+    searchConfigTarget.brightdata = { apiKey: value };
+    return;
+  }
+  (scoped as Record<string, unknown>).apiKey = value;
+}
+
+export function createBrightDataWebSearchProvider(): WebSearchProviderPlugin {
+  return {
+    id: "brightdata",
+    label: "Bright Data Search",
+    hint: "SERP results via Google/Bing/Yandex with bot bypass",
+    envVars: ["BRIGHTDATA_API_TOKEN"],
+    placeholder: "...",
+    signupUrl: "https://brightdata.com/",
+    docsUrl: "https://docs.openclaw.ai/tools/brightdata",
+    autoDetectOrder: 65,
+    credentialPath: "plugins.entries.brightdata.config.webSearch.apiKey",
+    inactiveSecretPaths: ["plugins.entries.brightdata.config.webSearch.apiKey"],
+    getCredentialValue: getScopedCredentialValue,
+    setCredentialValue: setScopedCredentialValue,
+    getConfiguredCredentialValue: (config) =>
+      resolveProviderWebSearchPluginConfig(config, "brightdata")?.apiKey,
+    setConfiguredCredentialValue: (configTarget, value) => {
+      setProviderWebSearchPluginConfigValue(configTarget, "brightdata", "apiKey", value);
+    },
+    applySelectionConfig: (config) => enablePluginInConfig(config, "brightdata").config,
+    createTool: (ctx) => ({
+      description:
+        "Search the web using Bright Data. Returns structured search results. Use brightdata_search for Bright Data-specific knobs like engine, cursor, or geo_location.",
+      parameters: GenericBrightDataSearchSchema,
+      execute: async (args) =>
+        await runBrightDataSearch({
+          pluginConfig: ctx.searchConfig ? { webSearch: ctx.searchConfig } : undefined,
+          query: typeof args.query === "string" ? args.query : "",
+          count: typeof args.count === "number" ? args.count : undefined,
+        }),
+    }),
+  };
+}

package/src/brightdata-search-tool.ts

@@ -0,0 +1,88 @@
+import { Type } from "@sinclair/typebox";
+import { jsonResult, readNumberParam, readStringParam } from "openclaw/plugin-sdk/agent-runtime";
+import type { OpenClawPluginApi } from "openclaw/plugin-sdk/plugin-runtime";
+import { runBrightDataSearch } from "./brightdata-client.js";
+
+function optionalStringEnum<const T extends readonly string[]>(
+  values: T,
+  options: { description?: string } = {},
+) {
+  return Type.Optional(
+    Type.Unsafe<T[number]>({
+      type: "string",
+      enum: [...values],
+      ...options,
+    }),
+  );
+}
+
+const BrightDataSearchToolSchema = Type.Object(
+  {
+    query: Type.String({ description: "Search query string." }),
+    engine: optionalStringEnum(["google", "bing", "yandex"] as const, {
+      description: 'Search engine ("google", "bing", or "yandex"). Default: google.',
+    }),
+    count: Type.Optional(
+      Type.Number({
+        description: "Number of results to return (1-10).",
+        minimum: 1,
+        maximum: 10,
+      }),
+    ),
+    cursor: Type.Optional(
+      Type.String({
+        description: "Pagination cursor for the next page.",
+      }),
+    ),
+    geo_location: Type.Optional(
+      Type.String({
+        description: '2-letter country code for geo-targeted results, for example "us" or "uk".',
+        minLength: 2,
+        maxLength: 2,
+      }),
+    ),
+    timeoutSeconds: Type.Optional(
+      Type.Number({
+        description: "Timeout in seconds for the Bright Data Search request.",
+        minimum: 1,
+      }),
+    ),
+  },
+  { additionalProperties: false },
+);
+
+export function createBrightDataSearchTool(api: OpenClawPluginApi) {
+  return {
+    name: "brightdata_search",
+    label: "Bright Data Search",
+    description:
+      "Search the web using Bright Data SERP scraping. Supports Google, Bing, and Yandex with pagination and geo targeting.",
+    parameters: BrightDataSearchToolSchema,
+    execute: async (_toolCallId: string, rawParams: Record<string, unknown>) => {
+      const query = readStringParam(rawParams, "query", { required: true });
+      const engineRaw = readStringParam(rawParams, "engine");
+      const engine =
+        engineRaw === "google" || engineRaw === "bing" || engineRaw === "yandex"
+          ? engineRaw
+          : undefined;
+      const count = readNumberParam(rawParams, "count", { integer: true });
+      const cursor = readStringParam(rawParams, "cursor");
+      const geoLocation = readStringParam(rawParams, "geo_location");
+      const timeoutSeconds = readNumberParam(rawParams, "timeoutSeconds", {
+        integer: true,
+      });
+
+      return jsonResult(
+        await runBrightDataSearch({
+          pluginConfig: api.pluginConfig,
+          query,
+          engine,
+          count,
+          cursor,
+          geoLocation,
+          timeoutSeconds,
+        }),
+      );
+    },
+  };
+}