pi-agent-browser-native 0.2.48 → 0.2.49

package/dist/extensions/agent-browser/lib/orchestration/input-plan.js

@@ -0,0 +1,247 @@
+import { parseArgvDescriptor } from "../argv-descriptor.js";
+import { validateToolArgs, redactInvocationArgs, redactSensitiveText } from "../runtime.js";
+import { buildAgentBrowserResultCategoryDetails } from "../results/categories.js";
+import { compileAgentBrowserElectron, compileAgentBrowserJob, compileAgentBrowserNetworkSourceLookup, compileAgentBrowserQaPreset, compileAgentBrowserSemanticAction, compileAgentBrowserSourceLookup, redactNetworkSourceLookupArgs, redactNetworkSourceLookupUrl, } from "../input-modes.js";
+function redactCompiledElectron(compiled) {
+    if (!compiled)
+        return undefined;
+    if (compiled.action === "list") {
+        return { ...compiled, query: compiled.query ? redactSensitiveText(compiled.query) : undefined };
+    }
+    if (compiled.action === "launch") {
+        return { ...compiled, appArgs: compiled.appArgs ? redactInvocationArgs(compiled.appArgs) : undefined };
+    }
+    return { ...compiled };
+}
+function redactCompiledJob(compiled) {
+    const redactedSteps = compiled?.steps.map((step) => ({ ...step, args: redactInvocationArgs(step.args) }));
+    return compiled && redactedSteps
+        ? { ...compiled, stdin: JSON.stringify(redactedSteps.map((step) => step.args)), steps: redactedSteps }
+        : undefined;
+}
+function redactCompiledSourceLookup(compiled) {
+    const redactedSteps = compiled?.steps.map((step) => ({ ...step, args: redactInvocationArgs(step.args) }));
+    return compiled && redactedSteps
+        ? { ...compiled, stdin: JSON.stringify(redactedSteps.map((step) => step.args)), steps: redactedSteps }
+        : undefined;
+}
+function redactCompiledNetworkSourceLookup(compiled) {
+    const redactedSteps = compiled?.steps.map((step) => ({ ...step, args: redactNetworkSourceLookupArgs(step.args) }));
+    return compiled && redactedSteps
+        ? {
+            ...compiled,
+            args: redactNetworkSourceLookupArgs(compiled.args),
+            query: {
+                ...compiled.query,
+                filter: redactNetworkSourceLookupUrl(compiled.query.filter),
+                url: redactNetworkSourceLookupUrl(compiled.query.url),
+            },
+            stdin: JSON.stringify(redactedSteps.map((step) => step.args)),
+            steps: redactedSteps,
+        }
+        : undefined;
+}
+function normalizeExplicitEvalStdinArgs(args, stdin) {
+    if (stdin !== undefined) {
+        return { args, stdin };
+    }
+    const descriptor = parseArgvDescriptor(args);
+    if (descriptor.commandInfo.command !== "eval") {
+        return { args, stdin };
+    }
+    const stdinIndex = descriptor.commandTokens.indexOf("--stdin");
+    if (stdinIndex < 0 || stdinIndex >= descriptor.commandTokens.length - 1) {
+        return { args, stdin };
+    }
+    const commandStartIndex = args.length - descriptor.commandTokens.length;
+    const stdinValue = descriptor.commandTokens.slice(stdinIndex + 1).join(" ");
+    return {
+        args: [...args.slice(0, commandStartIndex), ...descriptor.commandTokens.slice(0, stdinIndex + 1)],
+        stdin: stdinValue,
+    };
+}
+export function resolveAgentBrowserInput(options) {
+    const { getBatchPreflightValidationError, managedSessionActive, params } = options;
+    const semanticActionResult = params.semanticAction === undefined ? {} : compileAgentBrowserSemanticAction(params.semanticAction);
+    const jobResult = params.job === undefined ? {} : compileAgentBrowserJob(params.job);
+    const qaResult = params.qa === undefined ? {} : compileAgentBrowserQaPreset(params.qa);
+    const sourceLookupResult = params.sourceLookup === undefined ? {} : compileAgentBrowserSourceLookup(params.sourceLookup);
+    const networkSourceLookupResult = params.networkSourceLookup === undefined ? {} : compileAgentBrowserNetworkSourceLookup(params.networkSourceLookup);
+    const electronResult = params.electron === undefined ? {} : compileAgentBrowserElectron(params.electron);
+    const hasExplicitArgs = Array.isArray(params.args);
+    const explicitInputModes = [
+        hasExplicitArgs,
+        Boolean(semanticActionResult.compiled),
+        Boolean(jobResult.compiled),
+        Boolean(qaResult.compiled),
+        Boolean(sourceLookupResult.compiled),
+        Boolean(networkSourceLookupResult.compiled),
+        Boolean(electronResult.compiled),
+    ].filter(Boolean).length;
+    const inputModeError = explicitInputModes !== 1
+        ? "Provide exactly one of args, semanticAction, job, qa, sourceLookup, networkSourceLookup, or electron."
+        : undefined;
+    const compiledSemanticAction = semanticActionResult.compiled;
+    const compiledQaPreset = qaResult.compiled;
+    const compiledSourceLookup = sourceLookupResult.compiled;
+    const compiledNetworkSourceLookup = networkSourceLookupResult.compiled;
+    const compiledElectron = electronResult.compiled;
+    const compiledJob = jobResult.compiled ?? compiledQaPreset;
+    const compiledGeneratedBatch = compiledNetworkSourceLookup ?? compiledSourceLookup ?? compiledJob;
+    const normalizedExplicitArgs = normalizeExplicitEvalStdinArgs(params.args ?? [], params.stdin);
+    const toolArgs = compiledElectron ? [] : compiledSemanticAction?.args ?? compiledGeneratedBatch?.args ?? normalizedExplicitArgs.args;
+    const toolStdin = compiledGeneratedBatch?.stdin ?? normalizedExplicitArgs.stdin;
+    const redactedArgs = redactInvocationArgs(toolArgs);
+    const generatedStdinError = params.stdin !== undefined
+        ? compiledGeneratedBatch
+            ? "Do not provide stdin with job, qa, sourceLookup, or networkSourceLookup; those modes generate their own batch stdin."
+            : compiledElectron
+                ? "Do not provide stdin with electron; electron mode is host-only or manages its own input."
+                : undefined
+        : undefined;
+    const outputPathError = params.outputPath !== undefined && (typeof params.outputPath !== "string" || params.outputPath.trim().length === 0)
+        ? "outputPath must be a non-empty string when provided."
+        : undefined;
+    const timeoutMsError = params.timeoutMs !== undefined && (typeof params.timeoutMs !== "number" || !Number.isSafeInteger(params.timeoutMs) || params.timeoutMs <= 0)
+        ? "timeoutMs must be a positive integer when provided."
+        : compiledElectron && params.timeoutMs !== undefined
+            ? "Use electron.timeoutMs for electron actions; top-level timeoutMs applies only to browser CLI subprocess calls."
+            : undefined;
+    const attachedQaSessionError = compiledQaPreset?.checks.attached
+        ? params.sessionMode === "fresh"
+            ? "qa.attached cannot be used with sessionMode=fresh; attach or launch a session first, then run qa.attached with the current session."
+            : !managedSessionActive
+                ? "qa.attached requires an active attached session. Run electron.launch or connect to an Electron debug port first."
+                : undefined
+        : undefined;
+    const validationError = semanticActionResult.error
+        ?? jobResult.error
+        ?? qaResult.error
+        ?? sourceLookupResult.error
+        ?? networkSourceLookupResult.error
+        ?? electronResult.error
+        ?? inputModeError
+        ?? generatedStdinError
+        ?? outputPathError
+        ?? timeoutMsError
+        ?? attachedQaSessionError
+        ?? (compiledElectron ? undefined : validateToolArgs(toolArgs) ?? getBatchPreflightValidationError(toolArgs, toolStdin));
+    const redactedCompiledJob = redactCompiledJob(compiledJob);
+    const redactedCompiledSemanticAction = compiledSemanticAction
+        ? { ...compiledSemanticAction, args: redactInvocationArgs(compiledSemanticAction.args) }
+        : undefined;
+    const attemptedKind = compiledElectron
+        ? "electron"
+        : compiledNetworkSourceLookup
+            ? "networkSourceLookup"
+            : compiledSourceLookup
+                ? "sourceLookup"
+                : compiledQaPreset
+                    ? "qa"
+                    : jobResult.compiled
+                        ? "job"
+                        : compiledSemanticAction
+                            ? "semanticAction"
+                            : hasExplicitArgs
+                                ? "args"
+                                : undefined;
+    const redactedCompiledElectron = redactCompiledElectron(compiledElectron);
+    const redactedCompiledNetworkSourceLookup = redactCompiledNetworkSourceLookup(compiledNetworkSourceLookup);
+    const redactedCompiledQaPreset = compiledQaPreset && redactedCompiledJob ? { ...redactedCompiledJob, checks: compiledQaPreset.checks } : undefined;
+    const redactedCompiledSourceLookup = redactCompiledSourceLookup(compiledSourceLookup);
+    const resolvedBase = { redactedArgs, toolArgs, toolStdin };
+    if (validationError) {
+        return {
+            ...resolvedBase,
+            attemptedKind,
+            compiledElectron,
+            compiledGeneratedBatch,
+            compiledJob,
+            compiledNetworkSourceLookup,
+            compiledQaPreset,
+            compiledSemanticAction,
+            compiledSourceLookup,
+            kind: "invalid",
+            redactedCompiledElectron,
+            redactedCompiledJob,
+            redactedCompiledNetworkSourceLookup,
+            redactedCompiledQaPreset,
+            redactedCompiledSemanticAction,
+            redactedCompiledSourceLookup,
+            status: "invalid",
+            validationError,
+        };
+    }
+    if (compiledElectron && redactedCompiledElectron) {
+        return { ...resolvedBase, compiledElectron, kind: "electron", redactedCompiledElectron, status: "valid" };
+    }
+    if (compiledNetworkSourceLookup && redactedCompiledNetworkSourceLookup) {
+        return {
+            ...resolvedBase,
+            compiledGeneratedBatch: compiledNetworkSourceLookup,
+            compiledNetworkSourceLookup,
+            kind: "networkSourceLookup",
+            redactedCompiledNetworkSourceLookup,
+            status: "valid",
+        };
+    }
+    if (compiledSourceLookup && redactedCompiledSourceLookup) {
+        return {
+            ...resolvedBase,
+            compiledGeneratedBatch: compiledSourceLookup,
+            compiledSourceLookup,
+            kind: "sourceLookup",
+            redactedCompiledSourceLookup,
+            status: "valid",
+        };
+    }
+    if (compiledQaPreset && redactedCompiledJob && redactedCompiledQaPreset) {
+        return {
+            ...resolvedBase,
+            compiledGeneratedBatch: compiledQaPreset,
+            compiledJob: compiledQaPreset,
+            compiledQaPreset,
+            kind: "qa",
+            redactedCompiledJob,
+            redactedCompiledQaPreset,
+            status: "valid",
+        };
+    }
+    if (jobResult.compiled && redactedCompiledJob) {
+        return {
+            ...resolvedBase,
+            compiledGeneratedBatch: jobResult.compiled,
+            compiledJob: jobResult.compiled,
+            kind: "job",
+            redactedCompiledJob,
+            status: "valid",
+        };
+    }
+    if (compiledSemanticAction && redactedCompiledSemanticAction) {
+        return { ...resolvedBase, compiledSemanticAction, kind: "semanticAction", redactedCompiledSemanticAction, status: "valid" };
+    }
+    return { ...resolvedBase, kind: "args", status: "valid" };
+}
+export function buildValidationFailureResult(input) {
+    const validationError = input.validationError ?? "Invalid agent_browser input.";
+    return {
+        content: [{ type: "text", text: validationError }],
+        details: {
+            args: input.redactedArgs,
+            compiledElectron: input.redactedCompiledElectron,
+            compiledJob: input.redactedCompiledJob,
+            compiledQaPreset: input.redactedCompiledQaPreset,
+            compiledSourceLookup: input.redactedCompiledSourceLookup,
+            compiledNetworkSourceLookup: input.redactedCompiledNetworkSourceLookup,
+            compiledSemanticAction: input.redactedCompiledSemanticAction,
+            ...buildAgentBrowserResultCategoryDetails({
+                args: input.redactedArgs,
+                errorText: validationError,
+                succeeded: false,
+                validationError,
+            }),
+            validationError,
+        },
+        isError: true,
+    };
+}

package/dist/extensions/agent-browser/lib/orchestration/output-file.js

@@ -0,0 +1,68 @@
+import { mkdir, writeFile } from "node:fs/promises";
+import { dirname, isAbsolute, resolve } from "node:path";
+import { isRecord } from "../parsing.js";
+function normalizeRequestedOutputPath(path) {
+    return path.startsWith("@") ? path.slice(1) : path;
+}
+function getTextContent(result) {
+    return result.content
+        ?.filter((item) => item.type === "text")
+        .map((item) => item.text)
+        .join("\n\n") ?? "";
+}
+function getOutputPayload(result) {
+    const details = isRecord(result.details) ? result.details : undefined;
+    if (details && details.data !== undefined)
+        return { source: "details.data", value: details.data };
+    return { source: "content.text", value: getTextContent(result) };
+}
+function serializeOutputPayload(value) {
+    return typeof value === "string" ? value : `${JSON.stringify(value, null, 2)}\n`;
+}
+function appendOutputFileNotice(result, message) {
+    const content = [...(result.content ?? [])];
+    if (content[0]?.type === "text") {
+        content[0] = { ...content[0], text: `${content[0].text}\n\n${message}` };
+        return content;
+    }
+    return [{ type: "text", text: message }, ...content];
+}
+export async function applyAgentBrowserOutputPath(options) {
+    if (!options.outputPath)
+        return options.result;
+    if (options.result.isError || (isRecord(options.result.details) && options.result.details.resultCategory === "failure"))
+        return options.result;
+    const requestedPath = normalizeRequestedOutputPath(options.outputPath);
+    const absolutePath = isAbsolute(requestedPath) ? requestedPath : resolve(options.cwd, requestedPath);
+    const payload = getOutputPayload(options.result);
+    try {
+        const serialized = serializeOutputPayload(payload.value);
+        await mkdir(dirname(absolutePath), { recursive: true });
+        await writeFile(absolutePath, serialized, "utf8");
+        const bytes = Buffer.byteLength(serialized, "utf8");
+        const outputFile = { absolutePath, bytes, path: requestedPath, source: payload.source, status: "saved" };
+        const details = isRecord(options.result.details) ? { ...options.result.details, outputFile } : { outputFile };
+        return {
+            ...options.result,
+            content: options.preserveTextContent ? options.result.content : appendOutputFileNotice(options.result, `Output file: ${requestedPath} (${bytes} bytes from ${payload.source}).`),
+            details,
+        };
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        const outputFile = { absolutePath, error: message, path: requestedPath, source: payload.source, status: "failed" };
+        const details = isRecord(options.result.details)
+            ? (() => {
+                const rest = { ...options.result.details };
+                delete rest.successCategory;
+                return { ...rest, failureCategory: rest.failureCategory ?? "upstream-error", outputFile, resultCategory: "failure" };
+            })()
+            : { failureCategory: "upstream-error", outputFile, resultCategory: "failure" };
+        return {
+            ...options.result,
+            content: options.preserveTextContent ? options.result.content : appendOutputFileNotice(options.result, `Output file failed: ${requestedPath} (${message}).`),
+            details,
+            isError: true,
+        };
+    }
+}

package/{extensions/agent-browser/lib/parsing.ts → dist/extensions/agent-browser/lib/parsing.js}

@@ -5,16 +5,17 @@
  * Usage: Imported by agent-browser wrapper modules that parse untyped JSON, persisted state, or environment variables.
  * Invariants/Assumptions: Arrays intentionally count as records to preserve existing object-boundary semantics, and positive integers must be safe base-10 integer strings greater than zero.
  */
-
-export function isRecord(value: unknown): value is Record<string, unknown> {
-	return typeof value === "object" && value !== null;
+export function isRecord(value) {
+    return typeof value === "object" && value !== null;
 }
-
-export function parsePositiveInteger(rawValue: string | undefined): number | undefined {
-	if (typeof rawValue !== "string") return undefined;
-	const normalizedValue = rawValue.trim();
-	if (!/^\d+$/.test(normalizedValue)) return undefined;
-	const parsedValue = Number(normalizedValue);
-	if (!Number.isSafeInteger(parsedValue) || parsedValue <= 0) return undefined;
-	return parsedValue;
+export function parsePositiveInteger(rawValue) {
+    if (typeof rawValue !== "string")
+        return undefined;
+    const normalizedValue = rawValue.trim();
+    if (!/^\d+$/.test(normalizedValue))
+        return undefined;
+    const parsedValue = Number(normalizedValue);
+    if (!Number.isSafeInteger(parsedValue) || parsedValue <= 0)
+        return undefined;
+    return parsedValue;
 }

package/dist/extensions/agent-browser/lib/pi-tool-rendering.js

@@ -0,0 +1,241 @@
+import { getKeybindings, Text, truncateToWidth } from "@earendil-works/pi-tui";
+import { compileAgentBrowserElectron, compileAgentBrowserJob, compileAgentBrowserNetworkSourceLookup, compileAgentBrowserQaPreset, compileAgentBrowserSemanticAction, compileAgentBrowserSourceLookup, } from "./input-modes.js";
+import { isRecord } from "./parsing.js";
+import { redactInvocationArgs } from "./runtime.js";
+const TUI_INVOCATION_PREVIEW_MAX_CHARS = 160;
+const TUI_COLLAPSED_OUTPUT_MAX_LINES = 12;
+const ANSI_CONTROL_SEQUENCE_PATTERN = /\x1B(?:\][^\x07\x1B]*(?:\x07|\x1B\\)|\[[0-?]*[ -/]*[@-~]|P[^\x1B]*(?:\x1B\\)|_[^\x1B]*(?:\x1B\\)|\^[^\x1B]*(?:\x1B\\)|[@-Z\\-_])/g;
+const JSON_TOKEN_PATTERN = /"(?:\\.|[^"\\])*"(?=\s*:)|"(?:\\.|[^"\\])*"|-?\d+(?:\.\d+)?(?:[eE][+-]?\d+)?|true|false|null|[{}\[\],:]/g;
+const UNSAFE_DISPLAY_CONTROL_PATTERN = /[\x00-\x08\x0B\x0C\x0E-\x1F\x7F\x80-\x9F]/g;
+function sanitizeDisplayText(value) {
+    return value
+        .replace(ANSI_CONTROL_SEQUENCE_PATTERN, "")
+        .replace(/\r/g, "")
+        .replace(UNSAFE_DISPLAY_CONTROL_PATTERN, "�");
+}
+function replaceTabsForDisplay(value) {
+    return value.replaceAll("\t", "    ");
+}
+function trimTrailingBlankLines(lines) {
+    let end = lines.length;
+    while (end > 0 && lines[end - 1].trim().length === 0) {
+        end -= 1;
+    }
+    return lines.slice(0, end);
+}
+function isJsonDocumentText(value) {
+    const trimmed = value.trim();
+    if (!trimmed.startsWith("{") && !trimmed.startsWith("["))
+        return false;
+    try {
+        JSON.parse(trimmed);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+function colorizeJsonLine(line, theme) {
+    let output = "";
+    let cursor = 0;
+    for (const match of line.matchAll(JSON_TOKEN_PATTERN)) {
+        const token = match[0];
+        const index = match.index ?? 0;
+        output += line.slice(cursor, index);
+        const color = token.startsWith('"')
+            ? /"\s*$/.test(token) && line.slice(index + token.length).trimStart().startsWith(":")
+                ? "syntaxVariable"
+                : "syntaxString"
+            : /^[{}\[\],:]$/.test(token)
+                ? "syntaxPunctuation"
+                : "syntaxType";
+        output += theme.fg(color, token);
+        cursor = index + token.length;
+    }
+    return output + line.slice(cursor);
+}
+function getPrimaryTextContent(result) {
+    const textContent = result.content.find((item) => item.type === "text");
+    return textContent?.type === "text" ? textContent.text : "";
+}
+function colorizeToolOutputLines(outputText, theme, isError) {
+    const normalizedLines = trimTrailingBlankLines(replaceTabsForDisplay(sanitizeDisplayText(outputText)).split("\n"));
+    const normalizedText = normalizedLines.join("\n");
+    if (normalizedText.length === 0)
+        return [];
+    const isJsonDocument = !isError && isJsonDocumentText(normalizedText);
+    return normalizedLines.map((line) => {
+        if (line.length === 0) {
+            return "";
+        }
+        if (isJsonDocument)
+            return colorizeJsonLine(line, theme);
+        return isError ? theme.fg("error", line) : theme.fg("toolOutput", line);
+    });
+}
+function formatExpandHint(theme) {
+    try {
+        const [key] = getKeybindings().getKeys("app.tools.expand");
+        if (key)
+            return `${theme.fg("dim", key)} ${theme.fg("muted", "to expand")}`;
+    }
+    catch {
+        // Fall through to the built-in default key when coding-agent keybindings are unavailable.
+    }
+    return `${theme.fg("dim", "ctrl+o")} ${theme.fg("muted", "to expand")}`;
+}
+function formatVisualTruncationNotice(remainingLines, totalLines, theme, width) {
+    const notice = `${theme.fg("muted", `... (${remainingLines} more lines, ${totalLines} total, `)}${formatExpandHint(theme)}${theme.fg("muted", ")")}`;
+    return truncateToWidth(notice, Math.max(0, width));
+}
+function getStructuredModeInvocation(input) {
+    if (Array.isArray(input.args))
+        return { rawArgs: input.args.filter((value) => typeof value === "string") };
+    if (input.semanticAction !== undefined)
+        return { mode: "semanticAction", rawArgs: compileAgentBrowserSemanticAction(input.semanticAction).compiled?.args ?? [] };
+    if (input.job !== undefined)
+        return { mode: "job", rawArgs: compileAgentBrowserJob(input.job).compiled?.args ?? [] };
+    if (input.qa !== undefined)
+        return { mode: "qa", rawArgs: compileAgentBrowserQaPreset(input.qa).compiled?.args ?? [] };
+    if (input.sourceLookup !== undefined)
+        return { mode: "sourceLookup", rawArgs: compileAgentBrowserSourceLookup(input.sourceLookup).compiled?.args ?? [] };
+    if (input.networkSourceLookup !== undefined)
+        return { mode: "networkSourceLookup", rawArgs: compileAgentBrowserNetworkSourceLookup(input.networkSourceLookup).compiled?.args ?? [] };
+    if (input.electron !== undefined) {
+        const electron = compileAgentBrowserElectron(input.electron);
+        return { mode: "electron", rawArgs: electron.compiled ? ["electron", electron.compiled.action] : [] };
+    }
+    return { rawArgs: [] };
+}
+function formatInvocationPreview(rawArgs) {
+    const redactedArgs = redactInvocationArgs(rawArgs);
+    const invocation = sanitizeDisplayText(redactedArgs.join(" ")).replace(/\s+/g, " ").trim();
+    return invocation.length > TUI_INVOCATION_PREVIEW_MAX_CHARS
+        ? `${invocation.slice(0, TUI_INVOCATION_PREVIEW_MAX_CHARS - 3)}...`
+        : invocation;
+}
+export function formatAgentBrowserRenderCall(args, theme) {
+    const input = isRecord(args) ? args : {};
+    const { mode, rawArgs } = getStructuredModeInvocation(input);
+    const invocationPreview = formatInvocationPreview(rawArgs);
+    let text = theme.fg("toolTitle", theme.bold("agent_browser"));
+    if (mode) {
+        text += ` ${theme.fg("accent", mode)}`;
+        if (invocationPreview.length > 0) {
+            text += ` ${theme.fg("dim", "→")} ${theme.fg("accent", invocationPreview)}`;
+        }
+    }
+    else if (invocationPreview.length > 0) {
+        text += ` ${theme.fg("accent", invocationPreview)}`;
+    }
+    if (input.sessionMode === "fresh") {
+        text += theme.fg("dim", " sessionMode=fresh");
+    }
+    if (typeof input.stdin === "string") {
+        text += theme.fg("dim", " + stdin");
+    }
+    return text;
+}
+export function formatAgentBrowserRenderResult(result, options, theme, isError) {
+    if (options.isPartial) {
+        return theme.fg("warning", "Running agent-browser...");
+    }
+    const outputText = getPrimaryTextContent(result);
+    const failureCategoryNotice = formatModelVisibleFailureCategoryNotice(result.details);
+    const outputLines = colorizeToolOutputLines(outputText, theme, isError);
+    if (failureCategoryNotice && outputLines.length > 0) {
+        outputLines.unshift(theme.fg("error", failureCategoryNotice), "");
+    }
+    if (outputLines.length === 0) {
+        const details = isRecord(result.details) ? result.details : undefined;
+        const rawSummary = typeof details?.summary === "string" ? details.summary : isError ? "agent-browser failed" : "Done";
+        const sanitizedSummary = sanitizeDisplayText(rawSummary).trim();
+        const summary = sanitizedSummary.length > 0 ? sanitizedSummary : isError ? "agent-browser failed" : "Done";
+        return isError ? theme.fg("error", summary) : theme.fg("success", summary);
+    }
+    return `\n${outputLines.join("\n")}`;
+}
+function formatModelVisibleFailureCategoryNotice(details) {
+    if (!isRecord(details) || details.resultCategory !== "failure")
+        return undefined;
+    const failureCategory = typeof details.failureCategory === "string" && details.failureCategory.length > 0
+        ? details.failureCategory
+        : undefined;
+    return `Result category: failure${failureCategory ? `; failureCategory: ${failureCategory}` : ""}; Pi tool isError: true.`;
+}
+function agentBrowserToolResultRequestedJson(event) {
+    const details = isRecord(event.details) ? event.details : undefined;
+    const detailArgs = Array.isArray(details?.args) ? details.args : undefined;
+    const inputArgs = isRecord(event.input) && Array.isArray(event.input.args) ? event.input.args : undefined;
+    return detailArgs?.includes("--json") === true || inputArgs?.includes("--json") === true;
+}
+function agentBrowserToolResultHasParseableJsonContent(content) {
+    return content.some((item) => {
+        if (item.type !== "text" || typeof item.text !== "string")
+            return false;
+        const text = item.text.trim();
+        if (text.length === 0)
+            return false;
+        try {
+            JSON.parse(text);
+            return true;
+        }
+        catch {
+            return false;
+        }
+    });
+}
+function appendModelVisibleFailureCategoryNotice(content, notice) {
+    const noticeContent = { type: "text", text: notice };
+    const textIndex = content.findIndex((item) => item.type === "text" && typeof item.text === "string");
+    if (textIndex === -1)
+        return [noticeContent, ...content];
+    const textItem = content[textIndex];
+    if (textItem.type !== "text" || typeof textItem.text !== "string" || textItem.text.includes(notice))
+        return undefined;
+    return content.map((item, index) => index === textIndex
+        ? { ...item, text: `${textItem.text}\n\n${notice}` }
+        : item);
+}
+export function buildAgentBrowserToolResultPatch(event) {
+    if (event.toolName !== "agent_browser")
+        return undefined;
+    const preservesParseableJson = agentBrowserToolResultRequestedJson(event) && agentBrowserToolResultHasParseableJsonContent(event.content);
+    const notice = preservesParseableJson ? undefined : formatModelVisibleFailureCategoryNotice(event.details);
+    const content = notice ? appendModelVisibleFailureCategoryNotice(event.content, notice) : undefined;
+    const shouldMarkError = isRecord(event.details) && event.details.resultCategory === "failure" && event.isError !== true;
+    if (!shouldMarkError && !content)
+        return undefined;
+    return {
+        ...(content ? { content } : {}),
+        ...(shouldMarkError ? { isError: true } : {}),
+    };
+}
+export class AgentBrowserResultComponent {
+    expanded = false;
+    theme;
+    text = new Text("", 0, 0);
+    setState(value, expanded, theme) {
+        this.text.setText(value);
+        this.expanded = expanded;
+        this.theme = theme;
+    }
+    render(width) {
+        const lines = this.text.render(width);
+        if (this.expanded || lines.length <= TUI_COLLAPSED_OUTPUT_MAX_LINES) {
+            return lines;
+        }
+        const theme = this.theme;
+        if (!theme) {
+            return lines.slice(0, TUI_COLLAPSED_OUTPUT_MAX_LINES);
+        }
+        const hiddenLineCount = lines.length - TUI_COLLAPSED_OUTPUT_MAX_LINES;
+        return [
+            ...lines.slice(0, TUI_COLLAPSED_OUTPUT_MAX_LINES),
+            formatVisualTruncationNotice(hiddenLineCount, lines.length, theme, width),
+        ];
+    }
+    invalidate() {
+        this.text.invalidate();
+    }
+}