pi-agent-browser-native 0.2.48 → 0.2.50

package/dist/extensions/agent-browser/lib/results/presentation/registry.js

@@ -0,0 +1,216 @@
+import { isRecord } from "../../parsing.js";
+import { detectConfirmationRequired } from "../confirmation.js";
+import { formatRawSnapshotText, formatSnapshotSummary } from "../snapshot.js";
+import { redactModelFacingText, stringifyModelFacing } from "./common.js";
+import { formatDiagnosticSummary, formatDiagnosticText, formatProfilesText, getStreamSummary, getTabSummary } from "./diagnostics.js";
+import { getScreenshotSummary } from "./artifacts.js";
+import { formatSkillsText } from "./skills.js";
+import { formatExtractionSummary, formatExtractionText, formatNavigationActionResult, formatNavigationSummary, getNavigationSummary, isNavigationObservableCommand, } from "./navigation.js";
+import { formatSemanticActionPresentationSummary, formatSemanticActionPresentationText, resolvePresentationCommandInfo, } from "./semantic-action.js";
+function getPageSummary(data) {
+    const title = typeof data.title === "string" ? data.title : undefined;
+    const url = typeof data.url === "string" ? data.url : undefined;
+    if (!title && !url)
+        return undefined;
+    if (title && url)
+        return `${title}\n${url}`;
+    return title ?? url;
+}
+function formatConfirmationRequiredSummary(confirmation) {
+    return `Confirmation required: ${confirmation.id}`;
+}
+const VITALS_METRICS = ["lcp", "fcp", "ttfb", "inp", "cls"];
+function coerceVitalsMetricValue(value) {
+    if (typeof value === "number" && Number.isFinite(value))
+        return value;
+    if (isRecord(value)) {
+        for (const nestedKey of ["value", "duration", "startTime", "score"]) {
+            const nestedValue = value[nestedKey];
+            if (typeof nestedValue === "number" && Number.isFinite(nestedValue))
+                return nestedValue;
+        }
+    }
+    return undefined;
+}
+function getVitalsMetric(data, key) {
+    const metrics = isRecord(data.metrics) ? data.metrics : undefined;
+    return coerceVitalsMetricValue(data[key] ?? data[key.toUpperCase()] ?? metrics?.[key] ?? metrics?.[key.toUpperCase()]);
+}
+function formatVitalsMetric(key, value) {
+    return key === "cls" ? `${key.toUpperCase()}: ${value}` : `${key.toUpperCase()}: ${Math.round(value)}ms`;
+}
+function getVitalsMetrics(data) {
+    return VITALS_METRICS.flatMap((key) => {
+        const value = getVitalsMetric(data, key);
+        return value === undefined ? [] : [formatVitalsMetric(key, value)];
+    });
+}
+function getVitalsUnavailableReason(data) {
+    for (const key of ["reason", "message", "error", "status"]) {
+        const value = data[key];
+        if (typeof value === "string" && value.trim().length > 0)
+            return redactModelFacingText(value.trim());
+    }
+    return "No Core Web Vitals metric fields were present in the upstream result.";
+}
+function formatVitalsText(data) {
+    const url = typeof data.url === "string" && data.url.trim().length > 0 ? redactModelFacingText(data.url.trim()) : undefined;
+    const metrics = getVitalsMetrics(data);
+    const lines = [url ? `Vitals for ${url}` : "Vitals result"];
+    if (metrics.length > 0)
+        lines.push(...metrics.map((metric) => `- ${metric}`));
+    else
+        lines.push(`Metrics unavailable: ${getVitalsUnavailableReason(data)}`);
+    return lines.join("\n");
+}
+function formatVitalsSummary(data) {
+    const metrics = getVitalsMetrics(data);
+    if (metrics.length > 0)
+        return `Vitals: ${metrics.join(", ")}`;
+    return "Vitals: metrics unavailable";
+}
+function formatConfirmationRequiredText(confirmation) {
+    const lines = [
+        "Confirmation required.",
+        `Pending confirmation id: ${confirmation.id}`,
+    ];
+    if (confirmation.actionText)
+        lines.push(`Action: ${confirmation.actionText}`);
+    lines.push("", "Next steps:", `- Approve: { "args": ["confirm", "${confirmation.id}"] }`, `- Deny: { "args": ["deny", "${confirmation.id}"] }`);
+    return lines.join("\n");
+}
+const COMMAND_PRESENTERS = {
+    profiles: {
+        summary: (_commandInfo, data) => Array.isArray(data) ? `Chrome profiles: ${data.length}` : undefined,
+        text: (_commandInfo, data) => Array.isArray(data) ? formatProfilesText(data, "Chrome profiles") : undefined,
+    },
+    screenshot: {
+        summary: (_commandInfo, data) => isRecord(data) && typeof data.path === "string" ? `Screenshot saved: ${data.path}` : undefined,
+        text: (_commandInfo, data) => isRecord(data) ? getScreenshotSummary(data) : undefined,
+    },
+    skills: {
+        summary: (commandInfo, data) => {
+            if (Array.isArray(data) && commandInfo.subcommand === "list")
+                return `agent-browser skills: ${data.length}`;
+            if (commandInfo.subcommand === "get")
+                return "agent-browser skill loaded";
+            if (commandInfo.subcommand === "path")
+                return "agent-browser skill path";
+            return undefined;
+        },
+        text: formatSkillsText,
+    },
+    snapshot: {
+        summary: (_commandInfo, data) => isRecord(data) ? formatSnapshotSummary(data) : undefined,
+        text: (_commandInfo, data) => isRecord(data) ? formatRawSnapshotText(data) : undefined,
+    },
+    stream: {
+        summary: (commandInfo, data) => {
+            if (!isRecord(data) || commandInfo.subcommand !== "status")
+                return undefined;
+            const port = typeof data.port === "number" ? ` on port ${data.port}` : "";
+            return `Stream ${data.enabled === true ? "enabled" : "disabled"}${port}`;
+        },
+        text: (commandInfo, data) => isRecord(data) && commandInfo.subcommand === "status" ? getStreamSummary(data) : undefined,
+    },
+    tab: {
+        summary: (_commandInfo, data) => isRecord(data) && Array.isArray(data.tabs) ? `Tabs: ${data.tabs.length}` : undefined,
+        text: (_commandInfo, data) => isRecord(data) ? getTabSummary(data) : undefined,
+    },
+    vitals: {
+        summary: (_commandInfo, data) => isRecord(data) ? formatVitalsSummary(data) : undefined,
+        text: (_commandInfo, data) => isRecord(data) ? formatVitalsText(data) : undefined,
+    },
+    "web-vitals": {
+        summary: (_commandInfo, data) => isRecord(data) ? formatVitalsSummary(data) : undefined,
+        text: (_commandInfo, data) => isRecord(data) ? formatVitalsText(data) : undefined,
+    },
+};
+function formatBatchSummary(data) {
+    if (!Array.isArray(data))
+        return undefined;
+    const successCount = data.filter((item) => isRecord(item) && item.success !== false).length;
+    return successCount === data.length
+        ? `Batch: ${successCount}/${data.length} succeeded`
+        : `Batch failed: ${successCount}/${data.length} succeeded`;
+}
+export function formatPresentationSummary(commandInfo, data, compiledSemanticAction) {
+    const confirmationRequired = detectConfirmationRequired(data);
+    if (confirmationRequired)
+        return formatConfirmationRequiredSummary(confirmationRequired);
+    const presentationCommandInfo = resolvePresentationCommandInfo(commandInfo, compiledSemanticAction);
+    if (commandInfo.command === "batch") {
+        const batchSummary = formatBatchSummary(data);
+        if (batchSummary)
+            return batchSummary;
+    }
+    if (isRecord(data)) {
+        if (compiledSemanticAction) {
+            const semanticSummary = formatSemanticActionPresentationSummary(compiledSemanticAction, data);
+            if (semanticSummary)
+                return semanticSummary;
+        }
+        const navigationSummary = getNavigationSummary(data);
+        if (navigationSummary && isNavigationObservableCommand(presentationCommandInfo.command)) {
+            const navigationText = formatNavigationSummary(navigationSummary);
+            if (navigationText) {
+                return `${presentationCommandInfo.command ?? "navigation"} → ${navigationText.split("\n", 1)[0] ?? navigationText}`;
+            }
+        }
+    }
+    const presenterSummary = commandInfo.command ? COMMAND_PRESENTERS[commandInfo.command]?.summary?.(commandInfo, data) : undefined;
+    if (presenterSummary)
+        return presenterSummary;
+    if (isRecord(data)) {
+        const diagnosticSummary = formatDiagnosticSummary(commandInfo, data);
+        if (diagnosticSummary)
+            return diagnosticSummary;
+        const extractionSummary = formatExtractionSummary(commandInfo, data);
+        if (extractionSummary)
+            return extractionSummary;
+        const pageSummary = getPageSummary(data);
+        if (pageSummary)
+            return pageSummary.split("\n", 1)[0] ?? "agent-browser result";
+    }
+    if (typeof data === "string" && data.length > 0)
+        return data.split("\n", 1)[0] ?? data;
+    return `${presentationCommandInfo.command ?? commandInfo.command ?? "agent-browser"} completed`;
+}
+export function formatPresentationContentText(commandInfo, data, compiledSemanticAction) {
+    const confirmationRequired = detectConfirmationRequired(data);
+    if (confirmationRequired)
+        return formatConfirmationRequiredText(confirmationRequired);
+    const presenterText = commandInfo.command ? COMMAND_PRESENTERS[commandInfo.command]?.text?.(commandInfo, data) : undefined;
+    if (presenterText)
+        return presenterText;
+    if (typeof data === "string")
+        return redactModelFacingText(data);
+    if (typeof data === "number" || typeof data === "boolean")
+        return String(data);
+    if (!isRecord(data))
+        return stringifyModelFacing(data);
+    if (compiledSemanticAction) {
+        const semanticText = formatSemanticActionPresentationText(compiledSemanticAction, data);
+        if (semanticText)
+            return semanticText;
+    }
+    const presentationCommandInfo = resolvePresentationCommandInfo(commandInfo, compiledSemanticAction);
+    const navigationSummary = getNavigationSummary(data);
+    if (navigationSummary && isNavigationObservableCommand(presentationCommandInfo.command)) {
+        const navigationText = formatNavigationSummary(navigationSummary);
+        if (navigationText) {
+            const actionText = formatNavigationActionResult(data);
+            return actionText ? `${actionText}\n\nCurrent page:\n${navigationText}` : `Current page:\n${navigationText}`;
+        }
+    }
+    const extractionText = formatExtractionText(commandInfo, data);
+    if (extractionText)
+        return extractionText;
+    const diagnosticText = formatDiagnosticText(commandInfo, data);
+    if (diagnosticText)
+        return diagnosticText;
+    const pageSummary = getPageSummary(data);
+    if (pageSummary)
+        return redactModelFacingText(pageSummary);
+    return stringifyModelFacing(data);
+}

package/dist/extensions/agent-browser/lib/results/presentation/semantic-action.js

@@ -0,0 +1,104 @@
+/**
+ * Purpose: Map successful semanticAction results to the same presentation signals as direct ref commands.
+ * Responsibilities: Resolve presentation command names, compact action prose, and navigation-summary probe gates.
+ * Scope: semanticAction success presentation only.
+ */
+import { getCompiledSemanticActionCommandIndex, isCompiledSemanticActionFindCommand, } from "../../input-modes/semantic-action.js";
+import { isRecord } from "../../parsing.js";
+import { formatNavigationSummary, getNavigationSummary, isNavigationObservableCommand, } from "./navigation.js";
+import { redactModelFacingText } from "./common.js";
+const SEMANTIC_NAVIGATION_PROBE_ACTIONS = new Set(["check", "click"]);
+const SEMANTIC_PRESENTATION_ACTIONS = new Set(["check", "click", "fill", "select"]);
+function getPageSummary(data) {
+    const title = typeof data.title === "string" ? data.title : undefined;
+    const url = typeof data.url === "string" ? data.url : undefined;
+    if (!title && !url)
+        return undefined;
+    if (title && url)
+        return `${title}\n${url}`;
+    return title ?? url;
+}
+function formatSemanticActionTarget(compiled) {
+    if (compiled.action === "select") {
+        const selector = compiled.selector ?? "selector";
+        const values = compiled.values?.length ? compiled.values.join(", ") : "";
+        return values ? `${selector} → ${values}` : selector;
+    }
+    const commandIndex = getCompiledSemanticActionCommandIndex(compiled);
+    const locator = compiled.locator ?? compiled.args[commandIndex + 1] ?? "locator";
+    const locatorValue = compiled.args[commandIndex + 2];
+    const nameIndex = compiled.args.indexOf("--name");
+    const name = nameIndex >= 0 ? compiled.args[nameIndex + 1] : undefined;
+    const quotedValue = JSON.stringify(locatorValue ?? "");
+    const target = `${locator} ${quotedValue}`;
+    return name ? `${target} (name ${JSON.stringify(name)})` : target;
+}
+export function formatSemanticActionCompactLine(compiled) {
+    const target = formatSemanticActionTarget(compiled);
+    switch (compiled.action) {
+        case "click":
+            return `Clicked: ${target}`;
+        case "fill":
+            return `Filled: ${target}`;
+        case "check":
+            return `Checked: ${target}`;
+        case "select":
+            return `Selected: ${target}`;
+        default:
+            return `${compiled.action}: ${target}`;
+    }
+}
+export function resolveSemanticPresentationCommand(compiled) {
+    if (!compiled || !SEMANTIC_PRESENTATION_ACTIONS.has(compiled.action))
+        return undefined;
+    if (compiled.action === "select")
+        return "select";
+    if (isCompiledSemanticActionFindCommand(compiled))
+        return compiled.action;
+    return undefined;
+}
+export function resolvePresentationCommandInfo(commandInfo, compiledSemanticAction) {
+    const presentationCommand = resolveSemanticPresentationCommand(compiledSemanticAction);
+    if (!presentationCommand)
+        return commandInfo;
+    return { ...commandInfo, command: presentationCommand };
+}
+export function shouldCaptureSemanticActionNavigationSummary(compiled, data) {
+    if (!compiled || !SEMANTIC_NAVIGATION_PROBE_ACTIONS.has(compiled.action))
+        return false;
+    if (!isCompiledSemanticActionFindCommand(compiled))
+        return false;
+    return !isRecord(data) || (typeof data.title !== "string" && typeof data.url !== "string");
+}
+export function formatSemanticActionPresentationText(compiled, data) {
+    const presentationCommand = resolveSemanticPresentationCommand(compiled);
+    if (!presentationCommand)
+        return undefined;
+    const actionLine = formatSemanticActionCompactLine(compiled);
+    const navigationSummary = getNavigationSummary(data);
+    if (navigationSummary && isNavigationObservableCommand(presentationCommand)) {
+        const navigationText = formatNavigationSummary(navigationSummary);
+        if (navigationText)
+            return `${actionLine}\n\nCurrent page:\n${navigationText}`;
+    }
+    const pageSummary = getPageSummary(data);
+    if (pageSummary)
+        return `${actionLine}\n\nCurrent page:\n${redactModelFacingText(pageSummary)}`;
+    return actionLine;
+}
+export function formatSemanticActionPresentationSummary(compiled, data) {
+    const presentationCommand = resolveSemanticPresentationCommand(compiled);
+    if (!presentationCommand)
+        return undefined;
+    const navigationSummary = getNavigationSummary(data);
+    if (navigationSummary && isNavigationObservableCommand(presentationCommand)) {
+        const navigationText = formatNavigationSummary(navigationSummary);
+        if (navigationText) {
+            return `${presentationCommand} → ${navigationText.split("\n", 1)[0] ?? navigationText}`;
+        }
+    }
+    const pageSummary = getPageSummary(data);
+    if (pageSummary)
+        return `${presentationCommand} → ${pageSummary.split("\n", 1)[0] ?? pageSummary}`;
+    return `${presentationCommand} → ${formatSemanticActionTarget(compiled)}`;
+}

package/dist/extensions/agent-browser/lib/results/presentation/skills.js

@@ -0,0 +1,152 @@
+/**
+ * Purpose: Render upstream agent-browser skills output as native pi tool guidance.
+ * Responsibilities: Format skills list/path/get results and translate agent-browser shell snippets to agent_browser tool calls.
+ * Scope: Skills command presentation only.
+ */
+import { isRecord } from "../../parsing.js";
+import { getStringField, redactModelFacingText, stringifyModelFacing } from "./common.js";
+function formatSkillsListText(skills) {
+    if (skills.length === 0)
+        return "No agent-browser skills found.";
+    return skills
+        .map((item, index) => {
+        if (!isRecord(item))
+            return `${index + 1}. ${stringifyModelFacing(item)}`;
+        const name = redactModelFacingText(getStringField(item, "name") ?? `(skill ${index + 1})`);
+        const description = getStringField(item, "description");
+        return description ? `${index + 1}. ${name} — ${redactModelFacingText(description)}` : `${index + 1}. ${name}`;
+    })
+        .join("\n");
+}
+function getSkillContent(data) {
+    if (typeof data === "string")
+        return data;
+    if (isRecord(data) && typeof data.content === "string")
+        return data.content;
+    if (!Array.isArray(data))
+        return undefined;
+    const content = data.flatMap((item) => (isRecord(item) && typeof item.content === "string" ? [item.content] : []));
+    return content.length > 0 ? content.join("\n\n") : undefined;
+}
+function splitShellWords(input) {
+    const words = [];
+    let current = "";
+    let quote;
+    for (let index = 0; index < input.length; index += 1) {
+        const char = input[index];
+        if (quote === "single") {
+            if (char === "'")
+                quote = undefined;
+            else
+                current += char;
+            continue;
+        }
+        if (quote === "double") {
+            if (char === '"')
+                quote = undefined;
+            else if (char === "\\" && index + 1 < input.length) {
+                index += 1;
+                current += input[index];
+            }
+            else
+                current += char;
+            continue;
+        }
+        if (char === "'") {
+            quote = "single";
+            continue;
+        }
+        if (char === '"') {
+            quote = "double";
+            continue;
+        }
+        if (char === "\\" && index + 1 < input.length) {
+            index += 1;
+            current += input[index];
+            continue;
+        }
+        if (char === "#" && current.length === 0) {
+            break;
+        }
+        if (/\s/.test(char)) {
+            if (current.length > 0) {
+                words.push(current);
+                current = "";
+            }
+            continue;
+        }
+        current += char;
+    }
+    if (quote)
+        return undefined;
+    if (current.length > 0)
+        words.push(current);
+    return words;
+}
+function formatNativeAgentBrowserCall(args, stdin) {
+    return stdin === undefined
+        ? `agent_browser { "args": ${JSON.stringify(args)} }`
+        : `agent_browser { "args": ${JSON.stringify(args)}, "stdin": ${JSON.stringify(stdin)} }`;
+}
+function formatNativeSkillContent(content) {
+    const lines = content.replace(/^allowed-tools:.*agent-browser.*\n?/gim, "").replace(/^```bash\s*$/gim, "```text").split("\n");
+    const output = [];
+    for (let index = 0; index < lines.length; index += 1) {
+        const line = lines[index];
+        const commandMatch = /^(\s*)agent-browser\s+(.+?)\s*$/.exec(line);
+        if (!commandMatch) {
+            output.push(line);
+            continue;
+        }
+        const indent = commandMatch[1];
+        const rawArgsText = commandMatch[2];
+        const heredocMatch = /^(.*?)\s+(<<-?)['"]?([A-Za-z_][A-Za-z0-9_]*)['"]?\s*$/.exec(rawArgsText);
+        const argsText = heredocMatch?.[1] ?? rawArgsText;
+        const args = splitShellWords(argsText);
+        if (!args || args.length === 0) {
+            output.push(line);
+            continue;
+        }
+        if (!heredocMatch) {
+            output.push(`${indent}${formatNativeAgentBrowserCall(args)}`);
+            continue;
+        }
+        const stripsLeadingTabs = heredocMatch[2] === "<<-";
+        const delimiter = heredocMatch[3];
+        const stdinLines = [];
+        let cursor = index + 1;
+        while (cursor < lines.length) {
+            const candidate = stripsLeadingTabs ? lines[cursor].replace(/^\t+/, "") : lines[cursor];
+            if (candidate === delimiter)
+                break;
+            stdinLines.push(candidate);
+            cursor += 1;
+        }
+        if (cursor >= lines.length) {
+            output.push(line);
+            continue;
+        }
+        output.push(`${indent}${formatNativeAgentBrowserCall(args, stdinLines.join("\n"))}`);
+        index = cursor;
+    }
+    return output.join("\n");
+}
+export function formatSkillsText(commandInfo, data) {
+    if (commandInfo.command !== "skills")
+        return undefined;
+    if (commandInfo.subcommand === "path")
+        return typeof data === "string" ? redactModelFacingText(data) : undefined;
+    if (commandInfo.subcommand === "list" && Array.isArray(data))
+        return formatSkillsListText(data);
+    const content = getSkillContent(data);
+    if (content) {
+        const note = [
+            "Pi native-tool note: upstream skill text was adapted for this native tool.",
+            "Use args for CLI tokens and stdin only for batch, eval --stdin, or auth save --password-stdin; do not pipe heredocs through bash unless the user explicitly asks for a bash workflow.",
+        ].join("\n");
+        return `${note}\n\n${redactModelFacingText(formatNativeSkillContent(content))}`;
+    }
+    if (typeof data === "string")
+        return redactModelFacingText(formatNativeSkillContent(data));
+    return undefined;
+}

package/dist/extensions/agent-browser/lib/results/presentation.js

@@ -0,0 +1,177 @@
+/*
+ * Purpose: Render parsed agent-browser results into concise pi-facing summaries, text content, and optional inline image attachments.
+ * Responsibilities: Orchestrate specialized presentation modules, attach inline images within size limits, and keep generic record formatting distinct from envelope parsing.
+ * Scope: Presentation shaping only; upstream stdout parsing and snapshot compaction internals live in separate modules.
+ */
+import { isRecord } from "../parsing.js";
+import { buildAgentBrowserNextActions } from "./action-recommendations.js";
+import { buildAgentBrowserResultCategoryDetails } from "./categories.js";
+import { detectConfirmationRequired } from "./confirmation.js";
+import { buildSnapshotPresentation } from "./snapshot.js";
+import { parseJsonPreviewString, redactModelFacingText, stringifyModelFacing } from "./presentation/common.js";
+import { applyArtifactManifest, attachInlineImage, buildArtifactVerificationSummary, buildManifestEntriesForFileArtifacts, classifyPresentationSuccessCategory, extractFileArtifacts, extractImagePath, formatArtifactMetadataLines, formatArtifactSummary, formatMissingArtifactFailureText, getSavedFileDetails, hasMissingFileArtifact, isManifestFileArtifact, } from "./presentation/artifacts.js";
+import { buildBatchPresentation, isAgentBrowserBatchResultArray } from "./presentation/batch.js";
+import { getPresentationPaths } from "./presentation/content.js";
+import { buildNetworkRequestsNextActions, buildStreamNextActions, enrichStreamStatusData, formatNetworkRouteDiagnosticsText, redactPresentationData, } from "./presentation/diagnostics.js";
+import { buildErrorPresentation } from "./presentation/errors.js";
+import { compactLargePresentationOutput } from "./presentation/large-output.js";
+import { buildPageChangeSummary } from "./presentation/navigation.js";
+import { formatPresentationContentText, formatPresentationSummary } from "./presentation/registry.js";
+import { resolvePresentationCommandInfo } from "./presentation/semantic-action.js";
+function sanitizeModelFacingPresentation(presentation) {
+    presentation.content = presentation.content.map((item) => {
+        if (item.type !== "text")
+            return item;
+        const parsed = parseJsonPreviewString(item.text);
+        return parsed === item.text ? item : { ...item, text: stringifyModelFacing(parsed) };
+    });
+    presentation.summary = redactModelFacingText(presentation.summary);
+    return presentation;
+}
+function mergeNextActions(...groups) {
+    const merged = groups.flatMap((group) => group ?? []);
+    return merged.length > 0 ? merged : undefined;
+}
+function shouldAddAnnotatedScreenshotGuidance(commandInfo, args) {
+    return commandInfo.command === "screenshot" && (args?.includes("--annotate") ?? false);
+}
+export async function buildToolPresentation(options) {
+    const { args, artifactManifest, artifactRequest, commandInfo, compiledSemanticAction, cwd, envelope, errorText, networkRouteDiagnostics, networkRoutes, persistentArtifactStore, sessionName, } = options;
+    const presentationCommandInfo = resolvePresentationCommandInfo(commandInfo, compiledSemanticAction);
+    if (errorText) {
+        return buildErrorPresentation({ args, commandInfo, errorText, sessionName });
+    }
+    const data = enrichStreamStatusData(commandInfo, envelope?.data);
+    const presentationData = redactPresentationData(commandInfo, data);
+    const artifacts = await extractFileArtifacts({ artifactManifest, artifactRequest, commandInfo: presentationCommandInfo, cwd, data, sessionName });
+    const artifactVerification = buildArtifactVerificationSummary(artifacts);
+    const artifactSummary = formatArtifactSummary(artifacts);
+    const summary = artifactSummary ?? formatPresentationSummary(commandInfo, data, compiledSemanticAction);
+    const artifactText = artifacts.length > 0 ? formatArtifactMetadataLines(artifacts).join("\n") : undefined;
+    let presentation;
+    if (commandInfo.command === "batch" && isAgentBrowserBatchResultArray(data)) {
+        presentation = await buildBatchPresentation({
+            artifactManifest,
+            artifactRequests: options.batchArtifactRequests,
+            buildNestedToolPresentation: buildToolPresentation,
+            cwd,
+            data,
+            networkRoutes,
+            persistentArtifactStore,
+            sessionName,
+            summary,
+        });
+    }
+    else if (commandInfo.command === "snapshot" && isRecord(data)) {
+        presentation = await buildSnapshotPresentation(data, persistentArtifactStore, artifactManifest);
+    }
+    else {
+        presentation = {
+            artifactVerification,
+            artifacts: artifacts.length > 0 ? artifacts : undefined,
+            content: [{ type: "text", text: artifactText ?? formatPresentationContentText(commandInfo, data, compiledSemanticAction) }],
+            data: presentationData,
+            summary,
+        };
+    }
+    if (networkRouteDiagnostics && networkRouteDiagnostics.length > 0 && presentation.content[0]?.type === "text") {
+        const diagnosticText = formatNetworkRouteDiagnosticsText(networkRouteDiagnostics);
+        if (diagnosticText)
+            presentation.content[0] = { ...presentation.content[0], text: `${diagnosticText}\n\n${presentation.content[0].text}` };
+        presentation.networkRouteDiagnostics = networkRouteDiagnostics;
+    }
+    if (artifacts.length > 0 && !presentation.artifacts) {
+        presentation.artifacts = artifacts;
+    }
+    presentation.artifactVerification = presentation.artifactVerification ?? artifactVerification;
+    if (isRecord(data)) {
+        const savedFile = getSavedFileDetails(commandInfo, data);
+        if (savedFile) {
+            presentation.savedFile = savedFile;
+            presentation.savedFilePath = savedFile.path;
+        }
+    }
+    if (shouldAddAnnotatedScreenshotGuidance(commandInfo, args) && presentation.content[0]?.type === "text") {
+        const guidance = "Annotated screenshot note: dense pages can produce overlapping labels. If the labels are noisy, capture a scoped element screenshot, take a non-annotated screenshot, or use snapshot -i high-value refs as the machine-readable map.";
+        presentation.content[0] = { ...presentation.content[0], text: `${presentation.content[0].text}\n\n${guidance}` };
+    }
+    const imagePath = artifactRequest?.absolutePath ?? extractImagePath(commandInfo, cwd, data);
+    const presentationWithImage = imagePath ? await attachInlineImage(presentation, imagePath) : presentation;
+    const compactedPresentation = await compactLargePresentationOutput({
+        artifactManifest,
+        commandInfo,
+        data: presentationData,
+        persistentArtifactStore,
+        presentation: presentationWithImage,
+    });
+    const presentationWithManifest = applyArtifactManifest(compactedPresentation, compactedPresentation.artifactManifest ?? artifactManifest, buildManifestEntriesForFileArtifacts(artifacts.filter(isManifestFileArtifact)));
+    const currentSpillPaths = new Set(getPresentationPaths({
+        primaryPath: presentationWithManifest.fullOutputPath,
+        secondaryPaths: presentationWithManifest.fullOutputPaths,
+    }));
+    presentationWithManifest.artifactVerification = buildArtifactVerificationSummary(artifacts, presentationWithManifest.artifactManifest, currentSpillPaths) ?? presentationWithManifest.artifactVerification;
+    const confirmationRequired = detectConfirmationRequired(data);
+    const missingArtifactFailureText = formatMissingArtifactFailureText(presentationWithManifest.artifacts);
+    if (missingArtifactFailureText && hasMissingFileArtifact(presentationWithManifest.artifacts)) {
+        presentationWithManifest.resultCategory = "failure";
+        presentationWithManifest.failureCategory = "artifact-missing";
+        presentationWithManifest.successCategory = undefined;
+        presentationWithManifest.summary = missingArtifactFailureText;
+        if (presentationWithManifest.content[0]?.type === "text") {
+            presentationWithManifest.content[0] = { ...presentationWithManifest.content[0], text: `${missingArtifactFailureText}\n\n${presentationWithManifest.content[0].text}` };
+        }
+        else {
+            presentationWithManifest.content.unshift({ type: "text", text: missingArtifactFailureText });
+        }
+    }
+    if (!presentationWithManifest.resultCategory) {
+        const categoryDetails = buildAgentBrowserResultCategoryDetails({
+            artifacts: presentationWithManifest.artifacts,
+            command: presentationCommandInfo.command,
+            confirmationRequired: confirmationRequired !== undefined,
+            errorText: envelope?.success === false ? presentationWithManifest.summary : undefined,
+            savedFile: presentationWithManifest.savedFile,
+            succeeded: envelope?.success !== false,
+        });
+        presentationWithManifest.resultCategory = categoryDetails.resultCategory;
+        presentationWithManifest.successCategory = categoryDetails.resultCategory === "success"
+            ? classifyPresentationSuccessCategory({
+                artifactVerification: presentationWithManifest.artifactVerification,
+                artifacts: presentationWithManifest.artifacts,
+                savedFile: presentationWithManifest.savedFile,
+            })
+            : categoryDetails.successCategory;
+        presentationWithManifest.failureCategory = categoryDetails.failureCategory;
+    }
+    if (presentationWithManifest.resultCategory === "success") {
+        presentationWithManifest.successCategory = classifyPresentationSuccessCategory({
+            artifactVerification: presentationWithManifest.artifactVerification,
+            artifacts: presentationWithManifest.artifacts,
+            savedFile: presentationWithManifest.savedFile,
+        });
+    }
+    const genericNextActions = presentationWithManifest.nextActions ? undefined : buildAgentBrowserNextActions({
+        artifacts: presentationWithManifest.artifacts,
+        args,
+        command: presentationCommandInfo.command,
+        confirmationId: confirmationRequired?.id,
+        failureCategory: presentationWithManifest.failureCategory,
+        resultCategory: presentationWithManifest.resultCategory ?? "success",
+        savedFilePath: presentationWithManifest.savedFilePath,
+        successCategory: presentationWithManifest.successCategory,
+    });
+    const networkNextActions = commandInfo.command === "network" && commandInfo.subcommand === "requests" && presentationWithManifest.resultCategory === "success"
+        ? buildNetworkRequestsNextActions(data, sessionName, presentationWithManifest.networkRouteDiagnostics)
+        : undefined;
+    const streamNextActions = presentationWithManifest.resultCategory === "success" ? buildStreamNextActions(commandInfo, data, sessionName) : undefined;
+    presentationWithManifest.nextActions = mergeNextActions(presentationWithManifest.nextActions, genericNextActions, networkNextActions, streamNextActions);
+    presentationWithManifest.pageChangeSummary = presentationWithManifest.pageChangeSummary ?? buildPageChangeSummary({
+        artifacts: presentationWithManifest.artifacts,
+        commandInfo: presentationCommandInfo,
+        data,
+        nextActions: presentationWithManifest.nextActions,
+        savedFilePath: presentationWithManifest.savedFilePath,
+        summary: presentationWithManifest.summary,
+    });
+    return sanitizeModelFacingPresentation(presentationWithManifest);
+}