@mjasnikovs/pi-task 0.18.5 → 0.18.7

package/dist/config/config.d.ts

@@ -1,3 +1,4 @@
+import { type SearchProvider } from '../workers/search-types.js';
 export interface PiTaskConfig {
     remote: boolean;
     compressReasoning: boolean;
@@ -23,6 +24,12 @@ export interface PiTaskConfig {
      * collide).
      */
     researchCache: boolean;
+    /**
+     * Which engine backs web search (pi-worker-search + freshness/enrichment).
+     * `exa` and `ddg` need no API key; `brave` needs BRAVE_SEARCH_API_KEY.
+     * DEFAULT `exa` so search works out of the box with zero configuration.
+     */
+    searchProvider: SearchProvider;
 }
 export declare function getConfig(): PiTaskConfig;
 export declare function saveConfig(config: PiTaskConfig): Promise<void>;

package/dist/config/config.js

@@ -2,6 +2,7 @@ import * as fs from 'node:fs';
 import * as fsp from 'node:fs/promises';
 import * as path from 'node:path';
 import * as os from 'node:os';
+import { isSearchProvider } from '../workers/search-types.js';
 const DEFAULTS = {
     remote: true,
     compressReasoning: true,
@@ -12,7 +13,8 @@ const DEFAULTS = {
     parallelResearchWorkers: false,
     // ON: the F10 live A/B showed no answer-quality regression (fidelity 3/3, quality
     // 3/3, 0 collisions; ~14.5s of repeated docs lookups collapse to 0ms on a hit).
-    researchCache: true
+    researchCache: true,
+    searchProvider: 'exa'
 };
 const CONFIG_PATH = path.join(os.homedir(), '.config', 'pi-task', 'config.json');
 const _g = globalThis;
@@ -26,6 +28,10 @@ if (!G.loaded) {
     try {
         const raw = fs.readFileSync(CONFIG_PATH, 'utf8');
         const parsed = JSON.parse(raw);
+        // A hand-edited or stale enum value must not leak an unknown provider
+        // into the dispatch switch — fall back to the default.
+        if (!isSearchProvider(parsed.searchProvider))
+            delete parsed.searchProvider;
         G.config = { ...DEFAULTS, ...parsed };
     }
     catch {

package/dist/config/register.js

@@ -1,5 +1,6 @@
 import { SettingsList, visibleWidth } from '@earendil-works/pi-tui';
 import { registerBridgeCommand } from '../remote/bridge.js';
+import { SEARCH_PROVIDERS, SEARCH_PROVIDER_LABELS, providerForLabel } from '../workers/search-types.js';
 import { getConfig, saveConfig } from './config.js';
 const CONFIG_TITLE = 'pi-task settings';
 /**
@@ -46,6 +47,10 @@ class BorderedBox {
         this.child.handleInput(data);
     }
 }
+/**
+ * Every setting rendered by /task-config. Boolean settings omit `values` and
+ * toggle on/off; enum settings list their values and cycle through them.
+ */
 const ITEMS = [
     { id: 'remote', label: 'remote', description: 'Remote UI server (QR code, phone access)' },
     {
@@ -82,8 +87,23 @@ const ITEMS = [
         id: 'researchCache',
         label: 'research cache',
         description: 'Cache docs/search/fetch results within one /task-auto run so sibling tasks reuse the first pipeline’s digest instead of re-fetching the same external docs. Per-run isolated, external-only, success-only'
+    },
+    {
+        id: 'searchProvider',
+        label: 'search provider',
+        description: 'Engine behind web search (pi-worker-search + freshness checks). Exa and DuckDuckGo need no API key; Brave needs BRAVE_SEARCH_API_KEY',
+        // Display full engine names; the stored config value stays the short id.
+        values: SEARCH_PROVIDERS.map(p => SEARCH_PROVIDER_LABELS[p])
     }
 ];
+/** What /task-config shows for a setting's current value. */
+function displayValue(cfg, id, isEnum) {
+    if (id === 'searchProvider')
+        return SEARCH_PROVIDER_LABELS[cfg.searchProvider];
+    if (isEnum)
+        return String(cfg[id]);
+    return cfg[id] ? 'on' : 'off';
+}
 function makeTheme(theme) {
     return {
         label: (text, selected) => (selected ? theme.fg('accent', text) : text),
@@ -96,21 +116,29 @@ function makeTheme(theme) {
 async function handleTaskConfig(_args, ctx) {
     const cfg = { ...getConfig() };
     if (ctx.mode !== 'tui') {
-        const lines = ITEMS.map(({ id, label }) => `${label.padEnd(22)} ${cfg[id] ? 'on' : 'off'}`);
+        const lines = ITEMS.map(({ id, label, values }) => `${label.padEnd(22)} ${displayValue(cfg, id, Boolean(values))}`);
         ctx.ui.notify(lines.join('  |  '), 'info');
         return;
     }
     await ctx.ui.custom((_tui, theme, _kb, done) => {
         const listTheme = makeTheme(theme);
-        const items = ITEMS.map(({ id, label, description }) => ({
+        const items = ITEMS.map(({ id, label, description, values }) => ({
             id,
             label,
             description,
-            currentValue: cfg[id] ? 'on' : 'off',
-            values: ['on', 'off']
+            currentValue: displayValue(cfg, id, Boolean(values)),
+            values: values ?? ['on', 'off']
         }));
         const list = new SettingsList(items, 10, listTheme, (id, newValue) => {
-            cfg[id] = newValue === 'on';
+            if (id === 'searchProvider') {
+                const provider = providerForLabel(newValue);
+                if (provider)
+                    cfg.searchProvider = provider;
+            }
+            else {
+                ;
+                cfg[id] = newValue === 'on';
+            }
             saveConfig(cfg).catch(() => { });
         }, () => done(undefined));
         return new BorderedBox(list, CONFIG_TITLE, s => theme.fg('borderMuted', s), s => theme.fg('accent', theme.bold(s)));

package/dist/task/phases.d.ts

@@ -6,6 +6,7 @@ import type { ExtensionCommandContext } from '@earendil-works/pi-coding-agent';
 import { docsFocused } from '../workers/docs-core.js';
 import { fetchFocused } from '../workers/fetch-core.js';
 import type { SearchCoreInput, SearchCoreResult } from '../workers/search-core.js';
+import type { SearchProvider } from '../workers/search-types.js';
 import { type ExternalContextDeps } from './external-context.js';
 import { MAX_GRILL_QUESTIONS } from './prompts.js';
 import { type PhaseName } from './task-types.js';
@@ -63,8 +64,11 @@ export declare function phaseVerifyTooling(deps: PhaseDeps, research: string): P
 export interface PhaseResearchDeps extends ExternalContextDeps {
     getFileInventory?: (cwd: string, signal?: AbortSignal) => Promise<string>;
 }
-/** Is live web search configured for this process? Mirrors search-core's env lookup. */
-export declare function searchConfigured(getEnv?: (k: string) => string | undefined): boolean;
+/**
+ * Is live web search configured for this process? The keyless providers (exa,
+ * ddg) always are; only brave needs its API key — mirrors search-core's lookup.
+ */
+export declare function searchConfigured(getEnv?: (k: string) => string | undefined, provider?: SearchProvider): boolean;
 /** Extra prompt block for the APIS worker when search is available — trigger-framed
  *  (the validated shape for getting a local model to actually reach for search). */
 export declare const RESEARCH_SEARCH_HINT: string;

package/dist/task/phases.js

@@ -166,8 +166,13 @@ const DOCS_EXTENSION_PATH = new URL('../workers/docs-extension.js', import.meta.
  *  STRUCTURAL: three consecutive audited runs made 0 search calls because the
  *  child literally did not have the tool. */
 const SEARCH_EXTENSION_PATH = new URL('../workers/search-extension.js', import.meta.url).pathname;
-/** Is live web search configured for this process? Mirrors search-core's env lookup. */
-export function searchConfigured(getEnv = k => process.env[k]) {
+/**
+ * Is live web search configured for this process? The keyless providers (exa,
+ * ddg) always are; only brave needs its API key — mirrors search-core's lookup.
+ */
+export function searchConfigured(getEnv = k => process.env[k], provider = getConfig().searchProvider) {
+    if (provider !== 'brave')
+        return true;
     return Boolean(getEnv('BRAVE_SEARCH_API_KEY') ?? getEnv('BRAVE_API_KEY'));
 }
 /** Extra prompt block for the APIS worker when search is available — trigger-framed

package/dist/task/service-blocks.d.ts

@@ -1,3 +1,3 @@
-import type { BraveResult } from '../workers/brave-search.js';
-export declare function formatServiceBlock(name: string, fullQuery: string, results: BraveResult[]): string;
+import type { SearchResult } from '../workers/search-types.js';
+export declare function formatServiceBlock(name: string, fullQuery: string, results: SearchResult[]): string;
 export declare function formatFreshnessSkippedBlock(names: string[]): string;

package/dist/task/service-blocks.js

@@ -5,6 +5,8 @@ export function formatServiceBlock(name, fullQuery, results) {
     const bullets = results.map(r => `- **${r.title}** — ${r.url}\n  ${r.description}`).join('\n');
     return `${header}\n${bullets}`;
 }
+// Only the brave provider can be unconfigured (exa/ddg are keyless), so the
+// skip reason names its missing key directly.
 export function formatFreshnessSkippedBlock(names) {
-    return `### freshness-check skipped\nCould not verify external services (BRAVE_SEARCH_API_KEY not set):\n${names.map(n => `- ${n}`).join('\n')}`;
+    return `### freshness-check skipped\nCould not verify external services (search provider is brave but BRAVE_SEARCH_API_KEY is not set):\n${names.map(n => `- ${n}`).join('\n')}`;
 }

package/dist/workers/brave-search.d.ts

@@ -1,8 +1,5 @@
-export interface BraveResult {
-    title: string;
-    url: string;
-    description: string;
-}
+import type { SearchResult } from './search-types.js';
+export type BraveResult = SearchResult;
 export interface BraveSearchOpts {
     apiKey: string;
     count?: number;

package/dist/workers/brave-warning.d.ts

@@ -1,10 +1,8 @@
 /**
- * One-line startup hint shown when no Brave Search key is configured.
- *
- * pi-task's web-search worker needs BRAVE_SEARCH_API_KEY (or BRAVE_API_KEY).
- * When neither is set we surface a single, unobtrusive widget line on session
- * start so the user knows search is disabled — it never blocks work and clears
- * itself on the first interaction (any keystroke).
+ * One-line startup hint shown when Brave is the selected search provider but
+ * no key is configured (Brave is the only provider that needs one — exa and
+ * ddg are keyless, so no hint renders for them). It never blocks work and
+ * clears itself on the first interaction (any keystroke).
  */
 import type { ExtensionAPI } from '@earendil-works/pi-coding-agent';
 export declare function registerBraveKeyWarning(pi: ExtensionAPI): void;

package/dist/workers/brave-warning.js

@@ -1,14 +1,14 @@
 /**
- * One-line startup hint shown when no Brave Search key is configured.
- *
- * pi-task's web-search worker needs BRAVE_SEARCH_API_KEY (or BRAVE_API_KEY).
- * When neither is set we surface a single, unobtrusive widget line on session
- * start so the user knows search is disabled — it never blocks work and clears
- * itself on the first interaction (any keystroke).
+ * One-line startup hint shown when Brave is the selected search provider but
+ * no key is configured (Brave is the only provider that needs one — exa and
+ * ddg are keyless, so no hint renders for them). It never blocks work and
+ * clears itself on the first interaction (any keystroke).
  */
+import { getConfig } from '../config/config.js';
 const WIDGET_KEY = 'pi-task-brave-warning';
-const WARNING = '⚠ pi-task: BRAVE_SEARCH_API_KEY not set — web search is disabled. '
-    + 'Get a free key at https://api.search.brave.com/app/keys';
+const WARNING = '⚠ pi-task: search provider is Brave but BRAVE_SEARCH_API_KEY is not set — web search '
+    + 'is disabled. Get a free key at https://api.search.brave.com/app/keys or switch '
+    + 'provider in /task-config';
 /** Mirrors the lookup in search-core so the hint matches what the worker reads. */
 function hasBraveKey() {
     return Boolean(process.env.BRAVE_SEARCH_API_KEY ?? process.env.BRAVE_API_KEY);
@@ -16,8 +16,9 @@ function hasBraveKey() {
 export function registerBraveKeyWarning(pi) {
     pi.on('session_start', (_event, ctx) => {
         // Terminal-only hint: needs an interactive TUI to render and to catch the
-        // keystroke that dismisses it. Skip when a key is already present.
-        if (ctx.mode !== 'tui' || hasBraveKey())
+        // keystroke that dismisses it. Only the brave provider can be misconfigured;
+        // skip whenever another provider is selected or a key is already present.
+        if (ctx.mode !== 'tui' || getConfig().searchProvider !== 'brave' || hasBraveKey())
             return;
         let unsubscribe = null;
         const clear = () => {

package/dist/workers/ddg-search.d.ts

@@ -0,0 +1,24 @@
+/**
+ * Web search via DuckDuckGo's HTML endpoint — no API key required.
+ *
+ * DDG has no official web-results API; html.duckduckgo.com/html serves plain
+ * HTML result pages that parse cleanly with linkedom. Result links are wrapped
+ * in a `duckduckgo.com/l/?uddg=<encoded>` redirect that we unwrap so callers
+ * get the destination URL. Ad rows redirect through duckduckgo.com itself and
+ * are dropped.
+ */
+import type { FetchLike } from './exa-search.js';
+import type { SearchResult } from './search-types.js';
+export interface DdgSearchOpts {
+    count?: number;
+    timeoutMs?: number;
+    signal?: AbortSignal;
+    fetchImpl?: FetchLike;
+}
+export declare class DdgSearchError extends Error {
+    readonly kind: 'http' | 'network' | 'aborted' | 'rate-limit';
+    readonly status?: number | undefined;
+    constructor(message: string, kind: 'http' | 'network' | 'aborted' | 'rate-limit', status?: number | undefined);
+}
+export declare function ddgSearch(query: string, opts?: DdgSearchOpts): Promise<SearchResult[]>;
+export declare function parseDdgHtml(html: string): SearchResult[];

package/dist/workers/ddg-search.js

@@ -0,0 +1,130 @@
+/**
+ * Web search via DuckDuckGo's HTML endpoint — no API key required.
+ *
+ * DDG has no official web-results API; html.duckduckgo.com/html serves plain
+ * HTML result pages that parse cleanly with linkedom. Result links are wrapped
+ * in a `duckduckgo.com/l/?uddg=<encoded>` redirect that we unwrap so callers
+ * get the destination URL. Ad rows redirect through duckduckgo.com itself and
+ * are dropped.
+ */
+import { parseHTML } from 'linkedom';
+const DDG_ENDPOINT = 'https://html.duckduckgo.com/html/';
+const DEFAULT_COUNT = 10;
+const MAX_COUNT = 20;
+const DEFAULT_TIMEOUT_MS = 15_000;
+// DDG serves a bot-challenge page to clients without a browser-ish UA.
+const USER_AGENT = 'Mozilla/5.0 (X11; Linux x86_64; rv:127.0) Gecko/20100101 Firefox/127.0';
+export class DdgSearchError extends Error {
+    kind;
+    status;
+    constructor(message, kind, status) {
+        super(message);
+        this.kind = kind;
+        this.status = status;
+        this.name = 'DdgSearchError';
+    }
+}
+export async function ddgSearch(query, opts = {}) {
+    const count = Math.max(1, Math.min(MAX_COUNT, opts.count ?? DEFAULT_COUNT));
+    const timeoutMs = opts.timeoutMs ?? DEFAULT_TIMEOUT_MS;
+    const fetchImpl = opts.fetchImpl ?? fetch;
+    const url = `${DDG_ENDPOINT}?q=${encodeURIComponent(query)}`;
+    const internalController = new AbortController();
+    let userAborted = false;
+    const timeoutHandle = setTimeout(() => internalController.abort(), timeoutMs);
+    const onUserAbort = () => {
+        userAborted = true;
+        internalController.abort();
+    };
+    if (opts.signal) {
+        if (opts.signal.aborted)
+            onUserAbort();
+        else
+            opts.signal.addEventListener('abort', onUserAbort, { once: true });
+    }
+    try {
+        let response;
+        try {
+            response = await fetchImpl(url, {
+                method: 'GET',
+                headers: {
+                    'user-agent': USER_AGENT,
+                    accept: 'text/html'
+                },
+                signal: internalController.signal
+            });
+        }
+        catch (err) {
+            if (userAborted)
+                throw new DdgSearchError('Search aborted.', 'aborted');
+            throw new DdgSearchError(`DuckDuckGo request failed: ${describeError(err)}`, 'network');
+        }
+        if (response.status === 429 || response.status === 403) {
+            throw new DdgSearchError(`DuckDuckGo is rate-limiting this client (HTTP ${response.status}). Try again in a moment.`, 'rate-limit', response.status);
+        }
+        if (!response.ok) {
+            throw new DdgSearchError(`DuckDuckGo HTTP ${response.status} ${response.statusText}`, 'http', response.status);
+        }
+        return parseDdgHtml(await response.text()).slice(0, count);
+    }
+    finally {
+        clearTimeout(timeoutHandle);
+        if (opts.signal)
+            opts.signal.removeEventListener('abort', onUserAbort);
+    }
+}
+export function parseDdgHtml(html) {
+    const { document } = parseHTML(html);
+    const doc = document;
+    const results = [];
+    for (const anchor of doc.querySelectorAll('a.result__a')) {
+        if (anchor.closest('.result--ad'))
+            continue;
+        const href = anchor.getAttribute('href');
+        const targetUrl = href === null ? null : unwrapDdgRedirect(href);
+        // A row whose link never leaves duckduckgo.com is an ad/module, not a hit.
+        if (targetUrl === null)
+            continue;
+        const title = collapse(anchor.textContent ?? '');
+        if (!title)
+            continue;
+        const row = anchor.closest('.result');
+        const snippet = row?.querySelector('.result__snippet')?.textContent ?? '';
+        results.push({ title, url: targetUrl, description: collapse(snippet) });
+    }
+    return results;
+}
+/**
+ * Result hrefs look like `//duckduckgo.com/l/?uddg=<encoded-destination>&rut=…`;
+ * return the decoded destination, a non-DDG href unchanged, or null for links
+ * that stay on duckduckgo.com (ad click-trackers).
+ */
+function unwrapDdgRedirect(href) {
+    let parsed;
+    try {
+        parsed = new URL(href, 'https://duckduckgo.com');
+    }
+    catch {
+        return null;
+    }
+    if (parsed.hostname.endsWith('duckduckgo.com')) {
+        const uddg = parsed.searchParams.get('uddg');
+        if (!uddg)
+            return null;
+        try {
+            return new URL(uddg).toString();
+        }
+        catch {
+            return null;
+        }
+    }
+    return parsed.toString();
+}
+function collapse(text) {
+    return text.replace(/\s+/g, ' ').trim();
+}
+function describeError(err) {
+    if (err instanceof Error)
+        return err.message;
+    return String(err);
+}

package/dist/workers/exa-search.d.ts

@@ -0,0 +1,24 @@
+/**
+ * Web search via Exa's public MCP endpoint — no API key required.
+ *
+ * Exa hosts https://mcp.exa.ai/mcp as an intentionally keyless entry point: a
+ * single JSON-RPC `tools/call` of `web_search_exa` returns search results with
+ * content snippets. The response is SSE-framed (`data:` lines) or plain JSON,
+ * and the result payload is one text blob of `Title:`/`URL:`/`Text:` blocks
+ * separated by `---`, which we parse back into structured results.
+ */
+import type { SearchResult } from './search-types.js';
+/** Injectable fetch — the narrow signature keeps test fakes free of Bun's extras. */
+export type FetchLike = (url: string, init?: RequestInit) => Promise<Response>;
+export interface ExaSearchOpts {
+    count?: number;
+    timeoutMs?: number;
+    signal?: AbortSignal;
+    fetchImpl?: FetchLike;
+}
+export declare class ExaSearchError extends Error {
+    readonly kind: 'http' | 'network' | 'aborted' | 'protocol';
+    readonly status?: number | undefined;
+    constructor(message: string, kind: 'http' | 'network' | 'aborted' | 'protocol', status?: number | undefined);
+}
+export declare function exaSearch(query: string, opts?: ExaSearchOpts): Promise<SearchResult[]>;

package/dist/workers/exa-search.js

@@ -0,0 +1,164 @@
+/**
+ * Web search via Exa's public MCP endpoint — no API key required.
+ *
+ * Exa hosts https://mcp.exa.ai/mcp as an intentionally keyless entry point: a
+ * single JSON-RPC `tools/call` of `web_search_exa` returns search results with
+ * content snippets. The response is SSE-framed (`data:` lines) or plain JSON,
+ * and the result payload is one text blob of `Title:`/`URL:`/`Text:` blocks
+ * separated by `---`, which we parse back into structured results.
+ */
+const EXA_MCP_ENDPOINT = 'https://mcp.exa.ai/mcp';
+const DEFAULT_COUNT = 10;
+const MAX_COUNT = 20;
+const DEFAULT_TIMEOUT_MS = 30_000;
+const MAX_DESCRIPTION_CHARS = 400;
+export class ExaSearchError extends Error {
+    kind;
+    status;
+    constructor(message, kind, status) {
+        super(message);
+        this.kind = kind;
+        this.status = status;
+        this.name = 'ExaSearchError';
+    }
+}
+export async function exaSearch(query, opts = {}) {
+    const count = Math.max(1, Math.min(MAX_COUNT, opts.count ?? DEFAULT_COUNT));
+    const timeoutMs = opts.timeoutMs ?? DEFAULT_TIMEOUT_MS;
+    const fetchImpl = opts.fetchImpl ?? fetch;
+    const internalController = new AbortController();
+    let userAborted = false;
+    const timeoutHandle = setTimeout(() => internalController.abort(), timeoutMs);
+    const onUserAbort = () => {
+        userAborted = true;
+        internalController.abort();
+    };
+    if (opts.signal) {
+        if (opts.signal.aborted)
+            onUserAbort();
+        else
+            opts.signal.addEventListener('abort', onUserAbort, { once: true });
+    }
+    try {
+        let response;
+        try {
+            response = await fetchImpl(EXA_MCP_ENDPOINT, {
+                method: 'POST',
+                headers: {
+                    'content-type': 'application/json',
+                    accept: 'application/json, text/event-stream'
+                },
+                body: JSON.stringify({
+                    jsonrpc: '2.0',
+                    id: 1,
+                    method: 'tools/call',
+                    params: {
+                        name: 'web_search_exa',
+                        arguments: {
+                            query,
+                            numResults: count,
+                            type: 'auto',
+                            livecrawl: 'fallback',
+                            contextMaxCharacters: 3000
+                        }
+                    }
+                }),
+                signal: internalController.signal
+            });
+        }
+        catch (err) {
+            if (userAborted)
+                throw new ExaSearchError('Search aborted.', 'aborted');
+            throw new ExaSearchError(`Exa search request failed: ${describeError(err)}`, 'network');
+        }
+        if (!response.ok) {
+            throw new ExaSearchError(`Exa search HTTP ${response.status} ${response.statusText}`, 'http', response.status);
+        }
+        const rpc = parseRpcBody(await response.text());
+        if (rpc.error) {
+            throw new ExaSearchError(`Exa MCP error${rpc.error.code !== undefined ? ` ${rpc.error.code}` : ''}: ${rpc.error.message ?? 'unknown error'}`, 'protocol');
+        }
+        const text = rpc.result?.content?.find(c => c.type === 'text' && typeof c.text === 'string' && c.text.trim().length > 0)?.text;
+        if (rpc.result?.isError) {
+            throw new ExaSearchError(text?.trim() || 'Exa MCP returned an error result.', 'protocol');
+        }
+        if (!text)
+            throw new ExaSearchError('Exa MCP returned no text content.', 'protocol');
+        return parseResultBlocks(text).slice(0, count);
+    }
+    finally {
+        clearTimeout(timeoutHandle);
+        if (opts.signal)
+            opts.signal.removeEventListener('abort', onUserAbort);
+    }
+}
+/**
+ * The endpoint answers either as a text/event-stream (`data: {json}` lines) or
+ * as a plain JSON body; accept both and take the first frame carrying a
+ * JSON-RPC result or error.
+ */
+function parseRpcBody(body) {
+    for (const line of body.split('\n')) {
+        if (!line.startsWith('data:'))
+            continue;
+        const payload = line.slice(5).trim();
+        if (!payload)
+            continue;
+        try {
+            const candidate = JSON.parse(payload);
+            if (candidate.result || candidate.error)
+                return candidate;
+        }
+        catch {
+            /* not this frame */
+        }
+    }
+    try {
+        const candidate = JSON.parse(body);
+        if (candidate.result || candidate.error)
+            return candidate;
+    }
+    catch {
+        /* fall through */
+    }
+    throw new ExaSearchError('Exa MCP returned an unparseable response.', 'protocol');
+}
+/**
+ * Split the tool's text payload into `Title:`/`URL:` blocks. The per-result
+ * content lives after a `Text:` label (full text) or a `Highlights:` line
+ * (snippet mode); either becomes the description, whitespace-collapsed and
+ * capped so a result line stays a snippet, not a page dump.
+ */
+function parseResultBlocks(text) {
+    const blocks = text.split(/(?=^Title: )/m).filter(b => b.trim().length > 0);
+    const results = [];
+    for (const block of blocks) {
+        const title = block.match(/^Title: (.+)/m)?.[1]?.trim() ?? '';
+        const url = block.match(/^URL: (.+)/m)?.[1]?.trim() ?? '';
+        if (!url)
+            continue;
+        let content = '';
+        const textStart = block.indexOf('\nText: ');
+        if (textStart >= 0) {
+            content = block.slice(textStart + '\nText: '.length);
+        }
+        else {
+            const highlights = block.match(/\nHighlights:[ \t]*\n/);
+            if (highlights?.index !== undefined) {
+                content = block.slice(highlights.index + highlights[0].length);
+            }
+        }
+        const description = content
+            .replace(/\n---\s*$/, '')
+            .replace(/\s+/g, ' ')
+            .trim()
+            .slice(0, MAX_DESCRIPTION_CHARS);
+        results.push({ title: title || url, url, description });
+    }
+    return results;
+}
+function describeError(err) {
+    if (err instanceof Error)
+        return err.message;
+    return String(err);
+}

package/dist/workers/pi-worker-search.d.ts

@@ -1,7 +1,13 @@
 import type { ExtensionAPI } from '@earendil-works/pi-coding-agent';
-import { braveSearch as defaultBraveSearch } from './brave-search.js';
+import type { braveSearch as defaultBraveSearch } from './brave-search.js';
+import type { ddgSearch as defaultDdgSearch } from './ddg-search.js';
+import type { exaSearch as defaultExaSearch } from './exa-search.js';
+import type { SearchProvider } from './search-types.js';
 export interface PiWorkerSearchInternals {
     braveSearch?: typeof defaultBraveSearch;
+    exaSearch?: typeof defaultExaSearch;
+    ddgSearch?: typeof defaultDdgSearch;
+    provider?: SearchProvider;
     getEnv?: (key: string) => string | undefined;
 }
 export declare function registerPiWorkerSearch(pi: ExtensionAPI, internals?: PiWorkerSearchInternals): void;

package/dist/workers/pi-worker-search.js

@@ -1,5 +1,6 @@
 import { Type } from '@sinclair/typebox';
 import { Text } from '@earendil-works/pi-tui';
+import { getConfig } from '../config/config.js';
 import { search } from './search-core.js';
 import { makeWorkerTool } from './shared.js';
 import { normalizeQuery } from './research-cache.js';
@@ -12,26 +13,29 @@ const Params = Type.Object({
     }))
 });
 export function registerPiWorkerSearch(pi, internals = {}) {
+    const provider = () => internals.provider ?? getConfig().searchProvider;
     makeWorkerTool(pi, {
         name: 'pi-worker-search',
         label: 'Pi Worker Search',
-        description: 'Search the live web via Brave Search. CALL THIS BEFORE ANSWERING any '
+        description: 'Search the live web. CALL THIS BEFORE ANSWERING any '
             + 'question about current or version-specific external facts: '
             + 'library/framework versions and their APIs, latest releases, recently '
             + 'shipped features, current events, prices, or who currently holds a '
             + 'role. Your built-in knowledge is out of date — do NOT answer such '
             + 'questions from memory and do NOT shell out with bash to guess. Returns '
             + 'a compact markdown list of up to 10 results (title, URL, snippet); then '
-            + 'call `pi-worker-fetch` on the URL you want to read. '
-            + 'Requires BRAVE_SEARCH_API_KEY env var.',
+            + 'call `pi-worker-fetch` on the URL you want to read.',
         parameters: Params,
         async run(params, signal) {
             const result = await search({
                 query: params.query,
                 count: params.count,
                 signal,
+                provider: internals.provider,
                 getEnv: internals.getEnv,
-                braveSearch: internals.braveSearch
+                braveSearch: internals.braveSearch,
+                exaSearch: internals.exaSearch,
+                ddgSearch: internals.ddgSearch
             });
             if (result.kind === 'no_key' || result.kind === 'error') {
                 return { text: result.message, details: { resultCount: 0 } };
@@ -53,8 +57,9 @@ export function registerPiWorkerSearch(pi, internals = {}) {
         },
         // Cache search results per run (the same query re-run across sibling tasks hits
         // the live web anew otherwise). Count is part of the key — a larger request is a
-        // different result set.
-        cacheKey: params => `${normalizeQuery(params.query)}::${params.count ?? ''}`,
+        // different result set — and so is the provider: two engines' result sets for
+        // one query are different answers and must not serve for each other.
+        cacheKey: params => `${provider()}::${normalizeQuery(params.query)}::${params.count ?? ''}`,
         // Only a non-empty result set is worth caching; no-key, error, and empty results
         // (resultCount 0) fall through so a later attempt can succeed.
         cacheable: d => d.resultCount > 0

package/dist/workers/search-core.d.ts

@@ -1,14 +1,21 @@
-import { braveSearch as defaultBraveSearch, type BraveResult } from './brave-search.js';
+import { braveSearch as defaultBraveSearch } from './brave-search.js';
+import { ddgSearch as defaultDdgSearch } from './ddg-search.js';
+import { exaSearch as defaultExaSearch } from './exa-search.js';
+import type { SearchProvider, SearchResult } from './search-types.js';
 export interface SearchCoreInput {
     query: string;
     count?: number;
     signal?: AbortSignal;
     getEnv?: (key: string) => string | undefined;
+    /** Engine override; defaults to the configured `searchProvider` (exa). */
+    provider?: SearchProvider;
     braveSearch?: typeof defaultBraveSearch;
+    exaSearch?: typeof defaultExaSearch;
+    ddgSearch?: typeof defaultDdgSearch;
 }
 export type SearchCoreResult = {
     kind: 'ok';
-    results: BraveResult[];
+    results: SearchResult[];
 } | {
     kind: 'no_key';
     message: string;
@@ -16,4 +23,9 @@ export type SearchCoreResult = {
     kind: 'error';
     message: string;
 };
+/**
+ * Provider selection is STRICT: the configured (or overridden) engine is the
+ * only one tried — a failure reports as an error rather than silently switching
+ * engines, so results always come from where the user thinks they do.
+ */
 export declare function search(input: SearchCoreInput): Promise<SearchCoreResult>;

package/dist/workers/search-core.js

@@ -1,18 +1,50 @@
+import { getConfig } from '../config/config.js';
 import { braveSearch as defaultBraveSearch, BraveSearchError } from './brave-search.js';
+import { ddgSearch as defaultDdgSearch } from './ddg-search.js';
+import { exaSearch as defaultExaSearch } from './exa-search.js';
 function isLikeBraveSearchError(err) {
     return (typeof err === 'object'
         && err !== null
         && err.name === 'BraveSearchError');
 }
+/**
+ * Provider selection is STRICT: the configured (or overridden) engine is the
+ * only one tried — a failure reports as an error rather than silently switching
+ * engines, so results always come from where the user thinks they do.
+ */
 export async function search(input) {
+    const provider = input.provider ?? getConfig().searchProvider;
+    if (provider === 'brave')
+        return braveSearchCore(input);
+    const run = provider === 'exa' ?
+        () => (input.exaSearch ?? defaultExaSearch)(input.query, {
+            count: input.count,
+            signal: input.signal
+        })
+        : () => (input.ddgSearch ?? defaultDdgSearch)(input.query, {
+            count: input.count,
+            signal: input.signal
+        });
+    try {
+        return { kind: 'ok', results: await run() };
+    }
+    catch (err) {
+        return {
+            kind: 'error',
+            message: err instanceof Error ? err.message : String(err)
+        };
+    }
+}
+async function braveSearchCore(input) {
     const getEnv = input.getEnv ?? ((k) => process.env[k]);
     const braveSearch = input.braveSearch ?? defaultBraveSearch;
     const apiKey = getEnv('BRAVE_SEARCH_API_KEY') ?? getEnv('BRAVE_API_KEY');
     if (!apiKey) {
         return {
             kind: 'no_key',
-            message: 'Brave Search not configured. Set BRAVE_SEARCH_API_KEY env var. '
-                + 'Get a key at https://api.search.brave.com/app/keys'
+            message: 'Brave Search not configured. Set BRAVE_SEARCH_API_KEY env var '
+                + '(get a key at https://api.search.brave.com/app/keys) or switch '
+                + 'the search provider in /task-config.'
         };
     }
     try {

package/dist/workers/search-types.d.ts

@@ -0,0 +1,21 @@
+/** One web-search hit, in the shape every provider normalises to. */
+export interface SearchResult {
+    title: string;
+    url: string;
+    description: string;
+}
+/**
+ * Which engine backs pi-worker-search and the freshness/enrichment lookups.
+ * - `exa`   — Exa's public MCP endpoint; no key needed (default).
+ * - `ddg`   — DuckDuckGo's HTML endpoint; no key needed.
+ * - `brave` — Brave Search API; needs BRAVE_SEARCH_API_KEY.
+ */
+export type SearchProvider = 'exa' | 'ddg' | 'brave';
+export declare const SEARCH_PROVIDERS: readonly SearchProvider[];
+/**
+ * Human-readable engine names for the config UI. The short ids stay the stored
+ * value (config-file compat); only the display layer uses these.
+ */
+export declare const SEARCH_PROVIDER_LABELS: Record<SearchProvider, string>;
+export declare function providerForLabel(label: string): SearchProvider | undefined;
+export declare function isSearchProvider(value: unknown): value is SearchProvider;

package/dist/workers/search-types.js

@@ -0,0 +1,16 @@
+export const SEARCH_PROVIDERS = ['exa', 'ddg', 'brave'];
+/**
+ * Human-readable engine names for the config UI. The short ids stay the stored
+ * value (config-file compat); only the display layer uses these.
+ */
+export const SEARCH_PROVIDER_LABELS = {
+    exa: 'Exa',
+    ddg: 'DuckDuckGo',
+    brave: 'Brave'
+};
+export function providerForLabel(label) {
+    return SEARCH_PROVIDERS.find(p => SEARCH_PROVIDER_LABELS[p] === label);
+}
+export function isSearchProvider(value) {
+    return typeof value === 'string' && SEARCH_PROVIDERS.includes(value);
+}

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@mjasnikovs/pi-task",
-    "version": "0.18.5",
+    "version": "0.18.7",
     "description": "Deterministic task planning and spec-orchestration for local models — crash-safe /task pipelines with verify/enforce gates, a real-time remote web view, and web/docs/fetch/worker subagent tools.",
     "type": "module",
     "main": "./dist/index.js",