@wha7ever/dsh-web-search-anysearch 0.2.0

package/lib/client.js

@@ -0,0 +1,488 @@
+/** Shared HTTP client for every AnySearch provider and tool operation. */
+import { ANYSEARCH_DSH_CLIENT_ID } from "./version.js";
+import { ANYSEARCH_HTTP_TIMEOUT_MS, MAX_CANONICAL_CONTENT_CHARS, MAX_UPSTREAM_ERROR_CHARS, } from "./limits.js";
+export { ANYSEARCH_DSH_CLIENT_ID } from "./version.js";
+/** Public AnySearch API origin. */
+export const ANYSEARCH_DEFAULT_BASE_URL = 'https://api.anysearch.com';
+const API_KEY_PLACEHOLDERS = new Set([
+    'ANYSEARCH_API_KEY',
+    'as_sk_your_key',
+]);
+/** Safe HTTP and credential failure surfaced by the shared client. */
+export class AnySearchClientError extends Error {
+    /** Failure category used by Harness adapters. */
+    kind;
+    /** Operation that failed. */
+    operation;
+    /** Upstream HTTP status when a response arrived. */
+    httpStatus;
+    /** Authentication mode used for an upstream response. */
+    authentication;
+    /** AnySearch request id when the response supplied one. */
+    requestId;
+    /** Upstream retry delay retained for diagnostics; the client never retries. */
+    retryAfter;
+    /** Stable AnySearch business error code when the response supplied one. */
+    errorCode;
+    constructor(message, options) {
+        super(message, options.cause === undefined ? undefined : { cause: options.cause });
+        this.name = 'AnySearchClientError';
+        this.kind = options.kind ?? 'provider';
+        this.operation = options.operation;
+        if (options.httpStatus !== undefined)
+            this.httpStatus = options.httpStatus;
+        if (options.authentication !== undefined)
+            this.authentication = options.authentication;
+        if (options.requestId !== undefined)
+            this.requestId = options.requestId;
+        if (options.retryAfter !== undefined)
+            this.retryAfter = options.retryAfter;
+        if (options.errorCode !== undefined)
+            this.errorCode = options.errorCode;
+    }
+}
+/** HTTP client shared by the native Provider and AnySearch-specific tools. */
+export class AnySearchClient {
+    options;
+    constructor(options) {
+        this.options = options;
+    }
+    /** Whether the configured base URL can produce public HTTP endpoints. */
+    available() {
+        return endpoint(this.options.baseURL, '/v1/search') !== undefined;
+    }
+    /** Execute one search and validate its complete response. */
+    async search(request, signal) {
+        const envelope = await this.request('/v1/search', 'search', {
+            method: 'POST',
+            body: JSON.stringify({
+                query: request.query,
+                ...request.maxResults !== undefined ? { max_results: request.maxResults } : {},
+                ...request.tag !== undefined ? { tag: request.tag } : {},
+                ...request.params !== undefined ? { params: request.params } : {},
+                ...request.zone !== undefined ? { zone: request.zone } : {},
+                ...request.language !== undefined ? { language: request.language } : {},
+            }),
+        }, signal);
+        return parseOperationData('search', envelope, parseSearchData);
+    }
+    /** Extract and validate the cleaned content of one public HTTP(S) URL. */
+    async extract(request, signal) {
+        const envelope = await this.request('/v1/extract', 'extract', {
+            method: 'POST',
+            body: JSON.stringify({ url: request.url }),
+        }, signal);
+        return parseOperationData('extract', envelope, parseExtractData);
+    }
+    /** List all top-level domains in the dynamic capability catalog. */
+    async listDomains(signal) {
+        const envelope = await this.request('/v1/domains', 'domains', { method: 'GET' }, signal);
+        return parseOperationData('domains', envelope, parseDomainsData);
+    }
+    /** Read detailed capabilities for the supplied ordered domain names. */
+    async getSubDomains(domains, signal) {
+        const query = new URLSearchParams();
+        for (const domain of domains)
+            query.append('domain', domain);
+        const suffix = query.toString();
+        const envelope = await this.request(`/v1/sub-domains${suffix.length > 0 ? `?${suffix}` : ''}`, 'sub_domains', { method: 'GET' }, signal);
+        return parseOperationData('sub_domains', envelope, parseSubDomainsData);
+    }
+    async request(path, operation, init, signal) {
+        const url = endpoint(this.options.baseURL, path);
+        if (url === undefined) {
+            throw new AnySearchClientError('AnySearch base URL is invalid', { operation });
+        }
+        const apiKey = await this.resolveApiKey(operation, signal);
+        const authentication = apiKey === undefined ? 'anonymous' : 'credential';
+        const headers = {
+            'accept': 'application/json',
+            'user-agent': ANYSEARCH_DSH_CLIENT_ID,
+            'x-anysearch-client': ANYSEARCH_DSH_CLIENT_ID,
+        };
+        if (init.body !== undefined)
+            headers['content-type'] = 'application/json';
+        if (apiKey !== undefined)
+            headers.authorization = `Bearer ${apiKey}`;
+        const timeoutController = new AbortController();
+        const timeout = setTimeout(() => {
+            timeoutController.abort(new DOMException('AnySearch HTTP request timed out', 'TimeoutError'));
+        }, ANYSEARCH_HTTP_TIMEOUT_MS);
+        const requestSignal = signal === undefined
+            ? timeoutController.signal
+            : AbortSignal.any([signal, timeoutController.signal]);
+        let response;
+        try {
+            response = await fetch(url, {
+                method: init.method,
+                redirect: 'error',
+                headers,
+                ...init.body === undefined ? {} : { body: init.body },
+                signal: requestSignal,
+            });
+        }
+        catch (error) {
+            clearTimeout(timeout);
+            if (signal?.aborted === true)
+                throw aborted(operation, signal, error);
+            if (timeoutController.signal.aborted)
+                throw timedOut(operation, error);
+            if (isAbortError(error))
+                throw aborted(operation, signal, error);
+            throw new AnySearchClientError(`AnySearch ${operation} request failed: ${String(error)}`, { operation, cause: error });
+        }
+        const retryAfter = response.headers.get('retry-after') ?? undefined;
+        let value;
+        try {
+            value = await response.json();
+        }
+        catch (error) {
+            if (signal?.aborted === true)
+                throw aborted(operation, signal, error);
+            if (timeoutController.signal.aborted)
+                throw timedOut(operation, error);
+            if (isAbortError(error))
+                throw aborted(operation, signal, error);
+            if (!response.ok) {
+                throw upstreamError(operation, `API error`, response.status, authentication, undefined, retryAfter);
+            }
+            throw new AnySearchClientError(`AnySearch ${operation} returned invalid JSON: ${String(error)}`, {
+                operation,
+                httpStatus: response.status,
+                ...retryAfter === undefined ? {} : { retryAfter },
+                cause: error,
+            });
+        }
+        finally {
+            clearTimeout(timeout);
+        }
+        const diagnosticRequestId = optionalStringField(value, 'request_id');
+        const diagnosticErrorCode = optionalStringField(value, 'error_code');
+        if (!response.ok) {
+            const message = messageField(value) ?? 'API error';
+            throw upstreamError(operation, message, response.status, authentication, diagnosticRequestId, retryAfter, diagnosticErrorCode);
+        }
+        try {
+            const envelope = record(value, 'response');
+            const requestId = optionalStringRecordField(envelope, 'request_id', 'request_id');
+            const code = numberField(envelope, 'code', 'code');
+            const message = stringField(envelope, 'message', 'message');
+            if (code !== 0) {
+                throw upstreamError(operation, message.length > 0 ? message : `API error ${code}`, response.status, authentication, requestId, retryAfter, optionalStringRecordField(envelope, 'error_code', 'error_code'));
+            }
+            return {
+                data: record(envelope.data, 'data'),
+                ...requestId === undefined ? {} : { requestId },
+            };
+        }
+        catch (error) {
+            if (error instanceof AnySearchClientError)
+                throw error;
+            throw new AnySearchClientError(`AnySearch ${operation} returned an invalid response: ${errorMessage(error)}`, {
+                operation,
+                httpStatus: response.status,
+                ...diagnosticRequestId === undefined ? {} : { requestId: diagnosticRequestId },
+                ...retryAfter === undefined ? {} : { retryAfter },
+                cause: error,
+            });
+        }
+    }
+    async resolveApiKey(operation, signal) {
+        if (signal?.aborted === true)
+            throw aborted(operation, signal);
+        let value;
+        try {
+            value = await abortable(this.options.resolveApiKey(), signal);
+        }
+        catch (error) {
+            if (isSignalAborted(signal) || isAbortError(error))
+                throw aborted(operation, signal, error);
+            throw new AnySearchClientError(`AnySearch ${operation} credential resolution failed: ${String(error)}`, { operation, cause: error });
+        }
+        const trimmed = value?.trim();
+        if (trimmed === undefined || trimmed.length === 0)
+            return undefined;
+        if (trimmed === this.options.apiKeyReference || API_KEY_PLACEHOLDERS.has(trimmed)) {
+            throw new AnySearchClientError(`AnySearch ${operation} credential is a placeholder; remove it for anonymous access or configure a valid API key`, { operation });
+        }
+        return trimmed;
+    }
+}
+function parseOperationData(operation, envelope, parse) {
+    try {
+        return parse(envelope);
+    }
+    catch (error) {
+        throw new AnySearchClientError(`AnySearch ${operation} returned an invalid response: ${errorMessage(error)}`, {
+            operation,
+            ...envelope.requestId === undefined ? {} : { requestId: envelope.requestId },
+            cause: error,
+        });
+    }
+}
+function endpoint(baseURL, path) {
+    try {
+        const url = new URL(baseURL);
+        if (url.protocol !== 'http:' && url.protocol !== 'https:')
+            return undefined;
+        const [pathname, query = ''] = path.split('?', 2);
+        url.pathname = `${url.pathname.replace(/\/+$/u, '')}${pathname}`;
+        url.search = query.length > 0 ? `?${query}` : '';
+        url.hash = '';
+        return url.href;
+    }
+    catch {
+        return undefined;
+    }
+}
+function parseSearchData(envelope) {
+    const parsedItems = arrayField(envelope.data, 'results', 'data.results')
+        .map((value, index) => parseSearchResult(value, index));
+    const parsedResults = parsedItems.flatMap(item => item.kind === 'invalid-url' ? [] : [item.result]);
+    const urlLessResults = parsedItems.filter(item => item.kind === 'url-less').length;
+    const droppedInvalidUrlResults = parsedItems.filter(item => item.kind === 'invalid-url').length;
+    let remainingContentCharacters = MAX_CANONICAL_CONTENT_CHARS;
+    const results = parsedResults.map((result) => {
+        if (result.content === undefined)
+            return result;
+        const content = result.content.slice(0, remainingContentCharacters);
+        remainingContentCharacters -= content.length;
+        return { ...result, content };
+    });
+    const metadata = record(envelope.data.metadata, 'data.metadata');
+    return {
+        ...envelope.requestId === undefined ? {} : { requestId: envelope.requestId },
+        results,
+        metadata: {
+            totalResults: nonNegativeIntegerField(metadata, 'total_results', 'data.metadata.total_results'),
+            searchTimeMs: nonNegativeIntegerField(metadata, 'search_time_ms', 'data.metadata.search_time_ms'),
+            ...urlLessResults === 0 ? {} : { urlLessResults },
+            ...droppedInvalidUrlResults === 0 ? {} : { droppedInvalidUrlResults },
+        },
+    };
+}
+function parseExtractData(envelope) {
+    const data = envelope.data;
+    const url = absoluteHTTPURLField(data, 'url', 'data.url');
+    const title = stringField(data, 'title', 'data.title');
+    const content = stringField(data, 'content', 'data.content');
+    return {
+        ...envelope.requestId === undefined ? {} : { requestId: envelope.requestId },
+        url,
+        title,
+        content,
+    };
+}
+function parseSearchResult(value, index) {
+    const path = `data.results[${index}]`;
+    const result = record(value, path);
+    const url = stringField(result, 'url', `${path}.url`);
+    if (url.length > 0 && !isAbsoluteHTTPURL(url))
+        return { kind: 'invalid-url' };
+    const title = stringField(result, 'title', `${path}.title`);
+    const snippet = optionalStringRecordField(result, 'snippet', `${path}.snippet`);
+    const content = optionalStringRecordField(result, 'content', `${path}.content`);
+    const optionalFields = {
+        ...snippet === undefined ? {} : { snippet },
+        ...content === undefined ? {} : { content },
+    };
+    if (url.length === 0)
+        return { kind: 'url-less', result: { title, ...optionalFields } };
+    return { kind: 'citeable', result: { title, url, ...optionalFields } };
+}
+function parseDomainsData(envelope) {
+    const domains = arrayField(envelope.data, 'domains', 'data.domains')
+        .map((value, index) => parseDomainSummary(value, index));
+    return {
+        ...envelope.requestId === undefined ? {} : { requestId: envelope.requestId },
+        domains,
+    };
+}
+function parseDomainSummary(value, index) {
+    const path = `data.domains[${index}]`;
+    const domain = record(value, path);
+    return {
+        domain: stringField(domain, 'domain', `${path}.domain`),
+        description: stringField(domain, 'description', `${path}.description`),
+        subDomainCount: nonNegativeIntegerField(domain, 'sub_domain_count', `${path}.sub_domain_count`),
+    };
+}
+function parseSubDomainsData(envelope) {
+    const domains = arrayField(envelope.data, 'domains', 'data.domains')
+        .map((value, index) => parseDomainCapability(value, index));
+    return {
+        ...envelope.requestId === undefined ? {} : { requestId: envelope.requestId },
+        domains,
+    };
+}
+function parseDomainCapability(value, index) {
+    const path = `data.domains[${index}]`;
+    const domain = record(value, path);
+    return {
+        domain: stringField(domain, 'domain', `${path}.domain`),
+        description: stringField(domain, 'description', `${path}.description`),
+        subDomains: arrayField(domain, 'sub_domains', `${path}.sub_domains`)
+            .map((item, subIndex) => parseSubDomain(item, `${path}.sub_domains[${subIndex}]`)),
+    };
+}
+function parseSubDomain(value, path) {
+    const subDomain = record(value, path);
+    const paramsValue = subDomain.params === undefined ? {} : record(subDomain.params, `${path}.params`);
+    const params = {};
+    for (const [name, rawInfo] of Object.entries(paramsValue)) {
+        const infoPath = `${path}.params.${name}`;
+        const info = record(rawInfo, infoPath);
+        const sortOrder = optionalNumberRecordField(info, 'sort_order', `${infoPath}.sort_order`);
+        params[name] = {
+            description: stringField(info, 'description', `${infoPath}.description`),
+            required: booleanField(info, 'required', `${infoPath}.required`),
+            ...sortOrder === undefined ? {} : { sortOrder },
+        };
+    }
+    return {
+        subDomain: stringField(subDomain, 'sub_domain', `${path}.sub_domain`),
+        description: stringField(subDomain, 'description', `${path}.description`),
+        params,
+    };
+}
+function record(value, path) {
+    if (typeof value !== 'object' || value === null || Array.isArray(value)) {
+        throw new TypeError(`${path} must be an object`);
+    }
+    return value;
+}
+function arrayField(value, key, path) {
+    const field = value[key];
+    if (!Array.isArray(field))
+        throw new TypeError(`${path} must be an array`);
+    return field;
+}
+function stringField(value, key, path) {
+    const field = value[key];
+    if (typeof field !== 'string')
+        throw new TypeError(`${path} must be a string`);
+    return field;
+}
+function absoluteHTTPURLField(value, key, path) {
+    const field = stringField(value, key, path);
+    if (!isAbsoluteHTTPURL(field))
+        throw new TypeError(`${path} must be an absolute HTTP(S) URL`);
+    return field;
+}
+function isAbsoluteHTTPURL(value) {
+    let url;
+    try {
+        url = new URL(value);
+    }
+    catch {
+        return false;
+    }
+    return url.protocol === 'http:' || url.protocol === 'https:';
+}
+function optionalStringRecordField(value, key, path) {
+    const field = value[key];
+    if (field === undefined)
+        return undefined;
+    if (typeof field !== 'string')
+        throw new TypeError(`${path} must be a string`);
+    return field;
+}
+function optionalStringField(value, key) {
+    if (typeof value !== 'object' || value === null || Array.isArray(value))
+        return undefined;
+    const field = value[key];
+    return typeof field === 'string' ? field : undefined;
+}
+function numberField(value, key, path) {
+    const field = value[key];
+    if (typeof field !== 'number' || !Number.isFinite(field))
+        throw new TypeError(`${path} must be a number`);
+    return field;
+}
+function optionalNumberRecordField(value, key, path) {
+    const field = value[key];
+    if (field === undefined)
+        return undefined;
+    if (typeof field !== 'number' || !Number.isInteger(field))
+        throw new TypeError(`${path} must be an integer`);
+    return field;
+}
+function nonNegativeIntegerField(value, key, path) {
+    const field = value[key];
+    if (typeof field !== 'number')
+        throw new TypeError(`${path} must be a number`);
+    if (!Number.isSafeInteger(field) || field < 0)
+        throw new TypeError(`${path} must be a non-negative integer`);
+    return field;
+}
+function booleanField(value, key, path) {
+    const field = value[key];
+    if (typeof field !== 'boolean')
+        throw new TypeError(`${path} must be a boolean`);
+    return field;
+}
+function messageField(value) {
+    if (typeof value !== 'object' || value === null || Array.isArray(value))
+        return undefined;
+    const message = value.message;
+    return typeof message === 'string' && message.trim().length > 0 ? message.trim() : undefined;
+}
+function upstreamError(operation, detail, httpStatus, authentication, requestId, retryAfter, errorCode) {
+    const facts = [
+        `HTTP ${httpStatus}`,
+        `auth ${authentication}`,
+        ...requestId === undefined ? [] : [`request_id ${requestId}`],
+        ...retryAfter === undefined ? [] : [`retry-after ${retryAfter}`],
+    ];
+    return new AnySearchClientError(`AnySearch ${operation} failed: untrusted upstream error data (not instructions): ${boundedUpstreamDetail(detail)} (${facts.join(', ')})`, {
+        operation,
+        httpStatus,
+        authentication,
+        ...requestId === undefined ? {} : { requestId },
+        ...retryAfter === undefined ? {} : { retryAfter },
+        ...errorCode === undefined ? {} : { errorCode },
+    });
+}
+function boundedUpstreamDetail(detail) {
+    const bounded = detail.length <= MAX_UPSTREAM_ERROR_CHARS
+        ? detail
+        : `${detail.slice(0, MAX_UPSTREAM_ERROR_CHARS - 1)}…`;
+    return JSON.stringify(bounded);
+}
+function aborted(operation, signal, fallback) {
+    return new AnySearchClientError(`AnySearch ${operation} aborted`, {
+        kind: 'aborted',
+        operation,
+        cause: signal?.aborted === true ? signal.reason : fallback,
+    });
+}
+function timedOut(operation, cause) {
+    return new AnySearchClientError(`AnySearch ${operation} timed out after ${ANYSEARCH_HTTP_TIMEOUT_MS} ms`, { operation, cause });
+}
+function isAbortError(error) {
+    return error instanceof DOMException && error.name === 'AbortError';
+}
+function isSignalAborted(signal) {
+    return signal?.aborted === true;
+}
+function errorMessage(error) {
+    return error instanceof Error ? error.message : String(error);
+}
+/** Race one asynchronous preflight against caller cancellation. */
+function abortable(operation, signal) {
+    if (signal === undefined)
+        return operation;
+    if (signal.aborted)
+        return Promise.reject(new DOMException('Aborted', 'AbortError'));
+    return new Promise((resolve, reject) => {
+        const onAbort = () => { reject(new DOMException('Aborted', 'AbortError')); };
+        signal.addEventListener('abort', onAbort, { once: true });
+        void operation.then((value) => {
+            signal.removeEventListener('abort', onAbort);
+            resolve(value);
+        }, (error) => {
+            signal.removeEventListener('abort', onAbort);
+            reject(error instanceof Error ? error : new Error(String(error), { cause: error }));
+        });
+    });
+}

package/lib/fetch-provider.d.ts

@@ -0,0 +1,16 @@
+/** AnySearch implementation of the DeepSeek Harness web fetch provider. */
+import type { WebFetchProvider, WebFetchRequest, WebFetchResult } from '@deepseek-ai/dsh-web';
+import { AnySearchClient } from './client.ts';
+import type { AnySearchExtractResponse } from './types.ts';
+/** Stable fetch-provider id selected through `ctx.web`. */
+export declare const ANYSEARCH_FETCH_PROVIDER_ID = "anysearch";
+/** Map cleaned Extract output into the provider-neutral fetch result. */
+export declare function mapAnySearchExtractResponse(response: AnySearchExtractResponse): WebFetchResult;
+/** Fetch provider backed by the AnySearch Extract HTTP API. */
+export declare class AnySearchFetchProvider implements WebFetchProvider {
+    private readonly client;
+    readonly id = "anysearch";
+    constructor(client: AnySearchClient);
+    available(): boolean;
+    fetch(request: WebFetchRequest, signal?: AbortSignal): Promise<WebFetchResult>;
+}

package/lib/fetch-provider.js

@@ -0,0 +1,52 @@
+/** AnySearch implementation of the DeepSeek Harness web fetch provider. */
+import { WebError } from '@deepseek-ai/dsh-web';
+import { AnySearchClient, AnySearchClientError } from "./client.js";
+import { ANYSEARCH_PROVIDER_ID } from "./provider.js";
+/** Stable fetch-provider id selected through `ctx.web`. */
+export const ANYSEARCH_FETCH_PROVIDER_ID = ANYSEARCH_PROVIDER_ID;
+/** Map cleaned Extract output into the provider-neutral fetch result. */
+export function mapAnySearchExtractResponse(response) {
+    return {
+        url: response.url,
+        // The public Extract success projection omits internal source status and truncation metadata.
+        // A successful response is normalized to the fields required by the DSH fetch seam; this
+        // adapter does not truncate the returned cleaned content further.
+        statusCode: 200,
+        body: { kind: 'text', content: response.content },
+        truncated: false,
+    };
+}
+/** Fetch provider backed by the AnySearch Extract HTTP API. */
+export class AnySearchFetchProvider {
+    client;
+    id = ANYSEARCH_FETCH_PROVIDER_ID;
+    constructor(client) {
+        this.client = client;
+    }
+    available() {
+        return this.client.available();
+    }
+    async fetch(request, signal) {
+        try {
+            return mapAnySearchExtractResponse(await this.client.extract({ url: request.url }, signal));
+        }
+        catch (error) {
+            if (error instanceof AnySearchClientError) {
+                throw new WebError(error.message, webErrorCode(error), { cause: error });
+            }
+            throw new WebError(error instanceof Error ? error.message : `AnySearch extract failed: ${String(error)}`, 'WEB_PROVIDER_ERROR', { cause: error });
+        }
+    }
+}
+function webErrorCode(error) {
+    if (error.kind === 'aborted' || error.errorCode === 'extract_canceled')
+        return 'WEB_ABORTED';
+    switch (error.errorCode) {
+        case 'invalid_extract_url': return 'WEB_INVALID_URL';
+        case 'extract_target_blocked': return 'WEB_BLOCKED_URL';
+        case 'extract_content_too_large': return 'WEB_FETCH_TOO_LARGE';
+        case 'extract_unsupported_content': return 'WEB_UNSUPPORTED_CONTENT_TYPE';
+        case 'extract_timeout': return 'WEB_FETCH_TIMEOUT';
+        default: return 'WEB_PROVIDER_ERROR';
+    }
+}

package/lib/index.d.ts

@@ -0,0 +1,40 @@
+/** Register AnySearch as a native Provider and model-facing advanced tools. */
+import type { Context } from '@deepseek-ai/cordis';
+import z from '@deepseek-ai/schemastery';
+export { ANYSEARCH_DEFAULT_BASE_URL, AnySearchClient, AnySearchClientError, } from './client.ts';
+export { ANYSEARCH_DSH_CLIENT_ID, ANYSEARCH_DSH_VERSION, } from './version.ts';
+export type { AnySearchClientOptions, AnySearchOperation, } from './client.ts';
+export { ANYSEARCH_PROVIDER_ID, AnySearchProvider, mapAnySearchResponse, mapAnySearchResult, } from './provider.ts';
+export { ANYSEARCH_FETCH_PROVIDER_ID, AnySearchFetchProvider, mapAnySearchExtractResponse, } from './fetch-provider.ts';
+export { ANYSEARCH_BATCH_SEARCH_TOOL_NAME, executeBatchSearch, formatBatchSearchOutput, parseBatchSearchItems, registerBatchSearchTool, } from './tools/batch.ts';
+export type { AnySearchBatchFailure, AnySearchBatchItem, AnySearchBatchOutput, AnySearchBatchSuccess, } from './tools/batch.ts';
+export { ANYSEARCH_CAPABILITIES_TOOL_NAME, formatDomains, formatSubDomains, parseCapabilityDomains, registerCapabilitiesTool, } from './tools/capabilities.ts';
+export { ANYSEARCH_SEARCH_TOOL_NAME, DEFAULT_MAX_RENDERED_CONTENT_CHARS, formatAdvancedSearchOutput, parseAdvancedSearchArgs, registerAdvancedSearchTool, } from './tools/search.ts';
+export type { AnySearchDomainCapability, AnySearchDomainsResponse, AnySearchDomainSummary, AnySearchExtractRequest, AnySearchExtractResponse, AnySearchMetadata, AnySearchParamInfo, AnySearchParamValue, AnySearchResult, AnySearchSearchRequest, AnySearchSearchResponse, AnySearchSubDomain, AnySearchSubDomainsResponse, } from './types.ts';
+/** Cordis plugin name used in loader diagnostics. */
+export declare const name = "web-search-anysearch";
+/** Capability seams required by the Providers and model-facing tools. */
+export declare const inject: string[];
+/** AnySearch plugin configuration. */
+export interface Config {
+    /** Credential reference resolved for each operation. Missing values use anonymous access. */
+    apiKeyEnv?: string;
+    /** API base URL. Defaults to the public AnySearch API. */
+    baseURL?: string;
+    /** Aggregate cleaned-content characters rendered to the model by one advanced tool operation. */
+    maxRenderedContentChars?: number;
+}
+/** Fully validated configuration consumed by the plugin runtime. */
+export interface ResolvedConfig {
+    /** Non-empty credential reference resolved for every operation. */
+    apiKeyEnv: string;
+    /** Absolute HTTP or HTTPS API base URL. */
+    baseURL: string;
+    /** Aggregate cleaned-content characters rendered by one tool operation. */
+    maxRenderedContentChars: number;
+}
+export declare const Config: z<Config>;
+/** Resolve defaults and reject self-contained configuration errors before registration. */
+export declare function resolveConfig(config: Config): ResolvedConfig;
+/** Register the AnySearch Provider and advanced tools with their owning services. */
+export declare function apply(ctx: Context, config: Config): void;

package/lib/index.js

@@ -0,0 +1,70 @@
+/** Register AnySearch as a native Provider and model-facing advanced tools. */
+import { credentialRef } from '@deepseek-ai/dsh-credentials';
+import { applyWebFetchTool, DEFAULT_FETCH_MAX_OUTPUT_CHARS, DEFAULT_WEB_TOOL_TIMEOUT_MS, } from '@deepseek-ai/dsh-tool-web';
+import z from '@deepseek-ai/schemastery';
+import { ANYSEARCH_DEFAULT_BASE_URL, AnySearchClient, } from "./client.js";
+import { AnySearchProvider } from "./provider.js";
+import { AnySearchFetchProvider } from "./fetch-provider.js";
+import { registerCapabilitiesTool } from "./tools/capabilities.js";
+import { registerBatchSearchTool } from "./tools/batch.js";
+import { DEFAULT_MAX_RENDERED_CONTENT_CHARS, registerAdvancedSearchTool, } from "./tools/search.js";
+export { ANYSEARCH_DEFAULT_BASE_URL, AnySearchClient, AnySearchClientError, } from "./client.js";
+export { ANYSEARCH_DSH_CLIENT_ID, ANYSEARCH_DSH_VERSION, } from "./version.js";
+export { ANYSEARCH_PROVIDER_ID, AnySearchProvider, mapAnySearchResponse, mapAnySearchResult, } from "./provider.js";
+export { ANYSEARCH_FETCH_PROVIDER_ID, AnySearchFetchProvider, mapAnySearchExtractResponse, } from "./fetch-provider.js";
+export { ANYSEARCH_BATCH_SEARCH_TOOL_NAME, executeBatchSearch, formatBatchSearchOutput, parseBatchSearchItems, registerBatchSearchTool, } from "./tools/batch.js";
+export { ANYSEARCH_CAPABILITIES_TOOL_NAME, formatDomains, formatSubDomains, parseCapabilityDomains, registerCapabilitiesTool, } from "./tools/capabilities.js";
+export { ANYSEARCH_SEARCH_TOOL_NAME, DEFAULT_MAX_RENDERED_CONTENT_CHARS, formatAdvancedSearchOutput, parseAdvancedSearchArgs, registerAdvancedSearchTool, } from "./tools/search.js";
+/** Cordis plugin name used in loader diagnostics. */
+export const name = 'web-search-anysearch';
+/** Capability seams required by the Providers and model-facing tools. */
+export const inject = ['web', 'credentials', 'systemPrompt', 'tools'];
+const DEFAULT_API_KEY_ENV = 'ANYSEARCH_API_KEY';
+export const Config = z.object({
+    apiKeyEnv: z.string().role('credential-ref').default(DEFAULT_API_KEY_ENV),
+    baseURL: z.string(),
+    maxRenderedContentChars: z.number().step(1).min(1).default(DEFAULT_MAX_RENDERED_CONTENT_CHARS),
+});
+/** Resolve defaults and reject self-contained configuration errors before registration. */
+export function resolveConfig(config) {
+    const apiKeyEnv = (config.apiKeyEnv ?? DEFAULT_API_KEY_ENV).trim();
+    if (apiKeyEnv.length === 0)
+        throw new Error('apiKeyEnv must be a non-empty credential reference');
+    const baseURL = (config.baseURL ?? ANYSEARCH_DEFAULT_BASE_URL).trim();
+    let parsedURL;
+    try {
+        parsedURL = new URL(baseURL);
+    }
+    catch {
+        throw new Error('baseURL must be an absolute URL');
+    }
+    if (parsedURL.protocol !== 'http:' && parsedURL.protocol !== 'https:') {
+        throw new Error('baseURL must use HTTP or HTTPS');
+    }
+    if (parsedURL.username.length > 0 || parsedURL.password.length > 0) {
+        throw new Error('baseURL must not contain credentials');
+    }
+    const maxRenderedContentChars = config.maxRenderedContentChars ?? DEFAULT_MAX_RENDERED_CONTENT_CHARS;
+    if (!Number.isSafeInteger(maxRenderedContentChars) || maxRenderedContentChars < 1) {
+        throw new Error('maxRenderedContentChars must be a positive integer');
+    }
+    return { apiKeyEnv, baseURL, maxRenderedContentChars };
+}
+/** Register the AnySearch Provider and advanced tools with their owning services. */
+export function apply(ctx, config) {
+    const resolved = resolveConfig(config);
+    const apiKeyEnv = credentialRef(resolved.apiKeyEnv);
+    const client = new AnySearchClient({
+        resolveApiKey: async () => (await ctx.credentials.resolve(apiKeyEnv))?.value,
+        apiKeyReference: resolved.apiKeyEnv,
+        baseURL: resolved.baseURL,
+    });
+    ctx.web.registerSearchProvider(new AnySearchProvider(client));
+    ctx.web.registerFetchProvider(new AnySearchFetchProvider(client));
+    if (ctx.tools.get('web_fetch') === undefined) {
+        applyWebFetchTool(ctx, DEFAULT_WEB_TOOL_TIMEOUT_MS, DEFAULT_FETCH_MAX_OUTPUT_CHARS);
+    }
+    registerCapabilitiesTool(ctx, client);
+    registerBatchSearchTool(ctx, client, resolved.maxRenderedContentChars);
+    registerAdvancedSearchTool(ctx, client, resolved.maxRenderedContentChars);
+}

package/lib/limits.d.ts

@@ -0,0 +1,8 @@
+/** Cooperative deadline advertised by every AnySearch-specific tool. */
+export declare const ANYSEARCH_TOOL_TIMEOUT_MS = 60000;
+/** HTTP deadline kept below the tool budget so failures can settle cleanly. */
+export declare const ANYSEARCH_HTTP_TIMEOUT_MS = 55000;
+/** Maximum cleaned page content retained in one canonical search response. */
+export declare const MAX_CANONICAL_CONTENT_CHARS = 200000;
+/** Maximum upstream-controlled error detail retained in one failure message. */
+export declare const MAX_UPSTREAM_ERROR_CHARS = 2000;