@ai-agent-forge/agent-forge 0.88.4 → 0.88.6

package/bundled-plugins/browser-playwright/dist/capability.js

@@ -0,0 +1,612 @@
+/**
+ * Browser capability factory: registers the seventeen browser tools on a
+ * `CapabilityAPI` and shapes every result as `PluginResultV1`.
+ *
+ * Tool surface: `browser_navigate`, `browser_snapshot`, `browser_locator_action`
+ * (click/dblclick/rightclick/fill/type/press/hover/select/check/uncheck/clear/
+ * upload/scroll), `browser_assert_postcondition`, `browser_collect_evidence`,
+ * the self-installing `browser_setup`, plus the prewritten operation tools
+ * `browser_evaluate` (escape hatch), `browser_console`, `browser_network`,
+ * `browser_performance`, `browser_wait`, `browser_drag`, `browser_mouse`,
+ * `browser_press_key`, `browser_tabs`, `browser_storage`, and
+ * `browser_viewport`. The readonly mode registers only the observation-only
+ * tools (`snapshot`, `assert_postcondition`, `collect_evidence`, `console`,
+ * `network`, `performance`, `wait`); everything that changes browser or disk
+ * state never registers there.
+ *
+ * All browser state lives behind the injected `BrowserRuntimeV1`; the factory
+ * itself has no Playwright knowledge. Error messages are sanitized like the
+ * pre-split capability: URLs collapse to origin + pathname (<=512) and the
+ * total message stays within 2048 chars.
+ */
+import { buildPluginResultV1, } from "@agent-forge/plugin-sdk";
+import { Type } from "typebox";
+import { boundedPreviewV1 } from "./setup.js";
+function objectInput(first, second) {
+    const value = second === undefined ? first : second;
+    if (value === null || typeof value !== "object" || Array.isArray(value)) {
+        throw new Error("Plugin tool input must be an object");
+    }
+    return value;
+}
+function toolInvocation(first, second) {
+    return {
+        input: objectInput(first, second),
+        operationId: typeof first === "string" && first.trim() !== "" ? first : "profile-runtime-tool-call",
+    };
+}
+function signalFrom(value) {
+    return value instanceof AbortSignal ? value : undefined;
+}
+function nonEmptyString(value, label) {
+    if (typeof value !== "string" || value.trim() === "")
+        throw new Error(`${label} must be a non-empty string`);
+    return value;
+}
+function requiredInteger(value, label) {
+    if (typeof value !== "number" || !Number.isInteger(value))
+        throw new Error(`${label} must be an integer`);
+    return value;
+}
+/** URL-sanitized, 2048-char bounded error text (pre-split browser contract). */
+function browserVisibleError(value) {
+    const raw = value instanceof Error && value.message.trim() !== "" ? value.message : "Browser operation failed";
+    const sanitized = raw.replace(/https?:\/\/[^\s"'<>]+/giu, (candidate) => {
+        try {
+            const parsed = new URL(candidate);
+            return `${parsed.origin}${parsed.pathname.slice(0, 512)}`;
+        }
+        catch {
+            return candidate.slice(0, 512);
+        }
+    });
+    return sanitized.length > 2048 ? `${sanitized.slice(0, 2047)}…` : sanitized;
+}
+function browserAbort(value) {
+    if (value instanceof Error && value.name === "AbortError")
+        return true;
+    return typeof value === "object" && value !== null && value.code === "ABORT_ERR";
+}
+const browserLocatorSchema = Type.Object({
+    kind: Type.Union([
+        Type.Literal("css"),
+        Type.Literal("id"),
+        Type.Literal("role"),
+        Type.Literal("text"),
+        Type.Literal("test-id"),
+    ]),
+    value: Type.String({ minLength: 1 }),
+    name: Type.Optional(Type.String()),
+});
+const browserMouseActionSchema = Type.Union([
+    Type.Literal("move"),
+    Type.Literal("click"),
+    Type.Literal("dblclick"),
+    Type.Literal("rightclick"),
+    Type.Literal("wheel"),
+]);
+const browserMouseButtonSchema = Type.Union([Type.Literal("left"), Type.Literal("right"), Type.Literal("middle")]);
+const browserTabsActionSchema = Type.Union([
+    Type.Literal("list"),
+    Type.Literal("new"),
+    Type.Literal("switch"),
+    Type.Literal("close"),
+]);
+const browserStorageActionSchema = Type.Union([
+    Type.Literal("get-cookies"),
+    Type.Literal("set-cookie"),
+    Type.Literal("clear-cookies"),
+    Type.Literal("get-local"),
+    Type.Literal("set-local"),
+    Type.Literal("clear-local"),
+]);
+const browserViewportActionSchema = Type.Union([Type.Literal("set"), Type.Literal("get")]);
+const browserWaitUntilKindSchema = Type.Union([
+    Type.Literal("selector"),
+    Type.Literal("navigation"),
+    Type.Literal("networkidle"),
+    Type.Literal("time"),
+]);
+const browserConsoleLevelSchema = Type.String({
+    pattern: "^(error|warning|info|debug)(,(error|warning|info|debug))*$",
+});
+const browserPostconditionSchema = Type.Union([
+    Type.Object({
+        kind: Type.Literal("url"),
+        equals: Type.String({ minLength: 1 }),
+        contains: Type.Optional(Type.String({ minLength: 1 })),
+    }),
+    Type.Object({
+        kind: Type.Literal("url"),
+        equals: Type.Optional(Type.String({ minLength: 1 })),
+        contains: Type.String({ minLength: 1 }),
+    }),
+    Type.Object({
+        kind: Type.Literal("element"),
+        locator: browserLocatorSchema,
+        state: Type.Union([Type.Literal("visible"), Type.Literal("hidden"), Type.Literal("value")]),
+        value: Type.Optional(Type.String()),
+    }),
+    Type.Object({
+        kind: Type.Literal("text"),
+        locator: Type.Optional(browserLocatorSchema),
+        contains: Type.String({ minLength: 1 }),
+    }),
+    Type.Object({
+        kind: Type.Literal("console"),
+        contains: Type.String({ minLength: 1 }),
+        level: Type.Optional(Type.String()),
+    }),
+    Type.Object({
+        kind: Type.Literal("network"),
+        containsUrl: Type.String({ minLength: 1 }),
+        status: Type.Optional(Type.Integer({ minimum: 100, maximum: 599 })),
+    }),
+]);
+const browserPostconditionInputSchema = Type.Union([
+    browserPostconditionSchema,
+    Type.Array(browserPostconditionSchema, { minItems: 1, maxItems: 32 }),
+]);
+function setupResult(operationId, outcome) {
+    if (!outcome.ok) {
+        return buildPluginResultV1({
+            version: 1,
+            operationId,
+            status: "failed",
+            summary: "Playwright browser dependency setup failed",
+            artifacts: [],
+            evidence: [],
+            error: {
+                version: 1,
+                code: "browser_setup_failed",
+                message: boundedPreviewV1(outcome.message, 8192),
+            },
+        });
+    }
+    return buildPluginResultV1({
+        version: 1,
+        operationId,
+        status: "succeeded",
+        summary: outcome.alreadyInstalled
+            ? "Playwright browser dependencies are already installed"
+            : "Playwright browser dependencies installed",
+        artifacts: [],
+        evidence: [
+            {
+                version: 1,
+                evidenceId: `${operationId}-evidence-1`,
+                kind: "log",
+                operationId,
+                summary: outcome.log.trim() === "" ? "(no output)" : boundedPreviewV1(outcome.log, 4096),
+            },
+        ],
+        verification: {
+            version: 1,
+            status: "passed",
+            checks: [outcome.alreadyInstalled ? "playwright-already-installed" : "playwright-install-completed"],
+        },
+    });
+}
+export function createBrowserCapabilityFactoryV1(runtime) {
+    return (api) => {
+        const readonlyMode = api.host.mode === "readonly";
+        let session;
+        const connect = () => {
+            if (session === undefined)
+                session = runtime.connect();
+            return session;
+        };
+        const withSession = async (operationId, action) => {
+            let active;
+            try {
+                active = await connect();
+            }
+            catch (error) {
+                session = undefined;
+                return buildPluginResultV1({
+                    version: 1,
+                    operationId,
+                    status: browserAbort(error) ? "cancelled" : "failed",
+                    summary: "Browser session connection failed",
+                    artifacts: [],
+                    evidence: [],
+                    error: {
+                        version: 1,
+                        code: browserAbort(error) ? "cancelled" : "browser_connection_failed",
+                        message: browserAbort(error) ? "Browser operation was cancelled" : browserVisibleError(error),
+                    },
+                });
+            }
+            try {
+                return await action(active);
+            }
+            catch (error) {
+                return buildPluginResultV1({
+                    version: 1,
+                    operationId,
+                    status: browserAbort(error) ? "cancelled" : "failed",
+                    summary: "Browser operation failed",
+                    artifacts: [],
+                    evidence: [],
+                    error: {
+                        version: 1,
+                        code: browserAbort(error) ? "cancelled" : "browser_operation_failed",
+                        message: browserAbort(error) ? "Browser operation was cancelled" : browserVisibleError(error),
+                    },
+                });
+            }
+        };
+        const operationOptions = (operationId, third) => ({
+            operationId,
+            ...(signalFrom(third) === undefined ? {} : { signal: signalFrom(third) }),
+        });
+        const registrations = [];
+        if (!readonlyMode) {
+            registrations.push(api.registerTool({
+                name: "browser_navigate",
+                label: "Browser navigate",
+                description: "Navigate the active browser session and return structured verification evidence. Requires Playwright in <agentDir>/browser-deps; when missing, run browser_setup or follow the returned install commands",
+                parameters: Type.Object({
+                    url: Type.String({ minLength: 1 }),
+                    waitUntil: Type.Optional(Type.Union([
+                        Type.Literal("commit"),
+                        Type.Literal("domcontentloaded"),
+                        Type.Literal("load"),
+                        Type.Literal("networkidle"),
+                    ])),
+                }),
+                execute: async (first, second, third) => {
+                    const { input, operationId } = toolInvocation(first, second);
+                    return withSession(operationId, (active) => active.navigate({
+                        url: nonEmptyString(input.url, "url"),
+                        ...(input.waitUntil === undefined
+                            ? {}
+                            : { waitUntil: input.waitUntil }),
+                    }, operationOptions(operationId, third)));
+                },
+            }));
+        }
+        registrations.push(api.registerTool({
+            name: "browser_snapshot",
+            label: "Browser snapshot",
+            description: "Capture accessibility, DOM, or screenshot evidence from the active browser session (styles capture is not supported in this build)",
+            parameters: Type.Object({
+                includeDom: Type.Optional(Type.Boolean()),
+                includeA11y: Type.Optional(Type.Boolean()),
+                includeStyles: Type.Optional(Type.Boolean()),
+                includeScreenshot: Type.Optional(Type.Boolean()),
+            }),
+            execute: async (first, second, third) => {
+                const { input, operationId } = toolInvocation(first, second);
+                return withSession(operationId, (active) => active.snapshot(input, operationOptions(operationId, third)));
+            },
+        }));
+        if (!readonlyMode) {
+            registrations.push(api.registerTool({
+                name: "browser_locator_action",
+                label: "Browser locator action",
+                description: "Perform a locator-based browser action (click/dblclick/rightclick/fill/type/press/hover/select/check/uncheck/clear/upload/scroll) and return post-action accessibility evidence",
+                parameters: Type.Object({
+                    locator: browserLocatorSchema,
+                    action: Type.Union([
+                        Type.Literal("click"),
+                        Type.Literal("dblclick"),
+                        Type.Literal("rightclick"),
+                        Type.Literal("fill"),
+                        Type.Literal("type"),
+                        Type.Literal("press"),
+                        Type.Literal("hover"),
+                        Type.Literal("select"),
+                        Type.Literal("check"),
+                        Type.Literal("uncheck"),
+                        Type.Literal("clear"),
+                        Type.Literal("upload"),
+                        Type.Literal("scroll"),
+                    ]),
+                    value: Type.Optional(Type.String({ maxLength: 4096 })),
+                    key: Type.Optional(Type.String({ maxLength: 128 })),
+                    delay: Type.Optional(Type.Integer({ minimum: 0, maximum: 60_000 })),
+                }),
+                execute: async (first, second, third) => {
+                    const { input, operationId } = toolInvocation(first, second);
+                    return withSession(operationId, (active) => active.locatorAction(input, operationOptions(operationId, third)));
+                },
+            }));
+        }
+        registrations.push(api.registerTool({
+            name: "browser_assert_postcondition",
+            label: "Browser assertion",
+            description: "Assert a URL, element, text, console, or network postcondition (single condition or an array of 1..32, all ANDed) without changing the browser",
+            parameters: Type.Object({
+                condition: browserPostconditionInputSchema,
+            }),
+            execute: async (first, second, third) => {
+                const { input, operationId } = toolInvocation(first, second);
+                return withSession(operationId, (active) => active.assertPostcondition(input.condition, operationOptions(operationId, third)));
+            },
+        }));
+        registrations.push(api.registerTool({
+            name: "browser_collect_evidence",
+            label: "Browser evidence",
+            description: "Collect console, network, or accessibility-snapshot evidence from the active browser session without changing it",
+            parameters: Type.Object({
+                kind: Type.Union([Type.Literal("console"), Type.Literal("network"), Type.Literal("snapshot")]),
+            }),
+            execute: async (first, second, third) => {
+                const { input, operationId } = toolInvocation(first, second);
+                const kind = input.kind;
+                if (kind !== "console" && kind !== "network" && kind !== "snapshot") {
+                    throw new Error("kind must be console, network, or snapshot");
+                }
+                return withSession(operationId, (active) => active.collectEvidence(kind, operationOptions(operationId, third)));
+            },
+        }));
+        registrations.push(api.registerTool({
+            name: "browser_console",
+            label: "Browser console",
+            description: "Read the bounded console ring buffer (page messages plus auto-accepted [dialog] traces) with optional level/contains filters, without changing the browser",
+            parameters: Type.Object({
+                level: Type.Optional(browserConsoleLevelSchema),
+                contains: Type.Optional(Type.String({ minLength: 1 })),
+                limit: Type.Optional(Type.Integer({ minimum: 1, maximum: 200 })),
+            }),
+            execute: async (first, second, third) => {
+                const { input, operationId } = toolInvocation(first, second);
+                return withSession(operationId, (active) => active.consoleEntries({
+                    ...(typeof input.level === "string" ? { level: input.level } : {}),
+                    ...(typeof input.contains === "string" ? { contains: input.contains } : {}),
+                    ...(typeof input.limit === "number" ? { limit: input.limit } : {}),
+                }, operationOptions(operationId, third)));
+            },
+        }), api.registerTool({
+            name: "browser_network",
+            label: "Browser network",
+            description: "Read the bounded network ring buffer (method/url/status/duration/size when available) with optional containsUrl/status/method filters, without changing the browser",
+            parameters: Type.Object({
+                containsUrl: Type.Optional(Type.String({ minLength: 1 })),
+                status: Type.Optional(Type.Integer({ minimum: 100, maximum: 599 })),
+                method: Type.Optional(Type.String({ minLength: 1, maxLength: 16 })),
+                limit: Type.Optional(Type.Integer({ minimum: 1, maximum: 200 })),
+            }),
+            execute: async (first, second, third) => {
+                const { input, operationId } = toolInvocation(first, second);
+                return withSession(operationId, (active) => active.networkEntries({
+                    ...(typeof input.containsUrl === "string" ? { containsUrl: input.containsUrl } : {}),
+                    ...(typeof input.status === "number" ? { status: input.status } : {}),
+                    ...(typeof input.method === "string" ? { method: input.method } : {}),
+                    ...(typeof input.limit === "number" ? { limit: input.limit } : {}),
+                }, operationOptions(operationId, third)));
+            },
+        }), api.registerTool({
+            name: "browser_performance",
+            label: "Browser performance",
+            description: "Read structured page performance metrics (Navigation Timing, paint, resource summary, DOM node count) without changing the browser",
+            parameters: Type.Object({}),
+            execute: async (first, second, third) => {
+                const { operationId } = toolInvocation(first, second);
+                return withSession(operationId, (active) => active.performance(operationOptions(operationId, third)));
+            },
+        }), api.registerTool({
+            name: "browser_wait",
+            label: "Browser wait",
+            description: "Wait until a selector is visible, navigation completes, the network goes idle, or a fixed time passes (max 30s) and report the actual wait duration",
+            parameters: Type.Object({
+                until: browserWaitUntilKindSchema,
+                locator: Type.Optional(browserLocatorSchema),
+                ms: Type.Optional(Type.Integer({ minimum: 0, maximum: 30_000 })),
+            }),
+            execute: async (first, second, third) => {
+                const { input, operationId } = toolInvocation(first, second);
+                const until = input.until;
+                if (until !== "selector" && until !== "navigation" && until !== "networkidle" && until !== "time") {
+                    throw new Error("until must be selector, navigation, networkidle, or time");
+                }
+                return withSession(operationId, (active) => active.wait({
+                    until,
+                    ...(until === "selector" ? { locator: input.locator } : {}),
+                    ...(typeof input.ms === "number" ? { ms: input.ms } : {}),
+                }, operationOptions(operationId, third)));
+            },
+        }));
+        if (!readonlyMode) {
+            registrations.push(api.registerTool({
+                name: "browser_evaluate",
+                label: "Browser evaluate",
+                description: "Escape hatch: evaluate a JavaScript expression in the page context and return the JSON-serialized result (bounded 64KiB, 30s timeout; dialogs are auto-accepted). Keep it a plain expression; for multi-statement logic use an IIFE string like ((() => { ... return x; })()) — a bare () => ... arrow string is not invoked and yields undefined. Only use this when no built-in browser tool covers the operation",
+                parameters: Type.Object({
+                    expression: Type.String({ minLength: 1, maxLength: 32_768 }),
+                    arg: Type.Optional(Type.Unknown()),
+                }),
+                execute: async (first, second, third) => {
+                    const { input, operationId } = toolInvocation(first, second);
+                    return withSession(operationId, (active) => active.evaluate({
+                        expression: nonEmptyString(input.expression, "expression"),
+                        ...(input.arg === undefined ? {} : { arg: input.arg }),
+                    }, operationOptions(operationId, third)));
+                },
+            }), api.registerTool({
+                name: "browser_drag",
+                label: "Browser drag",
+                description: "Drag from one element to another (hover source, press, hover target, stepped move to target center, release)",
+                parameters: Type.Object({
+                    from: browserLocatorSchema,
+                    to: browserLocatorSchema,
+                    steps: Type.Optional(Type.Integer({ minimum: 1, maximum: 100 })),
+                }),
+                execute: async (first, second, third) => {
+                    const { input, operationId } = toolInvocation(first, second);
+                    return withSession(operationId, (active) => active.drag({
+                        from: input.from,
+                        to: input.to,
+                        ...(typeof input.steps === "number" ? { steps: input.steps } : {}),
+                    }, operationOptions(operationId, third)));
+                },
+            }), api.registerTool({
+                name: "browser_mouse",
+                label: "Browser mouse",
+                description: "Raw mouse actions at viewport coordinates without needing an element (move/click/dblclick/rightclick/wheel); wheel is the basic page-scroll primitive",
+                parameters: Type.Object({
+                    action: browserMouseActionSchema,
+                    x: Type.Integer({ minimum: 0 }),
+                    y: Type.Integer({ minimum: 0 }),
+                    deltaX: Type.Optional(Type.Integer({ minimum: -100_000, maximum: 100_000 })),
+                    deltaY: Type.Optional(Type.Integer({ minimum: -100_000, maximum: 100_000 })),
+                    button: Type.Optional(browserMouseButtonSchema),
+                }),
+                execute: async (first, second, third) => {
+                    const { input, operationId } = toolInvocation(first, second);
+                    return withSession(operationId, (active) => active.mouse({
+                        action: input.action,
+                        x: requiredInteger(input.x, "x"),
+                        y: requiredInteger(input.y, "y"),
+                        ...(typeof input.deltaX === "number" ? { deltaX: input.deltaX } : {}),
+                        ...(typeof input.deltaY === "number" ? { deltaY: input.deltaY } : {}),
+                        ...(input.button === undefined ? {} : { button: input.button }),
+                    }, operationOptions(operationId, third)));
+                },
+            }), api.registerTool({
+                name: "browser_press_key",
+                label: "Browser press key",
+                description: "Press a page-level key combination by Playwright key name (e.g. Control+a, Enter, Meta+c) without needing an element",
+                parameters: Type.Object({
+                    key: Type.String({ minLength: 1, maxLength: 128 }),
+                    delay: Type.Optional(Type.Integer({ minimum: 0, maximum: 60_000 })),
+                }),
+                execute: async (first, second, third) => {
+                    const { input, operationId } = toolInvocation(first, second);
+                    return withSession(operationId, (active) => active.pressKey({
+                        key: nonEmptyString(input.key, "key"),
+                        ...(typeof input.delay === "number" ? { delay: input.delay } : {}),
+                    }, operationOptions(operationId, third)));
+                },
+            }), api.registerTool({
+                name: "browser_tabs",
+                label: "Browser tabs",
+                description: "Manage browser tabs: list (title/url/index), new (optional url), switch by index, or close by index",
+                parameters: Type.Object({
+                    action: browserTabsActionSchema,
+                    index: Type.Optional(Type.Integer({ minimum: 0 })),
+                    url: Type.Optional(Type.String({ minLength: 1, maxLength: 4096 })),
+                }),
+                execute: async (first, second, third) => {
+                    const { input, operationId } = toolInvocation(first, second);
+                    return withSession(operationId, (active) => active.tabs({
+                        action: input.action,
+                        ...(typeof input.index === "number" ? { index: input.index } : {}),
+                        ...(typeof input.url === "string" ? { url: input.url } : {}),
+                    }, operationOptions(operationId, third)));
+                },
+            }), api.registerTool({
+                name: "browser_storage",
+                label: "Browser storage",
+                description: "Manage browser storage: cookies (get-cookies/set-cookie/clear-cookies via the context) and localStorage (get-local/set-local/clear-local via the page)",
+                parameters: Type.Object({
+                    action: browserStorageActionSchema,
+                    name: Type.Optional(Type.String({ minLength: 1, maxLength: 4096 })),
+                    value: Type.Optional(Type.String({ maxLength: 4096 })),
+                    domain: Type.Optional(Type.String({ minLength: 1, maxLength: 255 })),
+                    path: Type.Optional(Type.String({ maxLength: 1024 })),
+                    expires: Type.Optional(Type.Number()),
+                    key: Type.Optional(Type.String({ minLength: 1, maxLength: 4096 })),
+                }),
+                execute: async (first, second, third) => {
+                    const { input, operationId } = toolInvocation(first, second);
+                    return withSession(operationId, (active) => active.storage({
+                        action: input.action,
+                        ...(typeof input.name === "string" ? { name: input.name } : {}),
+                        ...(typeof input.value === "string" ? { value: input.value } : {}),
+                        ...(typeof input.domain === "string" ? { domain: input.domain } : {}),
+                        ...(typeof input.path === "string" ? { path: input.path } : {}),
+                        ...(typeof input.expires === "number" ? { expires: input.expires } : {}),
+                        ...(typeof input.key === "string" ? { key: input.key } : {}),
+                    }, operationOptions(operationId, third)));
+                },
+            }), api.registerTool({
+                name: "browser_viewport",
+                label: "Browser viewport",
+                description: "Set the viewport size (width/height clamped into 320..7680) or read the current one",
+                parameters: Type.Object({
+                    action: browserViewportActionSchema,
+                    width: Type.Optional(Type.Integer({ minimum: 0, maximum: 100_000 })),
+                    height: Type.Optional(Type.Integer({ minimum: 0, maximum: 100_000 })),
+                }),
+                execute: async (first, second, third) => {
+                    const { input, operationId } = toolInvocation(first, second);
+                    return withSession(operationId, (active) => active.viewport({
+                        action: input.action,
+                        ...(typeof input.width === "number" ? { width: input.width } : {}),
+                        ...(typeof input.height === "number" ? { height: input.height } : {}),
+                    }, operationOptions(operationId, third)));
+                },
+            }));
+        }
+        if (!readonlyMode) {
+            registrations.push(api.registerTool({
+                name: "browser_setup",
+                label: "Browser setup",
+                description: "Install Playwright and the Chromium browser into <agentDir>/browser-deps (npm install playwright --prefix <dir>, then npx playwright install chromium). Reports alreadyInstalled when dependencies are present",
+                parameters: Type.Object({}),
+                execute: async (first, second, third) => {
+                    const { operationId } = toolInvocation(first, second);
+                    const signal = signalFrom(third);
+                    if (signal?.aborted) {
+                        return buildPluginResultV1({
+                            version: 1,
+                            operationId,
+                            status: "cancelled",
+                            summary: "Browser operation was cancelled",
+                            artifacts: [],
+                            evidence: [],
+                            error: { version: 1, code: "cancelled", message: "Browser operation was cancelled" },
+                        });
+                    }
+                    // Call through the runtime: extracting the method would drop
+                    // `this`, and the production class reads `this.options` in setup().
+                    if (runtime.setup === undefined) {
+                        return buildPluginResultV1({
+                            version: 1,
+                            operationId,
+                            status: "failed",
+                            summary: "This browser runtime does not support self-installation",
+                            artifacts: [],
+                            evidence: [],
+                            error: {
+                                version: 1,
+                                code: "browser_setup_unsupported",
+                                message: "The injected browser runtime exposes no setup face. Install Playwright manually with npm install playwright --prefix <agentDir>/browser-deps and npx playwright install chromium.",
+                            },
+                        });
+                    }
+                    try {
+                        return setupResult(operationId, await runtime.setup());
+                    }
+                    catch (error) {
+                        return buildPluginResultV1({
+                            version: 1,
+                            operationId,
+                            status: "failed",
+                            summary: "Playwright browser dependency setup failed",
+                            artifacts: [],
+                            evidence: [],
+                            error: {
+                                version: 1,
+                                code: "browser_setup_failed",
+                                message: browserVisibleError(error),
+                            },
+                        });
+                    }
+                },
+            }));
+        }
+        return {
+            dispose: () => {
+                if (session === undefined)
+                    return;
+                // Both a failed connection and a failed close happen after this synchronous
+                // disposer returns. Consume either rejection so disposal cannot leak a promise.
+                void session.then((active) => active.close()).catch(() => undefined);
+            },
+        };
+    };
+}
+//# sourceMappingURL=capability.js.map