pi-agent-browser-native 0.2.48 → 0.2.50

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

@@ -0,0 +1,205 @@
+import { isOpenNavigationCommand } from "../../command-taxonomy.js";
+import { redactSensitiveText } from "../../runtime.js";
+import { buildBrowserProfileConfigRecovery } from "./browser-profile-recovery.js";
+import { redactModelFacingText } from "./common.js";
+import { buildAgentBrowserNextActions } from "../action-recommendations.js";
+import { buildAgentBrowserResultCategoryDetails } from "../categories.js";
+import { withOptionalSessionArgs } from "../next-actions.js";
+const STALE_REF_ERROR_HINT = [
+    "Agent-browser hint: This ref may be stale after navigation, scrolling, or re-rendering.",
+    "Run `snapshot -i` again and retry with a current `@e…` ref; for less ref churn, use `find role|text|label|placeholder|alt|title|testid ...` or `scrollintoview` before interacting with off-screen elements.",
+].join(" ");
+const SELECTOR_DIALECT_ERROR_HINT = [
+    "Agent-browser hint: This selector may use an unsupported selector dialect.",
+    "Prefer refs from `snapshot -i`, or use supported `find role|text|label|placeholder|alt|title|testid ...` locators; use `scrollintoview` before interacting with off-screen elements.",
+].join(" ");
+const CLIPBOARD_PERMISSION_ERROR_HINT = [
+    "Agent-browser clipboard hint: Clipboard read/write access is environment-dependent and often fails in headless, managed, remote-profile, or file:// sessions.",
+    "If you see `NotAllowedError` or `permission denied`, treat it as a browser/OS permission limitation rather than proof that page state changed.",
+    "When possible, prefer page-native reads (`snapshot -i`, `get text`, `eval --stdin`) or direct input (`keyboard inserttext` / `keyboard type`) instead of relying on OS clipboard access.",
+    "If true clipboard access is required, retry in a browser/profile/session with explicit clipboard permission on a normal http(s) page.",
+].join(" ");
+const KEYBOARD_PRESS_ERROR_HINT = [
+    "Agent-browser keyboard hint: upstream keyboard commands are `keyboard type <text>` and `keyboard inserttext <text>`; `keyboard press` is not a supported subcommand in the targeted upstream version.",
+    'For Enter in text fields, use `keyboard type "\\n"` after focusing the intended control, then verify with a fresh snapshot, URL, or page-state check.',
+].join(" ");
+function isRecord(value) {
+    return typeof value === "object" && value !== null;
+}
+function getSelectorRecoveryHint(errorText) {
+    const normalized = errorText.trim();
+    if (normalized.length === 0)
+        return undefined;
+    if (/\bUnknown ref\b|\bstale ref\b|\bref\b.*\b(?:not found|missing|expired)\b/i.test(normalized)) {
+        return STALE_REF_ERROR_HINT;
+    }
+    const mentionsPlaywrightSelectorDialect = /(?:\btext=|:has-text\(|\bgetByRole\b|\bgetByText\b)/i.test(normalized);
+    const reportsSelectorMatchFailure = /\b(?:no elements? found|failed to find|could not find|unable to find)\b.*\b(?:selector|locator)\b/i.test(normalized) ||
+        /\b(?:selector|locator)\b.*\b(?:no elements? found|not found|missing|failed to find|could not find|unable to find)\b/i.test(normalized);
+    if (/\b(?:unsupported|unknown|invalid)\s+(?:selector|locator)\b/i.test(normalized) ||
+        /\bfailed to parse selector\b/i.test(normalized) ||
+        /\bselector\b.*\b(?:parse|syntax|unsupported|invalid)\b/i.test(normalized) ||
+        (mentionsPlaywrightSelectorDialect && reportsSelectorMatchFailure)) {
+        return SELECTOR_DIALECT_ERROR_HINT;
+    }
+    return undefined;
+}
+function getClipboardPermissionHint(commandInfo, errorText) {
+    if (commandInfo.command !== "clipboard")
+        return undefined;
+    if (!/\bNotAllowedError\b|\bclipboard\b.*\bpermission denied\b|\bpermission denied\b.*\bclipboard\b/i.test(errorText)) {
+        return undefined;
+    }
+    return CLIPBOARD_PERMISSION_ERROR_HINT;
+}
+function getKeyboardPressHint(commandInfo, errorText) {
+    if (commandInfo.command !== "keyboard" || commandInfo.subcommand !== "press")
+        return undefined;
+    if (!/\bunknown\s+subcommand\b|\bvalid options?\b/i.test(errorText))
+        return undefined;
+    return KEYBOARD_PRESS_ERROR_HINT;
+}
+export function redactClipboardPermissionEcho(commandInfo, errorText) {
+    if (commandInfo.command !== "clipboard")
+        return errorText;
+    return errorText
+        .replace(/(\b(?:read|write)\s+permission denied\b(?:\s+for)?\s+)([\s\S]+)$/gi, "$1[REDACTED]")
+        .replace(/(\bFailed to execute '[^']+' on 'Clipboard':\s*)([\s\S]+)$/gi, (match, prefix, suffix) => {
+        if (!/\bpermission denied\b/i.test(suffix))
+            return match;
+        return `${prefix}${suffix.replace(/(\bpermission denied\b(?:\s+for)?\s+)([\s\S]+)$/i, "$1[REDACTED]")}`;
+    });
+}
+export function getClipboardWritePayloadCandidates(commandTokens) {
+    if (commandTokens[0] !== "clipboard" || commandTokens[1] !== "write")
+        return [];
+    const payloadTokens = commandTokens.slice(2).filter((value) => value.length > 0);
+    return [...new Set([...payloadTokens, payloadTokens.join(" ")].filter((value) => value.length > 0))];
+}
+function shouldRedactClipboardPayloadField(key, value, payloadCandidates) {
+    return payloadCandidates.some((candidate) => {
+        if (value === candidate)
+            return true;
+        if (candidate.length < 8 || !/payload|clipboard|argument/i.test(key))
+            return false;
+        return value.includes(candidate);
+    });
+}
+export function redactClipboardPermissionErrorValue(commandInfo, value, payloadCandidates = []) {
+    if (commandInfo.command !== "clipboard")
+        return value;
+    if (typeof value === "string")
+        return payloadCandidates.includes(value) ? "[REDACTED]" : redactClipboardPermissionEcho(commandInfo, value);
+    if (Array.isArray(value))
+        return value.map((item) => redactClipboardPermissionErrorValue(commandInfo, item, payloadCandidates));
+    if (!isRecord(value))
+        return value;
+    return Object.fromEntries(Object.entries(value).map(([key, entryValue]) => [
+        key,
+        typeof entryValue === "string" && shouldRedactClipboardPayloadField(key, entryValue, payloadCandidates)
+            ? "[REDACTED]"
+            : redactClipboardPermissionErrorValue(commandInfo, entryValue, payloadCandidates),
+    ]));
+}
+const UNKNOWN_COMMAND_SUGGESTIONS = {
+    attr: [{ description: "Use `get attr <selector> <name>` to read an attribute from a selector or current `@ref`." }],
+    count: [{ description: "Use `get count <selector>` to count matching elements." }],
+    html: [{ description: "Use `get html <selector>` to read element HTML, or `get html` for the page when upstream supports it." }],
+    text: [{ description: "Use `get text <selector>` to read text from a selector or current `@ref`; run `snapshot -i` first when you need a safe `@ref`." }],
+    title: [{ args: ["get", "title"], description: "Use `get title` to read the current page title.", id: "use-get-title" }],
+    url: [{ args: ["get", "url"], description: "Use `get url` to read the current page URL.", id: "use-get-url" }],
+    value: [{ description: "Use `get value <selector>` to read form control value from a selector or current `@ref`." }],
+};
+function getUnknownCommandSuggestions(command, errorText) {
+    if (!command)
+        return [];
+    const normalizedCommand = command.trim().toLowerCase();
+    if (!/\bunknown\s+command\b|\bunknown\s+subcommand\b|\bunrecognized\s+command\b/i.test(errorText))
+        return [];
+    return UNKNOWN_COMMAND_SUGGESTIONS[normalizedCommand] ?? [];
+}
+function formatUnknownCommandSuggestionText(suggestions) {
+    if (suggestions.length === 0)
+        return undefined;
+    return ["Agent-browser hint: This looks like a getter shortcut, but upstream getter commands are grouped under `get`.", ...suggestions.map((suggestion) => suggestion.description)].join(" ");
+}
+function buildUnknownCommandSuggestionActions(suggestions, sessionName) {
+    const actions = suggestions
+        .filter((suggestion) => suggestion.args !== undefined && suggestion.id !== undefined)
+        .map((suggestion) => ({
+        id: suggestion.id,
+        params: { args: withOptionalSessionArgs(sessionName, suggestion.args) },
+        reason: suggestion.description,
+        safety: "Read-only getter command; safe to retry when you intended to inspect page state.",
+        tool: "agent_browser",
+    }));
+    return actions.length > 0 ? actions : undefined;
+}
+function getLocalhostNavigationHint(commandInfo, errorText) {
+    if (!commandInfo.command || !isOpenNavigationCommand(commandInfo.command) || !commandInfo.subcommand)
+        return undefined;
+    if (!/\bnet::ERR_(?:EMPTY_RESPONSE|CONNECTION_REFUSED|ADDRESS_UNREACHABLE|TIMED_OUT|CONNECTION_RESET)\b/i.test(errorText))
+        return undefined;
+    let targetUrl;
+    try {
+        targetUrl = new URL(commandInfo.subcommand);
+    }
+    catch {
+        return undefined;
+    }
+    if (!["localhost", "127.0.0.1", "::1", "[::1]"].includes(targetUrl.hostname.toLowerCase()))
+        return undefined;
+    return [
+        "Agent-browser local fixture hint: the browser process could not read a loopback URL from its own network namespace or browser host.",
+        "Verify the server is still running and bound to an address the browser host can reach; if curl works from the shell but browser navigation fails, try the other loopback alias, add a proxy bypass for localhost/127.0.0.1 if a proxy is configured, or use a browser-host-reachable URL.",
+        "Use file:// only for static fallback fixtures and clean up any temporary server process outside agent_browser when the check is done.",
+    ].join(" ");
+}
+export function appendSelectorRecoveryHint(errorText) {
+    const hint = getSelectorRecoveryHint(errorText);
+    if (!hint || errorText.includes("Agent-browser hint:"))
+        return errorText;
+    return `${errorText}\n\n${hint}`;
+}
+export function buildErrorPresentation(options) {
+    const { args, commandInfo, errorText, sessionName } = options;
+    const safeErrorText = redactModelFacingText(redactSensitiveText(redactClipboardPermissionEcho(commandInfo, errorText)));
+    const selectorHintedErrorText = appendSelectorRecoveryHint(safeErrorText);
+    const unknownCommandSuggestions = getUnknownCommandSuggestions(commandInfo.command, safeErrorText);
+    const unknownCommandSuggestionText = formatUnknownCommandSuggestionText(unknownCommandSuggestions);
+    const browserProfileConfigRecovery = buildBrowserProfileConfigRecovery({ args, commandInfo, errorText: safeErrorText });
+    const localhostNavigationHint = getLocalhostNavigationHint(commandInfo, safeErrorText);
+    const clipboardPermissionHint = getClipboardPermissionHint(commandInfo, safeErrorText);
+    const keyboardPressHint = getKeyboardPressHint(commandInfo, safeErrorText);
+    const hintedErrorParts = [
+        selectorHintedErrorText,
+        unknownCommandSuggestionText && !selectorHintedErrorText.includes("Agent-browser hint:") ? unknownCommandSuggestionText : undefined,
+        browserProfileConfigRecovery?.hint,
+        localhostNavigationHint,
+        clipboardPermissionHint,
+        keyboardPressHint,
+    ].filter((part) => Boolean(part));
+    const hintedErrorText = hintedErrorParts.join("\n\n");
+    const categoryDetails = buildAgentBrowserResultCategoryDetails({
+        args: [commandInfo.command, commandInfo.subcommand].filter((item) => item !== undefined),
+        command: commandInfo.command,
+        errorText: hintedErrorText,
+        succeeded: false,
+    });
+    const nextActions = [
+        ...(buildUnknownCommandSuggestionActions(unknownCommandSuggestions, sessionName) ?? []),
+        ...(browserProfileConfigRecovery?.actions ?? []),
+        ...(buildAgentBrowserNextActions({
+            args,
+            command: commandInfo.command,
+            failureCategory: categoryDetails.failureCategory,
+            resultCategory: "failure",
+        }) ?? []),
+    ];
+    return {
+        ...categoryDetails,
+        content: [{ type: "text", text: hintedErrorText }],
+        nextActions: nextActions.length > 0 ? nextActions : undefined,
+        summary: hintedErrorText,
+    };
+}

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

@@ -0,0 +1,134 @@
+/**
+ * Purpose: Compact oversized model-facing tool output into bounded previews and spill artifacts.
+ * Responsibilities: Write full output to persistent/session temp storage, update artifact manifests, and preserve safe previews.
+ * Scope: Large-output compaction only.
+ */
+import { writePersistentSessionArtifactFile, writeSecureTempFile, } from "../../temp.js";
+import { buildEvictedSessionArtifactEntries } from "../artifact-manifest.js";
+import { countLines, truncateText } from "../text.js";
+import { applyArtifactManifest } from "./artifacts.js";
+import { getPresentationText } from "./content.js";
+import { redactModelFacingText, stringifyModelFacing } from "./common.js";
+const LARGE_OUTPUT_INLINE_MAX_CHARS = 8_000;
+const LARGE_OUTPUT_INLINE_MAX_LINES = 120;
+const LARGE_OUTPUT_PREVIEW_MAX_CHARS = 2_500;
+const LARGE_OUTPUT_PREVIEW_MAX_LINES = 40;
+const LARGE_OUTPUT_FILE_PREFIX = "pi-agent-browser-output";
+function shouldCompactLargeOutput(text) {
+    return text.length > LARGE_OUTPUT_INLINE_MAX_CHARS || countLines(text) > LARGE_OUTPUT_INLINE_MAX_LINES;
+}
+function buildLargeOutputPreview(text) {
+    const lines = text.split("\n");
+    const previewLines = [];
+    let previewChars = 0;
+    for (const line of lines) {
+        if (previewLines.length >= LARGE_OUTPUT_PREVIEW_MAX_LINES || previewChars >= LARGE_OUTPUT_PREVIEW_MAX_CHARS) {
+            break;
+        }
+        const remainingChars = LARGE_OUTPUT_PREVIEW_MAX_CHARS - previewChars;
+        const previewLine = truncateText(line, Math.max(40, remainingChars));
+        previewLines.push(previewLine);
+        previewChars += previewLine.length + 1;
+    }
+    return {
+        omittedLineCount: Math.max(0, lines.length - previewLines.length),
+        previewText: previewLines.join("\n"),
+    };
+}
+async function writeLargeOutputSpillFile(options) {
+    const payload = typeof options.data === "string"
+        ? redactModelFacingText(options.data)
+        : typeof options.data === "number" || typeof options.data === "boolean"
+            ? String(options.data)
+            : options.data === undefined
+                ? redactModelFacingText(options.text)
+                : stringifyModelFacing(options.data);
+    const isStructuredPayload = typeof options.data !== "string" && typeof options.data !== "number" && typeof options.data !== "boolean";
+    const fileOptions = {
+        content: payload,
+        prefix: LARGE_OUTPUT_FILE_PREFIX,
+        suffix: isStructuredPayload ? ".json" : ".txt",
+    };
+    if (options.persistentArtifactStore) {
+        const result = await writePersistentSessionArtifactFile({ ...fileOptions, store: options.persistentArtifactStore });
+        return { ...result, storageScope: "persistent-session" };
+    }
+    return { evictedArtifacts: [], path: await writeSecureTempFile(fileOptions), storageScope: "process-temp" };
+}
+function buildSpillArtifactEntries(options) {
+    const nowMs = Date.now();
+    return [
+        {
+            command: options.commandInfo.command,
+            createdAtMs: nowMs,
+            kind: "spill",
+            path: options.path,
+            retentionState: options.storageScope === "persistent-session" ? "live" : "ephemeral",
+            storageScope: options.storageScope,
+            subcommand: options.commandInfo.subcommand,
+        },
+        ...buildEvictedSessionArtifactEntries(options.evictedArtifacts, nowMs),
+    ];
+}
+export async function compactLargePresentationOutput(options) {
+    const text = getPresentationText(options.presentation);
+    if (text.length === 0 || !shouldCompactLargeOutput(text)) {
+        return options.presentation;
+    }
+    let fullOutputPath;
+    let spill;
+    let spillErrorText;
+    try {
+        spill = await writeLargeOutputSpillFile({
+            data: options.data,
+            persistentArtifactStore: options.persistentArtifactStore,
+            text,
+        });
+        fullOutputPath = spill.path;
+    }
+    catch (error) {
+        spillErrorText = error instanceof Error ? error.message : String(error);
+    }
+    const { omittedLineCount, previewText } = buildLargeOutputPreview(text);
+    const commandLabel = options.commandInfo.command ?? "agent-browser";
+    const lines = [
+        `Large ${commandLabel} output compacted.`,
+        "",
+        "Preview:",
+        previewText,
+    ];
+    if (omittedLineCount > 0) {
+        lines.push(`- ... (${omittedLineCount} additional lines omitted)`);
+    }
+    lines.push("", fullOutputPath
+        ? `Full output path: ${fullOutputPath}`
+        : `Full output unavailable: ${spillErrorText ?? "spill file could not be created."}`);
+    const firstTextIndex = options.presentation.content.findIndex((part) => part.type === "text");
+    const compactedText = lines.join("\n");
+    if (firstTextIndex >= 0) {
+        options.presentation.content[firstTextIndex] = { type: "text", text: compactedText };
+    }
+    else {
+        options.presentation.content.unshift({ type: "text", text: compactedText });
+    }
+    options.presentation.data = {
+        compacted: true,
+        fullOutputPath,
+        outputCharCount: text.length,
+        outputLineCount: countLines(text),
+        previewCharCount: previewText.length,
+        previewLineCount: countLines(previewText),
+        spillError: spillErrorText,
+    };
+    options.presentation.fullOutputPath = fullOutputPath;
+    options.presentation.summary = `${options.presentation.summary} (compact)`;
+    if (fullOutputPath && spill) {
+        return applyArtifactManifest(options.presentation, options.presentation.artifactManifest ?? options.artifactManifest, buildSpillArtifactEntries({
+            commandInfo: options.commandInfo,
+            evictedArtifacts: spill.evictedArtifacts,
+            path: fullOutputPath,
+            storageScope: spill.storageScope,
+        }));
+    }
+    return options.presentation;
+}

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

@@ -0,0 +1,159 @@
+/**
+ * Purpose: Format scalar extraction results, navigation summaries, and page-change summaries.
+ * Responsibilities: Keep navigation/extraction presentation separate from core tool result orchestration.
+ * Scope: Navigation and get/eval extraction formatting only.
+ */
+import { isNavigationObservableCommandName, isPageChangeSummaryCommand } from "../../command-taxonomy.js";
+import { isRecord } from "../../parsing.js";
+import { detectConfirmationRequired } from "../confirmation.js";
+import { redactModelFacingText, stringifyModelFacing } from "./common.js";
+const NAVIGATION_SUMMARY_FIELD = "navigationSummary";
+function getScalarExtractionResult(data) {
+    const { result } = data;
+    if (typeof result === "string") {
+        return result.trim().length > 0 ? result : undefined;
+    }
+    if (typeof result === "number" || typeof result === "boolean") {
+        return String(result);
+    }
+    return undefined;
+}
+function getExtractionOrigin(data) {
+    if (typeof data.origin === "string" && data.origin.trim().length > 0) {
+        return data.origin.trim();
+    }
+    if (typeof data.url === "string" && data.url.trim().length > 0) {
+        return data.url.trim();
+    }
+    return undefined;
+}
+function formatGetSummaryLabel(subcommand) {
+    if (!subcommand) {
+        return "Get result";
+    }
+    if (subcommand.toLowerCase() === "url") {
+        return "URL";
+    }
+    return `${subcommand.slice(0, 1).toUpperCase()}${subcommand.slice(1)}`;
+}
+export function formatExtractionSummary(commandInfo, data) {
+    const scalarResult = getScalarExtractionResult(data);
+    if (!scalarResult) {
+        return undefined;
+    }
+    const safeScalarResult = redactModelFacingText(scalarResult);
+    const firstResultLine = safeScalarResult.split("\n", 1)[0] ?? safeScalarResult;
+    if (commandInfo.command === "get") {
+        return `${formatGetSummaryLabel(commandInfo.subcommand)}: ${firstResultLine}`;
+    }
+    if (commandInfo.command === "eval") {
+        return `Eval result: ${firstResultLine}`;
+    }
+    return undefined;
+}
+export function formatExtractionText(commandInfo, data) {
+    if (commandInfo.command !== "get" && commandInfo.command !== "eval") {
+        return undefined;
+    }
+    const scalarResult = getScalarExtractionResult(data);
+    if (!scalarResult) {
+        return undefined;
+    }
+    const origin = getExtractionOrigin(data);
+    const safeScalarResult = redactModelFacingText(scalarResult);
+    const safeOrigin = origin ? redactModelFacingText(origin) : undefined;
+    return safeOrigin && safeOrigin !== safeScalarResult ? `${safeScalarResult}\n\nOrigin: ${safeOrigin}` : safeScalarResult;
+}
+export function isNavigationObservableCommand(command) {
+    return isNavigationObservableCommandName(command);
+}
+function isNavigationSummary(value) {
+    return isRecord(value) && (typeof value.title === "string" || typeof value.url === "string");
+}
+export function getNavigationSummary(data) {
+    const candidate = data[NAVIGATION_SUMMARY_FIELD];
+    return isNavigationSummary(candidate) ? candidate : undefined;
+}
+function getTopLevelNavigationSummary(data) {
+    return isNavigationSummary(data)
+        ? {
+            title: typeof data.title === "string" ? data.title : undefined,
+            url: typeof data.url === "string" ? data.url : undefined,
+        }
+        : undefined;
+}
+function getNormalizedNavigationSummary(summary) {
+    const title = typeof summary?.title === "string" && summary.title.trim().length > 0 ? summary.title.trim() : undefined;
+    const url = typeof summary?.url === "string" && summary.url.trim().length > 0 ? summary.url.trim() : undefined;
+    return title || url ? { title, url } : undefined;
+}
+export function formatNavigationSummary(summary) {
+    const normalized = getNormalizedNavigationSummary(summary);
+    if (!normalized)
+        return undefined;
+    if (normalized.title && normalized.url)
+        return `${normalized.title}\n${normalized.url}`;
+    return normalized.title ?? normalized.url;
+}
+export function buildPageChangeSummary(options) {
+    const { artifacts, commandInfo, data, nextActions, savedFilePath } = options;
+    const artifactCount = artifacts?.length ?? 0;
+    const navigation = isRecord(data)
+        ? getNormalizedNavigationSummary(getNavigationSummary(data) ?? (isPageChangeSummaryCommand(commandInfo.command) ? getTopLevelNavigationSummary(data) : undefined))
+        : undefined;
+    const confirmationRequired = detectConfirmationRequired(data) !== undefined;
+    if (!navigation && !confirmationRequired && artifactCount === 0 && !savedFilePath && !isPageChangeSummaryCommand(commandInfo.command)) {
+        return undefined;
+    }
+    const changeType = savedFilePath || artifactCount > 0
+        ? "artifact"
+        : navigation
+            ? "navigation"
+            : confirmationRequired
+                ? "confirmation"
+                : "mutation";
+    const parts = [commandInfo.command ?? "agent-browser", changeType];
+    if (navigation?.title)
+        parts.push(navigation.title);
+    if (navigation?.url)
+        parts.push(navigation.url);
+    if (savedFilePath)
+        parts.push(savedFilePath);
+    else if (artifactCount > 0)
+        parts.push(`${artifactCount} artifact${artifactCount === 1 ? "" : "s"}`);
+    return {
+        ...(artifactCount > 0 ? { artifactCount } : {}),
+        changeType,
+        ...(commandInfo.command ? { command: commandInfo.command } : {}),
+        ...(nextActions ? { nextActionIds: nextActions.map((action) => action.id) } : {}),
+        ...(savedFilePath ? { savedFilePath } : {}),
+        summary: parts.join(" → "),
+        ...(navigation?.title ? { title: navigation.title } : {}),
+        ...(navigation?.url ? { url: navigation.url } : {}),
+    };
+}
+function stripNavigationSummary(data) {
+    const { [NAVIGATION_SUMMARY_FIELD]: _navigationSummary, ...rest } = data;
+    return rest;
+}
+export function formatNavigationActionResult(data) {
+    const actionData = stripNavigationSummary(data);
+    const lines = [];
+    if (typeof actionData.clicked === "string" || typeof actionData.clicked === "boolean") {
+        lines.push(`Clicked: ${String(actionData.clicked)}`);
+    }
+    if (typeof actionData.href === "string") {
+        lines.push(`Href: ${redactModelFacingText(actionData.href)}`);
+    }
+    if (typeof actionData.navigated === "boolean") {
+        lines.push(`Navigated: ${actionData.navigated}`);
+    }
+    if (lines.length > 0) {
+        return lines.join("\n");
+    }
+    const actionText = stringifyModelFacing(actionData).trim();
+    if (actionText.length === 0 || actionText === "{}") {
+        return undefined;
+    }
+    return actionText;
+}