@demigodmode/pi-web-agent 0.2.1 → 0.3.1

package/dist/extension.js

@@ -1,14 +1,111 @@
 import { Type } from '@sinclair/typebox';
+import { registerWebAgentConfigCommands } from './commands/web-agent-config.js';
+import { DEFAULT_PRESENTATION_CONFIG, resolvePresentationMode } from './presentation/config.js';
+import { loadPresentationConfigLayers } from './presentation/config-store.js';
+import { selectPresentationView } from './presentation/select-view.js';
 import { createWebExploreTool } from './tools/web-explore.js';
 import { createWebFetchTool } from './tools/web-fetch.js';
 import { createWebFetchHeadlessTool } from './tools/web-fetch-headless.js';
 import { createWebSearchTool } from './tools/web-search.js';
+async function getEffectivePresentationConfig(pi) {
+    const store = pi.__presentationConfigStore;
+    try {
+        const loaded = await (store?.load?.() ?? loadPresentationConfigLayers());
+        return loaded.effectiveConfig;
+    }
+    catch {
+        return DEFAULT_PRESENTATION_CONFIG;
+    }
+}
+async function renderToolText(pi, toolName, details) {
+    const config = await getEffectivePresentationConfig(pi);
+    const mode = resolvePresentationMode(toolName, config);
+    return selectPresentationView(details.presentation, mode) ?? JSON.stringify(details, null, 2);
+}
 export default function extension(pi) {
+    registerWebAgentConfigCommands(pi);
     const webSearch = createWebSearchTool();
     const webFetch = createWebFetchTool();
     const webFetchHeadless = createWebFetchHeadlessTool();
     const webExplore = createWebExploreTool();
+    let webExploreUsedInCurrentFlow = false;
+    const postWebExploreGuardError = {
+        code: 'POST_WEB_EXPLORE_GUARD',
+        message: 'web_explore already ran for this research task. Only use low-level web tools if there is a specific unresolved gap.'
+    };
+    async function guardSearchResponse() {
+        const result = {
+            status: 'error',
+            results: [],
+            metadata: {
+                backend: 'duckduckgo',
+                cacheHit: false
+            },
+            error: postWebExploreGuardError,
+            presentation: {
+                mode: 'compact',
+                views: {
+                    compact: `Search failed: ${postWebExploreGuardError.message}`
+                }
+            }
+        };
+        return {
+            content: [{ type: 'text', text: await renderToolText(pi, 'web_search', result) }],
+            details: result,
+            isError: true
+        };
+    }
+    async function guardFetchResponse(url) {
+        const result = {
+            status: 'error',
+            url,
+            metadata: {
+                method: 'http',
+                cacheHit: false
+            },
+            error: postWebExploreGuardError,
+            presentation: {
+                mode: 'compact',
+                views: {
+                    compact: `Fetch failed: ${postWebExploreGuardError.message}`
+                }
+            }
+        };
+        return {
+            content: [{ type: 'text', text: await renderToolText(pi, 'web_fetch', result) }],
+            details: result,
+            isError: true
+        };
+    }
+    async function guardHeadlessResponse(url) {
+        const result = {
+            status: 'error',
+            url,
+            metadata: {
+                method: 'headless',
+                cacheHit: false
+            },
+            error: postWebExploreGuardError,
+            presentation: {
+                mode: 'compact',
+                views: {
+                    compact: `Fetch failed: ${postWebExploreGuardError.message}`
+                }
+            }
+        };
+        return {
+            content: [
+                {
+                    type: 'text',
+                    text: await renderToolText(pi, 'web_fetch_headless', result)
+                }
+            ],
+            details: result,
+            isError: true
+        };
+    }
     pi.on('before_agent_start', async (event) => {
+        webExploreUsedInCurrentFlow = false;
         return {
             systemPrompt: `${event.systemPrompt}\n\n` +
                 'For web research questions that require finding and comparing multiple sources, prefer web_explore. ' +
@@ -25,9 +122,12 @@ export default function extension(pi) {
             query: Type.String({ description: 'Search query.' })
         }),
         async execute(_toolCallId, params) {
+            if (webExploreUsedInCurrentFlow) {
+                return guardSearchResponse();
+            }
             const result = await webSearch({ query: params.query });
             return {
-                content: [{ type: 'text', text: JSON.stringify(result, null, 2) }],
+                content: [{ type: 'text', text: await renderToolText(pi, 'web_search', result) }],
                 details: result,
                 isError: result.status === 'error'
             };
@@ -41,9 +141,12 @@ export default function extension(pi) {
             url: Type.String({ description: 'HTTP or HTTPS URL to fetch.' })
         }),
         async execute(_toolCallId, params) {
+            if (webExploreUsedInCurrentFlow) {
+                return guardFetchResponse(params.url);
+            }
             const result = await webFetch({ url: params.url });
             return {
-                content: [{ type: 'text', text: JSON.stringify(result, null, 2) }],
+                content: [{ type: 'text', text: await renderToolText(pi, 'web_fetch', result) }],
                 details: result,
                 isError: result.status === 'error'
             };
@@ -57,9 +160,12 @@ export default function extension(pi) {
             url: Type.String({ description: 'HTTP or HTTPS URL to fetch in headless mode.' })
         }),
         async execute(_toolCallId, params) {
+            if (webExploreUsedInCurrentFlow) {
+                return guardHeadlessResponse(params.url);
+            }
             const result = await webFetchHeadless({ url: params.url });
             return {
-                content: [{ type: 'text', text: JSON.stringify(result, null, 2) }],
+                content: [{ type: 'text', text: await renderToolText(pi, 'web_fetch_headless', result) }],
                 details: result,
                 isError: result.status === 'error'
             };
@@ -74,11 +180,14 @@ export default function extension(pi) {
         }),
         async execute(_toolCallId, params) {
             const result = await webExplore({ query: params.query });
+            if (result.status === 'ok') {
+                webExploreUsedInCurrentFlow = true;
+            }
             return {
                 content: [
                     {
                         type: 'text',
-                        text: result.status === 'ok' ? result.text : JSON.stringify(result, null, 2)
+                        text: await renderToolText(pi, 'web_explore', result)
                     }
                 ],
                 details: result,

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

@@ -0,0 +1,23 @@
+import type { PresentationConfig, PresentationConfigOverride, PresentationScope } from './types.js';
+export type PresentationConfigStoreOptions = {
+    homeDir?: string;
+    projectDir?: string;
+};
+export type PresentationConfigLayer = {
+    path: string;
+    exists: boolean;
+    rawConfig?: PresentationConfigOverride;
+    error?: string;
+};
+export type LoadedPresentationConfig = {
+    global: PresentationConfigLayer;
+    project: PresentationConfigLayer;
+    effectiveConfig: PresentationConfig;
+};
+export declare function getPresentationConfigPaths(options?: PresentationConfigStoreOptions): {
+    globalPath: string;
+    projectPath: string;
+};
+export declare function loadPresentationConfigLayers(options?: PresentationConfigStoreOptions): Promise<LoadedPresentationConfig>;
+export declare function savePresentationConfigScope(options: PresentationConfigStoreOptions, scope: PresentationScope, config: PresentationConfigOverride): Promise<void>;
+export declare function resetPresentationConfigScope(options: PresentationConfigStoreOptions, scope: PresentationScope): Promise<void>;

package/dist/presentation/config-store.js

@@ -0,0 +1,64 @@
+import { mkdir, readFile, rm, writeFile } from 'node:fs/promises';
+import path from 'node:path';
+import { DEFAULT_PRESENTATION_CONFIG, extractPresentationConfigOverride, mergePresentationConfigLayers } from './config.js';
+export function getPresentationConfigPaths(options = {}) {
+    const homeDir = options.homeDir ?? process.env.USERPROFILE ?? process.env.HOME ?? '';
+    const projectDir = options.projectDir ?? process.cwd();
+    return {
+        globalPath: path.join(homeDir, '.pi', 'agent', 'extensions', 'pi-web-agent', 'config.json'),
+        projectPath: path.join(projectDir, '.pi', 'extensions', 'pi-web-agent', 'config.json')
+    };
+}
+async function readPresentationConfigFile(filePath) {
+    try {
+        const rawText = await readFile(filePath, 'utf8');
+        const parsed = JSON.parse(rawText);
+        return {
+            path: filePath,
+            exists: true,
+            rawConfig: extractPresentationConfigOverride(parsed)
+        };
+    }
+    catch (error) {
+        if (error?.code === 'ENOENT') {
+            return { path: filePath, exists: false };
+        }
+        const message = error instanceof Error ? error.message : String(error);
+        return {
+            path: filePath,
+            exists: true,
+            error: message
+        };
+    }
+}
+function serializePresentationConfigOverride(config) {
+    const presentation = {};
+    if (config.defaultMode) {
+        presentation.defaultMode = config.defaultMode;
+    }
+    if (Object.keys(config.tools).length > 0) {
+        presentation.tools = config.tools;
+    }
+    return { presentation };
+}
+export async function loadPresentationConfigLayers(options = {}) {
+    const { globalPath, projectPath } = getPresentationConfigPaths(options);
+    const global = await readPresentationConfigFile(globalPath);
+    const project = await readPresentationConfigFile(projectPath);
+    return {
+        global,
+        project,
+        effectiveConfig: mergePresentationConfigLayers(DEFAULT_PRESENTATION_CONFIG, global.rawConfig, project.rawConfig)
+    };
+}
+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');
+}
+export async function resetPresentationConfigScope(options, scope) {
+    const { globalPath, projectPath } = getPresentationConfigPaths(options);
+    const filePath = scope === 'global' ? globalPath : projectPath;
+    await rm(filePath, { force: true });
+}

package/dist/presentation/config.d.ts

@@ -0,0 +1,7 @@
+import { type PresentationConfig, type PresentationConfigFile, type PresentationConfigOverride, type PresentationMode, type PresentationToolName } from './types.js';
+export declare const DEFAULT_PRESENTATION_CONFIG: PresentationConfig;
+export declare function isPresentationMode(value: unknown): value is PresentationMode;
+export declare function extractPresentationConfigOverride(file: PresentationConfigFile | null | undefined): PresentationConfigOverride;
+export declare function normalizePresentationConfigFile(file: PresentationConfigFile | null | undefined): PresentationConfig;
+export declare function mergePresentationConfigLayers(defaults: PresentationConfig, globalConfig?: PresentationConfigOverride, projectConfig?: PresentationConfigOverride): PresentationConfig;
+export declare function resolvePresentationMode(toolName: PresentationToolName, config?: PresentationConfig): PresentationMode;

package/dist/presentation/config.js

@@ -0,0 +1,44 @@
+import { PRESENTATION_MODES } from './types.js';
+const PRESENTATION_MODE_SET = new Set(PRESENTATION_MODES);
+export const DEFAULT_PRESENTATION_CONFIG = {
+    defaultMode: 'compact',
+    tools: {}
+};
+export function isPresentationMode(value) {
+    return typeof value === 'string' && PRESENTATION_MODE_SET.has(value);
+}
+export function extractPresentationConfigOverride(file) {
+    const presentation = file?.presentation;
+    const tools = Object.fromEntries(Object.entries(presentation?.tools ?? {}).flatMap(([toolName, value]) => {
+        if (!value || !isPresentationMode(value.mode)) {
+            return [];
+        }
+        return [[toolName, { mode: value.mode }]];
+    }));
+    return {
+        defaultMode: isPresentationMode(presentation?.defaultMode)
+            ? presentation.defaultMode
+            : undefined,
+        tools
+    };
+}
+export function normalizePresentationConfigFile(file) {
+    const override = extractPresentationConfigOverride(file);
+    return {
+        defaultMode: override.defaultMode ?? DEFAULT_PRESENTATION_CONFIG.defaultMode,
+        tools: override.tools
+    };
+}
+export function mergePresentationConfigLayers(defaults, globalConfig, projectConfig) {
+    return {
+        defaultMode: projectConfig?.defaultMode ?? globalConfig?.defaultMode ?? defaults.defaultMode,
+        tools: {
+            ...defaults.tools,
+            ...globalConfig?.tools,
+            ...projectConfig?.tools
+        }
+    };
+}
+export function resolvePresentationMode(toolName, config = DEFAULT_PRESENTATION_CONFIG) {
+    return config.tools[toolName]?.mode ?? config.defaultMode;
+}

package/dist/presentation/explore-presentation.d.ts

@@ -0,0 +1,3 @@
+import type { WebExploreResponse } from '../types.js';
+import type { PresentationEnvelope } from './types.js';
+export declare function buildExplorePresentation(result: WebExploreResponse): PresentationEnvelope;

package/dist/presentation/explore-presentation.js

@@ -0,0 +1,34 @@
+export function buildExplorePresentation(result) {
+    if (result.status === 'error') {
+        return {
+            mode: 'compact',
+            views: {
+                compact: `Research failed: ${result.error?.message ?? 'Unknown research failure.'}`
+            }
+        };
+    }
+    const preview = result.findings.map((finding) => `- ${finding}`).join('\n');
+    const verbose = [
+        'Findings',
+        ...result.findings.map((finding) => `- ${finding}`),
+        '',
+        'Sources',
+        ...result.sources.map((source) => `- ${source.title}: ${source.url}`),
+        result.caveat ? `\nCaveat\n${result.caveat}` : undefined
+    ]
+        .filter((line) => line !== undefined)
+        .join('\n');
+    return {
+        mode: 'compact',
+        views: {
+            compact: `Reviewed ${result.sources.length} sources · synthesized answer with ${result.findings.length} findings`,
+            preview,
+            verbose
+        },
+        metrics: {
+            sourceCount: result.sources.length,
+            resultCount: result.findings.length
+        },
+        sources: result.sources
+    };
+}

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

@@ -0,0 +1,5 @@
+import type { WebFetchHeadlessResponse, WebFetchResponse } from '../types.js';
+import type { PresentationEnvelope } from './types.js';
+type FetchLike = WebFetchResponse | WebFetchHeadlessResponse;
+export declare function buildFetchPresentation(result: FetchLike): PresentationEnvelope;
+export {};

package/dist/presentation/fetch-presentation.js

@@ -0,0 +1,40 @@
+function countWords(text) {
+    return text?.trim() ? text.trim().split(/\s+/).length : undefined;
+}
+function firstExcerpt(text, maxChars = 240) {
+    if (!text) {
+        return undefined;
+    }
+    return text.length <= maxChars ? text : `${text.slice(0, maxChars).trimEnd()}…`;
+}
+export function buildFetchPresentation(result) {
+    const wordCount = countWords(result.content?.text);
+    const compact = result.status === 'ok'
+        ? `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.'}`;
+    return {
+        mode: 'compact',
+        views: {
+            compact,
+            preview: result.content?.title
+                ? `${result.content.title}\n${firstExcerpt(result.content.text) ?? ''}`.trim()
+                : firstExcerpt(result.content?.text),
+            verbose: result.status === 'ok'
+                ? [
+                    `URL: ${result.url}`,
+                    result.content?.title ? `Title: ${result.content.title}` : undefined,
+                    firstExcerpt(result.content?.text, 500)
+                ]
+                    .filter(Boolean)
+                    .join('\n')
+                : undefined
+        },
+        metrics: {
+            wordCount,
+            cacheHit: result.metadata.cacheHit
+        },
+        sources: [{ title: result.content?.title ?? result.url, url: result.url }]
+    };
+}

package/dist/presentation/search-presentation.d.ts

@@ -0,0 +1,3 @@
+import type { WebSearchResponse } from '../types.js';
+import type { PresentationEnvelope } from './types.js';
+export declare function buildSearchPresentation(result: WebSearchResponse): PresentationEnvelope;

package/dist/presentation/search-presentation.js

@@ -0,0 +1,30 @@
+function formatCompact(result) {
+    if (result.status === 'error') {
+        return `Search failed: ${result.error?.message ?? 'Unknown search failure.'}`;
+    }
+    const suffix = result.results.length === 1 ? 'result' : 'results';
+    return `Found ${result.results.length} ${suffix}`;
+}
+export function buildSearchPresentation(result) {
+    const preview = result.results
+        .slice(0, 3)
+        .map((item, index) => `${index + 1}. ${item.title}`)
+        .join('\n');
+    const verbose = result.results
+        .slice(0, 5)
+        .map((item, index) => `${index + 1}. ${item.title}\n   ${item.url}\n   ${item.snippet}`)
+        .join('\n');
+    return {
+        mode: 'compact',
+        views: {
+            compact: formatCompact(result),
+            preview: preview || undefined,
+            verbose: verbose || undefined
+        },
+        metrics: {
+            resultCount: result.results.length,
+            cacheHit: result.metadata.cacheHit
+        },
+        sources: result.results.map((item) => ({ title: item.title, url: item.url }))
+    };
+}

package/dist/presentation/select-view.d.ts

@@ -0,0 +1,2 @@
+import type { PresentationEnvelope, PresentationMode } from './types.js';
+export declare function selectPresentationView(envelope: PresentationEnvelope | undefined, requestedMode: PresentationMode): string | undefined;

package/dist/presentation/select-view.js

@@ -0,0 +1,12 @@
+export function selectPresentationView(envelope, requestedMode) {
+    if (!envelope) {
+        return undefined;
+    }
+    if (requestedMode === 'preview' && envelope.views.preview) {
+        return envelope.views.preview;
+    }
+    if (requestedMode === 'verbose' && envelope.views.verbose) {
+        return envelope.views.verbose;
+    }
+    return envelope.views.compact;
+}

package/dist/presentation/types.d.ts

@@ -0,0 +1,50 @@
+export declare const PRESENTATION_MODES: readonly ["compact", "preview", "verbose"];
+export type PresentationMode = (typeof PRESENTATION_MODES)[number];
+export type PresentationViews = {
+    compact: string;
+    preview?: string;
+    verbose?: string;
+};
+export type PresentationMetrics = {
+    durationMs?: number;
+    resultCount?: number;
+    sourceCount?: number;
+    wordCount?: number;
+    statusCode?: number;
+    cacheHit?: boolean;
+    truncated?: boolean;
+};
+export type PresentationSource = {
+    title: string;
+    url: string;
+    domain?: string;
+};
+export type PresentationEnvelope = {
+    mode: PresentationMode;
+    views: PresentationViews;
+    metrics?: PresentationMetrics;
+    sources?: PresentationSource[];
+    debug?: Record<string, unknown>;
+};
+export type PresentationToolName = 'web_search' | 'web_fetch' | 'web_fetch_headless' | 'web_explore';
+export type PresentationScope = 'global' | 'project';
+export type PresentationToolOverrideMode = PresentationMode;
+export type PresentationToolConfig = {
+    mode: PresentationToolOverrideMode;
+};
+export type PresentationConfig = {
+    defaultMode: PresentationMode;
+    tools: Partial<Record<PresentationToolName, PresentationToolConfig>>;
+};
+export type PresentationConfigOverride = {
+    defaultMode?: PresentationMode;
+    tools: Partial<Record<PresentationToolName, PresentationToolConfig>>;
+};
+export type PresentationConfigFile = {
+    presentation?: {
+        defaultMode?: unknown;
+        tools?: Partial<Record<PresentationToolName, {
+            mode?: unknown;
+        }>>;
+    };
+};

package/dist/presentation/types.js

@@ -0,0 +1 @@
+export const PRESENTATION_MODES = ['compact', 'preview', 'verbose'];

package/dist/search/duckduckgo.d.ts

@@ -1,4 +1,9 @@
 import type { SearchResult } from '../types.js';
+export type ParsedDuckDuckGoResults = {
+    results: SearchResult[];
+    noResults: boolean;
+    hasResultContainers: boolean;
+};
 export declare function buildSearchUrl(query: string): string;
 export declare function fetchDuckDuckGoHtml(query: string): Promise<string>;
-export declare function parseDuckDuckGoResults(html: string): SearchResult[];
+export declare function parseDuckDuckGoResults(html: string): ParsedDuckDuckGoResults;

package/dist/search/duckduckgo.js

@@ -30,7 +30,8 @@ export async function fetchDuckDuckGoHtml(query) {
 }
 export function parseDuckDuckGoResults(html) {
     const $ = cheerio.load(html);
-    return $('.result')
+    const resultContainers = $('.result');
+    const results = resultContainers
         .map((_, element) => {
         const title = $(element).find('.result__a').first().text().trim();
         const url = normalizeDuckDuckGoUrl($(element).find('.result__a').first().attr('href')?.trim() ?? '');
@@ -39,4 +40,13 @@ export function parseDuckDuckGoResults(html) {
     })
         .get()
         .filter((value) => value !== null);
+    const text = $.text().toLowerCase();
+    const noResults = text.includes('no results found') ||
+        text.includes('no more results') ||
+        text.includes('did not match any documents');
+    return {
+        results,
+        noResults,
+        hasResultContainers: resultContainers.length > 0
+    };
 }

package/dist/tools/web-explore.d.ts

@@ -22,23 +22,13 @@ export declare function createWebExploreTool({ explore }?: {
 }): ({ query }: {
     query: string;
 }) => Promise<{
-    status: "error";
-    findings: never[];
-    sources: never[];
-    error: {
-        code: string;
-        message: string;
-    };
-    caveat?: undefined;
-    text?: undefined;
-} | {
-    status: "ok";
+    presentation: import("../presentation/types.js").PresentationEnvelope;
+    status: "ok" | "error";
     findings: string[];
-    sources: {
+    sources: Array<{
         title: string;
         url: string;
-    }[];
-    caveat: string | undefined;
-    text: string;
-    error?: undefined;
+    }>;
+    caveat?: string;
+    error?: import("../types.js").ToolError;
 }>;

package/dist/tools/web-explore.js

@@ -1,4 +1,5 @@
 import { createResearchWorkflow } from '../orchestration/index.js';
+import { buildExplorePresentation } from '../presentation/explore-presentation.js';
 function findingFromEvidence(evidence, index) {
     if (evidence.summary.includes('Use channel')) {
         return 'Use channel for branded Chrome or Edge when possible.';
@@ -12,23 +13,21 @@ function findingFromEvidence(evidence, index) {
     }
     return evidence.summary || `Finding ${index + 1}`;
 }
-function formatExploreText({ findings, sources, caveat }) {
-    const findingLines = findings.map((finding) => `- ${finding}`).join('\n');
-    const sourceLines = sources.map((source) => `- ${source.title}: ${source.url}`).join('\n');
-    const caveatBlock = caveat ? `\n\nCaveat\n${caveat}` : '';
-    return `Findings\n${findingLines}\n\nSources\n${sourceLines}${caveatBlock}`;
-}
 export function createWebExploreTool({ explore = createResearchWorkflow() } = {}) {
     const runExplore = typeof explore === 'function' ? explore : explore.run.bind(explore);
     return async function webExplore({ query }) {
         const normalizedQuery = query.trim();
         if (!normalizedQuery) {
-            return {
+            const result = {
                 status: 'error',
                 findings: [],
                 sources: [],
                 error: { code: 'INVALID_QUERY', message: 'Query must not be empty.' }
             };
+            return {
+                ...result,
+                presentation: buildExplorePresentation(result)
+            };
         }
         const result = await runExplore({ query: normalizedQuery });
         const findings = result.evidence.slice(0, 5).map(findingFromEvidence);
@@ -39,12 +38,15 @@ export function createWebExploreTool({ explore = createResearchWorkflow() } = {}
         const caveat = result.decision.action === 'answer'
             ? undefined
             : 'Evidence is partial, so this answer is based on the strongest source found so far.';
-        return {
+        const shaped = {
             status: 'ok',
             findings,
             sources,
-            caveat,
-            text: formatExploreText({ findings, sources, caveat })
+            caveat
+        };
+        return {
+            ...shaped,
+            presentation: buildExplorePresentation(shaped)
         };
     };
 }

package/dist/tools/web-fetch-headless.js

@@ -1,14 +1,23 @@
 import { headlessFetch } from '../fetch/headless-fetch.js';
+import { buildFetchPresentation } from '../presentation/fetch-presentation.js';
 export function createWebFetchHeadlessTool({ fetchPage = headlessFetch } = {}) {
     return async function webFetchHeadless({ url }) {
         if (!/^https?:\/\//.test(url)) {
-            return {
+            const result = {
                 status: 'unsupported',
                 url,
                 metadata: { method: 'headless', cacheHit: false },
                 error: { code: 'UNSUPPORTED_URL', message: 'Only http and https URLs are supported.' }
             };
+            return {
+                ...result,
+                presentation: buildFetchPresentation(result)
+            };
         }
-        return fetchPage(url);
+        const result = await fetchPage(url);
+        return {
+            ...result,
+            presentation: buildFetchPresentation(result)
+        };
     };
 }