genkitx-playwright 0.3.0

package/lib/index.js

@@ -0,0 +1,803 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var index_exports = {};
+__export(index_exports, {
+  ALL_TOOL_NAMES: () => ALL_TOOL_NAMES,
+  BrowserSession: () => BrowserSession,
+  PlaywrightOptionsSchema: () => PlaywrightOptionsSchema,
+  createPlaywrightTools: () => createPlaywrightTools,
+  playwright: () => playwright
+});
+module.exports = __toCommonJS(index_exports);
+
+// src/playwright.ts
+var import_genkit2 = require("genkit");
+
+// src/browser.ts
+var import_playwright = require("playwright");
+var browserLaunchers = { chromium: import_playwright.chromium, firefox: import_playwright.firefox, webkit: import_playwright.webkit };
+var BrowserSession = class {
+  constructor(options = {}) {
+    this.options = options;
+  }
+  options;
+  browser;
+  context;
+  launchPromise;
+  /** Captured console messages for the active page. */
+  consoleLogs = [];
+  /** The most recent dialog the page raised, awaiting handling. */
+  pendingDialog;
+  /** Ensures the browser + context are launched (idempotent). */
+  async ensureLaunched() {
+    if (this.context) return;
+    if (!this.launchPromise) {
+      this.launchPromise = (async () => {
+        const type = this.options.browser ?? "chromium";
+        const launcher = browserLaunchers[type];
+        if (!launcher) {
+          throw new Error(`Unsupported browser type: ${type}`);
+        }
+        this.browser = await launcher.launch({
+          headless: this.options.headless ?? true,
+          ...this.options.launchOptions
+        });
+        this.context = await this.browser.newContext(
+          this.options.contextOptions
+        );
+      })();
+    }
+    await this.launchPromise;
+  }
+  /** Returns the active page, creating one (and the browser) if needed. */
+  async getPage() {
+    await this.ensureLaunched();
+    const pages = this.context.pages();
+    let page = pages[pages.length - 1];
+    if (!page) {
+      page = await this.newPage();
+    }
+    return page;
+  }
+  /** Creates and wires up a new page (tab). */
+  async newPage() {
+    await this.ensureLaunched();
+    const page = await this.context.newPage();
+    this.attachListeners(page);
+    return page;
+  }
+  /** Returns all open pages (tabs). */
+  async getPages() {
+    await this.ensureLaunched();
+    return this.context.pages();
+  }
+  attachListeners(page) {
+    page.on("console", (msg) => {
+      this.consoleLogs.push({ type: msg.type(), text: msg.text() });
+    });
+    page.on("dialog", (dialog) => {
+      this.pendingDialog = {
+        type: dialog.type(),
+        message: dialog.message(),
+        defaultValue: dialog.defaultValue()
+      };
+      this.activeDialog = dialog;
+    });
+  }
+  /** The raw Playwright dialog object awaiting a response, if any. */
+  activeDialog;
+  /** Closes the browser and releases all resources. Safe to call repeatedly. */
+  async close() {
+    try {
+      await this.context?.close();
+    } catch {
+    }
+    try {
+      await this.browser?.close();
+    } catch {
+    }
+    this.context = void 0;
+    this.browser = void 0;
+    this.launchPromise = void 0;
+  }
+};
+
+// src/tools.ts
+var import_genkit = require("genkit");
+var import_beta = require("genkit/beta");
+var ALL_TOOL_NAMES = [
+  // navigation
+  "browser_navigate",
+  "browser_navigate_back",
+  "browser_navigate_forward",
+  // observation
+  "browser_snapshot",
+  "browser_screenshot",
+  "browser_get_console_logs",
+  "browser_get_network_requests",
+  // interaction
+  "browser_click",
+  "browser_type",
+  "browser_fill",
+  "browser_press_key",
+  "browser_hover",
+  "browser_select_option",
+  "browser_scroll",
+  "browser_drag",
+  "browser_file_upload",
+  // synchronization
+  "browser_wait_for",
+  // tabs
+  "browser_tab_list",
+  "browser_tab_new",
+  "browser_tab_select",
+  "browser_tab_close",
+  // dialogs
+  "browser_handle_dialog",
+  // escape hatch
+  "browser_evaluate"
+];
+var WRITE_TOOLS = [
+  "browser_click",
+  "browser_type",
+  "browser_fill",
+  "browser_press_key",
+  "browser_hover",
+  "browser_select_option",
+  "browser_scroll",
+  "browser_drag",
+  "browser_file_upload",
+  "browser_handle_dialog"
+];
+function hostnameAllowed(url, allowed, blocked) {
+  let host;
+  try {
+    host = new URL(url).hostname;
+  } catch {
+    return true;
+  }
+  const matches = (domain) => host === domain || host.endsWith(`.${domain}`);
+  if (blocked?.some(matches)) return false;
+  if (allowed && allowed.length > 0) return allowed.some(matches);
+  return true;
+}
+function locatorForRef(page, ref) {
+  return page.locator(`aria-ref=${ref}`);
+}
+async function snapshotForAI(page) {
+  try {
+    return await page.ariaSnapshot({ mode: "ai" });
+  } catch {
+    return page.locator("body").ariaSnapshot();
+  }
+}
+function createPlaywrightTools(opts) {
+  const { session } = opts;
+  const prefix = opts.toolNamePrefix ?? "";
+  const name = (n) => `${prefix}${n}`;
+  const enabled = new Set(opts.tools ?? ALL_TOOL_NAMES);
+  if (opts.readOnly) {
+    for (const t of WRITE_TOOLS) enabled.delete(t);
+  }
+  if (!opts.allowEvaluate) {
+    enabled.delete("browser_evaluate");
+  }
+  const refSchema = import_genkit.z.string().describe('Element ref from the latest browser_snapshot, e.g. "e12".');
+  const enqueueParts = (parts, toolName) => {
+    const queue = opts.messageQueue;
+    if (!queue) return;
+    const last = queue[queue.length - 1];
+    if (last && last.role === "user") {
+      last.content.push(...parts);
+    } else {
+      queue.push({
+        role: "user",
+        content: parts,
+        metadata: { playwrightMiddlewareTool: toolName }
+      });
+    }
+  };
+  const tools = [];
+  const add = (toolName, factory) => {
+    if (enabled.has(toolName)) tools.push(factory());
+  };
+  add(
+    "browser_navigate",
+    () => (0, import_beta.tool)(
+      {
+        name: name("browser_navigate"),
+        description: "Navigate the current page to a URL.",
+        inputSchema: import_genkit.z.object({
+          url: import_genkit.z.string().describe("Absolute URL to navigate to.")
+        }),
+        outputSchema: import_genkit.z.string()
+      },
+      async ({ url }) => {
+        if (!hostnameAllowed(url, opts.allowedDomains, opts.blockedDomains)) {
+          throw new Error(`Navigation to "${url}" is not allowed by policy.`);
+        }
+        const page = await session.getPage();
+        await page.goto(url, { waitUntil: "domcontentloaded" });
+        return `Navigated to ${page.url()} (title: "${await page.title()}").`;
+      }
+    )
+  );
+  add(
+    "browser_navigate_back",
+    () => (0, import_beta.tool)(
+      {
+        name: name("browser_navigate_back"),
+        description: "Go back to the previous page in history.",
+        inputSchema: import_genkit.z.object({}),
+        outputSchema: import_genkit.z.string()
+      },
+      async () => {
+        const page = await session.getPage();
+        await page.goBack({ waitUntil: "domcontentloaded" });
+        return `Went back to ${page.url()}.`;
+      }
+    )
+  );
+  add(
+    "browser_navigate_forward",
+    () => (0, import_beta.tool)(
+      {
+        name: name("browser_navigate_forward"),
+        description: "Go forward to the next page in history.",
+        inputSchema: import_genkit.z.object({}),
+        outputSchema: import_genkit.z.string()
+      },
+      async () => {
+        const page = await session.getPage();
+        await page.goForward({ waitUntil: "domcontentloaded" });
+        return `Went forward to ${page.url()}.`;
+      }
+    )
+  );
+  add(
+    "browser_snapshot",
+    () => (0, import_beta.tool)(
+      {
+        name: name("browser_snapshot"),
+        description: "Capture an accessibility snapshot of the current page. Each interactive element is tagged with a [ref=eN] id you can pass to interaction tools (click, type, etc.). Prefer this over screenshots for deciding what to interact with.",
+        inputSchema: import_genkit.z.object({}),
+        outputSchema: import_genkit.z.object({
+          url: import_genkit.z.string(),
+          title: import_genkit.z.string(),
+          snapshot: import_genkit.z.string()
+        })
+      },
+      async () => {
+        const page = await session.getPage();
+        return {
+          url: page.url(),
+          title: await page.title(),
+          snapshot: await snapshotForAI(page)
+        };
+      }
+    )
+  );
+  add(
+    "browser_screenshot",
+    () => (0, import_beta.tool)(
+      {
+        name: name("browser_screenshot"),
+        description: "Take a screenshot of the current page. The image is added to the conversation so you can view it on your next turn.",
+        inputSchema: import_genkit.z.object({
+          fullPage: import_genkit.z.boolean().optional().describe("Capture the full scrollable page. Defaults to false.")
+        }),
+        outputSchema: import_genkit.z.string()
+      },
+      async ({ fullPage }) => {
+        const page = await session.getPage();
+        const buffer = await page.screenshot({
+          fullPage: fullPage ?? false,
+          type: "png"
+        });
+        const dataUri = `data:image/png;base64,${buffer.toString("base64")}`;
+        enqueueParts(
+          [
+            { text: `
+
+browser_screenshot result image/png (${page.url()})` },
+            { media: { url: dataUri, contentType: "image/png" } }
+          ],
+          name("browser_screenshot")
+        );
+        return "Screenshot captured. The image is shown below.";
+      }
+    )
+  );
+  add(
+    "browser_get_console_logs",
+    () => (0, import_beta.tool)(
+      {
+        name: name("browser_get_console_logs"),
+        description: "Return console messages collected from the page.",
+        inputSchema: import_genkit.z.object({}),
+        outputSchema: import_genkit.z.array(
+          import_genkit.z.object({ type: import_genkit.z.string(), text: import_genkit.z.string() })
+        )
+      },
+      async () => session.consoleLogs
+    )
+  );
+  add(
+    "browser_get_network_requests",
+    () => (0, import_beta.tool)(
+      {
+        name: name("browser_get_network_requests"),
+        description: "List network requests made by the current page (URL, method, and response status when available).",
+        inputSchema: import_genkit.z.object({}),
+        outputSchema: import_genkit.z.array(
+          import_genkit.z.object({
+            url: import_genkit.z.string(),
+            method: import_genkit.z.string(),
+            status: import_genkit.z.number().optional()
+          })
+        )
+      },
+      async () => {
+        const page = await session.getPage();
+        const entries = await page.evaluate(() => {
+          const list = performance.getEntriesByType(
+            "resource"
+          );
+          return list.map((e) => ({
+            url: e.name,
+            method: "GET",
+            status: void 0
+          }));
+        });
+        return entries;
+      }
+    )
+  );
+  add(
+    "browser_click",
+    () => (0, import_beta.tool)(
+      {
+        name: name("browser_click"),
+        description: "Click an element identified by its snapshot ref.",
+        inputSchema: import_genkit.z.object({
+          ref: refSchema,
+          doubleClick: import_genkit.z.boolean().optional().describe("Perform a double click instead of a single click.")
+        }),
+        outputSchema: import_genkit.z.string()
+      },
+      async ({ ref, doubleClick }) => {
+        const page = await session.getPage();
+        const locator = locatorForRef(page, ref);
+        if (doubleClick) {
+          await locator.dblclick();
+        } else {
+          await locator.click();
+        }
+        return `Clicked element ${ref}.`;
+      }
+    )
+  );
+  add(
+    "browser_type",
+    () => (0, import_beta.tool)(
+      {
+        name: name("browser_type"),
+        description: "Type text into an element by ref, character by character (does not clear existing content).",
+        inputSchema: import_genkit.z.object({
+          ref: refSchema,
+          text: import_genkit.z.string().describe("Text to type."),
+          submit: import_genkit.z.boolean().optional().describe("Press Enter after typing.")
+        }),
+        outputSchema: import_genkit.z.string()
+      },
+      async ({ ref, text, submit }) => {
+        const page = await session.getPage();
+        const locator = locatorForRef(page, ref);
+        await locator.pressSequentially(text);
+        if (submit) await locator.press("Enter");
+        return `Typed into element ${ref}.`;
+      }
+    )
+  );
+  add(
+    "browser_fill",
+    () => (0, import_beta.tool)(
+      {
+        name: name("browser_fill"),
+        description: "Set the value of an input/textarea by ref, clearing it first.",
+        inputSchema: import_genkit.z.object({
+          ref: refSchema,
+          value: import_genkit.z.string().describe("Value to set.")
+        }),
+        outputSchema: import_genkit.z.string()
+      },
+      async ({ ref, value }) => {
+        const page = await session.getPage();
+        await locatorForRef(page, ref).fill(value);
+        return `Filled element ${ref}.`;
+      }
+    )
+  );
+  add(
+    "browser_press_key",
+    () => (0, import_beta.tool)(
+      {
+        name: name("browser_press_key"),
+        description: 'Press a keyboard key (e.g. "Enter", "Tab", "ArrowDown", "a"). Optionally targets an element by ref.',
+        inputSchema: import_genkit.z.object({
+          key: import_genkit.z.string().describe("Key to press."),
+          ref: refSchema.optional()
+        }),
+        outputSchema: import_genkit.z.string()
+      },
+      async ({ key, ref }) => {
+        const page = await session.getPage();
+        if (ref) {
+          await locatorForRef(page, ref).press(key);
+        } else {
+          await page.keyboard.press(key);
+        }
+        return `Pressed key "${key}".`;
+      }
+    )
+  );
+  add(
+    "browser_hover",
+    () => (0, import_beta.tool)(
+      {
+        name: name("browser_hover"),
+        description: "Hover the mouse over an element by ref.",
+        inputSchema: import_genkit.z.object({ ref: refSchema }),
+        outputSchema: import_genkit.z.string()
+      },
+      async ({ ref }) => {
+        const page = await session.getPage();
+        await locatorForRef(page, ref).hover();
+        return `Hovered element ${ref}.`;
+      }
+    )
+  );
+  add(
+    "browser_select_option",
+    () => (0, import_beta.tool)(
+      {
+        name: name("browser_select_option"),
+        description: "Select option(s) in a <select> element by ref.",
+        inputSchema: import_genkit.z.object({
+          ref: refSchema,
+          values: import_genkit.z.array(import_genkit.z.string()).describe("Option values or labels to select.")
+        }),
+        outputSchema: import_genkit.z.string()
+      },
+      async ({ ref, values }) => {
+        const page = await session.getPage();
+        await locatorForRef(page, ref).selectOption(values);
+        return `Selected ${values.length} option(s) in ${ref}.`;
+      }
+    )
+  );
+  add(
+    "browser_scroll",
+    () => (0, import_beta.tool)(
+      {
+        name: name("browser_scroll"),
+        description: "Scroll the page up or down, or scroll a specific element into view.",
+        inputSchema: import_genkit.z.object({
+          direction: import_genkit.z.enum(["up", "down"]).optional().describe('Direction to scroll the window. Defaults to "down".'),
+          ref: refSchema.optional().describe("If provided, scroll this element into view instead.")
+        }),
+        outputSchema: import_genkit.z.string()
+      },
+      async ({ direction, ref }) => {
+        const page = await session.getPage();
+        if (ref) {
+          await locatorForRef(page, ref).scrollIntoViewIfNeeded();
+          return `Scrolled element ${ref} into view.`;
+        }
+        const dir = direction ?? "down";
+        await page.evaluate((d) => {
+          window.scrollBy(0, d === "down" ? window.innerHeight : -window.innerHeight);
+        }, dir);
+        return `Scrolled ${dir}.`;
+      }
+    )
+  );
+  add(
+    "browser_drag",
+    () => (0, import_beta.tool)(
+      {
+        name: name("browser_drag"),
+        description: "Drag one element onto another, by their refs.",
+        inputSchema: import_genkit.z.object({
+          startRef: refSchema.describe("Ref of the element to drag."),
+          endRef: refSchema.describe("Ref of the drop target.")
+        }),
+        outputSchema: import_genkit.z.string()
+      },
+      async ({ startRef, endRef }) => {
+        const page = await session.getPage();
+        await locatorForRef(page, startRef).dragTo(locatorForRef(page, endRef));
+        return `Dragged ${startRef} onto ${endRef}.`;
+      }
+    )
+  );
+  add(
+    "browser_file_upload",
+    () => (0, import_beta.tool)(
+      {
+        name: name("browser_file_upload"),
+        description: "Set files on a file input element by ref (provide local file paths).",
+        inputSchema: import_genkit.z.object({
+          ref: refSchema,
+          paths: import_genkit.z.array(import_genkit.z.string()).describe("Local file paths to upload.")
+        }),
+        outputSchema: import_genkit.z.string()
+      },
+      async ({ ref, paths }) => {
+        const page = await session.getPage();
+        await locatorForRef(page, ref).setInputFiles(paths);
+        return `Uploaded ${paths.length} file(s) to ${ref}.`;
+      }
+    )
+  );
+  add(
+    "browser_wait_for",
+    () => (0, import_beta.tool)(
+      {
+        name: name("browser_wait_for"),
+        description: "Wait for text to appear/disappear on the page, or for a fixed time.",
+        inputSchema: import_genkit.z.object({
+          text: import_genkit.z.string().optional().describe("Text to wait to appear."),
+          textGone: import_genkit.z.string().optional().describe("Text to wait to disappear."),
+          time: import_genkit.z.number().optional().describe("Seconds to wait. Capped at 30.")
+        }),
+        outputSchema: import_genkit.z.string()
+      },
+      async ({ text, textGone, time }) => {
+        const page = await session.getPage();
+        if (text) {
+          await page.getByText(text).first().waitFor({ state: "visible" });
+          return `Text "${text}" appeared.`;
+        }
+        if (textGone) {
+          await page.getByText(textGone).first().waitFor({ state: "hidden" });
+          return `Text "${textGone}" disappeared.`;
+        }
+        const seconds = Math.min(time ?? 1, 30);
+        await page.waitForTimeout(seconds * 1e3);
+        return `Waited ${seconds}s.`;
+      }
+    )
+  );
+  add(
+    "browser_tab_list",
+    () => (0, import_beta.tool)(
+      {
+        name: name("browser_tab_list"),
+        description: "List open tabs with their index, URL, and title.",
+        inputSchema: import_genkit.z.object({}),
+        outputSchema: import_genkit.z.array(
+          import_genkit.z.object({
+            index: import_genkit.z.number(),
+            url: import_genkit.z.string(),
+            title: import_genkit.z.string()
+          })
+        )
+      },
+      async () => {
+        const pages = await session.getPages();
+        return Promise.all(
+          pages.map(async (p, index) => ({
+            index,
+            url: p.url(),
+            title: await p.title()
+          }))
+        );
+      }
+    )
+  );
+  add(
+    "browser_tab_new",
+    () => (0, import_beta.tool)(
+      {
+        name: name("browser_tab_new"),
+        description: "Open a new tab, optionally navigating it to a URL.",
+        inputSchema: import_genkit.z.object({
+          url: import_genkit.z.string().optional().describe("URL to open in the new tab.")
+        }),
+        outputSchema: import_genkit.z.string()
+      },
+      async ({ url }) => {
+        const page = await session.newPage();
+        if (url) {
+          if (!hostnameAllowed(url, opts.allowedDomains, opts.blockedDomains)) {
+            throw new Error(`Navigation to "${url}" is not allowed by policy.`);
+          }
+          await page.goto(url, { waitUntil: "domcontentloaded" });
+        }
+        const pages = await session.getPages();
+        return `Opened tab ${pages.length - 1}${url ? ` at ${url}` : ""}.`;
+      }
+    )
+  );
+  add(
+    "browser_tab_select",
+    () => (0, import_beta.tool)(
+      {
+        name: name("browser_tab_select"),
+        description: "Bring a tab to the front by its index.",
+        inputSchema: import_genkit.z.object({
+          index: import_genkit.z.number().describe("Tab index from browser_tab_list.")
+        }),
+        outputSchema: import_genkit.z.string()
+      },
+      async ({ index }) => {
+        const pages = await session.getPages();
+        const page = pages[index];
+        if (!page) throw new Error(`No tab at index ${index}.`);
+        await page.bringToFront();
+        return `Selected tab ${index}.`;
+      }
+    )
+  );
+  add(
+    "browser_tab_close",
+    () => (0, import_beta.tool)(
+      {
+        name: name("browser_tab_close"),
+        description: "Close a tab by index (defaults to the current/last tab).",
+        inputSchema: import_genkit.z.object({
+          index: import_genkit.z.number().optional().describe("Tab index to close.")
+        }),
+        outputSchema: import_genkit.z.string()
+      },
+      async ({ index }) => {
+        const pages = await session.getPages();
+        const page = index === void 0 ? pages[pages.length - 1] : pages[index];
+        if (!page) throw new Error(`No tab at index ${index}.`);
+        await page.close();
+        return `Closed tab ${index ?? pages.length - 1}.`;
+      }
+    )
+  );
+  add(
+    "browser_handle_dialog",
+    () => (0, import_beta.tool)(
+      {
+        name: name("browser_handle_dialog"),
+        description: "Accept or dismiss a pending JavaScript dialog (alert/confirm/prompt).",
+        inputSchema: import_genkit.z.object({
+          accept: import_genkit.z.boolean().describe("Accept (true) or dismiss (false)."),
+          promptText: import_genkit.z.string().optional().describe("Text to enter for prompt dialogs.")
+        }),
+        outputSchema: import_genkit.z.string()
+      },
+      async ({ accept, promptText }) => {
+        const dialog = session.activeDialog;
+        if (!dialog) return "No pending dialog to handle.";
+        if (accept) {
+          await dialog.accept(promptText);
+        } else {
+          await dialog.dismiss();
+        }
+        session.activeDialog = void 0;
+        session.pendingDialog = void 0;
+        return `Dialog ${accept ? "accepted" : "dismissed"}.`;
+      }
+    )
+  );
+  add(
+    "browser_evaluate",
+    () => (0, import_beta.tool)(
+      {
+        name: name("browser_evaluate"),
+        description: "Evaluate arbitrary JavaScript in the page context and return the JSON-serializable result. Use only when other tools are insufficient.",
+        inputSchema: import_genkit.z.object({
+          script: import_genkit.z.string().describe(
+            'A JS expression or function body, e.g. "document.title".'
+          )
+        }),
+        outputSchema: import_genkit.z.any()
+      },
+      async ({ script }) => {
+        const page = await session.getPage();
+        const result = await page.evaluate(
+          (code) => {
+            const fn = new Function(`return (async () => { ${code} })()`);
+            return fn();
+          },
+          /(\breturn\b|;)/.test(script) ? script : `return (${script});`
+        );
+        return result ?? null;
+      }
+    )
+  );
+  return tools;
+}
+
+// src/playwright.ts
+var PlaywrightOptionsSchema = import_genkit2.z.object({
+  readOnly: import_genkit2.z.boolean().optional().describe(
+    "If true, only observe-only tools are injected (no clicking, typing, etc.)."
+  ),
+  allowEvaluate: import_genkit2.z.boolean().optional().describe(
+    "If true, the browser_evaluate JS escape-hatch tool is enabled. Off by default."
+  ),
+  tools: import_genkit2.z.array(import_genkit2.z.enum(ALL_TOOL_NAMES)).optional().describe("Allow-list of tools to inject. Defaults to all tools."),
+  allowedDomains: import_genkit2.z.array(import_genkit2.z.string()).optional().describe("If set, navigation is restricted to these hostnames."),
+  blockedDomains: import_genkit2.z.array(import_genkit2.z.string()).optional().describe("Navigation to these hostnames is blocked."),
+  toolNamePrefix: import_genkit2.z.string().optional().describe("Prefix prepended to every injected tool name.")
+});
+var playwright = (0, import_genkit2.generateMiddleware)(
+  {
+    name: "playwright",
+    description: "Injects browser automation tools (navigate, snapshot, click, type, etc.) backed by a Playwright browser.",
+    configSchema: PlaywrightOptionsSchema
+  },
+  ({ config, pluginConfig }) => {
+    const session = new BrowserSession(pluginConfig ?? {});
+    const messageQueue = [];
+    const tools = createPlaywrightTools({
+      session,
+      messageQueue,
+      toolNamePrefix: config?.toolNamePrefix,
+      readOnly: config?.readOnly,
+      allowEvaluate: config?.allowEvaluate,
+      tools: config?.tools,
+      allowedDomains: config?.allowedDomains,
+      blockedDomains: config?.blockedDomains
+    });
+    return {
+      tools,
+      generate: async (envelope, ctx, next) => {
+        try {
+          const { request } = envelope;
+          let { messageIndex } = envelope;
+          if (messageQueue.length > 0) {
+            if (ctx.onChunk) {
+              for (const msg of messageQueue) {
+                ctx.onChunk({
+                  role: msg.role,
+                  index: messageIndex++,
+                  content: msg.content
+                });
+              }
+            }
+            request.messages.push(...messageQueue);
+            messageQueue.length = 0;
+          }
+          return await next({ ...envelope, request, messageIndex }, ctx);
+        } finally {
+          await session.close();
+        }
+      }
+    };
+  }
+);
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  ALL_TOOL_NAMES,
+  BrowserSession,
+  PlaywrightOptionsSchema,
+  createPlaywrightTools,
+  playwright
+});
+//# sourceMappingURL=index.js.map