scoutline 0.17.7 → 0.18.0

package/dist/providers/spider/adapter.js

@@ -0,0 +1,683 @@
+/**
+ * Spider.cloud Adapter — Search, Reader, Crawl, and Map Capabilities.
+ *
+ * Owns credentials, transport lifecycle, Provider field mapping, and
+ * failure normalization. Clones the Firecrawl adapter's capability
+ * structure (the locked analog adapter) with Spider-specific wire
+ * differences: the search term rides the `search` body field (not
+ * `query`), `domain` maps to `whitelist`, `location` maps to
+ * `country_code`, and a non-general `topic` is a query keyword (Z.AI /
+ * MiniMax precedent). `type` is Brave-only and rejected in `validate`
+ * before any transport call so the option-level fallback contract can
+ * continue past Spider to a capable Provider. The Reader POSTs the
+ * locked four-field `/scrape` body and rejects every request control
+ * with no Spider-native wire equivalent instead of accept-and-drop.
+ * Crawl and Map are SYNCHRONOUS one-shot POSTs (`/crawl`, `/links`)
+ * returning the final JSON array — no async job file, no poll loop —
+ * with the locked 200-status crawl filter and link deduplication.
+ * Quota reads GET /data/credits into a single unknown-limit "credits"
+ * category (remaining only — no fabricated percent/limit), and the
+ * Diagnostics probe rides the same free credits endpoint.
+ *
+ * The descriptor and capability interfaces below are declared locally
+ * with the `"spider"` literal; they become assignable to the shared
+ * `ProviderDescriptor` / `SearchCapability` contracts once `"spider"`
+ * joins `PROVIDER_IDS` during registry wiring.
+ */
+import crypto from "node:crypto";
+import { decodeReaderFetchResult } from "../../capabilities/reader.js";
+import { decodeCrawlResult } from "../../capabilities/crawl.js";
+import { decodeMapResult } from "../../capabilities/map.js";
+import { ApiError, AuthError, ConfigurationError, NetworkError, QuotaError, TimeoutError, UnsupportedOptionError, ValidationError, } from "../../lib/errors.js";
+import { applySearchTopic } from "../../lib/search-topic.js";
+import { fetchSpiderCrawl, fetchSpiderLinks, fetchSpiderScrape, fetchSpiderSearch, } from "./client.js";
+import { getSpiderApiKey, requireSpiderApiKey } from "./credentials.js";
+import { createSpiderQuotaCapability } from "./quota.js";
+import { createSpiderDiagnosticsCapability } from "./diagnostics.js";
+// ---------------------------------------------------------------------------
+// Credential + shape helpers
+// ---------------------------------------------------------------------------
+/**
+ * Full lowercase SHA-256 hex digest of the active credential. Cache code
+ * consumes the digest directly and never re-hashes it.
+ */
+function credentialFingerprint(apiKey) {
+    return crypto.createHash("sha256").update(apiKey, "utf8").digest("hex");
+}
+function isPlainObject(value) {
+    return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function assertHttpUrl(url, capability) {
+    if (typeof url !== "string" || url.length === 0) {
+        throw new ValidationError(`Spider ${capability} URL must be a non-empty string`);
+    }
+    if (!/^https?:\/\//.test(url)) {
+        throw new ValidationError("URL must start with http:// or https://");
+    }
+}
+// ---------------------------------------------------------------------------
+// Request mapping
+// ---------------------------------------------------------------------------
+/**
+ * Map `controls.recency` to the Google-style `tbs` filter Spider.cloud
+ * accepts. `noLimit` (and any unknown value) omits `tbs` entirely.
+ */
+function mapRecencyToTbs(recency) {
+    switch (recency) {
+        case "oneDay":
+            return "qdr:d";
+        case "oneWeek":
+            return "qdr:w";
+        case "oneMonth":
+            return "qdr:m";
+        case "oneYear":
+            return "qdr:y";
+        case "noLimit":
+            return undefined;
+        default:
+            return undefined;
+    }
+}
+/**
+ * Map Provider-neutral `SearchControls` to Spider-native search params.
+ *
+ *   domain      -> whitelist: [domain]
+ *   recency     -> tbs (qdr:*)
+ *   location    -> country_code (lowercased)
+ *   contentSize -> no branch: the canonical payload always requests
+ *                  `return_format: "markdown"` with `metadata: true`
+ *                  (SCHEMA §1), which is exactly what `high` observes;
+ *                  `medium` sees the same default format on the body.
+ *   topic       -> keyword appended to the search field (never a wire
+ *                  parameter)
+ */
+function mapSearchControls(request) {
+    const controls = request.controls;
+    const params = {
+        search: applySearchTopic(request.query, controls?.topic),
+        return_format: "markdown",
+        metadata: true,
+    };
+    if (controls?.domain) {
+        params.whitelist = [controls.domain];
+    }
+    if (controls?.recency) {
+        const tbs = mapRecencyToTbs(controls.recency);
+        if (tbs)
+            params.tbs = tbs;
+    }
+    if (controls?.location) {
+        params.country_code = controls.location.toLowerCase();
+    }
+    return params;
+}
+// ---------------------------------------------------------------------------
+// Response normalization
+// ---------------------------------------------------------------------------
+/**
+ * Normalize a raw Spider.cloud search response into `SearchSource[]`.
+ *
+ * The endpoint returns a flat array of page objects; a documented
+ * wrapper (`{ content: [...] }`) is also accepted. Per-item mapping
+ * (SCHEMA §1): `metadata.title` (empty string when absent) -> title,
+ * `url` -> url, `metadata.description || content || ""` -> summary, and
+ * every row is attributed to `"spider.cloud"`. Any malformed shape is a
+ * retryable `ApiError` 500.
+ */
+function normalizeSpiderSearchResults(raw) {
+    const results = Array.isArray(raw)
+        ? raw
+        : isPlainObject(raw) && Array.isArray(raw.content)
+            ? raw.content
+            : undefined;
+    if (results === undefined) {
+        throw new ApiError("Spider search returned a malformed response", 500);
+    }
+    const out = [];
+    for (const entry of results) {
+        if (!isPlainObject(entry) || typeof entry.url !== "string") {
+            throw new ApiError("Spider search returned a malformed response", 500);
+        }
+        const metadata = isPlainObject(entry.metadata) ? entry.metadata : undefined;
+        const title = typeof metadata?.title === "string" ? metadata.title : "";
+        const description = typeof metadata?.description === "string" ? metadata.description : undefined;
+        const content = typeof entry.content === "string" ? entry.content : undefined;
+        const result = {
+            title,
+            url: entry.url,
+            summary: description || content || "",
+            source: "spider.cloud",
+        };
+        out.push(result);
+    }
+    return out;
+}
+// ---------------------------------------------------------------------------
+// Reader response normalization
+// ---------------------------------------------------------------------------
+/**
+ * Normalize a raw Spider.cloud /scrape response into a
+ * `ReaderFetchResult`.
+ *
+ * The endpoint returns an array of page objects (one for the requested
+ * URL); a documented wrapper (`{ content: [...] }`) is also accepted.
+ * Per-item mapping: `content` -> content (non-empty, else `ApiError` —
+ * an empty fetch is an error, not a degenerate result), `url` ->
+ * finalUrl (request URL fallback), `metadata.title` -> title (null when
+ * absent/blank). The provider-derived `metadata` and `external` blobs
+ * are preserved verbatim on the `ReaderFetchResult` when the page
+ * carries them. Any malformed shape is a retryable `ApiError` 500.
+ */
+function normalizeSpiderScrapeResult(raw, request) {
+    const results = Array.isArray(raw)
+        ? raw
+        : isPlainObject(raw) && Array.isArray(raw.content)
+            ? raw.content
+            : undefined;
+    if (results === undefined || results.length === 0) {
+        throw new ApiError("Spider scrape returned a malformed response", 500);
+    }
+    const page = results[0];
+    if (!isPlainObject(page)) {
+        throw new ApiError("Spider scrape returned a malformed response", 500);
+    }
+    const content = typeof page.content === "string" ? page.content : undefined;
+    if (content === undefined || content.length === 0) {
+        throw new ApiError("Spider scrape returned no content", 500);
+    }
+    const finalUrl = typeof page.url === "string" && page.url.length > 0 ? page.url : request.url;
+    const metadata = isPlainObject(page.metadata) ? page.metadata : undefined;
+    const rawTitle = typeof metadata?.title === "string" ? metadata.title : undefined;
+    const title = rawTitle !== undefined && rawTitle.trim().length > 0 ? rawTitle : null;
+    return {
+        schemaVersion: 1,
+        url: request.url,
+        finalUrl,
+        title,
+        content,
+        contentFormat: request.format ?? "markdown",
+        ...(metadata !== undefined ? { metadata } : {}),
+        ...(page.external !== undefined ? { external: page.external } : {}),
+    };
+}
+// ---------------------------------------------------------------------------
+// Crawl / map response normalization
+// ---------------------------------------------------------------------------
+/**
+ * Resolve the Spider response envelope: a bare JSON array, or the
+ * documented `{ content: [...] }` wrapper. `undefined` means the payload
+ * is neither — a malformed response.
+ */
+function resolveSpiderEnvelope(raw) {
+    if (Array.isArray(raw))
+        return raw;
+    if (isPlainObject(raw) && Array.isArray(raw.content))
+        return raw.content;
+    return undefined;
+}
+/**
+ * Normalize a raw Spider.cloud /crawl response into a `CrawlResult`.
+ *
+ * The endpoint is synchronous (locked contract): the response IS the
+ * final array of crawled pages — no job id, no poll. The locked filter
+ * keeps only pages with `status === 200` AND a non-empty `content`
+ * (SCHEMA §3); everything else (404s, error rows, empty bodies) is
+ * dropped, not an error. Per-page mapping: `url` -> url, `content` ->
+ * content, `contentFormat` defaults to `"markdown"` (Firecrawl
+ * precedent). Any non-object entry is a retryable `ApiError` 500.
+ */
+function normalizeSpiderCrawlResult(raw, request) {
+    const results = resolveSpiderEnvelope(raw);
+    if (results === undefined) {
+        throw new ApiError("Spider crawl returned a malformed response", 500);
+    }
+    const contentFormat = request.format ?? "markdown";
+    const pages = [];
+    for (const entry of results) {
+        if (!isPlainObject(entry)) {
+            throw new ApiError("Spider crawl returned a malformed response", 500);
+        }
+        if (entry.status !== 200)
+            continue;
+        const content = typeof entry.content === "string" ? entry.content : undefined;
+        if (content === undefined || content.length === 0)
+            continue;
+        if (typeof entry.url !== "string" || entry.url.length === 0) {
+            throw new ApiError("Spider crawl returned a malformed response", 500);
+        }
+        pages.push({ url: entry.url, content, contentFormat });
+    }
+    return {
+        schemaVersion: 1,
+        baseUrl: request.url,
+        pages,
+        totalPages: pages.length,
+    };
+}
+/**
+ * Normalize a raw Spider.cloud /links response into a `MapResult`.
+ *
+ * Two accepted item shapes: the documented `{ url, status, links: [...] }`
+ * row (SCHEMA §4 — each `links[]` string is a discovered URL) and the
+ * flat `{ url }` row the API also returns for single-page maps. Every
+ * row carries its own `url`, and that URL is part of the map — a
+ * links row must not drop the mapped page itself (a site map that
+ * omits its root URL is wrong). All URLs are deduplicated through a
+ * `Set` (insertion order preserved); `totalUrls` is the deduplicated
+ * count. Any non-object entry, missing/invalid row `url`,
+ * present-but-non-array `links` (neither accepted shape), or
+ * non-string link is a retryable `ApiError` 500.
+ */
+function normalizeSpiderLinksResult(raw, request) {
+    const results = resolveSpiderEnvelope(raw);
+    if (results === undefined) {
+        throw new ApiError("Spider links returned a malformed response", 500);
+    }
+    const urls = new Set();
+    for (const entry of results) {
+        if (!isPlainObject(entry)) {
+            throw new ApiError("Spider links returned a malformed response", 500);
+        }
+        // The row's own URL first: the mapped page belongs in the map even
+        // when its links array is present (the documented row shape carries
+        // both). Deduplication absorbs a url that also appears in links.
+        if (typeof entry.url !== "string" || entry.url.length === 0) {
+            throw new ApiError("Spider links returned a malformed response", 500);
+        }
+        urls.add(entry.url);
+        if (entry.links !== undefined && !Array.isArray(entry.links)) {
+            throw new ApiError("Spider links returned a malformed response", 500);
+        }
+        if (Array.isArray(entry.links)) {
+            for (const link of entry.links) {
+                if (typeof link !== "string" || link.length === 0) {
+                    throw new ApiError("Spider links returned a malformed response", 500);
+                }
+                urls.add(link);
+            }
+        }
+    }
+    const unique = [...urls];
+    return {
+        schemaVersion: 1,
+        baseUrl: request.url,
+        urls: unique,
+        totalUrls: unique.length,
+    };
+}
+// ---------------------------------------------------------------------------
+// Failure normalization
+// ---------------------------------------------------------------------------
+function inferStatusCode(known) {
+    if (typeof known === "number" && Number.isFinite(known))
+        return known;
+    return 500;
+}
+/**
+ * Status-keyed outward message for rewrapped Spider ApiErrors. Curated
+ * constants only — a raw Provider body embedded upstream never survives.
+ */
+function spiderApiErrorMessage(statusCode) {
+    if (statusCode === 429)
+        return "Spider rate limit exceeded";
+    return "Spider request failed";
+}
+/**
+ * Normalize a Provider failure with sanitized messages. Raw response
+ * bodies never cross the adapter boundary. Mirrors the Firecrawl
+ * adapter's `normalizeFirecrawlError`.
+ */
+function normalizeSpiderError(error) {
+    // QuotaError pass-through — terminal retry guarantee preserved.
+    if (error instanceof QuotaError)
+        return error;
+    // Configuration/option/validation errors carry clean, human-authored
+    // messages and are safe to surface verbatim.
+    if (error instanceof ValidationError ||
+        error instanceof UnsupportedOptionError ||
+        error instanceof ConfigurationError) {
+        return error;
+    }
+    // Re-wrap typed transport errors with sanitized messages so a raw
+    // Provider response body embedded upstream never survives.
+    if (error instanceof AuthError) {
+        return new AuthError("Spider authentication failed", "SPIDER_API_KEY");
+    }
+    if (error instanceof NetworkError) {
+        return new NetworkError("Spider network error");
+    }
+    if (error instanceof TimeoutError) {
+        return new TimeoutError(error.durationMs);
+    }
+    if (error instanceof ApiError) {
+        const statusCode = inferStatusCode(error.statusCode);
+        return new ApiError(spiderApiErrorMessage(statusCode), statusCode);
+    }
+    const message = error instanceof Error ? error.message : String(error);
+    const lower = message.toLowerCase();
+    if (lower.includes("401") ||
+        lower.includes("403") ||
+        lower.includes("unauthorized") ||
+        lower.includes("forbidden")) {
+        return new AuthError("Spider authentication failed");
+    }
+    if (lower.includes("timeout") || lower.includes("timed out") || lower.includes("etimedout")) {
+        return new TimeoutError(30000);
+    }
+    if (lower.includes("econnrefused") ||
+        lower.includes("econnreset") ||
+        lower.includes("network") ||
+        lower.includes("enotfound") ||
+        lower.includes("fetch failed")) {
+        return new NetworkError("Spider network error");
+    }
+    if (lower.includes("429") || lower.includes("rate limit")) {
+        return new ApiError("Spider rate limit exceeded", 429);
+    }
+    return new ApiError("Spider request failed", 500);
+}
+function createSpiderSearchCapability(options) {
+    const { env, transport } = options;
+    const capability = {
+        validate(request) {
+            if (!request || typeof request.query !== "string" || request.query.trim() === "") {
+                throw new ValidationError("Search query must contain at least one non-whitespace character");
+            }
+            // Spider.cloud supports domain, recency, contentSize, location, and
+            // topic. `type` is Brave-only — reject before any transport call so
+            // the option-level fallback contract can continue past Spider to a
+            // Provider that supports it.
+            if (request.controls?.type !== undefined) {
+                throw new UnsupportedOptionError("spider", "search", "type");
+            }
+        },
+        cacheIdentity(request) {
+            const apiKey = getSpiderApiKey(env) ?? "";
+            const identityRequest = {
+                query: request.query,
+            };
+            if (request.controls) {
+                identityRequest.controls = request.controls;
+            }
+            return {
+                provider: "spider",
+                capability: "search",
+                credentialFingerprint: credentialFingerprint(apiKey),
+                request: identityRequest,
+            };
+        },
+        async invoke(request) {
+            capability.validate(request);
+            const apiKey = requireSpiderApiKey(env);
+            try {
+                const params = mapSearchControls(request);
+                const raw = await fetchSpiderSearch(apiKey, params, transport);
+                return normalizeSpiderSearchResults(raw);
+            }
+            catch (error) {
+                throw normalizeSpiderError(error);
+            }
+        },
+    };
+    return capability;
+}
+// ---------------------------------------------------------------------------
+// Reader Capability
+// ---------------------------------------------------------------------------
+/** Z.AI-only reader options that Spider.cloud has no native equivalent for. */
+const UNSUPPORTED_READER_OPTIONS = [
+    "withLinksSummary",
+    "noGfm",
+    "keepImgDataUrl",
+    "withImagesSummary",
+];
+/**
+ * Reject reader request controls the locked Spider `/scrape` body does
+ * not document. Accept-and-drop is banned: a control is either
+ * wire-consumed or rejected here, before any transport call.
+ */
+function assertNoUnsupportedReaderOptions(request) {
+    for (const key of UNSUPPORTED_READER_OPTIONS) {
+        // Only reject when the user explicitly enabled the option (`true`);
+        // the read command handler sets `false` when the flag is absent.
+        if (request[key] === true) {
+            throw new UnsupportedOptionError("spider", "reader", key);
+        }
+    }
+    // No native Spider `/scrape` image or timeout field exists — reject
+    // rather than silently discard the intent. `retainImages` is set only
+    // when an images flag is passed, so `!== undefined` is exact.
+    if (request.retainImages !== undefined) {
+        throw new UnsupportedOptionError("spider", "reader", "retainImages");
+    }
+    if (request.timeout !== undefined) {
+        throw new UnsupportedOptionError("spider", "reader", "timeout");
+    }
+}
+function createSpiderReaderCapability(options) {
+    const { env, transport } = options;
+    const fetch = {
+        kind: "reader-fetch",
+        validate(request) {
+            assertHttpUrl(request.url, "reader");
+            assertNoUnsupportedReaderOptions(request);
+        },
+        cacheIdentity(request) {
+            const apiKey = getSpiderApiKey(env) ?? "";
+            return {
+                provider: "spider",
+                capability: "reader",
+                operation: "reader-fetch",
+                credentialFingerprint: credentialFingerprint(apiKey),
+                request,
+                legacyCandidates: [],
+            };
+        },
+        decodeCached(value) {
+            return decodeReaderFetchResult(value);
+        },
+        async invoke(request, signal) {
+            fetch.validate(request);
+            const apiKey = requireSpiderApiKey(env);
+            try {
+                const contentFormat = request.format ?? "markdown";
+                const params = {
+                    url: request.url,
+                    return_format: contentFormat,
+                    filter_output_main_only: true,
+                    stealth: true,
+                };
+                const raw = await fetchSpiderScrape(apiKey, params, transport, signal);
+                return normalizeSpiderScrapeResult(raw, request);
+            }
+            catch (error) {
+                throw normalizeSpiderError(error);
+            }
+        },
+    };
+    return { fetch };
+}
+// ---------------------------------------------------------------------------
+// Crawl Capability
+// ---------------------------------------------------------------------------
+/**
+ * Crawl request controls the locked Spider `/crawl` body does not
+ * document. Accept-and-drop is banned: a control is either
+ * wire-consumed (`limit`, `depth`, `format`) or rejected here, before
+ * any transport call. `breadth`/`selectPaths`/`excludePaths`/
+ * `instructions`/`contentSize`/`timeout` have no Spider-native wire
+ * equivalent (SCHEMA §3 documents `url`, `limit`, `depth`,
+ * `return_format` — plus provider-side fields the neutral request
+ * cannot express).
+ */
+const UNSUPPORTED_CRAWL_OPTIONS = [
+    "breadth",
+    "selectPaths",
+    "excludePaths",
+    "instructions",
+    "contentSize",
+    "timeout",
+];
+function createSpiderCrawlCapability(options) {
+    const { env, transport } = options;
+    const fetch = {
+        kind: "crawl-fetch",
+        validate(request) {
+            assertHttpUrl(request.url, "crawl");
+            // The crawl endpoint is synchronous: no async-job state file, no
+            // poll loop, no request-scoped timeout field on the wire.
+            if (request.depth !== undefined) {
+                if (!Number.isInteger(request.depth) || request.depth < 1 || request.depth > 5) {
+                    throw new ValidationError("Crawl depth must be an integer between 1 and 5");
+                }
+            }
+            if (request.limit !== undefined) {
+                if (!Number.isInteger(request.limit) || request.limit < 1) {
+                    throw new ValidationError("Crawl limit must be a positive integer");
+                }
+            }
+            for (const key of UNSUPPORTED_CRAWL_OPTIONS) {
+                if (request[key] !== undefined) {
+                    throw new UnsupportedOptionError("spider", "crawl", key);
+                }
+            }
+        },
+        cacheIdentity(request) {
+            const apiKey = getSpiderApiKey(env) ?? "";
+            return {
+                provider: "spider",
+                capability: "crawl",
+                credentialFingerprint: credentialFingerprint(apiKey),
+                request,
+            };
+        },
+        decodeCached(value) {
+            return decodeCrawlResult(value);
+        },
+        async invoke(request) {
+            fetch.validate(request);
+            const apiKey = requireSpiderApiKey(env);
+            try {
+                const params = {
+                    url: request.url,
+                    return_format: request.format ?? "markdown",
+                };
+                if (request.limit !== undefined) {
+                    params.limit = request.limit;
+                }
+                if (request.depth !== undefined) {
+                    params.depth = request.depth;
+                }
+                // One-shot synchronous POST — the response is the final page
+                // array (locked contract; never a job id to poll).
+                const raw = await fetchSpiderCrawl(apiKey, params, transport);
+                return normalizeSpiderCrawlResult(raw, request);
+            }
+            catch (error) {
+                throw normalizeSpiderError(error);
+            }
+        },
+    };
+    return { fetch };
+}
+// ---------------------------------------------------------------------------
+// Map Capability
+// ---------------------------------------------------------------------------
+/**
+ * Map request controls the locked Spider `/links` body does not
+ * document. Accept-and-drop is banned: a control is either
+ * wire-consumed (`limit`) or rejected here, before any transport call.
+ * SCHEMA §4 documents exactly `url` + `limit`; `depth`, `breadth`,
+ * `selectPaths`, `excludePaths`, and `instructions` have no
+ * Spider-native wire equivalent.
+ */
+const UNSUPPORTED_MAP_OPTIONS = [
+    "depth",
+    "breadth",
+    "selectPaths",
+    "excludePaths",
+    "instructions",
+];
+function createSpiderMapCapability(options) {
+    const { env, transport } = options;
+    const fetch = {
+        kind: "map-fetch",
+        validate(request) {
+            assertHttpUrl(request.url, "map");
+            if (request.limit !== undefined) {
+                if (!Number.isInteger(request.limit) || request.limit < 1) {
+                    throw new ValidationError("Map limit must be a positive integer");
+                }
+            }
+            for (const key of UNSUPPORTED_MAP_OPTIONS) {
+                if (request[key] !== undefined) {
+                    throw new UnsupportedOptionError("spider", "map", key);
+                }
+            }
+        },
+        cacheIdentity(request) {
+            const apiKey = getSpiderApiKey(env) ?? "";
+            return {
+                provider: "spider",
+                capability: "map",
+                credentialFingerprint: credentialFingerprint(apiKey),
+                request,
+            };
+        },
+        decodeCached(value) {
+            return decodeMapResult(value);
+        },
+        async invoke(request) {
+            fetch.validate(request);
+            const apiKey = requireSpiderApiKey(env);
+            try {
+                const params = { url: request.url };
+                if (request.limit !== undefined) {
+                    params.limit = request.limit;
+                }
+                const raw = await fetchSpiderLinks(apiKey, params, transport);
+                return normalizeSpiderLinksResult(raw, request);
+            }
+            catch (error) {
+                throw normalizeSpiderError(error);
+            }
+        },
+    };
+    return { fetch };
+}
+/**
+ * Build the Spider.cloud Provider Descriptor. Advertises the full
+ * Spider.cloud capability set (Search, Reader, Crawl, Map, Quota,
+ * Diagnostics). `create()` is side-effect-free; the transport is
+ * invoked per Capability call.
+ */
+export function createSpiderDescriptor(dependencies) {
+    const transport = dependencies?.transport;
+    return {
+        id: "spider",
+        isConfigured(env) {
+            return getSpiderApiKey(env) !== undefined;
+        },
+        capabilities() {
+            return new Set([
+                "search",
+                "reader",
+                "crawl",
+                "map",
+                "quota",
+                "diagnostics",
+            ]);
+        },
+        create(context) {
+            const search = createSpiderSearchCapability({ env: context.env, transport });
+            const reader = createSpiderReaderCapability({ env: context.env, transport });
+            const crawl = createSpiderCrawlCapability({ env: context.env, transport });
+            const map = createSpiderMapCapability({ env: context.env, transport });
+            const quota = createSpiderQuotaCapability({ env: context.env, transport });
+            const diagnostics = createSpiderDiagnosticsCapability({ env: context.env, transport });
+            return { id: "spider", search, reader, crawl, map, quota, diagnostics };
+        },
+        credentialEnvVars: ["SPIDER_API_KEY"],
+    };
+}
+//# sourceMappingURL=adapter.js.map