pi-agent-browser-native 0.6.17 → 0.7.0

package/dist/extensions/agent-browser/lib/browser-transcript.js

@@ -0,0 +1,33 @@
+import { isRecord } from "./parsing.js";
+export const BROWSER_TRANSITION_ENTRY = "agent-browser-transition";
+export const BROWSER_RESULT_TOOLS = new Set([
+    "agent_browser", "agent_browser_code", "agent_browser_action", "agent_browser_qa", "agent_browser_electron",
+    "agent_browser_source", "agent_browser_network_source",
+]);
+/** Direct tools and ordered code calls replay through the same browser state reducers. */
+export function getBrowserResultMessage(entry) {
+    if (!isRecord(entry))
+        return undefined;
+    if (entry.type === "custom" && entry.customType === BROWSER_TRANSITION_ENTRY && isRecord(entry.data)) {
+        return isRecord(entry.data.details) && typeof entry.data.isError === "boolean" ? entry.data : undefined;
+    }
+    const message = entry.type === "message" && isRecord(entry.message) ? entry.message : undefined;
+    return message && typeof message.toolName === "string" && BROWSER_RESULT_TOOLS.has(message.toolName) ? message : undefined;
+}
+// Page data and rendered output are not state. Keep only fields consumed by the
+// existing replay reducers; recording reservations retain their own native journal.
+const TRANSITION_FIELDS = [
+    "args", "command", "subcommand", "sessionName", "namespace", "sessionMode", "usedImplicitSession",
+    "agentBrowserStarted", "resultCategory", "exitCode", "closeAllApplied", "attachedBrowserSession",
+    "sessionTabTarget", "sessionTabTargetUnknown", "sessionTabReopenPending", "refSnapshot", "refSnapshotInvalidation",
+    "readConfirmation", "compatibilityWorkaround", "managedSessionHeadedAutosaveDisabled", "managedSessionHeadedAutosaveInterval",
+    "managedSessionOutcome", "managedSessionCwd", "managedSessionRestoreDisabled", "artifactManifest", "electron", "compiledNetworkSourceLookup",
+];
+export function appendBrowserTransition(pi, toolCallId, details, isError) {
+    const state = Object.fromEntries(TRANSITION_FIELDS.filter(key => details[key] !== undefined).map(key => [key, details[key]]));
+    if (Array.isArray(details.batchSteps))
+        state.batchSteps = details.batchSteps.filter(isRecord).map(step => ({
+            command: step.command, success: step.success, lifecycle: step.lifecycle,
+        }));
+    pi.appendEntry(BROWSER_TRANSITION_ENTRY, { toolCallId, details: state, isError });
+}

package/dist/extensions/agent-browser/lib/execution-cwd.js

@@ -1,6 +1,7 @@
 import { readFileSync, statSync } from "node:fs";
 import { dirname, isAbsolute, join } from "node:path";
 import { isRecord } from "./parsing.js";
+import { getBrowserResultMessage } from "./browser-transcript.js";
 import { getAgentBrowserSessionIdentityKey } from "./argv-grammar.js";
 function isDirectoryOwner(source) {
     if (/^(?:npm:pi-change-working-dir|git:github\.com\/fitchmultz\/pi-change-working-dir(?:\.git)?)(?:@.+)?$/.test(source.source))
@@ -52,9 +53,10 @@ export function getBrowserCwdError(cwd) {
 export function restoreManagedSessionCwd(branch, sessionName, namespace, fallback) {
     const key = getAgentBrowserSessionIdentityKey(sessionName, namespace);
     for (const entry of [...branch].reverse()) {
-        if (!isRecord(entry) || entry.type !== "message" || !isRecord(entry.message) || entry.message.toolName !== "agent_browser")
+        const message = getBrowserResultMessage(entry);
+        if (!message)
             continue;
-        const details = entry.message.details;
+        const details = message.details;
         if (!isRecord(details) || typeof details.sessionName !== "string" || typeof details.managedSessionCwd !== "string" || !isAbsolute(details.managedSessionCwd))
             continue;
         if (getAgentBrowserSessionIdentityKey(details.sessionName, typeof details.namespace === "string" ? details.namespace : undefined) === key)

package/dist/extensions/agent-browser/lib/input-modes/job.js

@@ -1,218 +1,7 @@
 import { isRecord } from "../parsing.js";
 import { summarizeNetworkFailures } from "../results/network.js";
-import { getBatchResultItems, getCommandNameFromBatchItem, getSelectValues } from "./shared.js";
-import { compileAgentBrowserSemanticAction } from "./semantic-action.js";
-import { AGENT_BROWSER_JOB_STEP_ACTIONS, AGENT_BROWSER_JOB_TYPE_DELAYED_TEXT_MAX_CHARACTERS, AGENT_BROWSER_QA_LOAD_STATES, } from "./types.js";
-function getRequiredJobString(step, field, action) {
-    const value = step[field];
-    if (typeof value !== "string" || value.trim().length === 0) {
-        return { error: `job step ${action} requires a non-empty ${field} string.` };
-    }
-    return { value };
-}
-function compileJobClickOrFillStep(step, action) {
-    const hasSelector = typeof step.selector === "string" && step.selector.trim().length > 0;
-    const hasLocator = step.locator !== undefined || step.role !== undefined || step.name !== undefined || step.value !== undefined;
-    if (hasSelector && hasLocator) {
-        return { error: `job step ${action} must use either selector or semantic locator fields, not both.` };
-    }
-    if (hasSelector) {
-        if (action === "click")
-            return { args: ["click", step.selector] };
-        const text = getRequiredJobString(step, "text", action);
-        if (text.error)
-            return { error: text.error };
-        return { args: ["fill", step.selector, text.value] };
-    }
-    if (!hasLocator) {
-        return { error: `job step ${action} requires either a non-empty selector string or semantic locator fields.` };
-    }
-    const compiled = compileAgentBrowserSemanticAction({
-        action,
-        locator: step.locator,
-        name: step.name,
-        role: step.role,
-        text: step.text,
-        value: step.value,
-    });
-    if (compiled.error)
-        return { error: compiled.error.replaceAll("semanticAction", `job step ${action}`) };
-    return { args: compiled.compiled?.args };
-}
-function getUnsupportedJobStepField(step, allowedFields) {
-    return Object.keys(step).find((field) => !allowedFields.has(field));
-}
-function getUnsupportedJobStepFieldError(step, action, allowedFields) {
-    const unsupportedField = getUnsupportedJobStepField(step, allowedFields);
-    if (!unsupportedField)
-        return undefined;
-    const supportedFields = [...allowedFields].filter((field) => field !== "action");
-    const supportedText = supportedFields.length > 0 ? `supported fields are ${supportedFields.join(", ")}.` : "no additional fields are supported.";
-    return `job step ${action} does not support ${unsupportedField}; ${supportedText}`;
-}
-const JOB_STEP_ALLOWED_FIELDS = {
-    assertText: new Set(["action", "text"]),
-    assertUrl: new Set(["action", "url"]),
-    click: new Set(["action", "locator", "name", "role", "selector", "value"]),
-    fill: new Set(["action", "locator", "name", "role", "selector", "text", "value"]),
-    open: new Set(["action", "loadState", "url"]),
-    screenshot: new Set(["action", "path"]),
-    select: new Set(["action", "selector", "value", "values"]),
-    snapshot: new Set(["action"]),
-    type: new Set(["action", "delayMs", "press", "selector", "text"]),
-    wait: new Set(["action", "milliseconds"]),
-    waitForDownload: new Set(["action", "path"]),
-};
-function compileJobTypeSteps(step) {
-    const text = getRequiredJobString(step, "text", "type");
-    if (text.error)
-        return { error: text.error };
-    const selector = step.selector;
-    if (selector !== undefined && (typeof selector !== "string" || selector.trim().length === 0)) {
-        return { error: "job step type selector must be a non-empty string when provided." };
-    }
-    const delayMs = step.delayMs;
-    if (delayMs !== undefined && (typeof delayMs !== "number" || !Number.isInteger(delayMs) || delayMs <= 0)) {
-        return { error: "job step type delayMs must be a positive integer when provided." };
-    }
-    const press = step.press;
-    if (press !== undefined && (typeof press !== "string" || press.trim().length === 0)) {
-        return { error: "job step type press must be a non-empty key string when provided." };
-    }
-    const typedText = text.value;
-    const typedChars = Array.from(typedText);
-    if (typedChars.length === 0)
-        return { error: "job step type requires non-empty text." };
-    if (delayMs !== undefined && typedChars.length > AGENT_BROWSER_JOB_TYPE_DELAYED_TEXT_MAX_CHARACTERS) {
-        return { error: `job step type delayMs supports at most ${AGENT_BROWSER_JOB_TYPE_DELAYED_TEXT_MAX_CHARACTERS} characters; split longer text into shorter calls or omit delayMs.` };
-    }
-    const compiledSteps = [];
-    if (delayMs === undefined) {
-        compiledSteps.push({ action: "type", args: typeof selector === "string" ? ["type", selector, typedText] : ["keyboard", "type", typedText] });
-    }
-    else {
-        if (typeof selector === "string")
-            compiledSteps.push({ action: "type", args: ["focus", selector], generatedFrom: "type.selector" });
-        for (const [index, char] of typedChars.entries()) {
-            compiledSteps.push({ action: "type", args: ["keyboard", "type", char], generatedFrom: "type.delayMs" });
-            if (index < typedChars.length - 1)
-                compiledSteps.push({ action: "wait", args: ["wait", String(delayMs)], generatedFrom: "type.delayMs" });
-        }
-    }
-    if (typeof press === "string")
-        compiledSteps.push({ action: "type", args: ["press", press], generatedFrom: "type.press" });
-    return { steps: compiledSteps };
-}
-function compileOpenJobStep(step, index) {
-    const result = getRequiredJobString(step, "url", "open");
-    if (result.error)
-        return { error: result.error };
-    const extraSteps = [];
-    if (step.loadState !== undefined) {
-        if (typeof step.loadState !== "string" || !AGENT_BROWSER_QA_LOAD_STATES.includes(step.loadState)) {
-            return { error: `job.steps[${index}].loadState must be one of: ${AGENT_BROWSER_QA_LOAD_STATES.join(", ")}.` };
-        }
-        extraSteps.push({ action: "wait", args: ["wait", "--load", step.loadState], generatedFrom: "open.loadState" });
-    }
-    return { args: ["open", result.value], extraSteps };
-}
-function compileClickJobStep(step) {
-    return compileJobClickOrFillStep(step, "click");
-}
-function compileFillJobStep(step) {
-    return compileJobClickOrFillStep(step, "fill");
-}
-function compileTypeJobStep(step) {
-    const result = compileJobTypeSteps(step);
-    if (result.error)
-        return { error: result.error };
-    const [firstStep, ...extraSteps] = result.steps;
-    return { args: firstStep.args, extraSteps, generatedFrom: firstStep.generatedFrom };
-}
-function compileSelectJobStep(step, index) {
-    const selector = getRequiredJobString(step, "selector", "select");
-    if (selector.error)
-        return { error: selector.error };
-    const values = getSelectValues(step, `job.steps[${index}]`);
-    if (values.error)
-        return { error: values.error };
-    return { args: ["select", selector.value, ...values.values] };
-}
-function compileWaitJobStep(step) {
-    const milliseconds = step.milliseconds;
-    if (typeof milliseconds !== "number" || !Number.isInteger(milliseconds) || milliseconds <= 0) {
-        return { error: "job step wait requires a positive integer milliseconds value." };
-    }
-    return { args: ["wait", String(milliseconds)] };
-}
-function compileAssertTextJobStep(step) {
-    const result = getRequiredJobString(step, "text", "assertText");
-    if (result.error)
-        return { error: result.error };
-    return { args: ["wait", "--text", result.value] };
-}
-function compileAssertUrlJobStep(step) {
-    const result = getRequiredJobString(step, "url", "assertUrl");
-    if (result.error)
-        return { error: result.error };
-    return { args: ["wait", "--url", result.value] };
-}
-function compilePathArtifactJobStep(step, action) {
-    const result = getRequiredJobString(step, "path", action);
-    if (result.error)
-        return { error: result.error };
-    return { args: action === "waitForDownload" ? ["wait", "--download", result.value] : ["screenshot", result.value] };
-}
-// ponytail: allowedFields for each action live in JOB_STEP_ALLOWED_FIELDS (same key
-// alignment enforced by Record<AgentBrowserJobStepAction, …>), so the compiler map no
-// longer mirrors that set per entry; the call site looks it up by action.
-const JOB_STEP_COMPILERS = {
-    assertText: compileAssertTextJobStep,
-    assertUrl: compileAssertUrlJobStep,
-    click: compileClickJobStep,
-    fill: compileFillJobStep,
-    open: compileOpenJobStep,
-    screenshot: (step) => compilePathArtifactJobStep(step, "screenshot"),
-    select: compileSelectJobStep,
-    snapshot: () => ({ args: ["snapshot", "-i"] }),
-    type: compileTypeJobStep,
-    wait: compileWaitJobStep,
-    waitForDownload: (step) => compilePathArtifactJobStep(step, "waitForDownload"),
-};
-export function compileAgentBrowserJob(input) {
-    if (!isRecord(input)) {
-        return { error: "job must be an object." };
-    }
-    const rawFailFast = input.failFast;
-    if (rawFailFast !== undefined && typeof rawFailFast !== "boolean") {
-        return { error: "job.failFast must be a boolean when provided." };
-    }
-    const failFast = rawFailFast !== false;
-    const rawSteps = input.steps;
-    if (!Array.isArray(rawSteps) || rawSteps.length === 0) {
-        return { error: "job.steps must be a non-empty array." };
-    }
-    const steps = [];
-    for (const [index, rawStep] of rawSteps.entries()) {
-        if (!isRecord(rawStep)) {
-            return { error: `job.steps[${index}] must be an object.` };
-        }
-        const action = rawStep.action;
-        if (typeof action !== "string" || !AGENT_BROWSER_JOB_STEP_ACTIONS.includes(action)) {
-            return { error: `job.steps[${index}].action must be one of: ${AGENT_BROWSER_JOB_STEP_ACTIONS.join(", ")}.` };
-        }
-        const jobAction = action;
-        const compile = JOB_STEP_COMPILERS[jobAction];
-        const unsupportedFieldError = getUnsupportedJobStepFieldError(rawStep, jobAction, JOB_STEP_ALLOWED_FIELDS[jobAction]);
-        if (unsupportedFieldError)
-            return { error: `job.steps[${index}]: ${unsupportedFieldError}` };
-        const compiledStep = compile(rawStep, index);
-        if (compiledStep.error)
-            return { error: compiledStep.error.startsWith(`job.steps[${index}]`) ? compiledStep.error : `job.steps[${index}]: ${compiledStep.error}` };
-        steps.push({ action: jobAction, args: compiledStep.args, generatedFrom: compiledStep.generatedFrom }, ...(compiledStep.extraSteps ?? []));
-    }
-    return { compiled: { args: failFast ? ["batch", "--bail"] : ["batch"], failFast, stdin: JSON.stringify(steps.map((step) => step.args)), steps } };
-}
+import { getBatchResultItems, getCommandNameFromBatchItem } from "./shared.js";
+import { AGENT_BROWSER_QA_LOAD_STATES, } from "./types.js";
 function describeQaChecksRun(checks) {
     const parts = [`load:${checks.loadState}`];
     if (checks.expectedText.length > 0)

package/dist/extensions/agent-browser/lib/input-modes/params.js

@@ -1,149 +1,153 @@
 import { JsonSchema } from "../json-schema.js";
 import { StringEnum as localStringEnum } from "../string-enum-schema.js";
-import { AGENT_BROWSER_SCRIPT_CODE_MAX_BYTES } from "./script.js";
-import { ELECTRON_DISCOVERY_DEFAULT_MAX_RESULTS, ELECTRON_DISCOVERY_MAX_RESULTS, } from "../electron/discovery.js";
-import { AGENT_BROWSER_ELECTRON_HANDOFFS, AGENT_BROWSER_ELECTRON_TARGET_TYPES, AGENT_BROWSER_JOB_STEP_ACTIONS, AGENT_BROWSER_JOB_TYPE_DELAYED_TEXT_MAX_CHARACTERS, AGENT_BROWSER_QA_LOAD_STATES, AGENT_BROWSER_SEMANTIC_ACTIONS, AGENT_BROWSER_SEMANTIC_LOCATORS, DEFAULT_SESSION_MODE, SOURCE_LOOKUP_MAX_WORKSPACE_FILES, } from "./types.js";
-// Keep descriptions terse: Pi sends this schema every turn; workflows belong in prompt guidance and docs.
+import { ELECTRON_DISCOVERY_DEFAULT_MAX_RESULTS, ELECTRON_DISCOVERY_MAX_RESULTS } from "../electron/discovery.js";
+import { AGENT_BROWSER_ELECTRON_HANDOFFS, AGENT_BROWSER_ELECTRON_TARGET_TYPES, AGENT_BROWSER_QA_LOAD_STATES, AGENT_BROWSER_SEMANTIC_ACTIONS, AGENT_BROWSER_SEMANTIC_LOCATORS, DEFAULT_SESSION_MODE, SOURCE_LOOKUP_MAX_WORKSPACE_FILES, } from "./types.js";
+export const AGENT_BROWSER_ADVANCED_TOOLS = ["action", "qa", "electron", "source", "network"];
+export const AGENT_BROWSER_CODE_MAX_TIMEOUT_MS = 300_000;
+function outputProperties(Type) {
+    return {
+        outputPath: Type.Optional(Type.String({ description: "Result-data path, separate from browser artifact paths.", minLength: 1 })),
+        timeoutMs: Type.Optional(Type.Integer({ description: "Timeout in ms; exceed explicit waits.", minimum: 1 })),
+    };
+}
+function sessionModeProperty(Type, StringEnum) {
+    return Type.Optional(StringEnum(["auto", "fresh"], {
+        description: "Native configured sessions win; auto reuses the browser, fresh intentionally launches a separate managed browser.",
+        default: DEFAULT_SESSION_MODE,
+    }));
+}
+// Keep the always-on schemas small; specialized guidance belongs to each advanced tool.
 export function createAgentBrowserParamsSchema(Type = JsonSchema, StringEnum = localStringEnum) {
-    return Type.Object({
-        script: Type.Optional(Type.String({
-            description: "One-shot JavaScript orchestration with async browser({ args, stdin?, timeoutMs? }) and emit(value); isolated session and no host access.",
-            maxLength: AGENT_BROWSER_SCRIPT_CODE_MAX_BYTES,
-        })),
-        args: Type.Optional(Type.Array(Type.String(), {
-            description: "Raw agent-browser argv only: no binary, shell operators, or --json. Start with open → snapshot -i → act on current @refs; re-snapshot after page changes. Input: type <selector> <text>, or keyboard type <text> at current focus. Wait duration: wait <ms> (no --time). Artifacts: screenshot [selector] [path] [--full/-f]; record start <path> [url]; record restart <path> [url]; record stop. Paths are positional (no --path); use --full, not --full-page.",
-            minItems: 1,
-        })),
-        semanticAction: Type.Optional(Type.Object({
-            action: StringEnum(AGENT_BROWSER_SEMANTIC_ACTIONS),
-            locator: Type.Optional(StringEnum(AGENT_BROWSER_SEMANTIC_LOCATORS, { description: "Locator for check/click/fill; select supports role or label." })),
-            value: Type.Optional(Type.String({ description: "Locator value or one select option; for select by label, this is the label text." })),
-            values: Type.Optional(Type.Array(Type.String(), { description: "Select options; required for select by label.", minItems: 1 })),
-            selector: Type.Optional(Type.String({ description: "Direct selector or @ref." })),
-            text: Type.Optional(Type.String({ description: "Fill text." })),
-            role: Type.Optional(Type.String({ description: "Role for locator=role; select needs combobox or listbox." })),
-            name: Type.Optional(Type.String({ description: "Accessible name." })),
-            session: Type.Optional(Type.String({ description: "Upstream session name." })),
-        }, {
-            additionalProperties: false,
-            // Pi normalizes optional nulls through properties, not union branches.
-            anyOf: [
-                Type.Object({
-                    action: StringEnum(["select"]),
-                    locator: Type.Optional(StringEnum(["role", "label"])),
-                }, { not: { required: ["text"] } }),
-                Type.Object({
-                    action: StringEnum(["check", "click", "fill"]),
-                }, { not: { required: ["values"] } }),
-            ],
-            description: "Stable locator or direct-selector action. values only with action=select.",
-        })),
-        qa: Type.Optional(Type.Union([
-            Type.Object({
-                attached: Type.Literal(true),
-                expectedText: Type.Optional(Type.Union([Type.String(), Type.Array(Type.String())])),
-                expectedSelector: Type.Optional(Type.String()),
-                screenshotPath: Type.Optional(Type.String()),
-                checkConsole: Type.Optional(Type.Boolean()),
-                checkErrors: Type.Optional(Type.Boolean()),
-                checkNetwork: Type.Optional(Type.Boolean()),
-                loadState: Type.Optional(StringEnum(AGENT_BROWSER_QA_LOAD_STATES)),
-            }, { additionalProperties: false }),
-            Type.Object({
-                url: Type.String(),
-                attached: Type.Optional(Type.Literal(false)),
-                expectedText: Type.Optional(Type.Union([Type.String(), Type.Array(Type.String())])),
-                expectedSelector: Type.Optional(Type.String()),
-                screenshotPath: Type.Optional(Type.String()),
-                checkConsole: Type.Optional(Type.Boolean()),
-                checkErrors: Type.Optional(Type.Boolean()),
-                checkNetwork: Type.Optional(Type.Boolean()),
-                loadState: Type.Optional(StringEnum(AGENT_BROWSER_QA_LOAD_STATES)),
-            }, { additionalProperties: false }),
-        ], { description: "QA a URL or current session (attached=true). Default readiness: domcontentloaded; use networkidle only without long-lived requests. URL diagnostics default on, attached diagnostics off." })),
-        sourceLookup: Type.Optional(Type.Object({
-            selector: Type.Optional(Type.String({ description: "Visible selector or @ref." })),
-            reactFiberId: Type.Optional(Type.String({ description: "React fiber id; requires --enable react-devtools." })),
-            componentName: Type.Optional(Type.String({ description: "Component for local source search." })),
-            includeDomHints: Type.Optional(Type.Boolean({ description: "Inspect DOM source hints; default true." })),
-            maxWorkspaceFiles: Type.Optional(Type.Number({ description: "Source scan cap; default 2000.", minimum: 1, maximum: SOURCE_LOOKUP_MAX_WORKSPACE_FILES })),
-        }, { additionalProperties: false, description: "EXPERIMENTAL UI-to-source candidates; not guaranteed mappings." })),
-        networkSourceLookup: Type.Optional(Type.Object({
-            filter: Type.Optional(Type.String({ description: "Network request filter." })),
-            namespace: Type.Optional(Type.String()),
-            requestId: Type.Optional(Type.String({ description: "Request id to inspect." })),
-            session: Type.Optional(Type.String()),
-            url: Type.Optional(Type.String({ description: "Failed URL or fragment." })),
-            maxWorkspaceFiles: Type.Optional(Type.Number({ description: "Source scan cap; default 2000.", minimum: 1, maximum: SOURCE_LOOKUP_MAX_WORKSPACE_FILES })),
-        }, { additionalProperties: false, description: "EXPERIMENTAL failed-request-to-source candidates; not proof." })),
-        electron: Type.Optional(Type.Union([
-            Type.Object({
-                action: StringEnum(["list"]),
-                query: Type.Optional(Type.String({ description: "Case-insensitive app filter.", minLength: 1 })),
-                maxResults: Type.Optional(Type.Integer({ description: `Result cap; default ${ELECTRON_DISCOVERY_DEFAULT_MAX_RESULTS}, values over ${ELECTRON_DISCOVERY_MAX_RESULTS} are clamped.`, minimum: 1 })),
-            }, { additionalProperties: false }),
-            Type.Object({
-                action: StringEnum(["launch"]),
-                appPath: Type.Optional(Type.String({ description: "macOS .app path.", minLength: 1 })),
-                appName: Type.Optional(Type.String({ description: "Name from electron.list.", minLength: 1 })),
-                bundleId: Type.Optional(Type.String({ description: "Bundle id from electron.list.", minLength: 1 })),
-                executablePath: Type.Optional(Type.String({ description: "Executable path.", minLength: 1 })),
-                appArgs: Type.Optional(Type.Array(Type.String({ minLength: 1 }))),
-                handoff: Type.Optional(StringEnum(AGENT_BROWSER_ELECTRON_HANDOFFS)),
-                targetType: Type.Optional(StringEnum(AGENT_BROWSER_ELECTRON_TARGET_TYPES)),
-                timeoutMs: Type.Optional(Type.Integer({ minimum: 1 })),
-                allow: Type.Optional(Type.Array(Type.String({ minLength: 1 }))),
-                deny: Type.Optional(Type.Array(Type.String({ minLength: 1 }))),
-            }, { additionalProperties: false }),
-            Type.Object({
-                action: StringEnum(["status", "cleanup"]),
-                launchId: Type.String({ description: "Tracked launch id.", minLength: 1 }),
-                timeoutMs: Type.Optional(Type.Integer({ minimum: 1 })),
-            }, { additionalProperties: false }),
-            Type.Object({
-                action: StringEnum(["status", "cleanup"]),
-                all: Type.Literal(true),
-                timeoutMs: Type.Optional(Type.Integer({ minimum: 1 })),
-            }, { additionalProperties: false }),
-            Type.Object({
-                action: StringEnum(["status", "cleanup"]),
-                timeoutMs: Type.Optional(Type.Integer({ minimum: 1 })),
-            }, { additionalProperties: false }),
-            Type.Object({
-                action: StringEnum(["probe"]),
-                launchId: Type.Optional(Type.String({ description: "Tracked launch id.", minLength: 1 })),
-                timeoutMs: Type.Optional(Type.Integer({ minimum: 1 })),
-            }, { additionalProperties: false }),
-        ], { description: "Electron discovery, isolated-profile launch, status, probe, or cleanup. Launch defaults: handoff=snapshot, targetType=page; deny wins over allow; lifecycle/debug appArgs rejected." })),
-        job: Type.Optional(Type.Object({
-            failFast: Type.Optional(Type.Boolean({ description: "Stop on first failure; default true." })),
-            steps: Type.Array(Type.Object({
-                action: StringEnum(AGENT_BROWSER_JOB_STEP_ACTIONS),
-                url: Type.Optional(Type.String({ description: "Open URL, or assertUrl exact URL/glob that distinguishes the expected state from the starting page." })),
-                loadState: Type.Optional(StringEnum(AGENT_BROWSER_QA_LOAD_STATES, { description: "Readiness wait after open." })),
-                selector: Type.Optional(Type.String({ description: "Selector or @ref." })),
-                locator: Type.Optional(StringEnum(AGENT_BROWSER_SEMANTIC_LOCATORS, { description: "Locator when selector is omitted." })),
-                role: Type.Optional(Type.String({ description: "Role locator." })),
-                name: Type.Optional(Type.String({ description: "Accessible name." })),
-                text: Type.Optional(Type.String({ description: "Fill/type text; assertText uses only text, not selector/locator fields." })),
-                value: Type.Optional(Type.String({ description: "Select option or locator value." })),
-                values: Type.Optional(Type.Array(Type.String(), { description: "Select options.", minItems: 1 })),
-                path: Type.Optional(Type.String({ description: "Download or screenshot path." })),
-                delayMs: Type.Optional(Type.Integer({ description: `Per-character type delay; text is capped at ${AGENT_BROWSER_JOB_TYPE_DELAYED_TEXT_MAX_CHARACTERS} characters.`, minimum: 1 })),
-                press: Type.Optional(Type.String({ description: "Key to press after typing." })),
-                milliseconds: Type.Optional(Type.Number({ description: "Wait duration in milliseconds." })),
-            }, { additionalProperties: false }), { minItems: 1 }),
-        }, { additionalProperties: false, description: "Constrained multi-step batch. Clicks can stale later refs; split and re-snapshot before using them." })),
-        stdin: Type.Optional(Type.String({ description: "For batch, a JSON array of token arrays, e.g. [[\"get\",\"title\"]]. Raw text only for eval --stdin or auth save --password-stdin; unavailable with structured modes and electron." })),
-        outputPath: Type.Optional(Type.String({ description: "Workspace-relative or absolute result-data path; keep it distinct from screenshot, download, recording, and other browser artifact destinations.", minLength: 1 })),
-        timeoutMs: Type.Optional(Type.Integer({ description: "Wrapper timeout in ms; exceed explicit waits. electron.list has no configurable timeout; other Electron actions use electron.timeoutMs.", minimum: 1 })),
-        sessionMode: Type.Optional(StringEnum(["auto", "fresh"], {
-            description: "Native configured sessions win; otherwise auto reuses the managed session and fresh starts a new managed browser for launch-only flags.",
-            default: DEFAULT_SESSION_MODE,
-        })),
+    return Type.Unsafe(Type.Object({
+        args: Type.Array(Type.String(), { description: "Native agent-browser argv without the binary or shell syntax. Fixed sequences: batch --bail with JSON-array stdin.", minItems: 1 }),
+        stdin: Type.Optional(Type.String({ description: "Native batch JSON, eval --stdin source, or auth save --password-stdin text." })),
+        ...outputProperties(Type),
+        sessionMode: sessionModeProperty(Type, StringEnum),
+    }, { additionalProperties: false }));
+}
+export function createAgentBrowserCodeParamsSchema(Type = JsonSchema) {
+    return Type.Unsafe(Type.Object({
+        code: Type.String({ description: "JavaScript with await browser({args, stdin?, timeoutMs?}), emit(JSON), and emitImage(image handle). Fresh JS context; persistent browser.", minLength: 1, maxLength: 65_536 }),
+        session: Type.Optional(Type.String({ description: "Explicit native session; omitted uses the ordinary default browser.", minLength: 1 })),
+        namespace: Type.Optional(Type.String({ description: "Native namespace; empty string selects the default namespace." })),
+        ...outputProperties(Type),
+        timeoutMs: Type.Optional(Type.Integer({ minimum: 1, maximum: AGENT_BROWSER_CODE_MAX_TIMEOUT_MS })),
+    }, { additionalProperties: false }));
+}
+export function createAgentBrowserActionParamsSchema(Type = JsonSchema, StringEnum = localStringEnum) {
+    return Type.Unsafe(Type.Object({
+        action: StringEnum(AGENT_BROWSER_SEMANTIC_ACTIONS),
+        locator: Type.Optional(StringEnum(AGENT_BROWSER_SEMANTIC_LOCATORS, { description: "Select supports role or label." })),
+        value: Type.Optional(Type.String({ description: "Locator value or select option; label text for select by label." })),
+        values: Type.Optional(Type.Array(Type.String(), { description: "Select options; required for select by label.", minItems: 1 })),
+        selector: Type.Optional(Type.String({ description: "Direct selector or current @ref." })),
+        text: Type.Optional(Type.String({ description: "Fill text." })),
+        role: Type.Optional(Type.String({ description: "Role locator; select needs combobox or listbox." })),
+        name: Type.Optional(Type.String({ description: "Accessible name." })),
+        session: Type.Optional(Type.String({ description: "Upstream session name." })),
+        ...outputProperties(Type),
     }, {
         additionalProperties: false,
-        description: "Choose one input mode: script, args, semanticAction, job, qa, sourceLookup, networkSourceLookup, or electron.",
-    });
+        // Top-level properties let Pi normalize optional nulls before validating branches.
+        anyOf: [
+            Type.Object({ action: StringEnum(["select"]), locator: Type.Optional(StringEnum(["role", "label"])) }, { not: { required: ["text"] } }),
+            Type.Object({ action: StringEnum(["check", "click", "fill"]) }, { not: { required: ["values"] } }),
+        ],
+    }));
+}
+export function createAgentBrowserQaParamsSchema(Type = JsonSchema, StringEnum = localStringEnum) {
+    return Type.Unsafe(Type.Object({
+        url: Type.Optional(Type.String()),
+        attached: Type.Optional(Type.Boolean()),
+        expectedText: Type.Optional(Type.Union([Type.String(), Type.Array(Type.String())])),
+        expectedSelector: Type.Optional(Type.String()),
+        screenshotPath: Type.Optional(Type.String()),
+        checkConsole: Type.Optional(Type.Boolean()),
+        checkErrors: Type.Optional(Type.Boolean()),
+        checkNetwork: Type.Optional(Type.Boolean()),
+        loadState: Type.Optional(StringEnum(AGENT_BROWSER_QA_LOAD_STATES)),
+        ...outputProperties(Type),
+        sessionMode: sessionModeProperty(Type, StringEnum),
+    }, {
+        additionalProperties: false,
+        anyOf: [
+            Type.Object({ attached: Type.Literal(true), sessionMode: Type.Optional(StringEnum(["auto"])) }, { not: { required: ["url"] } }),
+            Type.Object({ url: Type.String(), attached: Type.Optional(Type.Literal(false)) }),
+        ],
+    }));
+}
+export function createAgentBrowserElectronParamsSchema(Type = JsonSchema, StringEnum = localStringEnum) {
+    const common = { outputPath: outputProperties(Type).outputPath };
+    const timeoutMs = Type.Optional(Type.Integer({ minimum: 1 }));
+    return Type.Unsafe(Type.Union([
+        Type.Object({
+            action: StringEnum(["list"]),
+            query: Type.Optional(Type.String({ description: "Case-insensitive app filter.", minLength: 1 })),
+            maxResults: Type.Optional(Type.Integer({ description: `Result cap; default ${ELECTRON_DISCOVERY_DEFAULT_MAX_RESULTS}, clamped to ${ELECTRON_DISCOVERY_MAX_RESULTS}.`, minimum: 1 })),
+            ...common,
+        }, { additionalProperties: false }),
+        Type.Object({
+            action: StringEnum(["launch"]),
+            appPath: Type.Optional(Type.String({ description: "macOS .app path.", minLength: 1 })),
+            appName: Type.Optional(Type.String({ description: "Name from agent_browser_electron list.", minLength: 1 })),
+            bundleId: Type.Optional(Type.String({ minLength: 1 })),
+            executablePath: Type.Optional(Type.String({ minLength: 1 })),
+            appArgs: Type.Optional(Type.Array(Type.String({ minLength: 1 }))),
+            handoff: Type.Optional(StringEnum(AGENT_BROWSER_ELECTRON_HANDOFFS)),
+            targetType: Type.Optional(StringEnum(AGENT_BROWSER_ELECTRON_TARGET_TYPES)),
+            timeoutMs,
+            allow: Type.Optional(Type.Array(Type.String({ minLength: 1 }))),
+            deny: Type.Optional(Type.Array(Type.String({ minLength: 1 }))),
+            ...common,
+        }, { additionalProperties: false }),
+        Type.Object({
+            action: StringEnum(["status", "cleanup"]),
+            launchId: Type.Optional(Type.String({ minLength: 1 })),
+            all: Type.Optional(Type.Literal(true)),
+            timeoutMs,
+            ...common,
+        }, { additionalProperties: false, not: { required: ["launchId", "all"] } }),
+        Type.Object({
+            action: StringEnum(["probe"]),
+            launchId: Type.Optional(Type.String({ minLength: 1 })),
+            timeoutMs,
+            ...common,
+        }, { additionalProperties: false }),
+    ]));
+}
+export function createAgentBrowserSourceParamsSchema(Type = JsonSchema, StringEnum = localStringEnum) {
+    return Type.Unsafe(Type.Object({
+        selector: Type.Optional(Type.String({ description: "Visible selector or @ref." })),
+        reactFiberId: Type.Optional(Type.String({ description: "React fiber id; requires --enable react-devtools." })),
+        componentName: Type.Optional(Type.String({ description: "Component for local source search." })),
+        includeDomHints: Type.Optional(Type.Boolean({ description: "Inspect DOM hints; default true." })),
+        maxWorkspaceFiles: Type.Optional(Type.Integer({ description: "Source scan cap; default 2000.", minimum: 1, maximum: SOURCE_LOOKUP_MAX_WORKSPACE_FILES })),
+        ...outputProperties(Type),
+        sessionMode: sessionModeProperty(Type, StringEnum),
+    }, { additionalProperties: false }));
+}
+export function createAgentBrowserNetworkSourceParamsSchema(Type = JsonSchema, StringEnum = localStringEnum) {
+    return Type.Unsafe(Type.Object({
+        filter: Type.Optional(Type.String({ description: "Network request filter." })),
+        namespace: Type.Optional(Type.String()),
+        requestId: Type.Optional(Type.String({ description: "Request id to inspect." })),
+        session: Type.Optional(Type.String()),
+        url: Type.Optional(Type.String({ description: "Failed URL or fragment." })),
+        maxWorkspaceFiles: Type.Optional(Type.Integer({ description: "Source scan cap; default 2000.", minimum: 1, maximum: SOURCE_LOOKUP_MAX_WORKSPACE_FILES })),
+        ...outputProperties(Type),
+        sessionMode: sessionModeProperty(Type, StringEnum),
+    }, { additionalProperties: false }));
+}
+export function createAgentBrowserToolsParamsSchema(Type = JsonSchema, StringEnum = localStringEnum) {
+    return Type.Unsafe(Type.Object({
+        enable: Type.Optional(Type.Array(StringEnum(AGENT_BROWSER_ADVANCED_TOOLS), { description: "Add capabilities to active tools; omit to list inventory." })),
+    }, { additionalProperties: false }));
 }
 export const AGENT_BROWSER_PARAMS = createAgentBrowserParamsSchema();
+export const AGENT_BROWSER_CODE_PARAMS = createAgentBrowserCodeParamsSchema();
+export const AGENT_BROWSER_ACTION_PARAMS = createAgentBrowserActionParamsSchema();
+export const AGENT_BROWSER_QA_PARAMS = createAgentBrowserQaParamsSchema();
+export const AGENT_BROWSER_ELECTRON_PARAMS = createAgentBrowserElectronParamsSchema();
+export const AGENT_BROWSER_SOURCE_PARAMS = createAgentBrowserSourceParamsSchema();
+export const AGENT_BROWSER_NETWORK_SOURCE_PARAMS = createAgentBrowserNetworkSourceParamsSchema();
+export const AGENT_BROWSER_TOOLS_PARAMS = createAgentBrowserToolsParamsSchema();