pi-agent-browser-native 0.9.3 → 0.9.4

package/dist/extensions/agent-browser/lib/orchestration/extension-version-check.js

@@ -0,0 +1,54 @@
+import { redactSensitiveText } from "../runtime.js";
+import { runAgentBrowserProcess } from "../process.js";
+import { getAgentBrowserProcessEnvironment } from "../process-environment.js";
+import { MINIMUM_AGENT_BROWSER_VERSION, SUPPORTED_AGENT_BROWSER_VERSION_LABEL, TARGET_AGENT_BROWSER_VERSION, getAgentBrowserVersionValidationError, parseAgentBrowserVersionOutput, } from "../upstream-version.js";
+function unavailableProbe(probe) {
+    const error = probe.spawnError;
+    return ((error !== undefined && "code" in error && error.code === "ENOENT") ||
+        probe.exitCode === 127 ||
+        probe.aborted);
+}
+function probeVersion(probe) {
+    if (probe.spawnError || probe.exitCode !== 0) {
+        const stderr = probe.stderr.trim();
+        const detail = redactSensitiveText(probe.spawnError?.message ?? (stderr !== "" ? stderr : `exit ${probe.exitCode}`));
+        return {
+            error: `agent-browser --version could not be validated (${detail}). Run pi-agent-browser-doctor before browser-backed calls.`,
+        };
+    }
+    return {
+        observedVersion: parseAgentBrowserVersionOutput(probe.stdout),
+        error: getAgentBrowserVersionValidationError(probe.stdout),
+    };
+}
+export async function validateUpstreamVersion(cache, cwd, signal) {
+    const env = getAgentBrowserProcessEnvironment();
+    const key = `${cwd}\0${env.PATH ?? env.Path ?? ""}`;
+    if (cache.has(key)) {
+        return undefined;
+    }
+    const probe = await runAgentBrowserProcess({ args: ["--version"], cwd, signal, timeoutMs: 5000 });
+    if (unavailableProbe(probe)) {
+        return undefined;
+    }
+    const { error, observedVersion } = probeVersion(probe);
+    if (error === undefined || error === "") {
+        cache.add(key);
+        return undefined;
+    }
+    return {
+        content: [{ type: "text", text: error }],
+        details: {
+            expectedVersion: TARGET_AGENT_BROWSER_VERSION,
+            failureCategory: "validation-error",
+            observedVersion,
+            resultCategory: "failure",
+            minimumSupportedVersion: MINIMUM_AGENT_BROWSER_VERSION,
+            versionValidation: {
+                expected: SUPPORTED_AGENT_BROWSER_VERSION_LABEL,
+                observed: observedVersion,
+            },
+        },
+        isError: true,
+    };
+}

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

@@ -0,0 +1 @@
+export {};

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

@@ -1,55 +1,19 @@
 import { parseArgvDescriptor } from "../argv-descriptor.js";
+import { isRecord } from "../parsing.js";
+import { isStringArray } from "../input-modes/shared.js";
 import { normalizeUrlLessOpen } from "./batch-stdin.js";
-import { isPlainTextInspectionArgs, validateToolArgs, redactInvocationArgs, redactSensitiveText } from "../runtime.js";
+import { isPlainTextInspectionArgs, validateToolArgs, redactInvocationArgs } from "../runtime.js";
 import { buildAgentBrowserResultCategoryDetails } from "../results/categories.js";
 import { compileAgentBrowserElectron } from "../input-modes/electron.js";
 import { compileAgentBrowserQaPreset } from "../input-modes/job.js";
-import { compileAgentBrowserNetworkSourceLookup, compileAgentBrowserSourceLookup, redactNetworkSourceLookupArgs, redactNetworkSourceLookupUrl } from "../input-modes/lookups.js";
+import { compileAgentBrowserNetworkSourceLookup, compileAgentBrowserSourceLookup, } from "../input-modes/lookups.js";
 import { compileAgentBrowserSemanticAction } from "../input-modes/semantic-action.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;
-}
+import { redactCompiledElectron, redactCompiledJob, redactCompiledNetworkSourceLookup, redactCompiledSourceLookup, } from "./input-redaction.js";
 function normalizeExplicitEvalStdinArgs(args, stdin) {
     if (stdin !== undefined) {
         return { args, stdin };
     }
-    const descriptor = parseArgvDescriptor(args);
+    const descriptor = parseArgvDescriptor([...args]);
     if (descriptor.commandInfo.command !== "eval") {
         return { args, stdin };
     }
@@ -58,164 +22,276 @@ function normalizeExplicitEvalStdinArgs(args, stdin) {
         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,
+        args: [
+            ...args.slice(0, commandStartIndex),
+            ...descriptor.commandTokens.slice(0, stdinIndex + 1),
+        ],
+        stdin: descriptor.commandTokens.slice(stdinIndex + 1).join(" "),
     };
 }
-export function resolveAgentBrowserInput(options) {
-    const { getBatchPreflightValidationError, params } = options;
-    const semanticActionResult = params.semanticAction === undefined ? {} : compileAgentBrowserSemanticAction(params.semanticAction);
-    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(qaResult.compiled),
-        Boolean(sourceLookupResult.compiled),
-        Boolean(networkSourceLookupResult.compiled),
-        Boolean(electronResult.compiled),
-    ].filter(Boolean).length;
-    const inputModeError = explicitInputModes !== 1
-        ? "Provide exactly one of args, semanticAction, 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 = 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 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
-            ? compiledElectron.action === "list"
-                ? "electron.list has no configurable timeout; remove top-level timeoutMs."
-                : "Use electron.timeoutMs for this action; 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."
-            : undefined
-        : undefined;
-    const validationError = semanticActionResult.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"
-                    : 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 normalized = validationError || isPlainTextInspectionArgs(toolArgs) ? { args: toolArgs, stdin: toolStdin } : normalizeUrlLessOpen(toolArgs, toolStdin);
-    const resolvedBase = { redactedArgs, toolArgs: normalized.args, toolStdin: normalized.stdin };
-    if (validationError) {
+function fieldShapeError(params) {
+    if (params.args !== undefined && !isStringArray(params.args)) {
+        return "args must be an array of strings when provided.";
+    }
+    if (params.stdin !== undefined && typeof params.stdin !== "string") {
+        return "stdin must be a string when provided.";
+    }
+    return undefined;
+}
+function outputPathError(value) {
+    if (value !== undefined && (typeof value !== "string" || value.trim().length === 0)) {
+        return "outputPath must be a non-empty string when provided.";
+    }
+    return undefined;
+}
+/** Compiles all requested modes once, then validates selection before exposing executable input. */
+class BrowserInputCompiler {
+    params;
+    preflight;
+    semanticAction;
+    qa;
+    sourceLookup;
+    networkSourceLookup;
+    electron;
+    modes;
+    constructor(params, preflight) {
+        this.params = params;
+        this.preflight = preflight;
+        this.semanticAction =
+            params.semanticAction === undefined
+                ? {}
+                : compileAgentBrowserSemanticAction(params.semanticAction);
+        this.qa = params.qa === undefined ? {} : compileAgentBrowserQaPreset(params.qa);
+        this.sourceLookup =
+            params.sourceLookup === undefined ? {} : compileAgentBrowserSourceLookup(params.sourceLookup);
+        this.networkSourceLookup =
+            params.networkSourceLookup === undefined
+                ? {}
+                : compileAgentBrowserNetworkSourceLookup(params.networkSourceLookup);
+        this.electron =
+            params.electron === undefined ? {} : compileAgentBrowserElectron(params.electron);
+        this.modes = this.projectModes();
+    }
+    projectModes() {
+        const compiledJob = this.qa.compiled;
+        const redactedCompiledJob = redactCompiledJob(compiledJob);
+        const compiledSemanticAction = this.semanticAction.compiled;
         return {
-            ...resolvedBase,
-            attemptedKind,
-            compiledElectron,
-            compiledGeneratedBatch,
+            compiledElectron: this.electron.compiled,
+            compiledGeneratedBatch: this.networkSourceLookup.compiled ?? this.sourceLookup.compiled ?? compiledJob,
             compiledJob,
-            compiledNetworkSourceLookup,
-            compiledQaPreset,
+            compiledNetworkSourceLookup: this.networkSourceLookup.compiled,
+            compiledQaPreset: this.qa.compiled,
             compiledSemanticAction,
-            compiledSourceLookup,
-            kind: "invalid",
-            redactedCompiledElectron,
+            compiledSourceLookup: this.sourceLookup.compiled,
+            redactedCompiledElectron: redactCompiledElectron(this.electron.compiled),
             redactedCompiledJob,
-            redactedCompiledNetworkSourceLookup,
-            redactedCompiledQaPreset,
-            redactedCompiledSemanticAction,
-            redactedCompiledSourceLookup,
-            status: "invalid",
-            validationError,
+            redactedCompiledNetworkSourceLookup: redactCompiledNetworkSourceLookup(this.networkSourceLookup.compiled),
+            redactedCompiledQaPreset: compiledJob !== undefined && redactedCompiledJob !== undefined
+                ? { ...redactedCompiledJob, checks: compiledJob.checks }
+                : undefined,
+            redactedCompiledSemanticAction: compiledSemanticAction === undefined
+                ? undefined
+                : {
+                    ...compiledSemanticAction,
+                    args: redactInvocationArgs([...compiledSemanticAction.args]),
+                },
+            redactedCompiledSourceLookup: redactCompiledSourceLookup(this.sourceLookup.compiled),
         };
     }
-    if (compiledElectron && redactedCompiledElectron) {
-        return { ...resolvedBase, compiledElectron, kind: "electron", redactedCompiledElectron, status: "valid" };
+    attemptedKind() {
+        if (this.electron.compiled !== undefined) {
+            return "electron";
+        }
+        if (this.networkSourceLookup.compiled !== undefined) {
+            return "networkSourceLookup";
+        }
+        if (this.sourceLookup.compiled !== undefined) {
+            return "sourceLookup";
+        }
+        if (this.qa.compiled !== undefined) {
+            return "qa";
+        }
+        if (this.semanticAction.compiled !== undefined) {
+            return "semanticAction";
+        }
+        return Array.isArray(this.params.args) ? "args" : undefined;
     }
-    if (compiledNetworkSourceLookup && redactedCompiledNetworkSourceLookup) {
-        return {
-            ...resolvedBase,
-            compiledGeneratedBatch: compiledNetworkSourceLookup,
-            compiledNetworkSourceLookup,
-            kind: "networkSourceLookup",
-            redactedCompiledNetworkSourceLookup,
-            status: "valid",
-        };
+    inputModeError() {
+        const selected = [
+            Array.isArray(this.params.args),
+            this.semanticAction.compiled !== undefined,
+            this.qa.compiled !== undefined,
+            this.sourceLookup.compiled !== undefined,
+            this.networkSourceLookup.compiled !== undefined,
+            this.electron.compiled !== undefined,
+        ].filter((active) => active).length;
+        return selected === 1
+            ? undefined
+            : "Provide exactly one of args, semanticAction, qa, sourceLookup, networkSourceLookup, or electron.";
     }
-    if (compiledSourceLookup && redactedCompiledSourceLookup) {
-        return {
-            ...resolvedBase,
-            compiledGeneratedBatch: compiledSourceLookup,
-            compiledSourceLookup,
-            kind: "sourceLookup",
-            redactedCompiledSourceLookup,
-            status: "valid",
-        };
+    generatedStdinError() {
+        if (this.params.stdin === undefined) {
+            return undefined;
+        }
+        if (this.modes.compiledGeneratedBatch !== undefined) {
+            return "Do not provide stdin with qa, sourceLookup, or networkSourceLookup; those modes generate their own batch stdin.";
+        }
+        return this.electron.compiled === undefined
+            ? undefined
+            : "Do not provide stdin with electron; electron mode is host-only or manages its own input.";
     }
-    if (compiledQaPreset && redactedCompiledJob && redactedCompiledQaPreset) {
+    timeoutError() {
+        const value = this.params.timeoutMs;
+        if (value === undefined) {
+            return undefined;
+        }
+        if (typeof value !== "number" || !Number.isSafeInteger(value) || value <= 0) {
+            return "timeoutMs must be a positive integer when provided.";
+        }
+        if (this.electron.compiled === undefined) {
+            return undefined;
+        }
+        return this.electron.compiled.action === "list"
+            ? "electron.list has no configurable timeout; remove top-level timeoutMs."
+            : "Use electron.timeoutMs for this action; top-level timeoutMs applies only to browser CLI subprocess calls.";
+    }
+    attachedQaError() {
+        return this.qa.compiled?.checks.attached === true && this.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."
+            : undefined;
+    }
+    validationError(args, stdin) {
+        const compilationError = this.compilationError();
+        const shapeError = fieldShapeError(this.params);
+        const modeError = this.inputModeError() ?? this.generatedStdinError();
+        const optionsError = this.optionsError();
+        const error = compilationError ?? shapeError ?? modeError ?? optionsError;
+        if (error !== undefined) {
+            return error;
+        }
+        return this.electron.compiled === undefined
+            ? (validateToolArgs([...args]) ?? this.preflight(args, stdin))
+            : undefined;
+    }
+    compilationError() {
+        return (this.semanticAction.error ??
+            this.qa.error ??
+            this.sourceLookup.error ??
+            this.networkSourceLookup.error ??
+            this.electron.error);
+    }
+    optionsError() {
+        return outputPathError(this.params.outputPath) ?? this.timeoutError() ?? this.attachedQaError();
+    }
+    validInput(base) {
+        const { compiledElectron, compiledSemanticAction, redactedCompiledElectron, redactedCompiledSemanticAction, } = this.modes;
+        if (compiledElectron !== undefined && redactedCompiledElectron !== undefined) {
+            return {
+                ...base,
+                compiledElectron,
+                kind: "electron",
+                redactedCompiledElectron,
+                status: "valid",
+            };
+        }
+        const generated = this.validGeneratedInput(base);
+        if (generated !== undefined) {
+            return generated;
+        }
+        if (compiledSemanticAction !== undefined && redactedCompiledSemanticAction !== undefined) {
+            return {
+                ...base,
+                compiledSemanticAction,
+                kind: "semanticAction",
+                redactedCompiledSemanticAction,
+                status: "valid",
+            };
+        }
+        return { ...base, kind: "args", status: "valid" };
+    }
+    validGeneratedInput(base) {
+        const { compiledNetworkSourceLookup, compiledSourceLookup, compiledQaPreset, redactedCompiledNetworkSourceLookup, redactedCompiledSourceLookup, redactedCompiledQaPreset, redactedCompiledJob, } = this.modes;
+        if (compiledNetworkSourceLookup !== undefined &&
+            redactedCompiledNetworkSourceLookup !== undefined) {
+            return {
+                ...base,
+                compiledGeneratedBatch: compiledNetworkSourceLookup,
+                compiledNetworkSourceLookup,
+                kind: "networkSourceLookup",
+                redactedCompiledNetworkSourceLookup,
+                status: "valid",
+            };
+        }
+        if (compiledSourceLookup !== undefined && redactedCompiledSourceLookup !== undefined) {
+            return {
+                ...base,
+                compiledGeneratedBatch: compiledSourceLookup,
+                compiledSourceLookup,
+                kind: "sourceLookup",
+                redactedCompiledSourceLookup,
+                status: "valid",
+            };
+        }
+        if (compiledQaPreset !== undefined &&
+            redactedCompiledJob !== undefined &&
+            redactedCompiledQaPreset !== undefined) {
+            return {
+                ...base,
+                compiledGeneratedBatch: compiledQaPreset,
+                compiledJob: compiledQaPreset,
+                compiledQaPreset,
+                kind: "qa",
+                redactedCompiledJob,
+                redactedCompiledQaPreset,
+                status: "valid",
+            };
+        }
+        return undefined;
+    }
+    explicitInput() {
+        return normalizeExplicitEvalStdinArgs(isStringArray(this.params.args) ? this.params.args : [], typeof this.params.stdin === "string" ? this.params.stdin : undefined);
+    }
+    executionInput() {
+        const explicit = this.explicitInput();
         return {
-            ...resolvedBase,
-            compiledGeneratedBatch: compiledQaPreset,
-            compiledJob: compiledQaPreset,
-            compiledQaPreset,
-            kind: "qa",
-            redactedCompiledJob,
-            redactedCompiledQaPreset,
-            status: "valid",
+            args: this.electron.compiled === undefined
+                ? (this.semanticAction.compiled?.args ??
+                    this.modes.compiledGeneratedBatch?.args ??
+                    explicit.args)
+                : [],
+            stdin: this.modes.compiledGeneratedBatch?.stdin ?? explicit.stdin,
         };
     }
-    if (compiledSemanticAction && redactedCompiledSemanticAction) {
-        return { ...resolvedBase, compiledSemanticAction, kind: "semanticAction", redactedCompiledSemanticAction, status: "valid" };
+    resolve() {
+        const { args, stdin } = this.executionInput();
+        const redactedArgs = redactInvocationArgs([...args]);
+        const validationError = this.validationError(args, stdin);
+        const normalized = validationError !== undefined || isPlainTextInspectionArgs([...args])
+            ? { args, stdin }
+            : normalizeUrlLessOpen([...args], stdin);
+        const base = { redactedArgs, toolArgs: normalized.args, toolStdin: normalized.stdin };
+        if (validationError !== undefined) {
+            return {
+                ...base,
+                ...this.modes,
+                attemptedKind: this.attemptedKind(),
+                kind: "invalid",
+                status: "invalid",
+                validationError,
+            };
+        }
+        return this.validInput(base);
     }
-    return { ...resolvedBase, kind: "args", status: "valid" };
+}
+export function resolveAgentBrowserInput(options) {
+    const params = isRecord(options.params) ? options.params : {};
+    return new BrowserInputCompiler(params, options.getBatchPreflightValidationError).resolve();
 }
 export function buildValidationFailureResult(input) {
-    const validationError = input.validationError ?? "Invalid agent_browser input.";
     return {
-        content: [{ type: "text", text: validationError }],
+        content: [{ type: "text", text: input.validationError }],
         details: {
             args: input.redactedArgs,
             compiledElectron: input.redactedCompiledElectron,
@@ -225,12 +301,12 @@ export function buildValidationFailureResult(input) {
             compiledNetworkSourceLookup: input.redactedCompiledNetworkSourceLookup,
             compiledSemanticAction: input.redactedCompiledSemanticAction,
             ...buildAgentBrowserResultCategoryDetails({
-                args: input.redactedArgs,
-                errorText: validationError,
+                args: [...input.redactedArgs],
+                errorText: input.validationError,
                 succeeded: false,
-                validationError,
+                validationError: input.validationError,
             }),
-            validationError,
+            validationError: input.validationError,
         },
         isError: true,
     };

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

@@ -0,0 +1,62 @@
+import { redactInvocationArgs, redactSensitiveText } from "../runtime.js";
+import { redactNetworkSourceLookupArgs, redactNetworkSourceLookupUrl, } from "../input-modes/lookups.js";
+export function redactCompiledElectron(compiled) {
+    if (compiled === undefined) {
+        return undefined;
+    }
+    if (compiled.action === "list") {
+        return {
+            ...compiled,
+            query: compiled.query !== undefined && compiled.query.length > 0
+                ? redactSensitiveText(compiled.query)
+                : undefined,
+        };
+    }
+    if (compiled.action === "launch") {
+        return {
+            ...compiled,
+            appArgs: compiled.appArgs === undefined ? undefined : redactInvocationArgs([...compiled.appArgs]),
+        };
+    }
+    return { ...compiled };
+}
+export function redactCompiledJob(compiled) {
+    if (compiled === undefined) {
+        return undefined;
+    }
+    const steps = compiled.steps.map((step) => ({
+        ...step,
+        args: redactInvocationArgs([...step.args]),
+    }));
+    return { ...compiled, stdin: JSON.stringify(steps.map((step) => step.args)), steps };
+}
+export function redactCompiledSourceLookup(compiled) {
+    if (compiled === undefined) {
+        return undefined;
+    }
+    const steps = compiled.steps.map((step) => ({
+        ...step,
+        args: redactInvocationArgs([...step.args]),
+    }));
+    return { ...compiled, stdin: JSON.stringify(steps.map((step) => step.args)), steps };
+}
+export function redactCompiledNetworkSourceLookup(compiled) {
+    if (compiled === undefined) {
+        return undefined;
+    }
+    const steps = compiled.steps.map((step) => ({
+        ...step,
+        args: redactNetworkSourceLookupArgs([...step.args]),
+    }));
+    return {
+        ...compiled,
+        args: redactNetworkSourceLookupArgs([...compiled.args]),
+        query: {
+            ...compiled.query,
+            filter: redactNetworkSourceLookupUrl(compiled.query.filter),
+            url: redactNetworkSourceLookupUrl(compiled.query.url),
+        },
+        stdin: JSON.stringify(steps.map((step) => step.args)),
+        steps,
+    };
+}