@revealui/ai 0.1.0

package/dist/tools/web/duck-duck-go.js

@@ -0,0 +1,202 @@
+/**
+ * DuckDuckGo Web Search Tool
+ *
+ * Uses the DuckDuckGo Instant Answer API (no API key required).
+ * Returns structured results suitable for agent consumption.
+ *
+ * Part of the WebSearch skill family — see types.ts for the
+ * WebSearchProvider interface used by future Tavily/Exa backends (P4-3).
+ */
+import { z } from 'zod/v4';
+const DDG_API_URL = 'https://api.duckduckgo.com/';
+/** Approximate token count for a string (4 chars ≈ 1 token). */
+function estimateTokens(text) {
+    return Math.ceil(text.length / 4);
+}
+// =============================================================================
+// Provider
+// =============================================================================
+/**
+ * DuckDuckGo search provider — zero-config, no API key required.
+ *
+ * Uses the DuckDuckGo Instant Answer API to retrieve the abstract summary
+ * and related topics for a query.
+ */
+export class DuckDuckGoProvider {
+    name = 'duckduckgo';
+    async search(query, maxResults) {
+        const url = new URL(DDG_API_URL);
+        url.searchParams.set('q', query);
+        url.searchParams.set('format', 'json');
+        url.searchParams.set('no_html', '1');
+        url.searchParams.set('skip_disambig', '1');
+        const controller = new AbortController();
+        const timeoutId = setTimeout(() => controller.abort(), 10_000);
+        let response;
+        try {
+            response = await fetch(url.toString(), { signal: controller.signal });
+        }
+        finally {
+            clearTimeout(timeoutId);
+        }
+        if (!response.ok) {
+            throw new Error(`DuckDuckGo API request failed: ${response.status} ${response.statusText}`);
+        }
+        const data = (await response.json());
+        const results = [];
+        // Add abstract if present
+        if (data.AbstractText && data.AbstractURL) {
+            results.push({
+                title: data.AbstractSource || query,
+                link: data.AbstractURL,
+                snippet: data.AbstractText,
+            });
+        }
+        // Add related topics (skip category group entries that have nested Topics)
+        for (const topic of data.RelatedTopics ?? []) {
+            if (results.length >= maxResults)
+                break;
+            if (topic.Topics)
+                continue; // category group — skip
+            const text = topic.Text;
+            const firstURL = topic.FirstURL;
+            if (!(firstURL && text))
+                continue;
+            const parts = text.split(' - ');
+            results.push({
+                title: parts[0]?.trim() ?? text,
+                link: firstURL,
+                snippet: text,
+            });
+        }
+        const tokenCount = results.reduce((acc, r) => acc + estimateTokens(r.title + r.link + r.snippet), 0);
+        return { results, query, tokenCount };
+    }
+}
+// =============================================================================
+// Tool
+// =============================================================================
+const WebSearchParamsSchema = z.object({
+    query: z.string().min(1).describe('The search query'),
+    maxResults: z
+        .number()
+        .int()
+        .min(1)
+        .max(20)
+        .default(5)
+        .describe('Maximum number of results to return (1–20, default 5)'),
+});
+/**
+ * Factory that creates a `web_search` tool backed by any WebSearchProvider.
+ *
+ * The singleton `webSearchTool` uses DuckDuckGo. Pass a TavilyProvider or
+ * ExaProvider here to get the same tool with a premium BYOK backend.
+ *
+ * @example
+ * ```typescript
+ * import { createWebSearchTool, TavilyProvider } from '@revealui/ai'
+ *
+ * const tool = createWebSearchTool(new TavilyProvider(apiKey))
+ * agent.tools.push(tool)
+ * ```
+ */
+export function createWebSearchTool(provider) {
+    return {
+        name: 'web_search',
+        description: `Search the web using ${provider.name}. Returns titles, URLs, and snippets for the given query.`,
+        parameters: WebSearchParamsSchema,
+        async execute(params) {
+            const { query, maxResults } = WebSearchParamsSchema.parse(params);
+            try {
+                const response = await provider.search(query, maxResults);
+                if (response.results.length === 0) {
+                    return {
+                        success: true,
+                        data: {
+                            results: [],
+                            query,
+                            tokenCount: 0,
+                            message: 'No results found for this query.',
+                        },
+                        metadata: { tokensUsed: 0 },
+                    };
+                }
+                return {
+                    success: true,
+                    data: response,
+                    metadata: { tokensUsed: response.tokenCount },
+                };
+            }
+            catch (error) {
+                return {
+                    success: false,
+                    error: `Web search failed: ${error instanceof Error ? error.message : String(error)}`,
+                };
+            }
+        },
+        getMetadata() {
+            return {
+                category: 'web',
+                version: '1.0.0',
+                author: 'RevealUI',
+            };
+        },
+    };
+}
+/**
+ * Web search tool backed by DuckDuckGo (zero-config).
+ *
+ * Register this on any agent that needs live web access. Requires no
+ * API key — backed by the DuckDuckGo Instant Answer API.
+ *
+ * @example
+ * ```typescript
+ * import { webSearchTool } from '@revealui/ai'
+ *
+ * agent.tools.push(webSearchTool)
+ * // Agent can now call web_search({ query: '...', maxResults: 5 })
+ * ```
+ */
+export const webSearchTool = {
+    name: 'web_search',
+    description: 'Search the web using DuckDuckGo. Returns titles, URLs, and snippets for the given query. ' +
+        'No API key required.',
+    parameters: WebSearchParamsSchema,
+    async execute(params) {
+        const { query, maxResults } = WebSearchParamsSchema.parse(params);
+        const provider = new DuckDuckGoProvider();
+        try {
+            const response = await provider.search(query, maxResults);
+            if (response.results.length === 0) {
+                return {
+                    success: true,
+                    data: {
+                        results: [],
+                        query,
+                        tokenCount: 0,
+                        message: 'No results found for this query.',
+                    },
+                    metadata: { tokensUsed: 0 },
+                };
+            }
+            return {
+                success: true,
+                data: response,
+                metadata: { tokensUsed: response.tokenCount },
+            };
+        }
+        catch (error) {
+            return {
+                success: false,
+                error: `Web search failed: ${error instanceof Error ? error.message : String(error)}`,
+            };
+        }
+    },
+    getMetadata() {
+        return {
+            category: 'web',
+            version: '1.0.0',
+            author: 'RevealUI',
+        };
+    },
+};

package/dist/tools/web/exa.d.ts

@@ -0,0 +1,34 @@
+/**
+ * Exa Web Search Provider (P4-3)
+ *
+ * Neural search backend using the Exa Search API.
+ * Exa uses embeddings to find semantically relevant results, making it
+ * especially good for research and complex queries. Requires an Exa API key.
+ *
+ * @see https://docs.exa.ai/reference/search
+ */
+import type { WebSearchProvider, WebSearchResponse } from './types.js';
+/**
+ * Exa neural search provider — BYOK, requires `EXA_API_KEY`.
+ *
+ * Exa uses embeddings to find semantically relevant results rather than
+ * keyword matching. Best for research-oriented queries.
+ *
+ * Register via `AgentConfig.webSearchProvider` to replace the default
+ * DuckDuckGo backend.
+ *
+ * @example
+ * ```typescript
+ * import { ExaProvider, createWebSearchTool } from '@revealui/ai'
+ *
+ * const tool = createWebSearchTool(new ExaProvider(process.env.EXA_API_KEY!))
+ * agent.config = { webSearchProvider: new ExaProvider(key) }
+ * ```
+ */
+export declare class ExaProvider implements WebSearchProvider {
+    readonly name = "exa";
+    private readonly apiKey;
+    constructor(apiKey: string);
+    search(query: string, maxResults: number): Promise<WebSearchResponse>;
+}
+//# sourceMappingURL=exa.d.ts.map

package/dist/tools/web/exa.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"exa.d.ts","sourceRoot":"","sources":["../../../src/tools/web/exa.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AAEH,OAAO,KAAK,EAAE,iBAAiB,EAAE,iBAAiB,EAAmB,MAAM,YAAY,CAAA;AAsBvF;;;;;;;;;;;;;;;;GAgBG;AACH,qBAAa,WAAY,YAAW,iBAAiB;IACnD,QAAQ,CAAC,IAAI,SAAQ;IACrB,OAAO,CAAC,QAAQ,CAAC,MAAM,CAAQ;gBAEnB,MAAM,EAAE,MAAM;IAKpB,MAAM,CAAC,KAAK,EAAE,MAAM,EAAE,UAAU,EAAE,MAAM,GAAG,OAAO,CAAC,iBAAiB,CAAC;CA+C5E"}

package/dist/tools/web/exa.js

@@ -0,0 +1,80 @@
+/**
+ * Exa Web Search Provider (P4-3)
+ *
+ * Neural search backend using the Exa Search API.
+ * Exa uses embeddings to find semantically relevant results, making it
+ * especially good for research and complex queries. Requires an Exa API key.
+ *
+ * @see https://docs.exa.ai/reference/search
+ */
+const EXA_API_URL = 'https://api.exa.ai/search';
+/** Approximate token count for a string (4 chars ≈ 1 token). */
+function estimateTokens(text) {
+    return Math.ceil(text.length / 4);
+}
+/**
+ * Exa neural search provider — BYOK, requires `EXA_API_KEY`.
+ *
+ * Exa uses embeddings to find semantically relevant results rather than
+ * keyword matching. Best for research-oriented queries.
+ *
+ * Register via `AgentConfig.webSearchProvider` to replace the default
+ * DuckDuckGo backend.
+ *
+ * @example
+ * ```typescript
+ * import { ExaProvider, createWebSearchTool } from '@revealui/ai'
+ *
+ * const tool = createWebSearchTool(new ExaProvider(process.env.EXA_API_KEY!))
+ * agent.config = { webSearchProvider: new ExaProvider(key) }
+ * ```
+ */
+export class ExaProvider {
+    name = 'exa';
+    apiKey;
+    constructor(apiKey) {
+        if (!apiKey)
+            throw new Error('ExaProvider: apiKey is required');
+        this.apiKey = apiKey;
+    }
+    async search(query, maxResults) {
+        const controller = new AbortController();
+        const timeoutId = setTimeout(() => controller.abort(), 10_000);
+        let response;
+        try {
+            response = await fetch(EXA_API_URL, {
+                method: 'POST',
+                headers: {
+                    'Content-Type': 'application/json',
+                    'x-api-key': this.apiKey,
+                },
+                body: JSON.stringify({
+                    query,
+                    num_results: maxResults,
+                    type: 'auto',
+                    contents: {
+                        text: { max_characters: 1000 },
+                    },
+                }),
+                signal: controller.signal,
+            });
+        }
+        finally {
+            clearTimeout(timeoutId);
+        }
+        if (!response.ok) {
+            throw new Error(`Exa API request failed: ${response.status} ${response.statusText}`);
+        }
+        const data = (await response.json());
+        const results = data.results.slice(0, maxResults).map((r) => {
+            const snippet = r.highlights?.join(' ') ?? r.text ?? '';
+            return {
+                title: r.title,
+                link: r.url,
+                snippet,
+            };
+        });
+        const tokenCount = results.reduce((acc, r) => acc + estimateTokens(r.title + r.link + r.snippet), 0);
+        return { results, query, tokenCount };
+    }
+}

package/dist/tools/web/index.d.ts

@@ -0,0 +1,6 @@
+export { createWebSearchTool, DuckDuckGoProvider, webSearchTool } from './duck-duck-go.js';
+export { ExaProvider } from './exa.js';
+export { webScraperTool } from './scraper.js';
+export { TavilyProvider } from './tavily.js';
+export type { WebSearchProvider, WebSearchResponse, WebSearchResult } from './types.js';
+//# sourceMappingURL=index.d.ts.map

package/dist/tools/web/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/tools/web/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,mBAAmB,EAAE,kBAAkB,EAAE,aAAa,EAAE,MAAM,mBAAmB,CAAA;AAC1F,OAAO,EAAE,WAAW,EAAE,MAAM,UAAU,CAAA;AACtC,OAAO,EAAE,cAAc,EAAE,MAAM,cAAc,CAAA;AAC7C,OAAO,EAAE,cAAc,EAAE,MAAM,aAAa,CAAA;AAC5C,YAAY,EAAE,iBAAiB,EAAE,iBAAiB,EAAE,eAAe,EAAE,MAAM,YAAY,CAAA"}

package/dist/tools/web/index.js

@@ -0,0 +1,4 @@
+export { createWebSearchTool, DuckDuckGoProvider, webSearchTool } from './duck-duck-go.js';
+export { ExaProvider } from './exa.js';
+export { webScraperTool } from './scraper.js';
+export { TavilyProvider } from './tavily.js';

package/dist/tools/web/scraper.d.ts

@@ -0,0 +1,9 @@
+/**
+ * Web Scraper Tool
+ *
+ * Fetches a URL, extracts text via HtmlParser (no external deps),
+ * and truncates to maxLength tokens with a helpful message.
+ */
+import type { Tool } from '../base.js';
+export declare const webScraperTool: Tool;
+//# sourceMappingURL=scraper.d.ts.map

package/dist/tools/web/scraper.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"scraper.d.ts","sourceRoot":"","sources":["../../../src/tools/web/scraper.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAIH,OAAO,KAAK,EAAE,IAAI,EAAc,MAAM,YAAY,CAAA;AA+ClD,eAAO,MAAM,cAAc,EAAE,IAwE5B,CAAA"}

package/dist/tools/web/scraper.js

@@ -0,0 +1,118 @@
+/**
+ * Web Scraper Tool
+ *
+ * Fetches a URL, extracts text via HtmlParser (no external deps),
+ * and truncates to maxLength tokens with a helpful message.
+ */
+import { z } from 'zod/v4';
+import { HtmlParser } from '../../ingestion/file-parsers.js';
+const ScraperParams = z.object({
+    url: z.url(),
+    maxLength: z.number().int().positive().default(4000),
+});
+const htmlParser = new HtmlParser();
+/**
+ * Returns true if the URL targets a private, loopback, or reserved address
+ * that agents must not be allowed to fetch (SSRF protection).
+ */
+function isPrivateOrLoopbackUrl(urlString) {
+    let url;
+    try {
+        url = new URL(urlString);
+    }
+    catch {
+        return true;
+    }
+    if (url.protocol !== 'http:' && url.protocol !== 'https:') {
+        return true;
+    }
+    const host = url.hostname.toLowerCase();
+    if (host === 'localhost' || host === '0.0.0.0')
+        return true;
+    if (host === '[::1]' || host === '::1')
+        return true;
+    const ipv4 = host.match(/^(\d+)\.(\d+)\.(\d+)\.(\d+)$/);
+    if (ipv4) {
+        const [, aStr, bStr] = ipv4;
+        const a = Number(aStr);
+        const b = Number(bStr);
+        if (a === 10)
+            return true; // Class A private (RFC 1918)
+        if (a === 127)
+            return true; // Loopback
+        if (a === 172 && b >= 16 && b <= 31)
+            return true; // Class B private
+        if (a === 192 && b === 168)
+            return true; // Class C private
+        if (a === 169 && b === 254)
+            return true; // Link-local / AWS IMDS
+        if (a === 100 && b >= 64 && b <= 127)
+            return true; // CGNAT (RFC 6598)
+        if (a === 0)
+            return true; // 0.x.x.x
+    }
+    return false;
+}
+export const webScraperTool = {
+    name: 'web_scrape',
+    description: 'Fetch a URL and extract its text content. Use this to read web pages, documentation, or articles. For long documents, use document_summarize instead.',
+    parameters: ScraperParams,
+    async execute(params) {
+        const start = Date.now();
+        const parsed = ScraperParams.safeParse(params);
+        if (!parsed.success) {
+            return { success: false, error: `Invalid parameters: ${parsed.error.message}` };
+        }
+        const { url, maxLength } = parsed.data;
+        const maxChars = maxLength * 4;
+        if (isPrivateOrLoopbackUrl(url)) {
+            return { success: false, error: 'URL targets a private or reserved address' };
+        }
+        try {
+            const controller = new AbortController();
+            const timer = setTimeout(() => controller.abort(), 10_000);
+            let html;
+            try {
+                const response = await fetch(url, {
+                    signal: controller.signal,
+                    headers: { 'User-Agent': 'RevealUI-Agent/1.0' },
+                });
+                clearTimeout(timer);
+                if (!response.ok) {
+                    return {
+                        success: false,
+                        error: `HTTP ${response.status}: ${response.statusText}`,
+                    };
+                }
+                html = await response.text();
+            }
+            finally {
+                clearTimeout(timer);
+            }
+            const { text } = htmlParser.parse(html);
+            const wordCount = text.split(/\s+/).filter((w) => w.length > 0).length;
+            let content = text;
+            let truncated = false;
+            if (content.length > maxChars) {
+                content =
+                    content.slice(0, maxChars) +
+                        ' [content truncated — use document_summarize for full content]';
+                truncated = true;
+            }
+            return {
+                success: true,
+                data: { url, content, wordCount, truncated },
+                metadata: { executionTime: Date.now() - start },
+            };
+        }
+        catch (error) {
+            if (error instanceof Error && error.name === 'AbortError') {
+                return { success: false, error: 'Request timed out after 10 seconds' };
+            }
+            return {
+                success: false,
+                error: error instanceof Error ? error.message : String(error),
+            };
+        }
+    },
+};

package/dist/tools/web/tavily.d.ts

@@ -0,0 +1,32 @@
+/**
+ * Tavily Web Search Provider (P4-3)
+ *
+ * High-quality BYOK search backend using the Tavily Search API.
+ * Tavily is optimised for LLM consumption — returns clean, summarised
+ * content rather than raw HTML. Requires a Tavily API key.
+ *
+ * @see https://docs.tavily.com/docs/tavily-api/rest_api
+ */
+import type { WebSearchProvider, WebSearchResponse } from './types.js';
+/**
+ * Tavily search provider — BYOK, requires `TAVILY_API_KEY`.
+ *
+ * Tavily returns high-quality, LLM-optimised results with relevance scoring.
+ * Register via `AgentConfig.webSearchProvider` to replace the default
+ * DuckDuckGo backend.
+ *
+ * @example
+ * ```typescript
+ * import { TavilyProvider, createWebSearchTool } from '@revealui/ai'
+ *
+ * const tool = createWebSearchTool(new TavilyProvider(process.env.TAVILY_API_KEY!))
+ * agent.config = { webSearchProvider: new TavilyProvider(key) }
+ * ```
+ */
+export declare class TavilyProvider implements WebSearchProvider {
+    readonly name = "tavily";
+    private readonly apiKey;
+    constructor(apiKey: string);
+    search(query: string, maxResults: number): Promise<WebSearchResponse>;
+}
+//# sourceMappingURL=tavily.d.ts.map

package/dist/tools/web/tavily.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"tavily.d.ts","sourceRoot":"","sources":["../../../src/tools/web/tavily.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AAEH,OAAO,KAAK,EAAE,iBAAiB,EAAE,iBAAiB,EAAmB,MAAM,YAAY,CAAA;AAsBvF;;;;;;;;;;;;;;GAcG;AACH,qBAAa,cAAe,YAAW,iBAAiB;IACtD,QAAQ,CAAC,IAAI,YAAW;IACxB,OAAO,CAAC,QAAQ,CAAC,MAAM,CAAQ;gBAEnB,MAAM,EAAE,MAAM;IAKpB,MAAM,CAAC,KAAK,EAAE,MAAM,EAAE,UAAU,EAAE,MAAM,GAAG,OAAO,CAAC,iBAAiB,CAAC;CA0C5E"}

package/dist/tools/web/tavily.js

@@ -0,0 +1,73 @@
+/**
+ * Tavily Web Search Provider (P4-3)
+ *
+ * High-quality BYOK search backend using the Tavily Search API.
+ * Tavily is optimised for LLM consumption — returns clean, summarised
+ * content rather than raw HTML. Requires a Tavily API key.
+ *
+ * @see https://docs.tavily.com/docs/tavily-api/rest_api
+ */
+const TAVILY_API_URL = 'https://api.tavily.com/search';
+/** Approximate token count for a string (4 chars ≈ 1 token). */
+function estimateTokens(text) {
+    return Math.ceil(text.length / 4);
+}
+/**
+ * Tavily search provider — BYOK, requires `TAVILY_API_KEY`.
+ *
+ * Tavily returns high-quality, LLM-optimised results with relevance scoring.
+ * Register via `AgentConfig.webSearchProvider` to replace the default
+ * DuckDuckGo backend.
+ *
+ * @example
+ * ```typescript
+ * import { TavilyProvider, createWebSearchTool } from '@revealui/ai'
+ *
+ * const tool = createWebSearchTool(new TavilyProvider(process.env.TAVILY_API_KEY!))
+ * agent.config = { webSearchProvider: new TavilyProvider(key) }
+ * ```
+ */
+export class TavilyProvider {
+    name = 'tavily';
+    apiKey;
+    constructor(apiKey) {
+        if (!apiKey)
+            throw new Error('TavilyProvider: apiKey is required');
+        this.apiKey = apiKey;
+    }
+    async search(query, maxResults) {
+        const controller = new AbortController();
+        const timeoutId = setTimeout(() => controller.abort(), 10_000);
+        let response;
+        try {
+            response = await fetch(TAVILY_API_URL, {
+                method: 'POST',
+                headers: {
+                    'Content-Type': 'application/json',
+                    Authorization: `Bearer ${this.apiKey}`,
+                },
+                body: JSON.stringify({
+                    query,
+                    max_results: maxResults,
+                    search_depth: 'basic',
+                    include_answer: false,
+                }),
+                signal: controller.signal,
+            });
+        }
+        finally {
+            clearTimeout(timeoutId);
+        }
+        if (!response.ok) {
+            throw new Error(`Tavily API request failed: ${response.status} ${response.statusText}`);
+        }
+        const data = (await response.json());
+        const results = data.results.slice(0, maxResults).map((r) => ({
+            title: r.title,
+            link: r.url,
+            snippet: r.content,
+        }));
+        const tokenCount = results.reduce((acc, r) => acc + estimateTokens(r.title + r.link + r.snippet), 0);
+        return { results, query, tokenCount };
+    }
+}

package/dist/tools/web/types.d.ts

@@ -0,0 +1,31 @@
+/**
+ * Web Search Types
+ *
+ * Shared types for web search tools and provider interface.
+ * The WebSearchProvider interface enables swappable backends:
+ * - DuckDuckGo (default, zero-config) — P3-1
+ * - Tavily, Exa (BYOK) — P4-3
+ */
+export interface WebSearchResult {
+    title: string;
+    link: string;
+    snippet: string;
+}
+export interface WebSearchResponse {
+    results: WebSearchResult[];
+    query: string;
+    /** Approximate token count of the response content (chars / 4) */
+    tokenCount: number;
+}
+/**
+ * Interface for pluggable web search backends.
+ *
+ * DuckDuckGo is the default zero-config implementation.
+ * Drop in Tavily or Exa by implementing this interface and registering
+ * it via AgentConfig.webSearchProvider (Phase 4, P4-3).
+ */
+export interface WebSearchProvider {
+    readonly name: string;
+    search(query: string, maxResults: number): Promise<WebSearchResponse>;
+}
+//# sourceMappingURL=types.d.ts.map

package/dist/tools/web/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../../src/tools/web/types.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAEH,MAAM,WAAW,eAAe;IAC9B,KAAK,EAAE,MAAM,CAAA;IACb,IAAI,EAAE,MAAM,CAAA;IACZ,OAAO,EAAE,MAAM,CAAA;CAChB;AAED,MAAM,WAAW,iBAAiB;IAChC,OAAO,EAAE,eAAe,EAAE,CAAA;IAC1B,KAAK,EAAE,MAAM,CAAA;IACb,kEAAkE;IAClE,UAAU,EAAE,MAAM,CAAA;CACnB;AAED;;;;;;GAMG;AACH,MAAM,WAAW,iBAAiB;IAChC,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAA;IACrB,MAAM,CAAC,KAAK,EAAE,MAAM,EAAE,UAAU,EAAE,MAAM,GAAG,OAAO,CAAC,iBAAiB,CAAC,CAAA;CACtE"}

package/dist/tools/web/types.js

@@ -0,0 +1,9 @@
+/**
+ * Web Search Types
+ *
+ * Shared types for web search tools and provider interface.
+ * The WebSearchProvider interface enables swappable backends:
+ * - DuckDuckGo (default, zero-config) — P3-1
+ * - Tavily, Exa (BYOK) — P4-3
+ */
+export {};