@tontoko/fast-playwright-mcp 0.0.4

package/lib/tab.js

@@ -0,0 +1,417 @@
+import { createRequire } from "node:module";
+var __create = Object.create;
+var __getProtoOf = Object.getPrototypeOf;
+var __defProp = Object.defineProperty;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __toESM = (mod, isNodeMode, target) => {
+  target = mod != null ? __create(__getProtoOf(mod)) : {};
+  const to = isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target;
+  for (let key of __getOwnPropNames(mod))
+    if (!__hasOwnProp.call(to, key))
+      __defProp(to, key, {
+        get: () => mod[key],
+        enumerable: true
+      });
+  return to;
+};
+var __require = /* @__PURE__ */ createRequire(import.meta.url);
+
+// src/tab.ts
+import { EventEmitter } from "node:events";
+import debug from "debug";
+import { TIMEOUTS } from "./config/constants.js";
+import { logUnhandledError } from "./log.js";
+import { ManualPromise } from "./manual-promise.js";
+import { callOnPageNoTrace, waitForCompletion } from "./tools/utils.js";
+var REF_VALUE_REGEX = /\[ref=([^\]]+)\]/;
+var TabEvents = {
+  modalState: "modalState"
+};
+var snapshotDebug = debug("pw:mcp:snapshot");
+
+class Tab extends EventEmitter {
+  context;
+  page;
+  _lastTitle = "about:blank";
+  _consoleMessages = [];
+  _recentConsoleMessages = [];
+  _requests = new Map;
+  _onPageClose;
+  _modalStates = [];
+  _downloads = [];
+  _navigationState = {
+    isNavigating: false,
+    lastNavigationStart: 0
+  };
+  constructor(context, page, onPageClose) {
+    super();
+    this.context = context;
+    this.page = page;
+    this._onPageClose = onPageClose;
+    page.on("console", (event) => this._handleConsoleMessage(messageToConsoleMessage(event)));
+    page.on("pageerror", (error) => this._handleConsoleMessage(pageErrorToConsoleMessage(error)));
+    page.on("request", (request) => this._requests.set(request, null));
+    page.on("response", (response) => this._requests.set(response.request(), response));
+    page.on("close", () => this._onClose());
+    page.on("filechooser", (chooser) => {
+      this.setModalState({
+        type: "fileChooser",
+        description: "File chooser",
+        fileChooser: chooser
+      });
+    });
+    page.on("dialog", (dialog) => this._dialogShown(dialog));
+    page.on("download", (download) => {
+      this._downloadStarted(download).catch(() => {});
+    });
+    page.on("framenavigated", (frame) => {
+      if (frame === page.mainFrame()) {
+        this._handleNavigationStart();
+      }
+    });
+    page.on("load", () => {
+      this._handleNavigationComplete();
+    });
+    page.on("domcontentloaded", () => {
+      this._navigationState.isNavigating = true;
+    });
+    page.setDefaultNavigationTimeout(60000);
+    page.setDefaultTimeout(TIMEOUTS.DEFAULT_PAGE_TIMEOUT);
+    page[tabSymbol] = this;
+  }
+  static forPage(page) {
+    return page[tabSymbol];
+  }
+  modalStates() {
+    return this._modalStates;
+  }
+  setModalState(modalState) {
+    this._modalStates.push(modalState);
+    this.emit(TabEvents.modalState, modalState);
+  }
+  clearModalState(modalState) {
+    this._modalStates = this._modalStates.filter((state) => state !== modalState);
+  }
+  modalStatesMarkdown() {
+    return renderModalStates(this.context, this.modalStates());
+  }
+  _dialogShown(dialog) {
+    this.setModalState({
+      type: "dialog",
+      description: `"${dialog.type()}" dialog with message "${dialog.message()}"`,
+      dialog
+    });
+  }
+  async _downloadStarted(download) {
+    const entry = {
+      download,
+      finished: false,
+      outputFile: await this.context.outputFile(download.suggestedFilename())
+    };
+    this._downloads.push(entry);
+    await download.saveAs(entry.outputFile);
+    entry.finished = true;
+  }
+  _clearCollectedArtifacts() {
+    this._consoleMessages.length = 0;
+    this._recentConsoleMessages.length = 0;
+    this._requests.clear();
+  }
+  _handleConsoleMessage(message) {
+    this._consoleMessages.push(message);
+    this._recentConsoleMessages.push(message);
+  }
+  _onClose() {
+    this._clearCollectedArtifacts();
+    this._onPageClose(this);
+  }
+  async updateTitle() {
+    await this._raceAgainstModalStates(async () => {
+      this._lastTitle = await callOnPageNoTrace(this.page, (page) => page.title());
+    });
+  }
+  lastTitle() {
+    return this._lastTitle;
+  }
+  isCurrentTab() {
+    return this === this.context.currentTab();
+  }
+  async waitForLoadState(state, options) {
+    await callOnPageNoTrace(this.page, (page) => page.waitForLoadState(state, options).catch(logUnhandledError));
+  }
+  _handleNavigationStart() {
+    this._navigationState.isNavigating = true;
+    this._navigationState.lastNavigationStart = Date.now();
+    this._navigationState.navigationPromise = this._createNavigationPromise();
+  }
+  _handleNavigationComplete() {
+    this._navigationState.isNavigating = false;
+  }
+  _createNavigationPromise() {
+    return new Promise((resolve) => {
+      const checkComplete = () => {
+        if (!this._navigationState.isNavigating) {
+          resolve();
+          return;
+        }
+        if (Date.now() - this._navigationState.lastNavigationStart > getNavigationTimeouts().navigationTimeout) {
+          this._navigationState.isNavigating = false;
+          resolve();
+          return;
+        }
+        setTimeout(checkComplete, getNavigationTimeouts().checkInterval);
+      };
+      setTimeout(checkComplete, getNavigationTimeouts().checkInterval);
+    });
+  }
+  isNavigating() {
+    const isStale = Date.now() - this._navigationState.lastNavigationStart > getNavigationTimeouts().staleTimeout;
+    if (isStale && this._navigationState.isNavigating) {
+      this._navigationState.isNavigating = false;
+    }
+    return this._navigationState.isNavigating;
+  }
+  async waitForNavigationComplete() {
+    if (this._navigationState.navigationPromise) {
+      await this._navigationState.navigationPromise;
+    }
+  }
+  async navigate(url) {
+    this._clearCollectedArtifacts();
+    const downloadEvent = callOnPageNoTrace(this.page, (page) => page.waitForEvent("download").catch(logUnhandledError));
+    try {
+      await this.page.goto(url, { waitUntil: "domcontentloaded" });
+    } catch (_e) {
+      const e = _e;
+      const mightBeDownload = e.message.includes("net::ERR_ABORTED") || e.message.includes("Download is starting");
+      if (!mightBeDownload) {
+        throw e;
+      }
+      const download = await Promise.race([
+        downloadEvent,
+        new Promise((resolve) => setTimeout(resolve, TIMEOUTS.LONG_DELAY))
+      ]);
+      if (!download) {
+        throw e;
+      }
+      await new Promise((resolve) => setTimeout(resolve, TIMEOUTS.SHORT_DELAY));
+      return;
+    }
+    await this.waitForLoadState("load", {
+      timeout: TIMEOUTS.LOAD_STATE_TIMEOUT
+    });
+  }
+  consoleMessages() {
+    return this._consoleMessages;
+  }
+  requests() {
+    return this._requests;
+  }
+  async captureSnapshot() {
+    return await this._captureSnapshotInternal();
+  }
+  async capturePartialSnapshot(selector, maxLength) {
+    return await this._captureSnapshotInternal(selector, maxLength);
+  }
+  async _captureSnapshotInternal(selector, maxLength) {
+    let tabSnapshot;
+    const modalStates = await this._raceAgainstModalStates(async () => {
+      let snapshot;
+      if (selector) {
+        const fullSnapshot = await this.page._snapshotForAI();
+        snapshot = this._extractPartialSnapshot(fullSnapshot, selector);
+      } else {
+        snapshot = await this.page._snapshotForAI();
+      }
+      if (maxLength && snapshot.length > maxLength) {
+        snapshot = this._truncateAtWordBoundary(snapshot, maxLength);
+      }
+      tabSnapshot = {
+        url: this.page.url(),
+        title: await this.page.title(),
+        ariaSnapshot: snapshot,
+        modalStates: [],
+        consoleMessages: [],
+        downloads: this._downloads
+      };
+    });
+    if (tabSnapshot) {
+      tabSnapshot.consoleMessages = this._recentConsoleMessages;
+      this._recentConsoleMessages = [];
+    }
+    return tabSnapshot ?? {
+      url: this.page.url(),
+      title: "",
+      ariaSnapshot: "",
+      modalStates,
+      consoleMessages: [],
+      downloads: []
+    };
+  }
+  _extractPartialSnapshot(fullSnapshot, selector) {
+    const lines = fullSnapshot.split(`
+`);
+    const selectorToRole = {
+      main: "main",
+      header: "banner",
+      footer: "contentinfo",
+      nav: "navigation",
+      aside: "complementary",
+      section: "region",
+      article: "article"
+    };
+    const expectedRole = selectorToRole[selector] ?? selector;
+    let capturing = false;
+    let captureIndent = -1;
+    const capturedLines = [];
+    for (const line of lines) {
+      const indent = line.length - line.trimStart().length;
+      const trimmedLine = line.trim();
+      const rolePattern = new RegExp(`^- ${expectedRole}\\s*(?:\\[[^\\]]*\\])*\\s*:?`);
+      if (!capturing && rolePattern.test(trimmedLine)) {
+        capturing = true;
+        captureIndent = indent;
+        capturedLines.push(line);
+        continue;
+      }
+      if (capturing) {
+        if (indent > captureIndent) {
+          capturedLines.push(line);
+        } else {
+          break;
+        }
+      }
+    }
+    if (capturedLines.length > 0) {
+      const minIndent = capturedLines[0].length - capturedLines[0].trimStart().length;
+      const normalizedLines = capturedLines.map((line) => {
+        if (line.trim() === "") {
+          return line;
+        }
+        const currentIndent = line.length - line.trimStart().length;
+        const newIndent = Math.max(0, currentIndent - minIndent);
+        return " ".repeat(newIndent) + line.trimStart();
+      });
+      return normalizedLines.join(`
+`);
+    }
+    snapshotDebug('Selector "%s" not found in snapshot, returning full snapshot', selector);
+    return fullSnapshot;
+  }
+  _truncateAtWordBoundary(text, maxLength) {
+    if (text.length <= maxLength) {
+      return text;
+    }
+    let truncateIndex = maxLength;
+    if (text[maxLength] && text[maxLength] !== " " && text[maxLength] !== `
+`) {
+      for (let i = maxLength - 1;i >= 0; i--) {
+        if (text[i] === " " || text[i] === `
+`) {
+          truncateIndex = i;
+          break;
+        }
+      }
+      if (maxLength - truncateIndex > 20) {
+        truncateIndex = maxLength;
+      }
+    }
+    let result = text.substring(0, truncateIndex).trim();
+    if (result.length > maxLength) {
+      result = result.substring(0, maxLength);
+    }
+    return result;
+  }
+  _javaScriptBlocked() {
+    return this._modalStates.some((state) => state.type === "dialog");
+  }
+  async _raceAgainstModalStates(action) {
+    if (this.modalStates().length) {
+      return this.modalStates();
+    }
+    const promise = new ManualPromise;
+    const listener = (modalState) => promise.resolve([modalState]);
+    this.once(TabEvents.modalState, listener);
+    return await Promise.race([
+      action().then(() => {
+        this.off(TabEvents.modalState, listener);
+        return [];
+      }),
+      promise
+    ]);
+  }
+  async waitForCompletion(callback) {
+    await this._raceAgainstModalStates(() => waitForCompletion(this, callback));
+  }
+  async refLocator(params) {
+    return (await this.refLocators([params]))[0];
+  }
+  async refLocators(params) {
+    const snapshot = await this.page._snapshotForAI();
+    return params.map((param) => {
+      if (!snapshot.includes(`[ref=${param.ref}]`)) {
+        const availableRefs = this._getAvailableRefs(snapshot);
+        throw new Error(`Ref ${param.ref} not found. Available refs: [${availableRefs.join(", ")}]. Element: ${param.element}. Consider capturing a new snapshot if the page has changed.`);
+      }
+      return this.page.locator(`aria-ref=${param.ref}`).describe(param.element);
+    });
+  }
+  async waitForTimeout(time) {
+    if (this._javaScriptBlocked()) {
+      await new Promise((f) => setTimeout(f, time));
+      return;
+    }
+    await callOnPageNoTrace(this.page, (page) => {
+      return page.evaluate((timeout) => new Promise((f) => setTimeout(f, timeout)), time);
+    });
+  }
+  _getAvailableRefs(snapshot) {
+    const refMatches = snapshot.match(/\[ref=([^\]]+)\]/g);
+    if (!refMatches) {
+      return [];
+    }
+    return refMatches.map((match) => {
+      const refValue = REF_VALUE_REGEX.exec(match);
+      return refValue ? refValue[1] : "";
+    }).filter(Boolean);
+  }
+}
+function messageToConsoleMessage(message) {
+  return {
+    type: message.type(),
+    text: message.text(),
+    toString: () => `[${message.type().toUpperCase()}] ${message.text()} @ ${message.location().url}:${message.location().lineNumber}`
+  };
+}
+function pageErrorToConsoleMessage(error) {
+  return {
+    type: undefined,
+    text: error.message,
+    toString: () => error.stack ?? error.message
+  };
+}
+function renderModalStates(context, modalStates) {
+  const result = ["### Modal state"];
+  if (modalStates.length === 0) {
+    result.push("- There is no modal state present");
+  }
+  for (const state of modalStates) {
+    const tool = context.tools.filter((t) => ("clearsModalState" in t)).find((t) => t.clearsModalState === state.type);
+    result.push(`- [${state.description}]: can be handled by the "${tool?.schema.name}" tool`);
+  }
+  return result;
+}
+var tabSymbol = Symbol("tabSymbol");
+function getNavigationTimeouts() {
+  return {
+    navigationTimeout: TIMEOUTS.DEFAULT_PAGE_TIMEOUT,
+    checkInterval: 100,
+    staleTimeout: 1e4
+  };
+}
+export {
+  renderModalStates,
+  TabEvents,
+  Tab
+};

package/lib/tools/base-tool-handler.js

@@ -0,0 +1,141 @@
+import { createRequire } from "node:module";
+var __create = Object.create;
+var __getProtoOf = Object.getPrototypeOf;
+var __defProp = Object.defineProperty;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __toESM = (mod, isNodeMode, target) => {
+  target = mod != null ? __create(__getProtoOf(mod)) : {};
+  const to = isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target;
+  for (let key of __getOwnPropNames(mod))
+    if (!__hasOwnProp.call(to, key))
+      __defProp(to, key, {
+        get: () => mod[key],
+        enumerable: true
+      });
+  return to;
+};
+var __require = /* @__PURE__ */ createRequire(import.meta.url);
+
+// src/tools/base-tool-handler.ts
+import { z } from "zod";
+import { expectationSchema } from "../schemas/expectation.js";
+import { getErrorMessage } from "../utils/common-formatters.js";
+var baseElementSchema = z.object({
+  element: z.string().optional().describe("Human-readable element description used to obtain permission to interact with the element"),
+  ref: z.string().optional().describe("Exact target element reference from the page snapshot")
+});
+var baseExpectationSchema = z.object({
+  expectation: expectationSchema
+});
+
+class BaseToolHandler {
+  toolName;
+  constructor(toolName) {
+    this.toolName = toolName;
+  }
+  async handle(tab, params, response) {
+    try {
+      this.handleExpectation(params, response);
+      await this.executeToolLogic(tab, params, response);
+    } catch (error) {
+      this.handleToolError(error, response, params);
+      throw error;
+    }
+  }
+  handleExpectation(params, response) {
+    if (params.expectation) {
+      this.applyExpectationToResponse(params.expectation, response);
+    }
+  }
+  applyExpectationToResponse(expectation, response) {
+    const exp = expectation;
+    if (exp.includeSnapshot !== false) {
+      response.setIncludeSnapshot();
+    }
+  }
+  handleToolError(error, response, params) {
+    const errorMessage = getErrorMessage(error);
+    response.addError(`Error in ${this.toolName}: ${errorMessage}`);
+    if ("element" in params && params.element) {
+      response.addResult(`Element context: ${params.element}`);
+    }
+    if ("ref" in params && params.ref) {
+      response.addResult(`Reference: ${params.ref}`);
+    }
+  }
+  addCodeComment(response, operation, context) {
+    const comment = context ? `// ${operation} - ${context}` : `// ${operation}`;
+    response.addCode(comment);
+  }
+  async waitForCompletion(tab, operation, operationName) {
+    try {
+      await tab.waitForCompletion(operation);
+    } catch (error) {
+      const operation_name = operationName ?? "operation";
+      throw new Error(`${this.toolName} ${operation_name} failed: ${getErrorMessage(error)}`);
+    }
+  }
+}
+
+class BaseElementToolHandler extends BaseToolHandler {
+  async resolveElementLocator(tab, params) {
+    if (params.ref && params.element) {
+      return await tab.refLocator({
+        ref: params.ref,
+        element: params.element
+      });
+    }
+  }
+  validateElementParams(params) {
+    if (params.ref && !params.element) {
+      throw new Error("Element description is required when ref is provided");
+    }
+    if (params.element && !params.ref) {
+      throw new Error("Element ref is required when element description is provided");
+    }
+  }
+  handleToolError(error, response, params) {
+    super.handleToolError(error, response, params);
+    if (params.element && params.ref) {
+      response.addResult("Suggestion: Verify element selector is still valid");
+      response.addResult("Suggestion: Check if element is visible and interactable");
+    }
+  }
+}
+function createToolWithBaseHandler(config, handlerClass) {
+  const handler = new handlerClass(config.name);
+  return {
+    capability: config.capability ?? "core",
+    schema: {
+      name: config.name,
+      title: config.title,
+      description: config.description,
+      inputSchema: config.inputSchema,
+      type: config.type ?? "readOnly"
+    },
+    handle: async (tab, params, response) => {
+      await handler.handle(tab, params, response);
+    }
+  };
+}
+var mouseCoordinateSchema = baseExpectationSchema.extend({
+  x: z.number().describe("X coordinate"),
+  y: z.number().describe("Y coordinate")
+});
+var navigationSchema = baseExpectationSchema.extend({
+  url: z.string().describe("The URL to navigate to")
+});
+var keyboardSchema = baseExpectationSchema.extend({
+  key: z.string().describe("Key to press")
+});
+export {
+  navigationSchema,
+  mouseCoordinateSchema,
+  keyboardSchema,
+  createToolWithBaseHandler,
+  baseExpectationSchema,
+  baseElementSchema,
+  BaseToolHandler,
+  BaseElementToolHandler
+};

package/lib/tools/batch-execute.js

@@ -0,0 +1,150 @@
+import { createRequire } from "node:module";
+var __create = Object.create;
+var __getProtoOf = Object.getPrototypeOf;
+var __defProp = Object.defineProperty;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __toESM = (mod, isNodeMode, target) => {
+  target = mod != null ? __create(__getProtoOf(mod)) : {};
+  const to = isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target;
+  for (let key of __getOwnPropNames(mod))
+    if (!__hasOwnProp.call(to, key))
+      __defProp(to, key, {
+        get: () => mod[key],
+        enumerable: true
+      });
+  return to;
+};
+var __require = /* @__PURE__ */ createRequire(import.meta.url);
+
+// src/tools/batch-execute.ts
+import { batchExecuteSchema } from "../types/batch.js";
+import { createBatchErrorHandler } from "../utils/error-handler-middleware.js";
+import { defineTool } from "./tool.js";
+var batchExecuteTool = defineTool({
+  capability: "core",
+  schema: {
+    name: "browser_batch_execute",
+    title: "Batch Execute Browser Actions",
+    description: `Execute multiple browser actions in sequence with optimized response handling.RECOMMENDED:Use this tool instead of individual actions when performing multiple operations to significantly reduce token usage and improve performance.BY DEFAULT use for:form filling(multiple type→click),multi-step navigation,any workflow with 2+ known steps.Saves 90% tokens vs individual calls.globalExpectation:{includeSnapshot:false,snapshotOptions:{selector:"#app"},diffOptions:{enabled:true}}.Per-step override:steps[].expectation.Example:[{tool:"browser_navigate",arguments:{url:"https://example.com"}},{tool:"browser_type",arguments:{element:"username",ref:"#user",text:"john"}},{tool:"browser_click",arguments:{element:"submit",ref:"#btn"}}].`,
+    inputSchema: batchExecuteSchema,
+    type: "destructive"
+  },
+  handle: async (context, params, response) => {
+    try {
+      const batchExecutor = getBatchExecutorOrError(context, response);
+      if (!batchExecutor) {
+        return;
+      }
+      const result = await batchExecutor.execute(params);
+      processExecutionResult(result, response);
+    } catch (error) {
+      const errorHandler = createBatchErrorHandler("BatchExecute");
+      const enrichedError = errorHandler(error);
+      response.addError(enrichedError.message);
+    }
+  }
+});
+function getBatchExecutorOrError(context, response) {
+  const batchExecutor = context.getBatchExecutor();
+  if (!batchExecutor) {
+    response.addError("Batch executor not available. Please ensure the browser context is properly initialized.");
+    return null;
+  }
+  return batchExecutor;
+}
+function processExecutionResult(result, response) {
+  response.addResult(formatBatchResult(result));
+  if (result.steps.length > 0) {
+    addStepDetails(result, response);
+  }
+  addFinalStateIfNeeded(result, response);
+  handleExecutionErrors(result, response);
+}
+function addStepDetails(result, response) {
+  response.addResult("");
+  response.addResult("### Step Details");
+  for (const stepResult of result.steps) {
+    addStepResult(stepResult, response);
+  }
+}
+function addStepResult(stepResult, response) {
+  const status = stepResult.success ? "✅" : "❌";
+  const duration = `${stepResult.executionTimeMs}ms`;
+  response.addResult(`${status} Step ${stepResult.stepIndex + 1}: ${stepResult.toolName} (${duration})`);
+  if (stepResult.success && stepResult.result) {
+    addSuccessfulStepContent(stepResult, response);
+  } else if (!stepResult.success && stepResult.error) {
+    response.addResult(`   Error: ${stepResult.error}`);
+  }
+}
+function addSuccessfulStepContent(stepResult, response) {
+  const stepContent = stepResult.result;
+  const textContent = stepContent.content?.[0]?.text;
+  if (typeof textContent === "string") {
+    const lines = textContent.split(`
+`).slice(0, 3);
+    response.addResult(`   ${lines.join(`
+   `)}`);
+    if (textContent.split(`
+`).length > 3) {
+      response.addResult("   ...");
+    }
+  }
+}
+function addFinalStateIfNeeded(result, response) {
+  const successfulStepsWithContent = getSuccessfulStepsWithContent(result);
+  if (successfulStepsWithContent.length > 0 && result.stopReason === "completed") {
+    response.addResult("");
+    response.addResult("### Final State");
+    const lastStep = successfulStepsWithContent.at(-1);
+    const finalContent = extractFinalStepContent(lastStep);
+    if (finalContent) {
+      response.addResult(finalContent);
+    }
+  }
+}
+function getSuccessfulStepsWithContent(result) {
+  return result.steps.filter((s) => s.success && s.result && typeof s.result === "object" && ("content" in s.result) && Array.isArray(s.result.content) && s.result.content[0]?.text && !(("isError" in s.result) && s.result.isError));
+}
+function extractFinalStepContent(lastStep) {
+  if (lastStep?.result && typeof lastStep.result === "object" && "content" in lastStep.result && Array.isArray(lastStep.result.content) && lastStep.result.content[0]?.text) {
+    return lastStep.result.content[0].text;
+  }
+  return null;
+}
+function handleExecutionErrors(result, response) {
+  if (result.stopReason === "error" || result.failedSteps > 0) {
+    const errorMessage = result.stopReason === "error" ? "stopped due to error" : "completed with failures";
+    response.addError(`Batch execution ${errorMessage}`);
+  }
+}
+function formatBatchResult(result) {
+  const lines = [];
+  lines.push("### Batch Execution Summary");
+  lines.push(`- Status: ${getStatusDisplay(result.stopReason)}`);
+  lines.push(`- Total Steps: ${result.totalSteps}`);
+  lines.push(`- Successful: ${result.successfulSteps}`);
+  lines.push(`- Failed: ${result.failedSteps}`);
+  lines.push(`- Total Time: ${result.totalExecutionTimeMs}ms`);
+  if (result.stopReason === "error") {
+    lines.push("- Note: Execution stopped early due to error");
+  }
+  return lines.join(`
+`);
+}
+function getStatusDisplay(stopReason) {
+  switch (stopReason) {
+    case "completed":
+      return "✅ Completed";
+    case "error":
+      return "❌ Stopped on Error";
+    case "stopped":
+      return "⏹️ Stopped";
+    default:
+      return "❓ Unknown";
+  }
+}
+export {
+  batchExecuteTool
+};