patchright-bun-core 1.58.0 → 1.59.0

package/lib/server/agent/performTools.js

@@ -1,262 +0,0 @@
-"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);
-var performTools_exports = {};
-__export(performTools_exports, {
-  default: () => performTools_default
-});
-module.exports = __toCommonJS(performTools_exports);
-var import_mcpBundle = require("../../mcpBundle");
-var import_tool = require("./tool");
-const navigateSchema = import_mcpBundle.z.object({
-  url: import_mcpBundle.z.string().describe("URL to navigate to")
-});
-const navigate = (0, import_tool.defineTool)({
-  schema: {
-    name: "browser_navigate",
-    title: "Navigate to URL",
-    description: "Navigate to a URL",
-    inputSchema: navigateSchema
-  },
-  handle: async (progress, context, params) => {
-    return await context.runActionNoWait(progress, {
-      method: "navigate",
-      url: params.url
-    });
-  }
-});
-const snapshot = (0, import_tool.defineTool)({
-  schema: {
-    name: "browser_snapshot",
-    title: "Page snapshot",
-    description: "Capture accessibility snapshot of the current page, this is better than screenshot",
-    inputSchema: import_mcpBundle.z.object({})
-  },
-  handle: async (progress, context, params) => {
-    return await context.snapshotResult(progress);
-  }
-});
-const elementSchema = import_mcpBundle.z.object({
-  element: import_mcpBundle.z.string().describe("Human-readable element description used to obtain permission to interact with the element"),
-  ref: import_mcpBundle.z.string().describe("Exact target element reference from the page snapshot")
-});
-const clickSchema = elementSchema.extend({
-  doubleClick: import_mcpBundle.z.boolean().optional().describe("Whether to perform a double click instead of a single click"),
-  button: import_mcpBundle.z.enum(["left", "right", "middle"]).optional().describe("Button to click, defaults to left"),
-  modifiers: import_mcpBundle.z.array(import_mcpBundle.z.enum(["Alt", "Control", "ControlOrMeta", "Meta", "Shift"])).optional().describe("Modifier keys to press")
-});
-const click = (0, import_tool.defineTool)({
-  schema: {
-    name: "browser_click",
-    title: "Click",
-    description: "Perform click on a web page",
-    inputSchema: clickSchema
-  },
-  handle: async (progress, context, params) => {
-    const [selector] = await context.refSelectors(progress, [params]);
-    return await context.runActionAndWait(progress, {
-      method: "click",
-      selector,
-      button: params.button,
-      modifiers: params.modifiers,
-      clickCount: params.doubleClick ? 2 : void 0
-    });
-  }
-});
-const drag = (0, import_tool.defineTool)({
-  schema: {
-    name: "browser_drag",
-    title: "Drag mouse",
-    description: "Perform drag and drop between two elements",
-    inputSchema: import_mcpBundle.z.object({
-      startElement: import_mcpBundle.z.string().describe("Human-readable source element description used to obtain the permission to interact with the element"),
-      startRef: import_mcpBundle.z.string().describe("Exact source element reference from the page snapshot"),
-      endElement: import_mcpBundle.z.string().describe("Human-readable target element description used to obtain the permission to interact with the element"),
-      endRef: import_mcpBundle.z.string().describe("Exact target element reference from the page snapshot")
-    })
-  },
-  handle: async (progress, context, params) => {
-    const [sourceSelector, targetSelector] = await context.refSelectors(progress, [
-      { ref: params.startRef, element: params.startElement },
-      { ref: params.endRef, element: params.endElement }
-    ]);
-    return await context.runActionAndWait(progress, {
-      method: "drag",
-      sourceSelector,
-      targetSelector
-    });
-  }
-});
-const hoverSchema = elementSchema.extend({
-  modifiers: import_mcpBundle.z.array(import_mcpBundle.z.enum(["Alt", "Control", "ControlOrMeta", "Meta", "Shift"])).optional().describe("Modifier keys to press")
-});
-const hover = (0, import_tool.defineTool)({
-  schema: {
-    name: "browser_hover",
-    title: "Hover mouse",
-    description: "Hover over element on page",
-    inputSchema: hoverSchema
-  },
-  handle: async (progress, context, params) => {
-    const [selector] = await context.refSelectors(progress, [params]);
-    return await context.runActionAndWait(progress, {
-      method: "hover",
-      selector,
-      modifiers: params.modifiers
-    });
-  }
-});
-const selectOptionSchema = elementSchema.extend({
-  values: import_mcpBundle.z.array(import_mcpBundle.z.string()).describe("Array of values to select in the dropdown. This can be a single value or multiple values.")
-});
-const selectOption = (0, import_tool.defineTool)({
-  schema: {
-    name: "browser_select_option",
-    title: "Select option",
-    description: "Select an option in a dropdown",
-    inputSchema: selectOptionSchema
-  },
-  handle: async (progress, context, params) => {
-    const [selector] = await context.refSelectors(progress, [params]);
-    return await context.runActionAndWait(progress, {
-      method: "selectOption",
-      selector,
-      labels: params.values
-    });
-  }
-});
-const pressKey = (0, import_tool.defineTool)({
-  schema: {
-    name: "browser_press_key",
-    title: "Press a key",
-    description: "Press a key on the keyboard",
-    inputSchema: import_mcpBundle.z.object({
-      key: import_mcpBundle.z.string().describe("Name of the key to press or a character to generate, such as `ArrowLeft` or `a`"),
-      modifiers: import_mcpBundle.z.array(import_mcpBundle.z.enum(["Alt", "Control", "ControlOrMeta", "Meta", "Shift"])).optional().describe("Modifier keys to press")
-    })
-  },
-  handle: async (progress, context, params) => {
-    return await context.runActionAndWait(progress, {
-      method: "pressKey",
-      key: params.modifiers ? [...params.modifiers, params.key].join("+") : params.key
-    });
-  }
-});
-const typeSchema = elementSchema.extend({
-  text: import_mcpBundle.z.string().describe("Text to type into the element"),
-  submit: import_mcpBundle.z.boolean().optional().describe("Whether to submit entered text (press Enter after)"),
-  slowly: import_mcpBundle.z.boolean().optional().describe("Whether to type one character at a time. Useful for triggering key handlers in the page. By default entire text is filled in at once.")
-});
-const type = (0, import_tool.defineTool)({
-  schema: {
-    name: "browser_type",
-    title: "Type text",
-    description: "Type text into editable element",
-    inputSchema: typeSchema
-  },
-  handle: async (progress, context, params) => {
-    const [selector] = await context.refSelectors(progress, [params]);
-    if (params.slowly) {
-      return await context.runActionAndWait(progress, {
-        method: "pressSequentially",
-        selector,
-        text: params.text,
-        submit: params.submit
-      });
-    } else {
-      return await context.runActionAndWait(progress, {
-        method: "fill",
-        selector,
-        text: params.text,
-        submit: params.submit
-      });
-    }
-  }
-});
-const fillForm = (0, import_tool.defineTool)({
-  schema: {
-    name: "browser_fill_form",
-    title: "Fill form",
-    description: "Fill multiple form fields. Always use this tool when you can fill more than one field at a time.",
-    inputSchema: import_mcpBundle.z.object({
-      fields: import_mcpBundle.z.array(import_mcpBundle.z.object({
-        name: import_mcpBundle.z.string().describe("Human-readable field name"),
-        type: import_mcpBundle.z.enum(["textbox", "checkbox", "radio", "combobox", "slider"]).describe("Type of the field"),
-        ref: import_mcpBundle.z.string().describe("Exact target field reference from the page snapshot"),
-        value: import_mcpBundle.z.string().describe("Value to fill in the field. If the field is a checkbox, the value should be `true` or `false`. If the field is a combobox, the value should be the text of the option.")
-      })).describe("Fields to fill in")
-    })
-  },
-  handle: async (progress, context, params) => {
-    const actions = [];
-    for (const field of params.fields) {
-      const [selector] = await context.refSelectors(progress, [{ ref: field.ref, element: field.name }]);
-      if (field.type === "textbox" || field.type === "slider") {
-        actions.push({
-          method: "fill",
-          selector,
-          text: field.value
-        });
-      } else if (field.type === "checkbox" || field.type === "radio") {
-        actions.push({
-          method: "setChecked",
-          selector,
-          checked: field.value === "true"
-        });
-      } else if (field.type === "combobox") {
-        actions.push({
-          method: "selectOption",
-          selector,
-          labels: [field.value]
-        });
-      }
-    }
-    return await context.runActionsAndWait(progress, actions);
-  }
-});
-const setCheckedSchema = elementSchema.extend({
-  checked: import_mcpBundle.z.boolean().describe("Whether to check the checkbox")
-});
-const setChecked = (0, import_tool.defineTool)({
-  schema: {
-    name: "browser_set_checked",
-    title: "Set checked",
-    description: "Set the checked state of a checkbox",
-    inputSchema: setCheckedSchema
-  },
-  handle: async (progress, context, params) => {
-    const [selector] = await context.refSelectors(progress, [params]);
-    return await context.runActionAndWait(progress, {
-      method: "setChecked",
-      selector,
-      checked: params.checked
-    });
-  }
-});
-var performTools_default = [
-  navigate,
-  snapshot,
-  click,
-  drag,
-  hover,
-  selectOption,
-  pressKey,
-  type,
-  fillForm,
-  setChecked
-];

package/lib/server/agent/tool.js

@@ -1,109 +0,0 @@
-"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);
-var tool_exports = {};
-__export(tool_exports, {
-  defineTool: () => defineTool,
-  toolsForLoop: () => toolsForLoop
-});
-module.exports = __toCommonJS(tool_exports);
-var import_mcpBundle = require("../../mcpBundle");
-var import_stringUtils = require("../../utils/isomorphic/stringUtils");
-function defineTool(tool) {
-  return tool;
-}
-function toolsForLoop(progress, context, toolDefinitions, options = {}) {
-  const tools = toolDefinitions.map((tool) => {
-    const result = {
-      name: tool.schema.name,
-      description: tool.schema.description,
-      inputSchema: import_mcpBundle.z.toJSONSchema(tool.schema.inputSchema)
-    };
-    return result;
-  });
-  if (options.resultSchema) {
-    tools.push({
-      name: "report_result",
-      description: "Report the result of the task.",
-      inputSchema: options.resultSchema
-    });
-  }
-  if (options.refuseToPerform === "allow") {
-    tools.push({
-      name: "refuse_to_perform",
-      description: "Refuse to perform action.",
-      inputSchema: {
-        type: "object",
-        properties: {
-          reason: {
-            type: "string",
-            description: `Call this when you believe that you can't perform the action because something is wrong with the page. The reason will be reported to the user.`
-          }
-        },
-        required: ["reason"]
-      }
-    });
-  }
-  let reportedResult;
-  let refusedToPerformReason;
-  const callTool = async (params) => {
-    if (params.name === "report_result") {
-      reportedResult = params.arguments;
-      return {
-        content: [{ type: "text", text: "Done" }],
-        isError: false
-      };
-    }
-    if (params.name === "refuse_to_perform") {
-      refusedToPerformReason = params.arguments.reason;
-      return {
-        content: [{ type: "text", text: "Done" }],
-        isError: false
-      };
-    }
-    const tool = toolDefinitions.find((t) => t.schema.name === params.name);
-    if (!tool) {
-      return {
-        content: [{
-          type: "text",
-          text: `Tool ${params.name} not found. Available tools: ${toolDefinitions.map((t) => t.schema.name)}`
-        }],
-        isError: true
-      };
-    }
-    try {
-      return await tool.handle(progress, context, params.arguments);
-    } catch (error) {
-      return {
-        content: [{ type: "text", text: (0, import_stringUtils.stripAnsiEscapes)(error.message) }],
-        isError: true
-      };
-    }
-  };
-  return {
-    tools,
-    callTool,
-    reportedResult: options.resultSchema ? () => reportedResult : void 0,
-    refusedToPerformReason: () => refusedToPerformReason
-  };
-}
-// Annotate the CommonJS export names for ESM import in node:
-0 && (module.exports = {
-  defineTool,
-  toolsForLoop
-});

package/lib/server/dispatchers/pageAgentDispatcher.js

@@ -1,96 +0,0 @@
-"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);
-var pageAgentDispatcher_exports = {};
-__export(pageAgentDispatcher_exports, {
-  PageAgentDispatcher: () => PageAgentDispatcher
-});
-module.exports = __toCommonJS(pageAgentDispatcher_exports);
-var import_dispatcher = require("./dispatcher");
-var import_pageAgent = require("../agent/pageAgent");
-var import_instrumentation = require("../instrumentation");
-var import_context = require("../agent/context");
-class PageAgentDispatcher extends import_dispatcher.Dispatcher {
-  constructor(scope, options) {
-    super(scope, new import_instrumentation.SdkObject(scope._object, "pageAgent"), "PageAgent", { page: scope });
-    this._type_PageAgent = true;
-    this._type_EventTarget = true;
-    this._usage = { turns: 0, inputTokens: 0, outputTokens: 0 };
-    this._page = scope._object;
-    this._context = new import_context.Context(this._page, options, this._eventSupport());
-  }
-  async perform(params, progress) {
-    try {
-      await (0, import_pageAgent.pageAgentPerform)(progress, this._context, params.task, params);
-    } finally {
-      this._context.pushHistory({ type: "perform", description: params.task });
-    }
-    return { usage: this._usage };
-  }
-  async expect(params, progress) {
-    try {
-      await (0, import_pageAgent.pageAgentExpect)(progress, this._context, params.expectation, params);
-    } finally {
-      this._context.pushHistory({ type: "expect", description: params.expectation });
-    }
-    return { usage: this._usage };
-  }
-  async extract(params, progress) {
-    const result = await (0, import_pageAgent.pageAgentExtract)(progress, this._context, params.query, params.schema, params);
-    return { result, usage: this._usage };
-  }
-  async usage(params, progress) {
-    return { usage: this._usage };
-  }
-  async dispose(params, progress) {
-    progress.metadata.potentiallyClosesScope = true;
-    void this.stopPendingOperations(new Error("The agent is disposed"));
-    this._dispose();
-  }
-  _eventSupport() {
-    const self = this;
-    return {
-      onBeforeTurn(params) {
-        const userMessage = params.conversation.messages.find((m) => m.role === "user");
-        self._dispatchEvent("turn", { role: "user", message: userMessage?.content ?? "" });
-      },
-      onAfterTurn(params) {
-        const usage = { inputTokens: params.totalUsage.input, outputTokens: params.totalUsage.output };
-        const intent = params.assistantMessage.content.filter((c) => c.type === "text").map((c) => c.text).join("\n");
-        self._dispatchEvent("turn", { role: "assistant", message: intent, usage });
-        if (!params.assistantMessage.content.filter((c) => c.type === "tool_call").length)
-          self._dispatchEvent("turn", { role: "assistant", message: `no tool calls`, usage });
-        self._usage = { turns: self._usage.turns + 1, inputTokens: self._usage.inputTokens + usage.inputTokens, outputTokens: self._usage.outputTokens + usage.outputTokens };
-      },
-      onBeforeToolCall(params) {
-        self._dispatchEvent("turn", { role: "assistant", message: `call tool "${params.toolCall.name}"` });
-      },
-      onAfterToolCall(params) {
-        const suffix = params.toolCall.result?.isError ? "failed" : "succeeded";
-        self._dispatchEvent("turn", { role: "user", message: `tool "${params.toolCall.name}" ${suffix}` });
-      },
-      onToolCallError(params) {
-        self._dispatchEvent("turn", { role: "user", message: `tool "${params.toolCall.name}" failed: ${params.error.message}` });
-      }
-    };
-  }
-}
-// Annotate the CommonJS export names for ESM import in node:
-0 && (module.exports = {
-  PageAgentDispatcher
-});