@stablyai/playwright-base 2.0.12-rc.1 → 2.0.12

package/dist/index.d.cts

@@ -0,0 +1,227 @@
+import * as _playwright_test from '@playwright/test';
+import { BrowserContext, Page, Locator, MatcherReturnType, Browser, BrowserType } from '@playwright/test';
+import * as z4 from 'zod/v4/core';
+
+type AnthropicModel = "anthropic/claude-sonnet-4-5-20250929";
+type GeminiModel = "google/gemini-2.5-computer-use-preview-10-2025";
+type Model = AnthropicModel | GeminiModel | (string & {});
+
+/**
+ * Options for configuring agent behavior during execution.
+ */
+type AgentActOptions = {
+    /**
+     * The page the agent will operate on.
+     */
+    page: Page;
+    /**
+     * Maximum number of thinking cycles the agent can perform.
+     * Each cycle includes observing the page, planning, and executing one or more actions.
+     * @default 30
+     */
+    maxCycles?: number;
+    /**
+     * AI model to use for agent reasoning.
+     * Different models may have different capabilities and performance characteristics.
+     */
+    model?: Model;
+};
+/**
+ * AI agent for automating browser interactions using natural language.
+ *
+ * The Agent can perform complex browser actions by interpreting natural language instructions.
+ * It observes the page state, makes decisions, and executes actions autonomously.
+ *
+ * Agents are created via {@link BrowserContext.newAgent} or {@link Browser.newAgent}.
+ *
+ * @example
+ * ```typescript
+ * const agent = context.newAgent();
+ * await agent.act('Fill out the login form and submit', { page });
+ * ```
+ */
+declare class Agent {
+    readonly browserContext: BrowserContext;
+    constructor(browserContext: BrowserContext);
+    /**
+     * Instructs the agent to perform actions on the page using natural language.
+     *
+     * The agent will analyze the page, plan actions, and execute them autonomously.
+     * It can perform multiple actions such as clicking, typing, navigating, and verifying
+     * page state based on the provided instruction.
+     *
+     * @param prompt - Natural language instruction describing what the agent should do
+     * @param options - Configuration for the agent's behavior including the page to operate on
+     * @returns Promise that resolves when the agent successfully completes the task
+     * @throws {Error} Throws an error if the agent fails to complete the task. The error message includes the AI's reasoning for the failure.
+     *
+     * @example
+     * ```typescript
+     * // Simple action
+     * await agent.act('Click the login button', { page });
+     *
+     * // Complex multi-step action
+     * await agent.act('Navigate to settings, enable notifications, and save changes', { page });
+     *
+     * // With custom options
+     * await agent.act('Complete the checkout process', {
+     *   page,
+     *   maxCycles: 20,
+     *   model: 'gpt-4'
+     * });
+     *
+     * // Handling failures with try-catch
+     * try {
+     *   await agent.act('Complete the task', { page });
+     *   console.log('Agent completed the task successfully');
+     * } catch (error) {
+     *   console.error('Agent failed:', error.message);
+     * }
+     * ```
+     */
+    act(prompt: string, options: AgentActOptions): Promise<void>;
+}
+
+type ExtractSchema = {
+    safeParseAsync(data: unknown, params?: z4.ParseContext<z4.$ZodIssue>): Promise<z4.util.SafeParseResult<z4.output<any>>>;
+} & z4.$ZodType;
+type SchemaOutput<T extends ExtractSchema> = z4.output<T>;
+
+type MatcherContext = {
+    isNot: boolean;
+    message?: () => string;
+};
+declare const stablyPlaywrightMatchers: {
+    readonly toMatchScreenshotPrompt: (this: MatcherContext, received: Page | Locator, condition: string, options?: ScreenshotPromptOptions) => Promise<MatcherReturnType>;
+};
+
+declare function augmentLocator<T extends Locator>(locator: T): T;
+declare function augmentPage<T extends Page>(page: T): T;
+declare function augmentBrowserContext<T extends BrowserContext>(context: T): T;
+declare function augmentBrowser<T extends Browser>(browser: T): T;
+declare function augmentBrowserType<TBrowser extends Browser>(browserType: BrowserType<TBrowser>): BrowserType<TBrowser>;
+
+declare function setApiKey(apiKey: string): void;
+declare function requireApiKey(): string;
+
+type ScreenshotPromptOptions = _playwright_test.PageAssertionsToHaveScreenshotOptions;
+
+type Expect<T = Page> = {
+    toMatchScreenshotPrompt(condition: string, options?: ScreenshotPromptOptions): Promise<void>;
+};
+declare module "@playwright/test" {
+    interface Locator {
+        /**
+         * Extracts information from this locator using Stably AI.
+         *
+         * Takes a screenshot of the locator and uses AI to extract information based on the
+         * provided prompt. When a schema is provided, the extracted data is validated and
+         * typed according to the schema.
+         *
+         * @param prompt - A natural language description of what information to extract
+         * @returns A string containing the extracted information
+         */
+        extract(prompt: string): Promise<string>;
+        /**
+         * Extracts information from this locator using Stably AI.
+         *
+         * Takes a screenshot of the locator and uses AI to extract information based on the
+         * provided prompt. The extracted data is validated and typed according to the schema.
+         *
+         * @param prompt - A natural language description of what information to extract
+         * @param options - Configuration object containing the Zod schema for validation
+         * @param options.schema - Zod schema to validate and type the extracted data
+         * @returns Typed data matching the provided schema
+         */
+        extract<T extends ExtractSchema>(prompt: string, options: {
+            schema: T;
+        }): Promise<SchemaOutput<T>>;
+    }
+    interface Page {
+        /**
+         * Extracts information from this page using Stably AI.
+         *
+         * Takes a screenshot of the page and uses AI to extract information based on the
+         * provided prompt. When a schema is provided, the extracted data is validated and
+         * typed according to the schema.
+         *
+         * @param prompt - A natural language description of what information to extract
+         * @returns A string containing the extracted information
+         */
+        extract(prompt: string): Promise<string>;
+        /**
+         * Extracts information from this page using Stably AI.
+         *
+         * Takes a screenshot of the page and uses AI to extract information based on the
+         * provided prompt. The extracted data is validated and typed according to the schema.
+         *
+         * @param prompt - A natural language description of what information to extract
+         * @param options - Configuration object containing the Zod schema for validation
+         * @param options.schema - Zod schema to validate and type the extracted data
+         * @returns Typed data matching the provided schema
+         */
+        extract<T extends ExtractSchema>(prompt: string, options: {
+            schema: T;
+        }): Promise<SchemaOutput<T>>;
+    }
+    interface BrowserContext {
+        /**
+         * Creates a new AI agent instance for automating browser interactions.
+         *
+         * An agent can perform complex browser actions by interpreting natural language instructions.
+         * It observes the page, makes autonomous decisions, and executes actions like clicking,
+         * typing, navigating, and verifying page state.
+         *
+         * The agent operates within this browser context and can interact with all pages in the context.
+         * Use the returned agent's [agent.act(prompt, options)](#agent-act) method to give instructions.
+         * The page to operate on is specified when calling `act()`.
+         *
+         * **Usage**
+         *
+         * ```js
+         * const context = await browser.newContext();
+         * const page = await context.newPage();
+         * await page.goto('https://example.com');
+         *
+         * // Create an agent for this context
+         * const agent = context.newAgent();
+         *
+         * // Give the agent natural language instructions with the page to operate on
+         * await agent.act('Click the login button and enter credentials', { page });
+         * ```
+         */
+        newAgent(): Agent;
+    }
+    interface Browser {
+        /**
+         * Creates a new AI agent instance for automating browser interactions.
+         *
+         * An agent can perform complex browser actions by interpreting natural language instructions.
+         * It observes the page, makes autonomous decisions, and executes actions like clicking,
+         * typing, navigating, and verifying page state.
+         *
+         * The agent operates within a browser context and can interact with all pages in that context.
+         * Use the returned agent's [agent.act(prompt, options)](#agent-act) method to give instructions.
+         * The page to operate on is specified when calling `act()`.
+         *
+         * **Usage**
+         *
+         * ```js
+         * const browser = await chromium.launch();
+         * const page = await browser.newPage();
+         * await page.goto('https://example.com');
+         *
+         * // Create an agent
+         * const agent = browser.newAgent();
+         *
+         * // Give the agent natural language instructions with the page to operate on
+         * await agent.act('Fill out the registration form and submit', { page });
+         * ```
+         */
+        newAgent(): Agent;
+    }
+}
+
+export { Agent, augmentBrowser, augmentBrowserContext, augmentBrowserType, augmentLocator, augmentPage, requireApiKey, setApiKey, stablyPlaywrightMatchers };
+export type { Expect, ExtractSchema, SchemaOutput, ScreenshotPromptOptions };
+//# sourceMappingURL=index.d.cts.map

package/dist/index.d.cts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.cts","sources":["../src/playwright-augment/methods/agent/models.ts","../src/playwright-augment/methods/agent.ts","../src/ai/extract.ts","../src/expect.ts","../src/playwright-augment/augment.ts","../src/runtime.ts","../src/index.ts"],"mappings":";;;;AAAA,KAAK,cAAc;AACnB,KAAK,WAAW;AACV,KAAM,KAAK,GAAG,cAAc,GAAG,WAAW;;ACchD;;;AAGA,KAAK,eAAe;;;;UAIZ,IAAI;;;;;;;;;;;YAWF,KAAK;;AAQf;;;;;;;;;;;;;;AAcA,cAAa,KAAK;6BACqB,cAAc;gCAAd,cAAc;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iCAsChB,eAAe,GAAG,OAAO;;;ACnFxD,KAAM,aAAa;2CAGZ,EAAE,CAAC,YAAY,CAAC,EAAE,CAAC,SAAS,IAEpC,OAAO,CAAC,EAAE,CAAC,IAAI,CAAC,eAAe,CAAC,EAAE,CAAC,MAAM;IAC1C,EAAE,CAAC,QAAQ;AAET,KAAM,YAAY,WAAW,aAAa,IAAI,EAAE,CAAC,MAAM;;ACT7D,KAAK,cAAc;;;;AA+BnB,cAAa,wBAAwB;6CAE3B,cAAc,YACV,IAAI,GAAG,OAAO,+BAEd,uBAAuB,KAChC,OAAO,CAAC,iBAAiB;;;AChB9B,iBAAgB,cAAc,WAAW,OAAO;AAchD,iBAAgB,WAAW,WAAW,IAAI;AAiB1C,iBAAgB,qBAAqB,WAAW,cAAc;AA8B9D,iBAAgB,cAAc,WAAW,OAAO;AAuChD,iBAAgB,kBAAkB,kBAAkB,OAAO,eAC5C,WAAW,aACvB,WAAW;;ACpId,iBAAgB,SAAS;AAQzB,iBAAgB,aAAa;;ACQvB,KAAM,uBAAuB,GAEjC,gBAAyB,CAAE,qCAAqC;;AAY5D,KAAM,MAAM,KAAKA,IAAY;yDAGrB,uBAAuB,GAChC,OAAO;;AAGZ;;;;;;;;;;;;iCAa6B,OAAO;;;;;;;;;;;;0BAYd,aAAa;;YAG5B,OAAO,CAAC,YAAY;;;;;;;;;;;;;iCAeE,OAAO;;;;;;;;;;;;0BAYd,aAAa;;YAG5B,OAAO,CAAC,YAAY;;;;;;;;;;;;;;;;;;;;;;;;;;;;oBA+BXC,KAAkD;;;;;;;;;;;;;;;;;;;;;;;;;;;;oBA+BlDA,KAAkD","names":["InternalPage","__playwright_augment_methods_agent.Agent"]}

package/dist/index.d.mts

@@ -222,4 +222,6 @@ declare module "@playwright/test" {
     }
 }
 
-export { Agent, type Expect, type ExtractSchema, type SchemaOutput, type ScreenshotPromptOptions, augmentBrowser, augmentBrowserContext, augmentBrowserType, augmentLocator, augmentPage, requireApiKey, setApiKey, stablyPlaywrightMatchers };
+export { Agent, augmentBrowser, augmentBrowserContext, augmentBrowserType, augmentLocator, augmentPage, requireApiKey, setApiKey, stablyPlaywrightMatchers };
+export type { Expect, ExtractSchema, SchemaOutput, ScreenshotPromptOptions };
+//# sourceMappingURL=index.d.mts.map

package/dist/index.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.mts","sources":["../src/playwright-augment/methods/agent/models.ts","../src/playwright-augment/methods/agent.ts","../src/ai/extract.ts","../src/expect.ts","../src/playwright-augment/augment.ts","../src/runtime.ts","../src/index.ts"],"mappings":";;;;AAAA,KAAK,cAAc;AACnB,KAAK,WAAW;AACV,KAAM,KAAK,GAAG,cAAc,GAAG,WAAW;;ACchD;;;AAGA,KAAK,eAAe;;;;UAIZ,IAAI;;;;;;;;;;;YAWF,KAAK;;AAQf;;;;;;;;;;;;;;AAcA,cAAa,KAAK;6BACqB,cAAc;gCAAd,cAAc;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iCAsChB,eAAe,GAAG,OAAO;;;ACnFxD,KAAM,aAAa;2CAGZ,EAAE,CAAC,YAAY,CAAC,EAAE,CAAC,SAAS,IAEpC,OAAO,CAAC,EAAE,CAAC,IAAI,CAAC,eAAe,CAAC,EAAE,CAAC,MAAM;IAC1C,EAAE,CAAC,QAAQ;AAET,KAAM,YAAY,WAAW,aAAa,IAAI,EAAE,CAAC,MAAM;;ACT7D,KAAK,cAAc;;;;AA+BnB,cAAa,wBAAwB;6CAE3B,cAAc,YACV,IAAI,GAAG,OAAO,+BAEd,uBAAuB,KAChC,OAAO,CAAC,iBAAiB;;;AChB9B,iBAAgB,cAAc,WAAW,OAAO;AAchD,iBAAgB,WAAW,WAAW,IAAI;AAiB1C,iBAAgB,qBAAqB,WAAW,cAAc;AA8B9D,iBAAgB,cAAc,WAAW,OAAO;AAuChD,iBAAgB,kBAAkB,kBAAkB,OAAO,eAC5C,WAAW,aACvB,WAAW;;ACpId,iBAAgB,SAAS;AAQzB,iBAAgB,aAAa;;ACQvB,KAAM,uBAAuB,GAEjC,gBAAyB,CAAE,qCAAqC;;AAY5D,KAAM,MAAM,KAAKA,IAAY;yDAGrB,uBAAuB,GAChC,OAAO;;AAGZ;;;;;;;;;;;;iCAa6B,OAAO;;;;;;;;;;;;0BAYd,aAAa;;YAG5B,OAAO,CAAC,YAAY;;;;;;;;;;;;;iCAeE,OAAO;;;;;;;;;;;;0BAYd,aAAa;;YAG5B,OAAO,CAAC,YAAY;;;;;;;;;;;;;;;;;;;;;;;;;;;;oBA+BXC,KAAkD;;;;;;;;;;;;;;;;;;;;;;;;;;;;oBA+BlDA,KAAkD","names":["InternalPage","__playwright_augment_methods_agent.Agent"]}

package/dist/index.d.ts

@@ -222,4 +222,6 @@ declare module "@playwright/test" {
     }
 }
 
-export { Agent, type Expect, type ExtractSchema, type SchemaOutput, type ScreenshotPromptOptions, augmentBrowser, augmentBrowserContext, augmentBrowserType, augmentLocator, augmentPage, requireApiKey, setApiKey, stablyPlaywrightMatchers };
+export { Agent, augmentBrowser, augmentBrowserContext, augmentBrowserType, augmentLocator, augmentPage, requireApiKey, setApiKey, stablyPlaywrightMatchers };
+export type { Expect, ExtractSchema, SchemaOutput, ScreenshotPromptOptions };
+//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sources":["../src/playwright-augment/methods/agent/models.ts","../src/playwright-augment/methods/agent.ts","../src/ai/extract.ts","../src/expect.ts","../src/playwright-augment/augment.ts","../src/runtime.ts","../src/index.ts"],"mappings":";;;;AAAA,KAAK,cAAc;AACnB,KAAK,WAAW;AACV,KAAM,KAAK,GAAG,cAAc,GAAG,WAAW;;ACchD;;;AAGA,KAAK,eAAe;;;;UAIZ,IAAI;;;;;;;;;;;YAWF,KAAK;;AAQf;;;;;;;;;;;;;;AAcA,cAAa,KAAK;6BACqB,cAAc;gCAAd,cAAc;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iCAsChB,eAAe,GAAG,OAAO;;;ACnFxD,KAAM,aAAa;2CAGZ,EAAE,CAAC,YAAY,CAAC,EAAE,CAAC,SAAS,IAEpC,OAAO,CAAC,EAAE,CAAC,IAAI,CAAC,eAAe,CAAC,EAAE,CAAC,MAAM;IAC1C,EAAE,CAAC,QAAQ;AAET,KAAM,YAAY,WAAW,aAAa,IAAI,EAAE,CAAC,MAAM;;ACT7D,KAAK,cAAc;;;;AA+BnB,cAAa,wBAAwB;6CAE3B,cAAc,YACV,IAAI,GAAG,OAAO,+BAEd,uBAAuB,KAChC,OAAO,CAAC,iBAAiB;;;AChB9B,iBAAgB,cAAc,WAAW,OAAO;AAchD,iBAAgB,WAAW,WAAW,IAAI;AAiB1C,iBAAgB,qBAAqB,WAAW,cAAc;AA8B9D,iBAAgB,cAAc,WAAW,OAAO;AAuChD,iBAAgB,kBAAkB,kBAAkB,OAAO,eAC5C,WAAW,aACvB,WAAW;;ACpId,iBAAgB,SAAS;AAQzB,iBAAgB,aAAa;;ACQvB,KAAM,uBAAuB,GAEjC,gBAAyB,CAAE,qCAAqC;;AAY5D,KAAM,MAAM,KAAKA,IAAY;yDAGrB,uBAAuB,GAChC,OAAO;;AAGZ;;;;;;;;;;;;iCAa6B,OAAO;;;;;;;;;;;;0BAYd,aAAa;;YAG5B,OAAO,CAAC,YAAY;;;;;;;;;;;;;iCAeE,OAAO;;;;;;;;;;;;0BAYd,aAAa;;YAG5B,OAAO,CAAC,YAAY;;;;;;;;;;;;;;;;;;;;;;;;;;;;oBA+BXC,KAAkD;;;;;;;;;;;;;;;;;;;;;;;;;;;;oBA+BlDA,KAAkD","names":["InternalPage","__playwright_augment_methods_agent.Agent"]}

package/dist/index.mjs

@@ -1,15 +1,9 @@
-var __require = /* @__PURE__ */ ((x) => typeof require !== "undefined" ? require : typeof Proxy !== "undefined" ? new Proxy(x, {
-  get: (a, b) => (typeof require !== "undefined" ? require : a)[b]
-}) : x)(function(x) {
-  if (typeof require !== "undefined") return require.apply(this, arguments);
-  throw Error('Dynamic require of "' + x + '" is not supported');
-});
+import{createRequire as _pkgrollCR}from"node:module";const require=_pkgrollCR(import.meta.url);import { test } from '@playwright/test';
+import * as jpeg from 'jpeg-js';
+import { PNG } from 'pngjs';
+import pRetry from 'p-retry';
 
-// src/expect.ts
-import { test } from "@playwright/test";
-
-// src/runtime.ts
-var configuredApiKey = process.env.STABLY_API_KEY;
+let configuredApiKey = process.env.STABLY_API_KEY;
 function setApiKey(apiKey) {
   configuredApiKey = apiKey;
 }
@@ -26,25 +20,22 @@ function requireApiKey() {
   return apiKey;
 }
 
-// src/type-predicate/is-object.ts
-var isObject = (value) => {
+const isObject = (value) => {
   return typeof value === "object" && value !== null;
 };
 
-// src/ai/metadata.ts
-var SDK_METADATA_HEADERS = {
+const SDK_METADATA_HEADERS = {
   "X-Client-Name": "stably-playwright-sdk-js",
-  "X-Client-Version": "2.0.12-rc.1"
+  "X-Client-Version": "2.0.12"
 };
 
-// src/ai/verify-prompt.ts
-var PROMPT_ASSERTION_PATH = "internal/v2/assert";
-var STABLY_API_URL = process.env.STABLY_API_URL || "https://api.stably.ai";
-var PROMPT_ASSERTION_ENDPOINT = new URL(
+const PROMPT_ASSERTION_PATH = "internal/v2/assert";
+const STABLY_API_URL$2 = process.env.STABLY_API_URL || "https://api.stably.ai";
+const PROMPT_ASSERTION_ENDPOINT = new URL(
   PROMPT_ASSERTION_PATH,
-  STABLY_API_URL
+  STABLY_API_URL$2
 ).toString();
-var parseSuccessResponse = (value) => {
+const parseSuccessResponse = (value) => {
   if (!isObject(value)) {
     throw new Error("Verify prompt returned unexpected response shape");
   }
@@ -60,7 +51,7 @@ var parseSuccessResponse = (value) => {
     success
   };
 };
-var parseErrorResponse = (value) => {
+const parseErrorResponse = (value) => {
   if (!isObject(value)) {
     return void 0;
   }
@@ -105,7 +96,6 @@ async function verifyPrompt({
   );
 }
 
-// src/playwright-type-predicates.ts
 function isPage(candidate) {
   return typeof candidate === "object" && candidate !== null && typeof candidate.screenshot === "function" && typeof candidate.goto === "function";
 }
@@ -113,10 +103,6 @@ function isLocator(candidate) {
   return typeof candidate === "object" && candidate !== null && typeof candidate.screenshot === "function" && typeof candidate.nth === "function";
 }
 
-// src/image-compare.ts
-import * as jpeg from "jpeg-js";
-
-// ../../node_modules/.pnpm/pixelmatch@7.1.0/node_modules/pixelmatch/index.js
 function pixelmatch(img1, img2, output, width, height, options = {}) {
   const {
     threshold = 0.1,
@@ -272,15 +258,13 @@ function drawGrayPixel(img, i, alpha, output) {
   drawPixel(output, i, val, val, val);
 }
 
-// src/image-compare.ts
-import { PNG } from "pngjs";
-var isPng = (buffer) => {
+const isPng = (buffer) => {
   return buffer.length >= 8 && buffer[0] === 137 && buffer[1] === 80 && buffer[2] === 78 && buffer[3] === 71 && buffer[4] === 13 && buffer[5] === 10 && buffer[6] === 26 && buffer[7] === 10;
 };
-var isJpeg = (buffer) => {
+const isJpeg = (buffer) => {
   return buffer.length >= 2 && buffer[0] === 255 && buffer[1] === 216;
 };
-var decodeImage = (buffer) => {
+const decodeImage = (buffer) => {
   if (isPng(buffer)) {
     const png2 = PNG.sync.read(buffer);
     return { data: png2.data, height: png2.height, width: png2.width };
@@ -292,7 +276,7 @@ var decodeImage = (buffer) => {
   const png = PNG.sync.read(buffer);
   return { data: png.data, height: png.height, width: png.width };
 };
-var imagesAreSimilar = ({
+const imagesAreSimilar = ({
   image1,
   image2,
   threshold
@@ -316,7 +300,6 @@ var imagesAreSimilar = ({
   return numDiffPixels === 0;
 };
 
-// src/screenshot.ts
 async function takeStableScreenshot(target, options) {
   const page = isPage(target) ? target : target.page();
   const totalTimeout = options?.timeout ?? 5e3;
@@ -363,8 +346,7 @@ async function takeStableScreenshot(target, options) {
   return actual ?? await safeScreenshot();
 }
 
-// src/expect.ts
-var MAX_ATTACHMENT_NAME_LENGTH = 80;
+const MAX_ATTACHMENT_NAME_LENGTH = 80;
 function createFailureMessage({
   condition,
   didPass,
@@ -382,7 +364,7 @@ Reason: ${reason}`;
   }
   return message;
 }
-var stablyPlaywrightMatchers = {
+const stablyPlaywrightMatchers = {
   async toMatchScreenshotPrompt(received, condition, options) {
     const target = isPage(received) ? received : isLocator(received) ? received : void 0;
     if (!target) {
@@ -438,14 +420,8 @@ var stablyPlaywrightMatchers = {
   }
 };
 
-// src/playwright-augment/methods/agent.ts
-import { test as test2 } from "@playwright/test";
-import pRetry from "p-retry";
+const truncate = (inp, length) => inp.length <= length || inp.length <= 3 ? inp : `${inp.slice(0, length - 3)}...`;
 
-// src/utils/truncate.ts
-var truncate = (inp, length) => inp.length <= length || inp.length <= 3 ? inp : `${inp.slice(0, length - 3)}...`;
-
-// src/playwright-augment/methods/agent/construct-payload.ts
 function constructAgentPayload({
   activePage,
   additionalContext,
@@ -493,7 +469,6 @@ function constructAgentPayload({
   return form;
 }
 
-// src/playwright-augment/methods/agent/scroll-helper.ts
 async function scrollAtPosition({
   amount,
   direction,
@@ -530,8 +505,7 @@ async function scrollAtPosition({
   }
 }
 
-// src/playwright-augment/methods/agent/exec-response.ts
-var DEFAULT_AGENT_WAIT_MS = 3e3;
+const DEFAULT_AGENT_WAIT_MS = 3e3;
 async function execResponse({
   activePage: initialActivePage,
   agentResponse,
@@ -673,11 +647,10 @@ ${ariaSnapshot}` }
   }
 }
 
-// src/playwright-augment/methods/agent.ts
-var AGENT_PATH = "internal/v3/agent";
-var STABLY_API_URL2 = process.env.STABLY_API_URL || "https://api.stably.ai";
-var AGENT_ENDPOINT = new URL(AGENT_PATH, STABLY_API_URL2).toString();
-var Agent = class {
+const AGENT_PATH = "internal/v3/agent";
+const STABLY_API_URL$1 = process.env.STABLY_API_URL || "https://api.stably.ai";
+const AGENT_ENDPOINT = new URL(AGENT_PATH, STABLY_API_URL$1).toString();
+class Agent {
   constructor(browserContext) {
     this.browserContext = browserContext;
   }
@@ -746,13 +719,13 @@ var Agent = class {
       newPageOpenedMsg = `opened new tab ${alias} (${page.url()})`;
     };
     this.browserContext.on("page", onNewPage);
-    return await test2.step(`[Agent] ${prompt}`, async () => {
+    return await test.step(`[Agent] ${prompt}`, async () => {
       try {
         for (let i = 0; i < maxCycles; i++) {
           if (agentMessage.shouldTerminate) {
             break;
           }
-          const agentResponses = await test2.step(`[Thinking ${i + 1}]`, async (stepInfo) => {
+          const agentResponses = await test.step(`[Thinking ${i + 1}]`, async (stepInfo) => {
             const screenshot = await takeStableScreenshot(activePage);
             const response = await pRetry(
               () => fetch(AGENT_ENDPOINT, {
@@ -842,22 +815,20 @@ var Agent = class {
       }
     });
   }
-};
-var createNewAgent = (browserContext) => new Agent(browserContext);
+}
+const createNewAgent = (browserContext) => new Agent(browserContext);
 
-// src/ai/extract.ts
-import { test as test3 } from "@playwright/test";
-var EXTRACT_PATH = "internal/v2/extract";
-var STABLY_API_URL3 = process.env.STABLY_API_URL || "https://api.stably.ai";
-var EXTRACT_ENDPOINT = new URL(EXTRACT_PATH, STABLY_API_URL3).toString();
-var zodV4 = (() => {
+const EXTRACT_PATH = "internal/v2/extract";
+const STABLY_API_URL = process.env.STABLY_API_URL || "https://api.stably.ai";
+const EXTRACT_ENDPOINT = new URL(EXTRACT_PATH, STABLY_API_URL).toString();
+const zodV4 = (() => {
   try {
-    return __require("zod/v4/core");
+    return require("zod/v4/core");
   } catch {
     return void 0;
   }
 })();
-var isExtractionResponse = (value) => {
+const isExtractionResponse = (value) => {
   if (!isObject(value)) {
     return false;
   }
@@ -866,16 +837,16 @@ var isExtractionResponse = (value) => {
   }
   return value.success === false && typeof value.error === "string";
 };
-var isErrorResponse = (value) => {
+const isErrorResponse = (value) => {
   return isObject(value) && typeof value.error === "string";
 };
-var ExtractValidationError = class extends Error {
+class ExtractValidationError extends Error {
   constructor(message, issues) {
     super(message);
     this.issues = issues;
     this.name = "ExtractValidationError";
   }
-};
+}
 async function validateWithSchema(schema, value) {
   const result = await schema.safeParseAsync(value);
   if (!result.success) {
@@ -900,7 +871,7 @@ async function extract({
     // eslint-disable-next-line @typescript-eslint/no-unsafe-type-assertion
     schema
   ) : void 0;
-  return await test3.step(`[Extract] ${prompt}`, async (stepInfo) => {
+  return await test.step(`[Extract] ${prompt}`, async (stepInfo) => {
     const apiKey = requireApiKey();
     const form = new FormData();
     form.append("prompt", prompt);
@@ -943,9 +914,8 @@ async function extract({
   });
 }
 
-// src/playwright-augment/methods/extract.ts
 function createExtract(pageOrLocator) {
-  const impl = async (prompt, options) => {
+  const impl = (async (prompt, options) => {
     if (options?.schema) {
       return extract({
         pageOrLocator,
@@ -954,18 +924,17 @@ function createExtract(pageOrLocator) {
       });
     }
     return extract({ pageOrLocator, prompt });
-  };
+  });
   return impl;
 }
-var createLocatorExtract = (locator) => createExtract(locator);
-var createPageExtract = (page) => createExtract(page);
+const createLocatorExtract = (locator) => createExtract(locator);
+const createPageExtract = (page) => createExtract(page);
 
-// src/playwright-augment/augment.ts
-var LOCATOR_PATCHED = Symbol.for("stably.playwright.locatorPatched");
-var PAGE_PATCHED = Symbol.for("stably.playwright.pagePatched");
-var CONTEXT_PATCHED = Symbol.for("stably.playwright.contextPatched");
-var BROWSER_PATCHED = Symbol.for("stably.playwright.browserPatched");
-var BROWSER_TYPE_PATCHED = Symbol.for("stably.playwright.browserTypePatched");
+const LOCATOR_PATCHED = Symbol.for("stably.playwright.locatorPatched");
+const PAGE_PATCHED = Symbol.for("stably.playwright.pagePatched");
+const CONTEXT_PATCHED = Symbol.for("stably.playwright.contextPatched");
+const BROWSER_PATCHED = Symbol.for("stably.playwright.browserPatched");
+const BROWSER_TYPE_PATCHED = Symbol.for("stably.playwright.browserTypePatched");
 function defineHiddenProperty(target, key, value) {
   Object.defineProperty(target, key, {
     configurable: true,
@@ -987,10 +956,10 @@ function augmentPage(page) {
     return page;
   }
   const originalLocator = page.locator.bind(page);
-  page.locator = (...args) => {
+  page.locator = ((...args) => {
     const locator = originalLocator(...args);
     return augmentLocator(locator);
-  };
+  });
   defineHiddenProperty(page, "extract", createPageExtract(page));
   defineHiddenProperty(page, PAGE_PATCHED, true);
   return page;
@@ -1000,13 +969,13 @@ function augmentBrowserContext(context) {
     return context;
   }
   const originalNewPage = context.newPage.bind(context);
-  context.newPage = async (...args) => {
+  context.newPage = (async (...args) => {
     const page = await originalNewPage(...args);
     return augmentPage(page);
-  };
+  });
   const originalPages = context.pages?.bind(context);
   if (originalPages) {
-    context.pages = () => originalPages().map((page) => augmentPage(page));
+    context.pages = (() => originalPages().map((page) => augmentPage(page)));
   }
   if (!context.newAgent) {
     defineHiddenProperty(context, "newAgent", () => {
@@ -1021,19 +990,19 @@ function augmentBrowser(browser) {
     return browser;
   }
   const originalNewContext = browser.newContext.bind(browser);
-  browser.newContext = async (...args) => {
+  browser.newContext = (async (...args) => {
     const context = await originalNewContext(...args);
     return augmentBrowserContext(context);
-  };
+  });
   const originalNewPage = browser.newPage.bind(browser);
-  browser.newPage = async (...args) => {
+  browser.newPage = (async (...args) => {
     const page = await originalNewPage(...args);
     return augmentPage(page);
-  };
+  });
   const originalContexts = browser.contexts.bind(browser);
-  browser.contexts = () => originalContexts().map(
+  browser.contexts = (() => originalContexts().map(
     (context) => augmentBrowserContext(context)
-  );
+  ));
   if (!browser.newAgent) {
     defineHiddenProperty(browser, "newAgent", () => {
       const contexts = browser.contexts();
@@ -1049,45 +1018,36 @@ function augmentBrowserType(browserType) {
     return browserType;
   }
   const originalLaunch = browserType.launch.bind(browserType);
-  browserType.launch = async (...args) => {
+  browserType.launch = (async (...args) => {
     const browser = await originalLaunch(...args);
     return augmentBrowser(browser);
-  };
+  });
   const originalConnect = browserType.connect?.bind(browserType);
   if (originalConnect) {
-    browserType.connect = async (...args) => {
+    browserType.connect = (async (...args) => {
       const browser = await originalConnect(...args);
       return augmentBrowser(browser);
-    };
+    });
   }
   const originalConnectOverCDP = browserType.connectOverCDP?.bind(
     browserType
   );
   if (originalConnectOverCDP) {
-    browserType.connectOverCDP = async (...args) => {
+    browserType.connectOverCDP = (async (...args) => {
       const browser = await originalConnectOverCDP(...args);
       return augmentBrowser(browser);
-    };
+    });
   }
   const originalLaunchPersistentContext = browserType.launchPersistentContext?.bind(browserType);
   if (originalLaunchPersistentContext) {
-    browserType.launchPersistentContext = async (...args) => {
+    browserType.launchPersistentContext = (async (...args) => {
       const context = await originalLaunchPersistentContext(...args);
       return augmentBrowserContext(context);
-    };
+    });
   }
   defineHiddenProperty(browserType, BROWSER_TYPE_PATCHED, true);
   return browserType;
 }
-export {
-  Agent,
-  augmentBrowser,
-  augmentBrowserContext,
-  augmentBrowserType,
-  augmentLocator,
-  augmentPage,
-  requireApiKey,
-  setApiKey,
-  stablyPlaywrightMatchers
-};
-//# sourceMappingURL=index.mjs.map
+
+export { Agent, augmentBrowser, augmentBrowserContext, augmentBrowserType, augmentLocator, augmentPage, requireApiKey, setApiKey, stablyPlaywrightMatchers };
+//# sourceMappingURL=index.mjs.map