@pellux/goodvibes-sdk 0.18.13 → 0.18.15

package/dist/_internal/platform/web-search/providers/brave.js

@@ -0,0 +1,89 @@
+import { buildDescriptor, executeJsonRequest, resolveDomain, resultFromRecord, withInlineApiKey, } from './shared.js';
+const BRAVE_DEFAULT_BASE_URL = 'https://api.search.brave.com';
+const BRAVE_ENV_KEYS = ['BRAVE_SEARCH_API_KEY', 'BRAVE_API_KEY'];
+const BRAVE_SERVICE_NAME = 'brave-search';
+function mapSafeSearch(value) {
+    switch (value) {
+        case 'strict':
+            return 'strict';
+        case 'off':
+            return 'off';
+        case 'moderate':
+            return 'moderate';
+        default:
+            return undefined;
+    }
+}
+export function createBraveSearchProvider(context) {
+    const env = context.env;
+    const serviceRegistry = context.serviceRegistry;
+    return {
+        id: 'brave',
+        label: 'Brave Search',
+        capabilities: ['search', 'evidence'],
+        descriptor() {
+            return buildDescriptor({
+                id: 'brave',
+                label: 'Brave Search',
+                note: 'Uses Brave Search JSON results. Configure via BRAVE_SEARCH_API_KEY or a brave-search service entry.',
+                envKeyCandidates: BRAVE_ENV_KEYS,
+                serviceName: BRAVE_SERVICE_NAME,
+                defaultBaseUrl: BRAVE_DEFAULT_BASE_URL,
+            }, { env, serviceRegistry });
+        },
+        async search(request) {
+            const maxResults = Math.max(1, Math.min(20, request.maxResults ?? 10));
+            const baseUrl = (serviceRegistry.get(BRAVE_SERVICE_NAME)?.baseUrl ?? BRAVE_DEFAULT_BASE_URL).replace(/\/+$/, '');
+            const { payload } = await executeJsonRequest({
+                url: `${baseUrl}/res/v1/web/search`,
+                params: {
+                    q: request.query,
+                    count: String(maxResults),
+                    ...(mapSafeSearch(request.safeSearch) ? { safesearch: mapSafeSearch(request.safeSearch) } : {}),
+                },
+                headers: { Accept: 'application/json' },
+                service: serviceRegistry.get(BRAVE_SERVICE_NAME) ? BRAVE_SERVICE_NAME : undefined,
+                auth: serviceRegistry.get(BRAVE_SERVICE_NAME) ? undefined : withInlineApiKey(env, BRAVE_ENV_KEYS, 'X-Subscription-Token'),
+                fetcher: context.fetcher,
+            });
+            const web = payload.web;
+            const results = Array.isArray(web?.results)
+                ? web.results
+                    .map((entry, index) => {
+                    if (!entry || typeof entry !== 'object')
+                        return null;
+                    const record = entry;
+                    const result = resultFromRecord('brave', index + 1, record, {
+                        urlKeys: ['url'],
+                        titleKeys: ['title'],
+                        snippetKeys: ['description'],
+                        metadata: {
+                            age: typeof record.age === 'string' ? record.age : undefined,
+                            language: typeof record.language === 'string' ? record.language : undefined,
+                        },
+                    });
+                    if (!result)
+                        return null;
+                    const profile = record.profile;
+                    return profile && typeof profile === 'object'
+                        ? {
+                            ...result,
+                            displayUrl: typeof profile.long_name === 'string'
+                                ? String(profile.long_name)
+                                : result.displayUrl,
+                            domain: result.domain ?? resolveDomain(result.url),
+                        }
+                        : result;
+                })
+                    .filter((entry) => entry !== null)
+                : [];
+            const query = payload.query;
+            return {
+                results,
+                metadata: {
+                    moreResultsAvailable: Boolean(query && typeof query === 'object' && query.more_results_available),
+                },
+            };
+        },
+    };
+}

package/dist/_internal/platform/web-search/providers/duckduckgo.d.ts

@@ -0,0 +1,13 @@
+import { type FetchOutput } from '../../tools/fetch/index.js';
+import type { FetchInput } from '@pellux/goodvibes-sdk/platform/tools/fetch/schema';
+import type { WebSearchProvider } from '@pellux/goodvibes-sdk/platform/web-search/types';
+type FetchExecutor = (input: FetchInput) => Promise<FetchOutput>;
+export interface DuckDuckGoProviderOptions {
+    readonly fetcher?: FetchExecutor;
+    readonly liteEndpoint?: string;
+    readonly instantEndpoint?: string;
+    readonly source?: string;
+}
+export declare function createDuckDuckGoProvider(options?: DuckDuckGoProviderOptions): WebSearchProvider;
+export {};
+//# sourceMappingURL=duckduckgo.d.ts.map

package/dist/_internal/platform/web-search/providers/duckduckgo.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"duckduckgo.d.ts","sourceRoot":"","sources":["../../../../../src/_internal/platform/web-search/providers/duckduckgo.ts"],"names":[],"mappings":"AAAA,OAAO,EAAqB,KAAK,WAAW,EAAE,MAAM,4BAA4B,CAAC;AACjF,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,mDAAmD,CAAC;AACpF,OAAO,KAAK,EAEV,iBAAiB,EAOlB,MAAM,iDAAiD,CAAC;AAEzD,KAAK,aAAa,GAAG,CAAC,KAAK,EAAE,UAAU,KAAK,OAAO,CAAC,WAAW,CAAC,CAAC;AAgKjE,MAAM,WAAW,yBAAyB;IACxC,QAAQ,CAAC,OAAO,CAAC,EAAE,aAAa,CAAC;IACjC,QAAQ,CAAC,YAAY,CAAC,EAAE,MAAM,CAAC;IAC/B,QAAQ,CAAC,eAAe,CAAC,EAAE,MAAM,CAAC;IAClC,QAAQ,CAAC,MAAM,CAAC,EAAE,MAAM,CAAC;CAC1B;AAED,wBAAgB,wBAAwB,CAAC,OAAO,GAAE,yBAA8B,GAAG,iBAAiB,CAyFnG"}

package/dist/_internal/platform/web-search/providers/duckduckgo.js

@@ -0,0 +1,243 @@
+import { executeFetchInput } from '../../tools/fetch/index.js';
+const DEFAULT_LITE_ENDPOINT = 'https://lite.duckduckgo.com/lite/';
+const DEFAULT_INSTANT_ENDPOINT = 'https://api.duckduckgo.com/';
+const DEFAULT_SOURCE = 'goodvibes-sdk';
+function decodeHtmlEntities(input) {
+    return input
+        .replace(/ /g, ' ')
+        .replace(/&/g, '&')
+        .replace(/&lt;/g, '<')
+        .replace(/&gt;/g, '>')
+        .replace(/&quot;/g, '"')
+        .replace(/&#39;/g, "'")
+        .replace(/&#x27;/gi, "'")
+        .replace(/&#x2F;/gi, '/')
+        .replace(/\s+/g, ' ')
+        .trim();
+}
+function stripTags(input) {
+    return decodeHtmlEntities(input.replace(/<[^>]+>/g, ' '));
+}
+function resolveDomain(url) {
+    try {
+        return new URL(url).hostname;
+    }
+    catch {
+        return undefined;
+    }
+}
+function mapSafeSearch(value) {
+    switch (value) {
+        case 'strict':
+            return '1';
+        case 'off':
+            return '-2';
+        case 'moderate':
+            return '-1';
+        default:
+            return undefined;
+    }
+}
+function mapTimeRange(value) {
+    switch (value) {
+        case 'day':
+            return 'd';
+        case 'week':
+            return 'w';
+        case 'month':
+            return 'm';
+        case 'year':
+            return 'y';
+        default:
+            return undefined;
+    }
+}
+function unwrapDuckDuckGoRedirect(rawHref) {
+    try {
+        const base = rawHref.startsWith('//') ? `https:${rawHref}` : new URL(rawHref, 'https://duckduckgo.com').toString();
+        const url = new URL(base);
+        const wrapped = url.searchParams.get('uddg');
+        return wrapped ? decodeURIComponent(wrapped) : base;
+    }
+    catch {
+        return rawHref;
+    }
+}
+function parseOrganicResults(html) {
+    const anchorRe = /<a\b(?=[^>]*class=['"]result-link['"])[^>]*>([\s\S]*?)<\/a>/gi;
+    const matches = [];
+    let anchorMatch;
+    while ((anchorMatch = anchorRe.exec(html)) !== null) {
+        const tag = anchorMatch[0] ?? '';
+        const hrefMatch = tag.match(/\bhref=["']([^"']+)["']/i);
+        matches.push({
+            href: hrefMatch?.[1] ?? '',
+            titleHtml: anchorMatch[1] ?? '',
+            index: anchorMatch.index,
+        });
+    }
+    const results = [];
+    for (let i = 0; i < matches.length; i++) {
+        const current = matches[i];
+        const nextIndex = matches[i + 1]?.index ?? html.length;
+        const segment = html.slice(Math.max(0, current.index - 200), nextIndex);
+        const rankMatch = segment.match(/<td[^>]*valign=["']top["'][^>]*>\s*([0-9]+)\.\s*&nbsp;/i);
+        const snippetMatch = segment.match(/<td[^>]*class=['"]result-snippet['"][^>]*>([\s\S]*?)<\/td>/i);
+        const displayMatch = segment.match(/<span[^>]*class=['"]link-text['"][^>]*>([\s\S]*?)<\/span>/i);
+        const resolvedUrl = unwrapDuckDuckGoRedirect(current.href);
+        results.push({
+            rank: Number(rankMatch?.[1] ?? results.length + 1),
+            url: resolvedUrl,
+            title: stripTags(current.titleHtml),
+            snippet: snippetMatch ? stripTags(snippetMatch[1]) : undefined,
+            displayUrl: displayMatch ? stripTags(displayMatch[1]) : undefined,
+            domain: resolveDomain(resolvedUrl),
+            type: 'organic',
+            providerId: 'duckduckgo',
+            metadata: {},
+        });
+    }
+    return results;
+}
+function flattenRelatedTopics(items) {
+    if (!Array.isArray(items))
+        return [];
+    const related = [];
+    for (const entry of items) {
+        if (!entry || typeof entry !== 'object')
+            continue;
+        const record = entry;
+        if (typeof record.Text === 'string' && typeof record.FirstURL === 'string') {
+            related.push({ text: record.Text, url: record.FirstURL });
+            continue;
+        }
+        if (Array.isArray(record.Topics)) {
+            related.push(...flattenRelatedTopics(record.Topics));
+        }
+    }
+    return related;
+}
+function parseInstantAnswer(raw) {
+    if (!raw || typeof raw !== 'object')
+        return undefined;
+    const record = raw;
+    const answer = typeof record.Answer === 'string' ? record.Answer : undefined;
+    const abstract = typeof record.Abstract === 'string' ? record.Abstract : undefined;
+    const heading = typeof record.Heading === 'string' ? record.Heading : undefined;
+    const url = typeof record.AbstractURL === 'string' ? record.AbstractURL : undefined;
+    const source = typeof record.AbstractSource === 'string'
+        ? record.AbstractSource
+        : typeof record.DefinitionSource === 'string'
+            ? record.DefinitionSource
+            : undefined;
+    const image = typeof record.Image === 'string' && record.Image.length > 0
+        ? record.Image.startsWith('http') ? record.Image : `https://duckduckgo.com${record.Image}`
+        : undefined;
+    const type = typeof record.Type === 'string' ? record.Type : '';
+    const related = flattenRelatedTopics(record.RelatedTopics);
+    if (!answer && !abstract && !heading && related.length === 0) {
+        return undefined;
+    }
+    return {
+        heading,
+        answer,
+        abstract,
+        source,
+        url,
+        image,
+        type,
+        related,
+        metadata: {},
+    };
+}
+export function createDuckDuckGoProvider(options = {}) {
+    const fetcher = options.fetcher ?? executeFetchInput;
+    const liteEndpoint = options.liteEndpoint ?? DEFAULT_LITE_ENDPOINT;
+    const instantEndpoint = options.instantEndpoint ?? DEFAULT_INSTANT_ENDPOINT;
+    const source = options.source ?? DEFAULT_SOURCE;
+    return {
+        id: 'duckduckgo',
+        label: 'DuckDuckGo',
+        capabilities: ['search', 'instant_answer', 'evidence'],
+        descriptor() {
+            return {
+                id: 'duckduckgo',
+                label: 'DuckDuckGo',
+                capabilities: ['search', 'instant_answer', 'evidence'],
+                requiresAuth: false,
+                configured: true,
+                note: 'Uses lite.duckduckgo.com for organic results and api.duckduckgo.com for instant-answer enrichment.',
+            };
+        },
+        async search(request) {
+            const maxResults = Math.max(1, Math.min(25, request.maxResults ?? 10));
+            const liteBody = {
+                q: request.query,
+                t: source,
+            };
+            if (request.region)
+                liteBody.kl = request.region;
+            const safe = mapSafeSearch(request.safeSearch);
+            if (safe)
+                liteBody.kp = safe;
+            const timeRange = mapTimeRange(request.timeRange);
+            if (timeRange)
+                liteBody.df = timeRange;
+            const input = {
+                urls: [
+                    {
+                        url: liteEndpoint,
+                        method: 'POST',
+                        body_type: 'form',
+                        body_data: liteBody,
+                        extract: 'raw',
+                    },
+                    ...(request.includeInstantAnswer === false ? [] : [{
+                            url: instantEndpoint,
+                            params: {
+                                q: request.query,
+                                format: 'json',
+                                no_html: '1',
+                                no_redirect: '1',
+                                skip_disambig: '1',
+                                t: source,
+                                ...(request.region ? { kl: request.region } : {}),
+                            },
+                            extract: 'json',
+                        }]),
+                ],
+                parallel: true,
+                verbosity: 'standard',
+                sanitize_mode: 'safe-text',
+                max_content_length: 250_000,
+                ...(request.trustedHosts ? { trusted_hosts: [...request.trustedHosts] } : {}),
+                ...(request.blockedHosts ? { blocked_hosts: [...request.blockedHosts] } : {}),
+            };
+            const output = await fetcher(input);
+            const lite = output.results?.[0];
+            if (!lite || lite.error || typeof lite.content !== 'string') {
+                throw new Error(lite?.error ?? 'DuckDuckGo lite search failed');
+            }
+            const results = parseOrganicResults(lite.content).slice(0, maxResults);
+            const instantRaw = output.results?.[1]?.content;
+            let instantAnswer;
+            if (typeof instantRaw === 'string') {
+                try {
+                    instantAnswer = parseInstantAnswer(JSON.parse(instantRaw));
+                }
+                catch {
+                    instantAnswer = undefined;
+                }
+            }
+            return {
+                results,
+                ...(instantAnswer ? { instantAnswer } : {}),
+                metadata: {
+                    organicStatus: lite.status,
+                    organicResultCount: results.length,
+                    ...(output.results?.[1]?.status ? { instantStatus: output.results[1].status } : {}),
+                },
+            };
+        },
+    };
+}

package/dist/_internal/platform/web-search/providers/exa.d.ts

@@ -0,0 +1,4 @@
+import type { WebSearchProvider } from '@pellux/goodvibes-sdk/platform/web-search/types';
+import { type SearchProviderContext } from './shared.js';
+export declare function createExaSearchProvider(context: SearchProviderContext): WebSearchProvider;
+//# sourceMappingURL=exa.d.ts.map

package/dist/_internal/platform/web-search/providers/exa.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"exa.d.ts","sourceRoot":"","sources":["../../../../../src/_internal/platform/web-search/providers/exa.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,iBAAiB,EAA+C,MAAM,iDAAiD,CAAC;AACtI,OAAO,EAML,KAAK,qBAAqB,EAC3B,MAAM,aAAa,CAAC;AAMrB,wBAAgB,uBAAuB,CAAC,OAAO,EAAE,qBAAqB,GAAG,iBAAiB,CA8DzF"}

package/dist/_internal/platform/web-search/providers/exa.js

@@ -0,0 +1,68 @@
+import { buildDescriptor, executeJsonRequest, firstString, resultFromRecord, withInlineApiKey, } from './shared.js';
+const EXA_DEFAULT_BASE_URL = 'https://api.exa.ai';
+const EXA_ENV_KEYS = ['EXA_API_KEY'];
+const EXA_SERVICE_NAME = 'exa';
+export function createExaSearchProvider(context) {
+    const env = context.env;
+    const serviceRegistry = context.serviceRegistry;
+    return {
+        id: 'exa',
+        label: 'Exa',
+        capabilities: ['search', 'evidence'],
+        descriptor() {
+            return buildDescriptor({
+                id: 'exa',
+                label: 'Exa',
+                note: 'Uses Exa Search JSON results. Configure via EXA_API_KEY or an exa service entry.',
+                envKeyCandidates: EXA_ENV_KEYS,
+                serviceName: EXA_SERVICE_NAME,
+                defaultBaseUrl: EXA_DEFAULT_BASE_URL,
+            }, { env, serviceRegistry });
+        },
+        async search(request) {
+            const maxResults = Math.max(1, Math.min(25, request.maxResults ?? 10));
+            const evidenceRequested = request.includeEvidence || request.verbosity === 'evidence' || request.verbosity === 'full';
+            const baseUrl = (serviceRegistry.get(EXA_SERVICE_NAME)?.baseUrl ?? EXA_DEFAULT_BASE_URL).replace(/\/+$/, '');
+            const { payload } = await executeJsonRequest({
+                url: `${baseUrl}/search`,
+                method: 'POST',
+                headers: { Accept: 'application/json' },
+                body: {
+                    query: request.query,
+                    numResults: maxResults,
+                    ...(evidenceRequested ? { text: true } : {}),
+                },
+                service: serviceRegistry.get(EXA_SERVICE_NAME) ? EXA_SERVICE_NAME : undefined,
+                auth: serviceRegistry.get(EXA_SERVICE_NAME) ? undefined : withInlineApiKey(env, EXA_ENV_KEYS, 'x-api-key'),
+                fetcher: context.fetcher,
+            });
+            const results = Array.isArray(payload.results)
+                ? payload.results
+                    .map((entry, index) => {
+                    if (!entry || typeof entry !== 'object')
+                        return null;
+                    const record = entry;
+                    const result = resultFromRecord('exa', index + 1, record, {
+                        urlKeys: ['url', 'id'],
+                        titleKeys: ['title'],
+                        snippetKeys: ['text', 'snippet'],
+                        evidenceKeys: ['text'],
+                        metadata: {
+                            publishedDate: firstString(record, ['publishedDate', 'published_date']),
+                            author: firstString(record, ['author']),
+                        },
+                    });
+                    return result;
+                })
+                    .filter((entry) => entry !== null)
+                : [];
+            return {
+                results,
+                metadata: {
+                    autopromptString: firstString(payload, ['autopromptString']),
+                    requestId: firstString(payload, ['requestId']),
+                },
+            };
+        },
+    };
+}

package/dist/_internal/platform/web-search/providers/firecrawl.d.ts

@@ -0,0 +1,4 @@
+import type { WebSearchProvider } from '@pellux/goodvibes-sdk/platform/web-search/types';
+import { type SearchProviderContext } from './shared.js';
+export declare function createFirecrawlSearchProvider(context: SearchProviderContext): WebSearchProvider;
+//# sourceMappingURL=firecrawl.d.ts.map

package/dist/_internal/platform/web-search/providers/firecrawl.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"firecrawl.d.ts","sourceRoot":"","sources":["../../../../../src/_internal/platform/web-search/providers/firecrawl.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,iBAAiB,EAA+C,MAAM,iDAAiD,CAAC;AACtI,OAAO,EAML,KAAK,qBAAqB,EAC3B,MAAM,aAAa,CAAC;AAqBrB,wBAAgB,6BAA6B,CAAC,OAAO,EAAE,qBAAqB,GAAG,iBAAiB,CA4D/F"}

package/dist/_internal/platform/web-search/providers/firecrawl.js

@@ -0,0 +1,80 @@
+import { buildDescriptor, executeJsonRequest, firstString, resultFromRecord, withInlineBearer, } from './shared.js';
+const FIRECRAWL_DEFAULT_BASE_URL = 'https://api.firecrawl.dev';
+const FIRECRAWL_ENV_KEYS = ['FIRECRAWL_API_KEY'];
+const FIRECRAWL_SERVICE_NAME = 'firecrawl';
+function mapTimeRange(value) {
+    switch (value) {
+        case 'day':
+            return 'qdr:d';
+        case 'week':
+            return 'qdr:w';
+        case 'month':
+            return 'qdr:m';
+        case 'year':
+            return 'qdr:y';
+        default:
+            return undefined;
+    }
+}
+export function createFirecrawlSearchProvider(context) {
+    const env = context.env;
+    const serviceRegistry = context.serviceRegistry;
+    return {
+        id: 'firecrawl',
+        label: 'Firecrawl',
+        capabilities: ['search', 'evidence'],
+        descriptor() {
+            return buildDescriptor({
+                id: 'firecrawl',
+                label: 'Firecrawl',
+                note: 'Uses Firecrawl search JSON results. Configure via FIRECRAWL_API_KEY or a firecrawl service entry.',
+                envKeyCandidates: FIRECRAWL_ENV_KEYS,
+                serviceName: FIRECRAWL_SERVICE_NAME,
+                defaultBaseUrl: FIRECRAWL_DEFAULT_BASE_URL,
+            }, { env, serviceRegistry });
+        },
+        async search(request) {
+            const maxResults = Math.max(1, Math.min(20, request.maxResults ?? 10));
+            const evidenceRequested = request.includeEvidence || request.verbosity === 'evidence' || request.verbosity === 'full';
+            const baseUrl = (serviceRegistry.get(FIRECRAWL_SERVICE_NAME)?.baseUrl ?? FIRECRAWL_DEFAULT_BASE_URL).replace(/\/+$/, '');
+            const { payload } = await executeJsonRequest({
+                url: `${baseUrl}/v1/search`,
+                method: 'POST',
+                headers: { Accept: 'application/json' },
+                body: {
+                    query: request.query,
+                    limit: maxResults,
+                    ...(mapTimeRange(request.timeRange) ? { tbs: mapTimeRange(request.timeRange) } : {}),
+                    ...(evidenceRequested ? { scrapeOptions: { formats: ['markdown'] } } : {}),
+                },
+                service: serviceRegistry.get(FIRECRAWL_SERVICE_NAME) ? FIRECRAWL_SERVICE_NAME : undefined,
+                auth: serviceRegistry.get(FIRECRAWL_SERVICE_NAME) ? undefined : withInlineBearer(env, FIRECRAWL_ENV_KEYS),
+                fetcher: context.fetcher,
+            });
+            const data = Array.isArray(payload.data)
+                ? payload.data
+                : Array.isArray(payload.results)
+                    ? payload.results
+                    : [];
+            const results = data
+                .map((entry, index) => {
+                if (!entry || typeof entry !== 'object')
+                    return null;
+                const record = entry;
+                return resultFromRecord('firecrawl', index + 1, record, {
+                    urlKeys: ['url'],
+                    titleKeys: ['title'],
+                    snippetKeys: ['description', 'snippet', 'markdown'],
+                    evidenceKeys: ['markdown'],
+                });
+            })
+                .filter((entry) => entry !== null);
+            return {
+                results,
+                metadata: {
+                    requestId: firstString(payload, ['id', 'requestId']),
+                },
+            };
+        },
+    };
+}

package/dist/_internal/platform/web-search/providers/perplexity.d.ts

@@ -0,0 +1,4 @@
+import type { WebSearchProvider } from '@pellux/goodvibes-sdk/platform/web-search/types';
+import { type SearchProviderContext } from './shared.js';
+export declare function createPerplexitySearchProvider(context: SearchProviderContext): WebSearchProvider;
+//# sourceMappingURL=perplexity.d.ts.map

package/dist/_internal/platform/web-search/providers/perplexity.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"perplexity.d.ts","sourceRoot":"","sources":["../../../../../src/_internal/platform/web-search/providers/perplexity.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,iBAAiB,EAA+C,MAAM,iDAAiD,CAAC;AACtI,OAAO,EAKL,KAAK,qBAAqB,EAC3B,MAAM,aAAa,CAAC;AAqBrB,wBAAgB,8BAA8B,CAAC,OAAO,EAAE,qBAAqB,GAAG,iBAAiB,CAyDhG"}

package/dist/_internal/platform/web-search/providers/perplexity.js

@@ -0,0 +1,77 @@
+import { buildDescriptor, executeJsonRequest, resultFromRecord, withInlineBearer, } from './shared.js';
+const PERPLEXITY_BASE_URL = 'https://api.perplexity.ai';
+const PERPLEXITY_ENV_KEYS = ['PERPLEXITY_API_KEY'];
+const PERPLEXITY_SERVICE_NAME = 'perplexity';
+function mapTimeRange(value) {
+    switch (value) {
+        case 'day':
+            return 'day';
+        case 'week':
+            return 'week';
+        case 'month':
+            return 'month';
+        case 'year':
+            return 'year';
+        default:
+            return undefined;
+    }
+}
+export function createPerplexitySearchProvider(context) {
+    const env = context.env;
+    const serviceRegistry = context.serviceRegistry;
+    return {
+        id: 'perplexity',
+        label: 'Perplexity',
+        capabilities: ['search', 'evidence'],
+        descriptor() {
+            return buildDescriptor({
+                id: 'perplexity',
+                label: 'Perplexity',
+                note: 'Uses Perplexity search API results when PERPLEXITY_API_KEY or a perplexity service entry is configured.',
+                envKeyCandidates: PERPLEXITY_ENV_KEYS,
+                serviceName: PERPLEXITY_SERVICE_NAME,
+                defaultBaseUrl: PERPLEXITY_BASE_URL,
+            }, { env, serviceRegistry });
+        },
+        async search(request) {
+            const maxResults = Math.max(1, Math.min(10, request.maxResults ?? 10));
+            const baseUrl = (serviceRegistry.get(PERPLEXITY_SERVICE_NAME)?.baseUrl ?? PERPLEXITY_BASE_URL).replace(/\/+$/, '');
+            const { payload } = await executeJsonRequest({
+                url: `${baseUrl}/search`,
+                method: 'POST',
+                headers: { Accept: 'application/json' },
+                service: serviceRegistry.get(PERPLEXITY_SERVICE_NAME) ? PERPLEXITY_SERVICE_NAME : undefined,
+                auth: serviceRegistry.get(PERPLEXITY_SERVICE_NAME) ? undefined : withInlineBearer(env, PERPLEXITY_ENV_KEYS),
+                body: {
+                    query: request.query,
+                    max_results: maxResults,
+                    ...(request.region?.trim() ? { country: request.region.trim() } : {}),
+                    ...(mapTimeRange(request.timeRange) ? { search_recency_filter: mapTimeRange(request.timeRange) } : {}),
+                },
+                fetcher: context.fetcher,
+            });
+            const rawResults = Array.isArray(payload['results']) ? payload['results'] : [];
+            const results = rawResults
+                .map((entry, index) => {
+                if (!entry || typeof entry !== 'object')
+                    return null;
+                const record = entry;
+                return resultFromRecord('perplexity', index + 1, record, {
+                    urlKeys: ['url'],
+                    titleKeys: ['title'],
+                    snippetKeys: ['snippet', 'description'],
+                    metadata: {
+                        published: typeof record['date'] === 'string' ? record['date'] : undefined,
+                    },
+                });
+            })
+                .filter((entry) => entry !== null);
+            return {
+                results,
+                metadata: {
+                    provider: 'perplexity',
+                },
+            };
+        },
+    };
+}

package/dist/_internal/platform/web-search/providers/searxng.d.ts

@@ -0,0 +1,4 @@
+import type { WebSearchProvider } from '@pellux/goodvibes-sdk/platform/web-search/types';
+import { type SearchProviderContext } from './shared.js';
+export declare function createSearxngSearchProvider(context: SearchProviderContext): WebSearchProvider;
+//# sourceMappingURL=searxng.d.ts.map

package/dist/_internal/platform/web-search/providers/searxng.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"searxng.d.ts","sourceRoot":"","sources":["../../../../../src/_internal/platform/web-search/providers/searxng.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,iBAAiB,EAA+C,MAAM,iDAAiD,CAAC;AACtI,OAAO,EAKL,KAAK,qBAAqB,EAC3B,MAAM,aAAa,CAAC;AAkBrB,wBAAgB,2BAA2B,CAAC,OAAO,EAAE,qBAAqB,GAAG,iBAAiB,CA8D7F"}