@demigodmode/pi-web-agent 1.0.0 → 1.2.0

package/CHANGELOG.md

@@ -18,6 +18,35 @@ The format is intentionally simple and release-oriented.
 ### Breaking
 - None.
 
+## [1.2.0] - 2026-06-01
+### Added
+- Added backend provider and fallback editing to `/web-agent settings`.
+- Added interactive URL prompts for SearXNG and Firecrawl backend setup.
+
+### Changed
+- Nothing yet.
+
+### Fixed
+- Nothing yet.
+
+### Breaking
+- None.
+
+## [1.1.0] - 2026-05-25
+### Added
+- Added explicit opt-in fallback from SearXNG to DuckDuckGo and Firecrawl to HTTP.
+- Added supported SearXNG and Firecrawl backend options in config.
+- Added env-gated live tests for local SearXNG and Firecrawl instances.
+
+### Changed
+- `/web-agent show` and `/web-agent doctor` now report configured backend fallback/options.
+
+### Fixed
+- Nothing yet.
+
+### Breaking
+- None.
+
 ## [1.0.0] - 2026-05-08
 ### Added
 - Added one-time `pi-web-agent` changelog notices after package updates and `/web-agent changelog` for manual viewing.

package/README.md

@@ -109,7 +109,17 @@ Example:
 }
 ```
 
-Backend config is also supported. Defaults remain DuckDuckGo search, plain HTTP fetch, and local browser headless fallback. If you already run SearXNG or Firecrawl, see the self-hosted backend guide:
+Backend config is also supported. Defaults remain DuckDuckGo search, plain HTTP fetch, and local browser headless fallback.
+
+Backend settings can be changed from:
+
+```text
+/web-agent settings
+```
+
+Choose **Backends** to edit search/fetch providers, fallback behavior, and SearXNG or Firecrawl base URLs interactively. Firecrawl API keys should stay in environment variables rather than being written into config files.
+
+If you already run SearXNG or Firecrawl, see the self-hosted backend guide:
 
 - https://demigodmode.github.io/pi-web-agent/self-hosted-backends
 

package/dist/backends/config.d.ts

@@ -1,11 +1,24 @@
+export type SearxngOptions = {
+    categories?: string[];
+    language?: string;
+    safesearch?: 0 | 1 | 2;
+};
+export type FirecrawlOptions = {
+    formats?: string[];
+    onlyMainContent?: boolean;
+};
 export type SearchBackendConfig = {
     provider: 'duckduckgo' | 'searxng';
     baseUrl?: string;
+    fallback?: 'duckduckgo';
+    options?: SearxngOptions;
 };
 export type FetchBackendConfig = {
     provider: 'http' | 'firecrawl';
     baseUrl?: string;
     apiKey?: string;
+    fallback?: 'http';
+    options?: FirecrawlOptions;
 };
 export type HeadlessBackendConfig = {
     provider: 'local-browser';
@@ -25,11 +38,15 @@ export type BackendConfigFile = {
         search?: {
             provider?: unknown;
             baseUrl?: unknown;
+            fallback?: unknown;
+            options?: unknown;
         };
         fetch?: {
             provider?: unknown;
             baseUrl?: unknown;
             apiKey?: unknown;
+            fallback?: unknown;
+            options?: unknown;
         };
         headless?: {
             provider?: unknown;

package/dist/backends/config.js

@@ -3,6 +3,38 @@ export const DEFAULT_BACKEND_CONFIG = {
     fetch: { provider: 'http' },
     headless: { provider: 'local-browser' }
 };
+function extractStringArray(value) {
+    if (!Array.isArray(value))
+        return undefined;
+    const strings = value.filter((item) => typeof item === 'string');
+    return strings.length === value.length ? strings : undefined;
+}
+function extractSearxngOptions(value) {
+    if (!value || typeof value !== 'object')
+        return undefined;
+    const raw = value;
+    const options = {};
+    const categories = extractStringArray(raw.categories);
+    if (categories)
+        options.categories = categories;
+    if (typeof raw.language === 'string')
+        options.language = raw.language;
+    if (raw.safesearch === 0 || raw.safesearch === 1 || raw.safesearch === 2)
+        options.safesearch = raw.safesearch;
+    return Object.keys(options).length > 0 ? options : undefined;
+}
+function extractFirecrawlOptions(value) {
+    if (!value || typeof value !== 'object')
+        return undefined;
+    const raw = value;
+    const options = {};
+    const formats = extractStringArray(raw.formats);
+    if (formats)
+        options.formats = formats;
+    if (typeof raw.onlyMainContent === 'boolean')
+        options.onlyMainContent = raw.onlyMainContent;
+    return Object.keys(options).length > 0 ? options : undefined;
+}
 export function extractBackendConfigOverride(file) {
     const backends = file?.backends;
     const override = {};
@@ -11,6 +43,13 @@ export function extractBackendConfigOverride(file) {
         if (typeof backends.search.baseUrl === 'string') {
             override.search.baseUrl = backends.search.baseUrl;
         }
+        if (backends.search.fallback === 'duckduckgo') {
+            override.search.fallback = 'duckduckgo';
+        }
+        const options = extractSearxngOptions(backends.search.options);
+        if (options) {
+            override.search.options = options;
+        }
     }
     if (backends?.fetch?.provider === 'http' || backends?.fetch?.provider === 'firecrawl') {
         override.fetch = { provider: backends.fetch.provider };
@@ -20,6 +59,13 @@ export function extractBackendConfigOverride(file) {
         if (typeof backends.fetch.apiKey === 'string') {
             override.fetch.apiKey = backends.fetch.apiKey;
         }
+        if (backends.fetch.fallback === 'http') {
+            override.fetch.fallback = 'http';
+        }
+        const options = extractFirecrawlOptions(backends.fetch.options);
+        if (options) {
+            override.fetch.options = options;
+        }
     }
     if (backends?.headless?.provider === 'local-browser') {
         override.headless = { provider: 'local-browser' };
@@ -34,6 +80,25 @@ export function validateBackendConfig(config) {
     if (config.fetch.provider === 'firecrawl' && !config.fetch.baseUrl) {
         issues.push('fetch provider firecrawl requires backends.fetch.baseUrl');
     }
+    if (config.search.fallback === 'duckduckgo' && config.search.provider !== 'searxng') {
+        issues.push('search fallback duckduckgo is only supported when search provider is searxng');
+    }
+    if (config.fetch.fallback === 'http' && config.fetch.provider !== 'firecrawl') {
+        issues.push('fetch fallback http is only supported when fetch provider is firecrawl');
+    }
+    if (config.search.options?.categories && config.search.options.categories.length === 0) {
+        issues.push('search options.categories must contain at least one category when provided');
+    }
+    if (config.search.options?.language !== undefined && !config.search.options.language.trim()) {
+        issues.push('search options.language must not be empty when provided');
+    }
+    if (config.search.options?.safesearch !== undefined &&
+        ![0, 1, 2].includes(config.search.options.safesearch)) {
+        issues.push('search options.safesearch must be 0, 1, or 2 when provided');
+    }
+    if (config.fetch.options?.formats && config.fetch.options.formats.length === 0) {
+        issues.push('fetch options.formats must contain at least one format when provided');
+    }
     return issues;
 }
 function mergeSearchConfig(current, override) {

package/dist/backends/doctor.js

@@ -6,12 +6,25 @@ function withTimeout(timeoutMs) {
 function message(error) {
     return error instanceof Error ? error.message : String(error);
 }
-function searxngDoctorUrl(baseUrl) {
+function searxngDoctorUrl(baseUrl, options = {}) {
     const url = new URL('/search', baseUrl.endsWith('/') ? baseUrl : `${baseUrl}/`);
     url.searchParams.set('q', 'pi-web-agent-doctor');
     url.searchParams.set('format', 'json');
+    if (options.categories?.length)
+        url.searchParams.set('categories', options.categories.join(','));
+    if (options.language)
+        url.searchParams.set('language', options.language);
+    if (options.safesearch !== undefined)
+        url.searchParams.set('safesearch', String(options.safesearch));
     return url.toString();
 }
+function firecrawlDoctorBody(options = {}) {
+    return {
+        url: 'https://example.com',
+        formats: options.formats ?? ['markdown'],
+        ...(options.onlyMainContent !== undefined ? { onlyMainContent: options.onlyMainContent } : {})
+    };
+}
 export async function checkBackendHealth(config, { fetchImpl = fetch, timeoutMs = 3_000 } = {}) {
     const lines = [];
     if (config.search.provider === 'duckduckgo') {
@@ -23,7 +36,7 @@ export async function checkBackendHealth(config, { fetchImpl = fetch, timeoutMs
     else {
         const timeout = withTimeout(timeoutMs);
         try {
-            const response = await fetchImpl(searxngDoctorUrl(config.search.baseUrl), { signal: timeout.signal });
+            const response = await fetchImpl(searxngDoctorUrl(config.search.baseUrl, config.search.options), { signal: timeout.signal });
             const json = (await response.json());
             lines.push(response.ok && Array.isArray(json.results)
                 ? 'search backend: searxng ok'
@@ -36,6 +49,9 @@ export async function checkBackendHealth(config, { fetchImpl = fetch, timeoutMs
             timeout.done();
         }
     }
+    if (config.search.fallback) {
+        lines.push(`search fallback: ${config.search.fallback}`);
+    }
     if (config.fetch.provider === 'http') {
         lines.push('fetch backend: http');
     }
@@ -52,7 +68,7 @@ export async function checkBackendHealth(config, { fetchImpl = fetch, timeoutMs
             const response = await fetchImpl(new URL('/v1/scrape', config.fetch.baseUrl).toString(), {
                 method: 'POST',
                 headers,
-                body: JSON.stringify({ url: 'https://example.com', formats: ['markdown'] }),
+                body: JSON.stringify(firecrawlDoctorBody(config.fetch.options)),
                 signal: timeout.signal
             });
             lines.push(response.ok ? 'fetch backend: firecrawl ok' : `fetch backend: firecrawl warning (HTTP ${response.status})`);
@@ -64,5 +80,8 @@ export async function checkBackendHealth(config, { fetchImpl = fetch, timeoutMs
             timeout.done();
         }
     }
+    if (config.fetch.fallback) {
+        lines.push(`fetch fallback: ${config.fetch.fallback}`);
+    }
     return lines;
 }

package/dist/backends/factory.d.ts

@@ -1,3 +1,8 @@
+import { createFirecrawlFetcher } from '../fetch/firecrawl-fetch.js';
+import { createSearxngSearchTool } from '../search/searxng.js';
+import { createWebFetchHeadlessTool } from '../tools/web-fetch-headless.js';
+import { createWebFetchTool } from '../tools/web-fetch.js';
+import { createWebSearchTool } from '../tools/web-search.js';
 import type { WebFetchHeadlessResponse, WebFetchResponse, WebSearchResponse } from '../types.js';
 import { type BackendConfig } from './config.js';
 export type BackendSet = {
@@ -11,4 +16,11 @@ export type BackendSet = {
         url: string;
     }) => Promise<WebFetchHeadlessResponse>;
 };
-export declare function createBackendSet(config?: BackendConfig): BackendSet;
+export type BackendFactoryDeps = {
+    createDuckDuckGoSearch?: typeof createWebSearchTool;
+    createSearxngSearch?: typeof createSearxngSearchTool;
+    createHttpFetch?: typeof createWebFetchTool;
+    createFirecrawlFetch?: typeof createFirecrawlFetcher;
+    createHeadlessFetch?: typeof createWebFetchHeadlessTool;
+};
+export declare function createBackendSet(config?: BackendConfig, deps?: BackendFactoryDeps): BackendSet;

package/dist/backends/factory.js

@@ -34,25 +34,72 @@ function invalidFirecrawlFetch() {
         return { ...result, presentation: buildFetchPresentation(result) };
     };
 }
-export function createBackendSet(config = DEFAULT_BACKEND_CONFIG) {
-    const search = config.search.provider === 'searxng'
+function withSearchFallback(primary, fallback) {
+    return async (input) => {
+        const first = await primary(input);
+        if (first.status !== 'error')
+            return first;
+        const second = await fallback(input);
+        const result = {
+            ...second,
+            metadata: {
+                ...second.metadata,
+                fallbackFrom: 'searxng',
+                fallbackReason: first.error?.message ?? 'SearXNG search failed.'
+            }
+        };
+        return { ...result, presentation: buildSearchPresentation(result) };
+    };
+}
+function withFetchFallback(primary, fallback) {
+    return async (input) => {
+        const first = await primary(input);
+        if (first.status !== 'error' && first.status !== 'needs_headless')
+            return first;
+        const second = await fallback(input);
+        const result = {
+            ...second,
+            metadata: {
+                ...second.metadata,
+                fallbackFrom: 'firecrawl',
+                fallbackReason: first.error?.message ?? 'Firecrawl fetch failed.'
+            }
+        };
+        return { ...result, presentation: buildFetchPresentation(result) };
+    };
+}
+export function createBackendSet(config = DEFAULT_BACKEND_CONFIG, deps = {}) {
+    const createDuckDuckGoSearch = deps.createDuckDuckGoSearch ?? createWebSearchTool;
+    const createSearxngSearch = deps.createSearxngSearch ?? createSearxngSearchTool;
+    const createHttpFetch = deps.createHttpFetch ?? createWebFetchTool;
+    const createFirecrawlFetch = deps.createFirecrawlFetch ?? createFirecrawlFetcher;
+    const createHeadlessFetch = deps.createHeadlessFetch ?? createWebFetchHeadlessTool;
+    let search = config.search.provider === 'searxng'
         ? config.search.baseUrl
-            ? createSearxngSearchTool({ baseUrl: config.search.baseUrl })
+            ? createSearxngSearch({ baseUrl: config.search.baseUrl, options: config.search.options })
             : invalidSearxngSearch()
-        : createWebSearchTool();
-    const fetchPage = config.fetch.provider === 'firecrawl'
+        : createDuckDuckGoSearch();
+    if (config.search.provider === 'searxng' && config.search.fallback === 'duckduckgo') {
+        search = withSearchFallback(search, createDuckDuckGoSearch());
+    }
+    const httpFetch = createHttpFetch();
+    let fetchPage = config.fetch.provider === 'firecrawl'
         ? config.fetch.baseUrl
-            ? createWebFetchTool({
-                fetchPage: createFirecrawlFetcher({
+            ? createHttpFetch({
+                fetchPage: createFirecrawlFetch({
                     baseUrl: config.fetch.baseUrl,
-                    apiKey: config.fetch.apiKey ?? process.env.PI_WEB_AGENT_FIRECRAWL_API_KEY
+                    apiKey: config.fetch.apiKey ?? process.env.PI_WEB_AGENT_FIRECRAWL_API_KEY,
+                    options: config.fetch.options
                 })
             })
-            : createWebFetchTool({ fetchPage: invalidFirecrawlFetch() })
-        : createWebFetchTool();
+            : createHttpFetch({ fetchPage: invalidFirecrawlFetch() })
+        : httpFetch;
+    if (config.fetch.provider === 'firecrawl' && config.fetch.fallback === 'http') {
+        fetchPage = withFetchFallback(fetchPage, httpFetch);
+    }
     return {
         search,
         fetchPage,
-        headlessFetch: createWebFetchHeadlessTool()
+        headlessFetch: createHeadlessFetch()
     };
 }

package/dist/commands/web-agent-config.d.ts

@@ -1,4 +1,4 @@
-import { type BackendConfig } from '../backends/config.js';
+import { type BackendConfig, type BackendConfigOverride } from '../backends/config.js';
 import { type ExtensionAPI } from '@earendil-works/pi-coding-agent';
 import { loadPresentationConfigLayers, type LoadedPresentationConfig } from '../presentation/config-store.js';
 import { type BrowserResolutionResult } from '../fetch/browser-resolution.js';
@@ -6,6 +6,7 @@ import type { PresentationConfig, PresentationConfigOverride, PresentationScope
 type CommandDeps = {
     load?: () => ReturnType<typeof loadPresentationConfigLayers>;
     save?: (scope: PresentationScope, config: PresentationConfigOverride) => Promise<void>;
+    saveBackends?: (scope: PresentationScope, config: BackendConfigOverride) => Promise<void>;
     reset?: (scope: PresentationScope) => Promise<void>;
     resolveBrowser?: () => Promise<BrowserResolutionResult>;
     runtime?: {
@@ -20,13 +21,25 @@ type CommandDeps = {
 export type SettingsDraftState = {
     scope: PresentationScope;
     drafts: Record<PresentationScope, PresentationConfig>;
+    backendDrafts: Record<PresentationScope, BackendConfig>;
     config: PresentationConfig;
+    backends: BackendConfig;
+};
+export declare function validateBackendUrl(value: string): {
+    ok: true;
+    value: string;
+} | {
+    ok: false;
+    message: string;
 };
 export declare function getInheritedConfigForScope(loaded: Awaited<LoadedPresentationConfig>, scope: PresentationScope): PresentationConfig;
 export declare function getScopeDisplayConfig(loaded: Awaited<LoadedPresentationConfig>, scope: PresentationScope): PresentationConfig;
+export declare function getInheritedBackendsForScope(loaded: Awaited<LoadedPresentationConfig>, scope: PresentationScope): BackendConfig;
+export declare function getScopeDisplayBackends(loaded: Awaited<LoadedPresentationConfig>, scope: PresentationScope): BackendConfig;
 export declare function createSettingsDraftState(loaded: Awaited<LoadedPresentationConfig>, initialScope: PresentationScope): SettingsDraftState;
 export declare function applySettingsValue(state: SettingsDraftState, id: string, newValue: string): SettingsDraftState;
 export declare function collapsePresentationConfigToOverride(config: PresentationConfig, inheritedConfig: PresentationConfig): PresentationConfigOverride;
+export declare function collapseBackendConfigToOverride(config: BackendConfig, inheritedConfig: BackendConfig): BackendConfigOverride;
 export declare function handleSettingsShortcut(data: string): {
     action: 'cancel' | 'reset' | 'save';
 } | undefined;

package/dist/commands/web-agent-config.js

@@ -1,9 +1,9 @@
-import { DEFAULT_BACKEND_CONFIG, validateBackendConfig } from '../backends/config.js';
+import { DEFAULT_BACKEND_CONFIG, mergeBackendConfigLayers, validateBackendConfig } from '../backends/config.js';
 import { checkBackendHealth } from '../backends/doctor.js';
 import { DynamicBorder, getSettingsListTheme } from '@earendil-works/pi-coding-agent';
 import { Container, SelectList, SettingsList, Text } from '@earendil-works/pi-tui';
 import { DEFAULT_PRESENTATION_CONFIG, mergePresentationConfigLayers, resolvePresentationMode } from '../presentation/config.js';
-import { loadPresentationConfigLayers, resetPresentationConfigScope, savePresentationConfigScope } from '../presentation/config-store.js';
+import { loadPresentationConfigLayers, resetPresentationConfigScope, saveBackendConfigScope, savePresentationConfigScope } from '../presentation/config-store.js';
 import { resolveBrowserExecutable } from '../fetch/browser-resolution.js';
 import { getLatestChangelogEntry } from '../changelog-notice.js';
 const PRESENTATION_TOOL_NAMES = ['web_explore'];
@@ -16,6 +16,34 @@ function clonePresentationConfig(config) {
         tools: { ...config.tools }
     };
 }
+function cloneBackendConfig(config) {
+    return {
+        search: {
+            ...config.search,
+            options: config.search.options ? { ...config.search.options } : undefined
+        },
+        fetch: {
+            ...config.fetch,
+            options: config.fetch.options ? { ...config.fetch.options } : undefined
+        },
+        headless: { ...config.headless }
+    };
+}
+function sameJson(left, right) {
+    return JSON.stringify(left) === JSON.stringify(right);
+}
+export function validateBackendUrl(value) {
+    try {
+        const url = new URL(value.trim());
+        if (url.protocol !== 'http:' && url.protocol !== 'https:') {
+            return { ok: false, message: 'Invalid URL. Include http:// or https://.' };
+        }
+        return { ok: true, value: url.toString().replace(/\/$/, '') };
+    }
+    catch {
+        return { ok: false, message: 'Invalid URL. Include http:// or https://.' };
+    }
+}
 async function defaultCheckTypebox() {
     try {
         await import('typebox');
@@ -25,16 +53,33 @@ async function defaultCheckTypebox() {
         return false;
     }
 }
+function formatSearchOptions(config) {
+    return [
+        config.fallback ? `fallback ${config.fallback}` : undefined,
+        config.options?.categories?.length ? `categories ${config.options.categories.join(',')}` : undefined,
+        config.options?.language ? `language ${config.options.language}` : undefined,
+        config.options?.safesearch !== undefined ? `safesearch ${config.options.safesearch}` : undefined
+    ].filter(Boolean).join(' ');
+}
+function formatFetchOptions(config) {
+    return [
+        config.fallback ? `fallback ${config.fallback}` : undefined,
+        config.options?.formats?.length ? `formats ${config.options.formats.join(',')}` : undefined,
+        config.options?.onlyMainContent !== undefined ? `onlyMainContent ${config.options.onlyMainContent}` : undefined
+    ].filter(Boolean).join(' ');
+}
 function formatBackendSummary(config = DEFAULT_BACKEND_CONFIG) {
-    const search = config.search.baseUrl
+    const searchSuffix = formatSearchOptions(config.search);
+    const fetchSuffix = formatFetchOptions(config.fetch);
+    const searchBase = config.search.baseUrl
         ? `search: ${config.search.provider} (${config.search.baseUrl})`
         : `search: ${config.search.provider}`;
-    const fetch = config.fetch.baseUrl
+    const fetchBase = config.fetch.baseUrl
         ? `fetch: ${config.fetch.provider} (${config.fetch.baseUrl})`
         : `fetch: ${config.fetch.provider}`;
     return [
-        search,
-        fetch,
+        searchSuffix ? `${searchBase} ${searchSuffix}` : searchBase,
+        fetchSuffix ? `${fetchBase} ${fetchSuffix}` : fetchBase,
         `headless: ${config.headless.provider}`
     ].join('\n');
 }
@@ -45,7 +90,7 @@ function formatConfigSummary(config) {
     }
     return lines.join('\n');
 }
-function buildSettingsItems(scope, config) {
+function buildPresentationSettingsItems(scope, config) {
     return [
         {
             id: 'scope',
@@ -67,6 +112,58 @@ function buildSettingsItems(scope, config) {
         }))
     ];
 }
+function buildBackendSettingsItems(scope, backends) {
+    return [
+        {
+            id: 'scope',
+            label: 'Write scope',
+            currentValue: scope,
+            values: ['project', 'global']
+        },
+        {
+            id: 'backend:search:provider',
+            label: 'Search backend',
+            currentValue: backends.search.provider,
+            values: ['duckduckgo', 'searxng']
+        },
+        {
+            id: 'backend:search:baseUrl',
+            label: 'SearXNG URL',
+            currentValue: backends.search.baseUrl ?? 'not set',
+            values: ['edit']
+        },
+        {
+            id: 'backend:search:fallback',
+            label: 'SearXNG fallback',
+            currentValue: backends.search.provider === 'searxng' ? backends.search.fallback ?? 'off' : 'off',
+            values: backends.search.provider === 'searxng' ? ['off', 'duckduckgo'] : ['off']
+        },
+        {
+            id: 'backend:fetch:provider',
+            label: 'Fetch backend',
+            currentValue: backends.fetch.provider,
+            values: ['http', 'firecrawl']
+        },
+        {
+            id: 'backend:fetch:baseUrl',
+            label: 'Firecrawl URL',
+            currentValue: backends.fetch.baseUrl ?? 'not set',
+            values: ['edit']
+        },
+        {
+            id: 'backend:fetch:fallback',
+            label: 'Firecrawl fallback',
+            currentValue: backends.fetch.provider === 'firecrawl' ? backends.fetch.fallback ?? 'off' : 'off',
+            values: backends.fetch.provider === 'firecrawl' ? ['off', 'http'] : ['off']
+        },
+        {
+            id: 'backend:secret:firecrawl',
+            label: 'Firecrawl API key',
+            currentValue: 'env var',
+            values: ['env var']
+        }
+    ];
+}
 function isToolName(value) {
     return PRESENTATION_TOOL_NAMES.includes(value);
 }
@@ -85,15 +182,33 @@ export function getScopeDisplayConfig(loaded, scope) {
     }
     return mergePresentationConfigLayers(DEFAULT_PRESENTATION_CONFIG, loaded.global.rawConfig, loaded.project.rawConfig);
 }
+export function getInheritedBackendsForScope(loaded, scope) {
+    if (scope === 'global') {
+        return DEFAULT_BACKEND_CONFIG;
+    }
+    return mergeBackendConfigLayers(DEFAULT_BACKEND_CONFIG, loaded.global.rawBackends);
+}
+export function getScopeDisplayBackends(loaded, scope) {
+    if (scope === 'global') {
+        return mergeBackendConfigLayers(DEFAULT_BACKEND_CONFIG, loaded.global.rawBackends);
+    }
+    return mergeBackendConfigLayers(DEFAULT_BACKEND_CONFIG, loaded.global.rawBackends, loaded.project.rawBackends);
+}
 export function createSettingsDraftState(loaded, initialScope) {
     const drafts = {
         global: getScopeDisplayConfig(loaded, 'global'),
         project: getScopeDisplayConfig(loaded, 'project')
     };
+    const backendDrafts = {
+        global: getScopeDisplayBackends(loaded, 'global'),
+        project: getScopeDisplayBackends(loaded, 'project')
+    };
     return {
         scope: initialScope,
         drafts,
-        config: clonePresentationConfig(drafts[initialScope])
+        backendDrafts,
+        config: clonePresentationConfig(drafts[initialScope]),
+        backends: cloneBackendConfig(backendDrafts[initialScope])
     };
 }
 export function applySettingsValue(state, id, newValue) {
@@ -101,16 +216,23 @@ export function applySettingsValue(state, id, newValue) {
         global: clonePresentationConfig(state.drafts.global),
         project: clonePresentationConfig(state.drafts.project)
     };
+    const nextBackendDrafts = {
+        global: cloneBackendConfig(state.backendDrafts.global),
+        project: cloneBackendConfig(state.backendDrafts.project)
+    };
     let nextScope = state.scope;
     if (id === 'scope' && (newValue === 'project' || newValue === 'global')) {
         nextScope = newValue;
         return {
             scope: nextScope,
             drafts: nextDrafts,
-            config: clonePresentationConfig(nextDrafts[nextScope])
+            backendDrafts: nextBackendDrafts,
+            config: clonePresentationConfig(nextDrafts[nextScope]),
+            backends: cloneBackendConfig(nextBackendDrafts[nextScope])
         };
     }
     const currentDraft = clonePresentationConfig(nextDrafts[nextScope]);
+    const currentBackends = cloneBackendConfig(nextBackendDrafts[nextScope]);
     if (id === 'defaultMode' && (newValue === 'compact' || newValue === 'preview' || newValue === 'verbose')) {
         currentDraft.defaultMode = newValue;
     }
@@ -127,11 +249,58 @@ export function applySettingsValue(state, id, newValue) {
         }
         currentDraft.tools = nextTools;
     }
+    if (id === 'backend:search:provider' && (newValue === 'duckduckgo' || newValue === 'searxng')) {
+        currentBackends.search.provider = newValue;
+        if (newValue === 'duckduckgo') {
+            delete currentBackends.search.fallback;
+        }
+    }
+    if (id === 'backend:search:fallback') {
+        if (newValue === 'duckduckgo' && currentBackends.search.provider === 'searxng') {
+            currentBackends.search.fallback = 'duckduckgo';
+        }
+        else if (newValue === 'off' || currentBackends.search.provider !== 'searxng') {
+            delete currentBackends.search.fallback;
+        }
+    }
+    if (id === 'backend:search:baseUrl') {
+        if (newValue.trim()) {
+            currentBackends.search.baseUrl = newValue.trim();
+        }
+        else {
+            delete currentBackends.search.baseUrl;
+        }
+    }
+    if (id === 'backend:fetch:provider' && (newValue === 'http' || newValue === 'firecrawl')) {
+        currentBackends.fetch.provider = newValue;
+        if (newValue === 'http') {
+            delete currentBackends.fetch.fallback;
+        }
+    }
+    if (id === 'backend:fetch:fallback') {
+        if (newValue === 'http' && currentBackends.fetch.provider === 'firecrawl') {
+            currentBackends.fetch.fallback = 'http';
+        }
+        else if (newValue === 'off' || currentBackends.fetch.provider !== 'firecrawl') {
+            delete currentBackends.fetch.fallback;
+        }
+    }
+    if (id === 'backend:fetch:baseUrl') {
+        if (newValue.trim()) {
+            currentBackends.fetch.baseUrl = newValue.trim();
+        }
+        else {
+            delete currentBackends.fetch.baseUrl;
+        }
+    }
     nextDrafts[nextScope] = currentDraft;
+    nextBackendDrafts[nextScope] = currentBackends;
     return {
         scope: nextScope,
         drafts: nextDrafts,
-        config: clonePresentationConfig(nextDrafts[nextScope])
+        backendDrafts: nextBackendDrafts,
+        config: clonePresentationConfig(nextDrafts[nextScope]),
+        backends: cloneBackendConfig(nextBackendDrafts[nextScope])
     };
 }
 export function collapsePresentationConfigToOverride(config, inheritedConfig) {
@@ -151,6 +320,44 @@ export function collapsePresentationConfigToOverride(config, inheritedConfig) {
         tools
     };
 }
+export function collapseBackendConfigToOverride(config, inheritedConfig) {
+    const override = {};
+    if (!sameJson(config.search, inheritedConfig.search)) {
+        override.search = config.search.provider !== inheritedConfig.search.provider
+            ? { ...config.search }
+            : {
+                ...(config.search.baseUrl !== inheritedConfig.search.baseUrl ? { baseUrl: config.search.baseUrl } : {}),
+                ...(config.search.fallback !== inheritedConfig.search.fallback ? { fallback: config.search.fallback } : {}),
+                ...(!sameJson(config.search.options, inheritedConfig.search.options) ? { options: config.search.options } : {})
+            };
+        if (config.search.provider !== inheritedConfig.search.provider) {
+            override.search.provider = config.search.provider;
+        }
+        else if (Object.keys(override.search).length === 0) {
+            delete override.search;
+        }
+    }
+    if (!sameJson(config.fetch, inheritedConfig.fetch)) {
+        override.fetch = config.fetch.provider !== inheritedConfig.fetch.provider
+            ? { ...config.fetch, apiKey: undefined }
+            : {
+                ...(config.fetch.baseUrl !== inheritedConfig.fetch.baseUrl ? { baseUrl: config.fetch.baseUrl } : {}),
+                ...(config.fetch.fallback !== inheritedConfig.fetch.fallback ? { fallback: config.fetch.fallback } : {}),
+                ...(!sameJson(config.fetch.options, inheritedConfig.fetch.options) ? { options: config.fetch.options } : {})
+            };
+        delete override.fetch.apiKey;
+        if (config.fetch.provider !== inheritedConfig.fetch.provider) {
+            override.fetch.provider = config.fetch.provider;
+        }
+        else if (Object.keys(override.fetch).length === 0) {
+            delete override.fetch;
+        }
+    }
+    if (!sameJson(config.headless, inheritedConfig.headless)) {
+        override.headless = { ...config.headless };
+    }
+    return override;
+}
 export function handleSettingsShortcut(data) {
     if (data === '\u001b') {
         return { action: 'cancel' };
@@ -167,9 +374,10 @@ async function openActionMenu(ctx) {
     return ctx.ui.custom((tui, theme, _kb, done) => {
         const container = new Container();
         const items = [
-            { value: 'settings', label: 'Settings', description: 'Edit presentation modes' },
+            { value: 'settings', label: 'Settings', description: 'Edit presentation modes and backends' },
             { value: 'show', label: 'Show config', description: 'Print effective config paths and modes' },
             { value: 'doctor', label: 'Doctor', description: 'Check runtime dependencies and browser detection' },
+            { value: 'changelog', label: 'Changelog', description: 'Show latest package changelog' },
             { value: 'reset-project', label: 'Reset project config', description: 'Delete project-level overrides' },
             { value: 'reset-global', label: 'Reset global config', description: 'Delete global overrides' }
         ];
@@ -197,22 +405,120 @@ async function openActionMenu(ctx) {
         };
     });
 }
-async function openSettingsUi(ctx, loaded, initialScope) {
+async function openSettingsSectionMenu(ctx) {
+    return ctx.ui.custom((tui, theme, _kb, done) => {
+        const container = new Container();
+        const items = [
+            { value: 'presentation', label: 'Presentation', description: 'Compact, preview, and verbose output modes' },
+            { value: 'backends', label: 'Backends', description: 'Search/fetch providers, URLs, and fallbacks' }
+        ];
+        container.addChild(new DynamicBorder((text) => theme.fg('accent', text)));
+        container.addChild(new Text(theme.fg('accent', theme.bold('pi-web-agent settings')), 1, 0));
+        const list = new SelectList(items, items.length, {
+            selectedPrefix: (text) => theme.fg('accent', text),
+            selectedText: (text) => theme.fg('accent', text),
+            description: (text) => theme.fg('muted', text),
+            scrollInfo: (text) => theme.fg('dim', text),
+            noMatch: (text) => theme.fg('warning', text)
+        });
+        list.onSelect = (item) => done(item.value);
+        list.onCancel = () => done(undefined);
+        container.addChild(list);
+        container.addChild(new Text(theme.fg('dim', '↑↓ navigate • enter select • esc cancel'), 1, 0));
+        container.addChild(new DynamicBorder((text) => theme.fg('accent', text)));
+        return {
+            render: (width) => container.render(width),
+            invalidate: () => container.invalidate(),
+            handleInput: (data) => {
+                list.handleInput?.(data);
+                tui.requestRender?.();
+            }
+        };
+    });
+}
+async function openPresentationSettingsUi(ctx, loaded, initialScope) {
     return ctx.ui.custom((_tui, theme, _kb, done) => {
         let state = createSettingsDraftState(loaded, initialScope);
         let settingsList;
         const container = new Container();
-        container.addChild(new Text(theme.fg('accent', theme.bold('pi-web-agent settings')), 1, 1));
+        container.addChild(new Text(theme.fg('accent', theme.bold('pi-web-agent · presentation')), 1, 1));
         container.addChild(new Text(theme.fg('muted', 'Ctrl+S save · Ctrl+R reset scope · Esc cancel'), 1, 2));
         const rebuildSettingsList = () => {
             if (settingsList) {
                 container.removeChild(settingsList);
             }
-            settingsList = new SettingsList(buildSettingsItems(state.scope, state.config), Math.min(PRESENTATION_TOOL_NAMES.length + 8, 18), getSettingsListTheme(), (id, newValue) => {
+            settingsList = new SettingsList(buildPresentationSettingsItems(state.scope, state.config), Math.min(PRESENTATION_TOOL_NAMES.length + 8, 18), getSettingsListTheme(), (id, newValue) => {
+                state = applySettingsValue(state, id, newValue);
+                rebuildSettingsList();
+                container.invalidate();
+            }, () => done({ action: 'save', scope: state.scope, config: state.config, backends: state.backends }), { enableSearch: true });
+            container.addChild(settingsList);
+        };
+        rebuildSettingsList();
+        return {
+            render: (width) => container.render(width),
+            invalidate: () => container.invalidate(),
+            handleInput: (data) => {
+                const shortcut = handleSettingsShortcut(JSON.stringify(data).slice(1, -1));
+                if (shortcut?.action === 'cancel') {
+                    done({ action: 'cancel' });
+                    return;
+                }
+                if (shortcut?.action === 'reset') {
+                    done({ action: 'reset', scope: state.scope });
+                    return;
+                }
+                if (shortcut?.action === 'save') {
+                    done({ action: 'save', scope: state.scope, config: state.config, backends: state.backends });
+                    return;
+                }
+                settingsList.handleInput?.(data);
+            }
+        };
+    });
+}
+async function openBackendSettingsUi(ctx, loaded, initialScope) {
+    return ctx.ui.custom((tui, theme, _kb, done) => {
+        let state = createSettingsDraftState(loaded, initialScope);
+        let settingsList;
+        const container = new Container();
+        container.addChild(new Text(theme.fg('accent', theme.bold('pi-web-agent · backends')), 1, 1));
+        container.addChild(new Text(theme.fg('muted', 'Ctrl+S save · Ctrl+R reset scope · Esc cancel · API keys stay in env vars'), 1, 2));
+        const editUrl = async (id) => {
+            const isSearchUrl = id === 'backend:search:baseUrl';
+            const label = isSearchUrl ? 'SearXNG base URL' : 'Firecrawl base URL';
+            const currentValue = isSearchUrl ? state.backends.search.baseUrl : state.backends.fetch.baseUrl;
+            const entered = await ctx.ui.input(label, currentValue ?? (isSearchUrl ? 'http://localhost:8080' : 'http://localhost:3002'));
+            if (entered === undefined)
+                return;
+            if (!entered.trim()) {
+                state = applySettingsValue(state, id, '');
+                rebuildSettingsList();
+                tui.requestRender?.();
+                return;
+            }
+            const validated = validateBackendUrl(entered);
+            if (!validated.ok) {
+                ctx.ui.notify(validated.message, 'warning');
+                return;
+            }
+            state = applySettingsValue(state, id, validated.value);
+            rebuildSettingsList();
+            tui.requestRender?.();
+        };
+        const rebuildSettingsList = () => {
+            if (settingsList) {
+                container.removeChild(settingsList);
+            }
+            settingsList = new SettingsList(buildBackendSettingsItems(state.scope, state.backends), 12, getSettingsListTheme(), (id, newValue) => {
+                if (id === 'backend:search:baseUrl' || id === 'backend:fetch:baseUrl') {
+                    void editUrl(id);
+                    return;
+                }
                 state = applySettingsValue(state, id, newValue);
                 rebuildSettingsList();
                 container.invalidate();
-            }, () => done({ action: 'save', scope: state.scope, config: state.config }), { enableSearch: true });
+            }, () => done({ action: 'save', scope: state.scope, config: state.config, backends: state.backends }), { enableSearch: true });
             container.addChild(settingsList);
         };
         rebuildSettingsList();
@@ -230,7 +536,7 @@ async function openSettingsUi(ctx, loaded, initialScope) {
                     return;
                 }
                 if (shortcut?.action === 'save') {
-                    done({ action: 'save', scope: state.scope, config: state.config });
+                    done({ action: 'save', scope: state.scope, config: state.config, backends: state.backends });
                     return;
                 }
                 settingsList.handleInput?.(data);
@@ -241,6 +547,7 @@ async function openSettingsUi(ctx, loaded, initialScope) {
 export function registerWebAgentConfigCommands(pi, deps = {}) {
     const load = deps.load ?? (() => loadPresentationConfigLayers());
     const save = deps.save ?? ((scope, config) => savePresentationConfigScope({}, scope, config));
+    const saveBackends = deps.saveBackends ?? ((scope, config) => saveBackendConfigScope({}, scope, config));
     const reset = deps.reset ?? ((scope) => resetPresentationConfigScope({}, scope));
     const resolveBrowser = deps.resolveBrowser ?? (() => resolveBrowserExecutable({}));
     const runtime = deps.runtime ?? {
@@ -345,7 +652,12 @@ export function registerWebAgentConfigCommands(pi, deps = {}) {
             if (!action || action === 'settings') {
                 const loaded = await load();
                 const initialScope = 'project';
-                const result = await openSettingsUi(ctx, loaded, initialScope);
+                const section = await openSettingsSectionMenu(ctx);
+                if (!section)
+                    return;
+                const result = section === 'presentation'
+                    ? await openPresentationSettingsUi(ctx, loaded, initialScope)
+                    : await openBackendSettingsUi(ctx, loaded, initialScope);
                 if (!result || result.action === 'cancel') {
                     return;
                 }
@@ -354,8 +666,13 @@ export function registerWebAgentConfigCommands(pi, deps = {}) {
                     ctx.ui.notify(`Reset ${result.scope} config`, 'info');
                     return;
                 }
-                await save(result.scope, collapsePresentationConfigToOverride(result.config, getInheritedConfigForScope(loaded, result.scope)));
-                ctx.ui.notify(`Saved ${result.scope} config`, 'info');
+                if (section === 'presentation') {
+                    await save(result.scope, collapsePresentationConfigToOverride(result.config, getInheritedConfigForScope(loaded, result.scope)));
+                    ctx.ui.notify(`Saved ${result.scope} presentation config`, 'info');
+                    return;
+                }
+                await saveBackends(result.scope, collapseBackendConfigToOverride(result.backends, getInheritedBackendsForScope(loaded, result.scope)));
+                ctx.ui.notify(`Saved ${result.scope} backend config`, 'info');
                 return;
             }
             ctx.ui.notify('Use /web-agent, /web-agent show, /web-agent doctor, /web-agent changelog, /web-agent reset project, or /web-agent settings', 'info');

package/dist/fetch/firecrawl-fetch.d.ts

@@ -1,6 +1,8 @@
+import type { FirecrawlOptions } from '../backends/config.js';
 import type { WebFetchResponse } from '../types.js';
-export declare function createFirecrawlFetcher({ baseUrl, apiKey, fetchImpl }: {
+export declare function createFirecrawlFetcher({ baseUrl, apiKey, options, fetchImpl }: {
     baseUrl: string;
     apiKey?: string;
+    options?: FirecrawlOptions;
     fetchImpl?: typeof fetch;
 }): (url: string) => Promise<WebFetchResponse>;

package/dist/fetch/firecrawl-fetch.js

@@ -4,17 +4,22 @@ function buildScrapeUrl(baseUrl) {
 function errorMessage(error) {
     return error instanceof Error ? error.message : String(error);
 }
-export function createFirecrawlFetcher({ baseUrl, apiKey, fetchImpl = fetch }) {
+export function createFirecrawlFetcher({ baseUrl, apiKey, options, fetchImpl = fetch }) {
     return async function firecrawlFetch(url) {
         try {
             const headers = { 'content-type': 'application/json' };
             if (apiKey) {
                 headers.Authorization = `Bearer ${apiKey}`;
             }
+            const body = {
+                url,
+                formats: options?.formats ?? ['markdown'],
+                ...(options?.onlyMainContent !== undefined ? { onlyMainContent: options.onlyMainContent } : {})
+            };
             const response = await fetchImpl(buildScrapeUrl(baseUrl), {
                 method: 'POST',
                 headers,
-                body: JSON.stringify({ url, formats: ['markdown'] })
+                body: JSON.stringify(body)
             });
             if (!response.ok) {
                 throw new Error(`HTTP ${response.status}`);

package/dist/presentation/config-store.d.ts

@@ -23,4 +23,5 @@ export declare function getPresentationConfigPaths(options?: PresentationConfigS
 };
 export declare function loadPresentationConfigLayers(options?: PresentationConfigStoreOptions): Promise<LoadedPresentationConfig>;
 export declare function savePresentationConfigScope(options: PresentationConfigStoreOptions, scope: PresentationScope, config: PresentationConfigOverride): Promise<void>;
+export declare function saveBackendConfigScope(options: PresentationConfigStoreOptions, scope: PresentationScope, config: BackendConfigOverride): Promise<void>;
 export declare function resetPresentationConfigScope(options: PresentationConfigStoreOptions, scope: PresentationScope): Promise<void>;

package/dist/presentation/config-store.js

@@ -49,6 +49,35 @@ function serializePresentationConfigOverride(config) {
     }
     return { presentation };
 }
+function serializeBackendConfigOverride(config) {
+    const backends = {};
+    if (config.search && Object.keys(config.search).length > 0) {
+        backends.search = { ...config.search };
+    }
+    if (config.fetch && Object.keys(config.fetch).length > 0) {
+        const { apiKey: _apiKey, ...fetch } = config.fetch;
+        backends.fetch = { ...fetch };
+    }
+    if (config.headless && Object.keys(config.headless).length > 0) {
+        backends.headless = { ...config.headless };
+    }
+    return { backends };
+}
+async function readConfigFileForWrite(filePath) {
+    try {
+        return JSON.parse(await readFile(filePath, 'utf8'));
+    }
+    catch (error) {
+        if (error?.code === 'ENOENT') {
+            return {};
+        }
+        throw error;
+    }
+}
+async function writeConfigFile(filePath, config) {
+    await mkdir(path.dirname(filePath), { recursive: true });
+    await writeFile(filePath, JSON.stringify(config, null, 2) + '\n', 'utf8');
+}
 export async function loadPresentationConfigLayers(options = {}) {
     const { globalPath, projectPath } = getPresentationConfigPaths(options);
     const global = await readPresentationConfigFile(globalPath);
@@ -63,8 +92,20 @@ export async function loadPresentationConfigLayers(options = {}) {
 export async function savePresentationConfigScope(options, scope, config) {
     const { globalPath, projectPath } = getPresentationConfigPaths(options);
     const filePath = scope === 'global' ? globalPath : projectPath;
-    await mkdir(path.dirname(filePath), { recursive: true });
-    await writeFile(filePath, JSON.stringify(serializePresentationConfigOverride(config), null, 2) + '\n', 'utf8');
+    const existing = await readConfigFileForWrite(filePath);
+    await writeConfigFile(filePath, {
+        ...existing,
+        ...serializePresentationConfigOverride(config)
+    });
+}
+export async function saveBackendConfigScope(options, scope, config) {
+    const { globalPath, projectPath } = getPresentationConfigPaths(options);
+    const filePath = scope === 'global' ? globalPath : projectPath;
+    const existing = await readConfigFileForWrite(filePath);
+    await writeConfigFile(filePath, {
+        ...existing,
+        ...serializeBackendConfigOverride(config)
+    });
 }
 export async function resetPresentationConfigScope(options, scope) {
     const { globalPath, projectPath } = getPresentationConfigPaths(options);

package/dist/presentation/fetch-presentation.js

@@ -9,11 +9,14 @@ function firstExcerpt(text, maxChars = 240) {
 }
 export function buildFetchPresentation(result) {
     const wordCount = countWords(result.content?.text);
+    const fallbackPrefix = result.metadata.fallbackFrom
+        ? `${result.metadata.fallbackFrom} failed; used ${result.metadata.method} fallback. `
+        : '';
     const compact = result.status === 'ok'
-        ? `Fetched page · article extracted${wordCount ? ` · ${wordCount} words` : ''}`
+        ? `${fallbackPrefix}Fetched page · article extracted${wordCount ? ` · ${wordCount} words` : ''}`
         : result.status === 'needs_headless'
-            ? `Needs headless rendering: ${result.error?.message ?? 'Headless rendering recommended.'}`
-            : `Fetch failed: ${result.error?.message ?? 'Unknown fetch failure.'}`;
+            ? `${fallbackPrefix}Needs headless rendering: ${result.error?.message ?? 'Headless rendering recommended.'}`
+            : `${fallbackPrefix}Fetch failed: ${result.error?.message ?? 'Unknown fetch failure.'}`;
     return {
         mode: 'compact',
         views: {

package/dist/presentation/search-presentation.js

@@ -1,9 +1,12 @@
 function formatCompact(result) {
+    const fallbackPrefix = result.metadata.fallbackFrom
+        ? `${result.metadata.fallbackFrom} failed; used ${result.metadata.backend} fallback. `
+        : '';
     if (result.status === 'error') {
-        return `Search failed: ${result.error?.message ?? 'Unknown search failure.'}`;
+        return `${fallbackPrefix}Search failed: ${result.error?.message ?? 'Unknown search failure.'}`;
     }
     const suffix = result.results.length === 1 ? 'result' : 'results';
-    return `Found ${result.results.length} ${suffix}`;
+    return `${fallbackPrefix}Found ${result.results.length} ${suffix}`;
 }
 export function buildSearchPresentation(result) {
     const preview = result.results

package/dist/search/searxng.d.ts

@@ -1,6 +1,8 @@
+import type { SearxngOptions } from '../backends/config.js';
 import type { WebSearchResponse } from '../types.js';
-export declare function createSearxngSearchTool({ baseUrl, fetchImpl }: {
+export declare function createSearxngSearchTool({ baseUrl, options, fetchImpl }: {
     baseUrl: string;
+    options?: SearxngOptions;
     fetchImpl?: typeof fetch;
 }): ({ query }: {
     query: string;

package/dist/search/searxng.js

@@ -1,8 +1,14 @@
 import { buildSearchPresentation } from '../presentation/search-presentation.js';
-function buildSearchUrl(baseUrl, query) {
+function buildSearchUrl(baseUrl, query, options = {}) {
     const url = new URL('/search', baseUrl.endsWith('/') ? baseUrl : `${baseUrl}/`);
     url.searchParams.set('q', query);
     url.searchParams.set('format', 'json');
+    if (options.categories?.length)
+        url.searchParams.set('categories', options.categories.join(','));
+    if (options.language)
+        url.searchParams.set('language', options.language);
+    if (options.safesearch !== undefined)
+        url.searchParams.set('safesearch', String(options.safesearch));
     return url.toString();
 }
 function normalizeResults(response) {
@@ -19,7 +25,7 @@ function normalizeResults(response) {
         ];
     });
 }
-export function createSearxngSearchTool({ baseUrl, fetchImpl = fetch }) {
+export function createSearxngSearchTool({ baseUrl, options, fetchImpl = fetch }) {
     return async function searxngSearch({ query }) {
         const normalizedQuery = query.trim();
         if (!normalizedQuery) {
@@ -32,7 +38,7 @@ export function createSearxngSearchTool({ baseUrl, fetchImpl = fetch }) {
             return { ...result, presentation: buildSearchPresentation(result) };
         }
         try {
-            const response = await fetchImpl(buildSearchUrl(baseUrl, normalizedQuery));
+            const response = await fetchImpl(buildSearchUrl(baseUrl, normalizedQuery, options));
             if (!response.ok) {
                 throw new Error(`HTTP ${response.status}`);
             }

package/dist/types.d.ts

@@ -13,10 +13,14 @@ export type ToolError = {
 export type SearchMetadata = {
     backend: 'duckduckgo' | 'searxng';
     cacheHit: boolean;
+    fallbackFrom?: 'searxng';
+    fallbackReason?: string;
 };
 export type FetchMetadata = {
     method: 'http' | 'headless' | 'firecrawl';
     cacheHit: boolean;
+    fallbackFrom?: 'firecrawl';
+    fallbackReason?: string;
     contentType?: string;
     truncated?: boolean;
     browser?: 'configured' | 'chrome' | 'edge' | 'brave' | 'chromium';

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@demigodmode/pi-web-agent",
-  "version": "1.0.0",
+  "version": "1.2.0",
   "description": "Pi package for reliable web access with explicit search, fetch, and headless boundaries.",
   "type": "module",
   "main": "./dist/extension.js",