@pedropaulovc/playwright-core 1.59.0-next → 1.59.0-next.3

package/lib/cli/program.js

@@ -39,7 +39,7 @@ var import_driver = require("./driver");
 var import_server = require("../server");
 var import_utils = require("../utils");
 var import_traceViewer = require("../server/trace/viewer/traceViewer");
-var import_traceExporter = require("../server/trace/viewer/traceExporter");
+var import_src = require("../../../../trace-exporter/src");
 var import_utils2 = require("../utils");
 var import_ascii = require("../server/utils/ascii");
 var import_utilsBundle = require("../utilsBundle");
@@ -295,19 +295,17 @@ Examples:
 
   $ show-trace
   $ show-trace https://example.com/trace.zip`);
-import_utilsBundle.program.command("export-trace <trace>").description("export trace to LLM-friendly markdown files").option("-o, --output <dir>", "output directory", "./trace-export").option("--no-assets", "skip extracting screenshots and snapshots").action(async function(trace, options) {
+import_utilsBundle.program.command("export-trace <trace>").description("export trace to LLM-friendly markdown files").option("-o, --output <dir>", "output directory", "./trace-export").action(async function(trace, options) {
   const traceFile = import_path.default.resolve(trace);
-  await (0, import_traceExporter.exportTraceToMarkdown)(traceFile, {
-    outputDir: import_path.default.resolve(options.output),
-    includeAssets: options.assets
+  await (0, import_src.exportTraceToMarkdown)(traceFile, {
+    outputDir: import_path.default.resolve(options.output)
   }).catch(logErrorAndExit);
   console.log(`Trace exported to ${options.output}`);
 }).addHelpText("afterAll", `
 Examples:
 
   $ export-trace trace.zip
-  $ export-trace trace.zip -o ./my-export
-  $ export-trace trace.zip --no-assets`);
+  $ export-trace trace.zip -o ./my-export`);
 async function launchContext(options, extraOptions) {
   validateOptions(options);
   const browserType = lookupBrowserType(options);

package/lib/client/page.js

@@ -676,7 +676,6 @@ class Page extends import_channelOwner.ChannelOwner {
     }
     return result.pdf;
   }
-  // @ts-expect-error agents are hidden
   async agent(options = {}) {
     const params = {
       api: options.provider?.api,
@@ -691,7 +690,6 @@ class Page extends import_channelOwner.ChannelOwner {
       maxTokens: options.limits?.maxTokens,
       maxActions: options.limits?.maxActions,
       maxActionRetries: options.limits?.maxActionRetries,
-      // @ts-expect-error runAgents is hidden
       secrets: options.secrets ? Object.entries(options.secrets).map(([name, value]) => ({ name, value })) : void 0,
       systemPrompt: options.systemPrompt
     };

package/lib/utilsBundle.js

@@ -63,6 +63,9 @@ const wsServer = require("./utilsBundleImpl").wsServer;
 const wsReceiver = require("./utilsBundleImpl").wsReceiver;
 const wsSender = require("./utilsBundleImpl").wsSender;
 const yaml = require("./utilsBundleImpl").yaml;
+program.exitOverride((err) => {
+  process.stdout.write("", () => process.stderr.write("", () => process.exit(err.exitCode)));
+});
 function ms(ms2) {
   if (!isFinite(ms2))
     return "-";

package/package.json

@@ -1,10 +1,10 @@
 {
   "name": "@pedropaulovc/playwright-core",
-  "version": "1.59.0-next",
+  "version": "1.59.0-next.3",
   "description": "A high-level API to automate web browsers",
   "repository": {
     "type": "git",
-    "url": "git+https://github.com/microsoft/playwright.git"
+    "url": "git+https://github.com/pedropaulovc/playwright.git"
   },
   "homepage": "https://playwright.dev",
   "engines": {

package/types/types.d.ts

@@ -27,6 +27,13 @@ type ElementHandleWaitForSelectorOptionsNotHidden = ElementHandleWaitForSelector
   state?: 'visible'|'attached';
 };
 
+// @ts-ignore this will be any if zod is not installed
+import { ZodTypeAny, z } from 'zod';
+// @ts-ignore this will be any if zod is not installed
+import * as z3 from 'zod/v3';
+type ZodSchema = ZodTypeAny | z3.ZodTypeAny;
+type InferZodSchema<T extends ZodSchema> = T extends z3.ZodTypeAny ? z3.infer<T> : T extends ZodTypeAny ? z.infer<T> : never;
+
 /**
  * Page provides methods to interact with a single tab in a [Browser](https://playwright.dev/docs/api/class-browser),
  * or an [extension background page](https://developer.chrome.com/extensions/background_pages) in Chromium. One
@@ -2088,6 +2095,89 @@ export interface Page {
     url?: string;
   }): Promise<ElementHandle>;
 
+  /**
+   * Initialize page agent with the llm provider and cache.
+   * @param options
+   */
+  agent(options?: {
+    cache?: {
+      /**
+       * Cache file to use/generate code for performed actions into. Cache is not used if not specified (default).
+       */
+      cacheFile?: string;
+
+      /**
+       * When specified, generated entries are written into the `cacheOutFile` instead of updating the `cacheFile`.
+       */
+      cacheOutFile?: string;
+    };
+
+    expect?: {
+      /**
+       * Default timeout for expect calls in milliseconds, defaults to 5000ms.
+       */
+      timeout?: number;
+    };
+
+    /**
+     * Limits to use for the agentic loop.
+     */
+    limits?: {
+      /**
+       * Maximum number of tokens to consume. The agentic loop will stop after input + output tokens exceed this value.
+       * Defaults to unlimited.
+       */
+      maxTokens?: number;
+
+      /**
+       * Maximum number of agentic actions to generate, defaults to 10.
+       */
+      maxActions?: number;
+
+      /**
+       * Maximum number retries per action, defaults to 3.
+       */
+      maxActionRetries?: number;
+    };
+
+    provider?: {
+      /**
+       * API to use.
+       */
+      api: "openai"|"openai-compatible"|"anthropic"|"google";
+
+      /**
+       * Endpoint to use if different from default.
+       */
+      apiEndpoint?: string;
+
+      /**
+       * API key for the LLM provider.
+       */
+      apiKey: string;
+
+      /**
+       * Amount of time to wait for the provider to respond to each request.
+       */
+      apiTimeout?: number;
+
+      /**
+       * Model identifier within the provider. Required in non-cache mode.
+       */
+      model: string;
+    };
+
+    /**
+     * Secrets to hide from the LLM.
+     */
+    secrets?: { [key: string]: string; };
+
+    /**
+     * System prompt for the agent's loop.
+     */
+    systemPrompt?: string;
+  }): Promise<PageAgent>;
+
   /**
    * Brings page to front (activates tab).
    */
@@ -5204,6 +5294,243 @@ export interface Page {
   [Symbol.asyncDispose](): Promise<void>;
 }
 
+/**
+ *
+ */
+export interface PageAgent {
+  /**
+   * Extract information from the page using the agentic loop, return it in a given Zod format.
+   *
+   * **Usage**
+   *
+   * ```js
+   * await agent.extract('List of items in the cart', z.object({
+   *   title: z.string().describe('Item title to extract'),
+   *   price: z.string().describe('Item price to extract'),
+   * }).array());
+   * ```
+   *
+   * @param query Task to perform using agentic loop.
+   * @param schema
+   * @param options
+   */
+  extract<Schema extends ZodSchema>(query: string, schema: Schema): Promise<{ result: InferZodSchema<Schema>, usage: { turns: number, inputTokens: number, outputTokens: number } }>;
+  /**
+   * Emitted when the agent makes a turn.
+   */
+  on(event: 'turn', listener: (data: {
+    role: string;
+
+    message: string;
+
+    usage?: {
+      inputTokens: number;
+
+      outputTokens: number;
+    };
+  }) => any): this;
+
+  /**
+   * Adds an event listener that will be automatically removed after it is triggered once. See `addListener` for more information about this event.
+   */
+  once(event: 'turn', listener: (data: {
+    role: string;
+
+    message: string;
+
+    usage?: {
+      inputTokens: number;
+
+      outputTokens: number;
+    };
+  }) => any): this;
+
+  /**
+   * Emitted when the agent makes a turn.
+   */
+  addListener(event: 'turn', listener: (data: {
+    role: string;
+
+    message: string;
+
+    usage?: {
+      inputTokens: number;
+
+      outputTokens: number;
+    };
+  }) => any): this;
+
+  /**
+   * Removes an event listener added by `on` or `addListener`.
+   */
+  removeListener(event: 'turn', listener: (data: {
+    role: string;
+
+    message: string;
+
+    usage?: {
+      inputTokens: number;
+
+      outputTokens: number;
+    };
+  }) => any): this;
+
+  /**
+   * Removes an event listener added by `on` or `addListener`.
+   */
+  off(event: 'turn', listener: (data: {
+    role: string;
+
+    message: string;
+
+    usage?: {
+      inputTokens: number;
+
+      outputTokens: number;
+    };
+  }) => any): this;
+
+  /**
+   * Emitted when the agent makes a turn.
+   */
+  prependListener(event: 'turn', listener: (data: {
+    role: string;
+
+    message: string;
+
+    usage?: {
+      inputTokens: number;
+
+      outputTokens: number;
+    };
+  }) => any): this;
+
+  /**
+   * Dispose this agent.
+   */
+  dispose(): Promise<void>;
+
+  /**
+   * Expect certain condition to be met.
+   *
+   * **Usage**
+   *
+   * ```js
+   * await agent.expect('"0 items" to be reported');
+   * ```
+   *
+   * @param expectation Expectation to assert.
+   * @param options
+   */
+  expect(expectation: string, options?: {
+    /**
+     * All the agentic actions are converted to the Playwright calls and are cached. By default, they are cached globally
+     * with the `task` as a key. This option allows controlling the cache key explicitly.
+     */
+    cacheKey?: string;
+
+    /**
+     * Maximum number of retries when generating each action, defaults to context-wide value specified in `agent`
+     * property.
+     */
+    maxActionRetries?: number;
+
+    /**
+     * Maximum number of agentic actions to generate, defaults to context-wide value specified in `agent` property.
+     */
+    maxActions?: number;
+
+    /**
+     * Maximum number of tokens to consume. The agentic loop will stop after input + output tokens exceed this value.
+     * Defaults to context-wide value specified in `agent` property.
+     */
+    maxTokens?: number;
+
+    /**
+     * Expect timeout in milliseconds. Defaults to `5000`. The default value can be changed via `expect.timeout` option in
+     * the config, or by specifying the `expect` property of the
+     * [`expect`](https://playwright.dev/docs/api/class-page#page-agent-option-expect) option. Pass `0` to disable
+     * timeout.
+     */
+    timeout?: number;
+  }): Promise<void>;
+
+  /**
+   * Perform action using agentic loop.
+   *
+   * **Usage**
+   *
+   * ```js
+   * await agent.perform('Click submit button');
+   * ```
+   *
+   * @param task Task to perform using agentic loop.
+   * @param options
+   */
+  perform(task: string, options?: {
+    /**
+     * All the agentic actions are converted to the Playwright calls and are cached. By default, they are cached globally
+     * with the `task` as a key. This option allows controlling the cache key explicitly.
+     */
+    cacheKey?: string;
+
+    /**
+     * Maximum number of retries when generating each action, defaults to context-wide value specified in `agent`
+     * property.
+     */
+    maxActionRetries?: number;
+
+    /**
+     * Maximum number of agentic actions to generate, defaults to context-wide value specified in `agent` property.
+     */
+    maxActions?: number;
+
+    /**
+     * Maximum number of tokens to consume. The agentic loop will stop after input + output tokens exceed this value.
+     * Defaults to context-wide value specified in `agent` property.
+     */
+    maxTokens?: number;
+
+    /**
+     * Perform timeout in milliseconds. Defaults to `5000`. The default value can be changed via `actionTimeout` option in
+     * the config, or by using the
+     * [browserContext.setDefaultTimeout(timeout)](https://playwright.dev/docs/api/class-browsercontext#browser-context-set-default-timeout)
+     * or [page.setDefaultTimeout(timeout)](https://playwright.dev/docs/api/class-page#page-set-default-timeout) methods.
+     * Pass `0` to disable timeout.
+     */
+    timeout?: number;
+  }): Promise<{
+    usage: {
+      turns: number;
+
+      inputTokens: number;
+
+      outputTokens: number;
+    };
+  }>;
+
+  /**
+   * Returns the current token usage for this agent.
+   *
+   * **Usage**
+   *
+   * ```js
+   * const usage = await agent.usage();
+   * console.log(`Tokens used: ${usage.inputTokens} in, ${usage.outputTokens} out`);
+   * ```
+   *
+   */
+  usage(): Promise<{
+    turns: number;
+
+    inputTokens: number;
+
+    outputTokens: number;
+  }>;
+
+  [Symbol.asyncDispose](): Promise<void>;
+}
+
 /**
  * At every point of time, page exposes its current frame tree via the
  * [page.mainFrame()](https://playwright.dev/docs/api/class-page#page-main-frame) and