@tontoko/fast-playwright-mcp 0.0.4

package/lib/loop/loop-open-ai.js

@@ -0,0 +1,222 @@
+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/loop/loop-open-ai.ts
+var model = "gpt-4.1";
+
+class OpenAIDelegate {
+  _openai;
+  async openai() {
+    if (!this._openai) {
+      const oai = await import("openai");
+      this._openai = new oai.OpenAI;
+    }
+    return this._openai;
+  }
+  createConversation(task, tools, oneShot) {
+    const genericTools = tools.map((tool) => ({
+      name: tool.name,
+      description: tool.description ?? "",
+      inputSchema: tool.inputSchema
+    }));
+    if (!oneShot) {
+      genericTools.push({
+        name: "done",
+        description: "Call this tool when the task is complete.",
+        inputSchema: {
+          type: "object",
+          properties: {}
+        }
+      });
+    }
+    return {
+      messages: [
+        {
+          role: "user",
+          content: task
+        }
+      ],
+      tools: genericTools
+    };
+  }
+  async makeApiCall(conversation) {
+    const formattedData = this.formatConversationForOpenAI(conversation);
+    const response = await this.executeOpenAIRequest(formattedData.messages, formattedData.tools);
+    return this.processApiResponse(conversation, response);
+  }
+  processApiResponse(conversation, response) {
+    return this.handleResponseProcessing(conversation, response);
+  }
+  handleResponseProcessing(conversation, response) {
+    const message = this.extractMessageFromResponse(response);
+    const toolCalls = this.extractToolCallsFromResponse(message);
+    this.updateConversationWithResponse(conversation, message, toolCalls);
+    return toolCalls;
+  }
+  extractMessageFromResponse(response) {
+    return response.choices[0].message;
+  }
+  updateConversationWithResponse(conversation, message, toolCalls) {
+    this.addAssistantMessageToConversation(conversation, message, toolCalls);
+  }
+  formatConversationForOpenAI(conversation) {
+    return {
+      messages: this.convertMessagesToOpenAIFormat(conversation.messages),
+      tools: this.convertToolsToOpenAIFormat(conversation.tools)
+    };
+  }
+  async executeOpenAIRequest(messages, tools) {
+    const openai = await this.openai();
+    return await openai.chat.completions.create({
+      model,
+      messages,
+      tools,
+      tool_choice: "auto"
+    });
+  }
+  convertMessagesToOpenAIFormat(messages) {
+    return this.transformMessagesToOpenAIFormat(messages);
+  }
+  transformMessagesToOpenAIFormat(messages) {
+    const convertedMessages = this.mapMessagesToOpenAIFormat(messages);
+    return this.filterValidMessages(convertedMessages);
+  }
+  mapMessagesToOpenAIFormat(messages) {
+    return messages.map((message) => this.convertSingleMessageToOpenAI(message));
+  }
+  filterValidMessages(messages) {
+    return messages.filter((message) => message !== null);
+  }
+  convertSingleMessageToOpenAI(message) {
+    return this.handleMessageConversion(message);
+  }
+  handleMessageConversion(message) {
+    switch (message.role) {
+      case "user":
+        return this.createUserMessage(message);
+      case "assistant":
+        return this.convertAssistantMessage(message);
+      case "tool":
+        return this.createToolMessage(message);
+      default:
+        return null;
+    }
+  }
+  createUserMessage(message) {
+    return {
+      role: "user",
+      content: message.content
+    };
+  }
+  createToolMessage(message) {
+    return {
+      role: "tool",
+      tool_call_id: message.toolCallId,
+      content: message.content
+    };
+  }
+  convertAssistantMessage(message) {
+    if (message.role !== "assistant") {
+      throw new Error("Expected assistant message");
+    }
+    const assistantMessage = { role: "assistant" };
+    if (message.content) {
+      assistantMessage.content = message.content;
+    }
+    if (this.hasValidToolCalls(message) && message.toolCalls) {
+      assistantMessage.tool_calls = this.convertToolCallsToOpenAI(message.toolCalls);
+    }
+    return assistantMessage;
+  }
+  hasValidToolCalls(message) {
+    return message.role === "assistant" && !!message.toolCalls && message.toolCalls.length > 0;
+  }
+  convertToolCallsToOpenAI(toolCalls) {
+    return toolCalls.map((toolCall) => ({
+      id: toolCall.id,
+      type: "function",
+      function: {
+        name: toolCall.name,
+        arguments: JSON.stringify(toolCall.arguments)
+      }
+    }));
+  }
+  convertToolsToOpenAIFormat(tools) {
+    return tools.map((tool) => ({
+      type: "function",
+      function: {
+        name: tool.name,
+        description: tool.description,
+        parameters: tool.inputSchema
+      }
+    }));
+  }
+  extractToolCallsFromResponse(message) {
+    const toolCalls = this.getToolCallsFromMessage(message);
+    return toolCalls.map((toolCall) => this.convertSingleToolCall(toolCall));
+  }
+  getToolCallsFromMessage(message) {
+    return message.tool_calls ?? [];
+  }
+  convertSingleToolCall(toolCall) {
+    if (toolCall.type === "function") {
+      return {
+        name: toolCall.function.name,
+        arguments: JSON.parse(toolCall.function.arguments),
+        id: toolCall.id
+      };
+    }
+    throw new Error(`Unsupported tool call type: ${toolCall.type}`);
+  }
+  addAssistantMessageToConversation(conversation, message, genericToolCalls) {
+    conversation.messages.push({
+      role: "assistant",
+      content: message.content ?? "",
+      toolCalls: genericToolCalls.length > 0 ? genericToolCalls : undefined
+    });
+  }
+  addToolResults(conversation, results) {
+    for (const result of results) {
+      this.addSingleToolResult(conversation, result);
+    }
+  }
+  addSingleToolResult(conversation, result) {
+    conversation.messages.push({
+      role: "tool",
+      toolCallId: result.toolCallId,
+      content: result.content,
+      isError: result.isError
+    });
+  }
+  checkDoneToolCall(toolCall) {
+    if (!this.isDoneToolCall(toolCall)) {
+      return null;
+    }
+    return this.extractDoneToolResult(toolCall);
+  }
+  isDoneToolCall(toolCall) {
+    return toolCall.name === "done";
+  }
+  extractDoneToolResult(toolCall) {
+    return toolCall.arguments.result ?? "";
+  }
+}
+export {
+  OpenAIDelegate
+};

package/lib/loop/loop.js

@@ -0,0 +1,174 @@
+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/loop/loop.ts
+import debug from "debug";
+import { getErrorMessage } from "../utils/common-formatters.js";
+async function runTask(delegate, client, task, oneShot = false) {
+  const { tools } = await client.listTools();
+  const taskContent = createTaskContent(task, oneShot);
+  const conversation = delegate.createConversation(taskContent, tools, oneShot);
+  return await runConversationLoop(delegate, client, conversation, oneShot);
+}
+async function runConversationLoop(delegate, client, conversation, oneShot) {
+  const MAX_ITERATIONS = 5;
+  return await runConversationLoopRecursive(delegate, client, conversation, oneShot, 0, MAX_ITERATIONS);
+}
+async function runConversationLoopRecursive(delegate, client, conversation, oneShot, iteration, maxIterations) {
+  if (iteration >= maxIterations) {
+    throw new Error("Failed to perform step, max attempts reached");
+  }
+  const result = await executeIteration(delegate, client, conversation, iteration);
+  if (shouldTerminateLoop(result, oneShot)) {
+    return conversation.messages;
+  }
+  return await runConversationLoopRecursive(delegate, client, conversation, oneShot, iteration + 1, maxIterations);
+}
+function shouldTerminateLoop(result, oneShot) {
+  return result.isDone || oneShot;
+}
+async function executeIteration(delegate, client, conversation, iteration) {
+  debug("history")("Making API call for iteration", iteration);
+  const toolCalls = await delegate.makeApiCall(conversation);
+  validateToolCallsPresent(toolCalls);
+  const { toolResults, isDone } = await processToolCalls(delegate, client, toolCalls);
+  return handleIterationResult(delegate, conversation, toolResults, isDone);
+}
+function validateToolCallsPresent(toolCalls) {
+  if (toolCalls.length === 0) {
+    throw new Error('Call the "done" tool when the task is complete.');
+  }
+}
+function handleIterationResult(delegate, conversation, toolResults, isDone) {
+  if (isDone) {
+    return { isDone: true };
+  }
+  delegate.addToolResults(conversation, toolResults);
+  return { isDone: false };
+}
+function createTaskContent(task, oneShot) {
+  if (oneShot) {
+    return `Perform following task: ${task}.`;
+  }
+  return `Perform following task: ${task}. Once the task is complete, call the "done" tool.`;
+}
+async function processToolCalls(delegate, client, toolCalls) {
+  const toolResults = createEmptyToolResults();
+  const processResult = await processAllToolCallsSequentially(delegate, client, toolCalls, toolResults);
+  return processResult || { toolResults, isDone: false };
+}
+async function processAllToolCallsSequentially(delegate, client, toolCalls, toolResults) {
+  return await processToolCallsRecursive(delegate, client, toolCalls, toolResults, 0);
+}
+async function processToolCallsRecursive(delegate, client, toolCalls, toolResults, index) {
+  if (index >= toolCalls.length) {
+    return null;
+  }
+  const toolCall = toolCalls[index];
+  const processingResult = await processSingleToolCall(delegate, client, toolCall, toolCalls, toolResults);
+  if (shouldReturnEarly(processingResult)) {
+    return createProcessResult(processingResult, toolResults);
+  }
+  return await processToolCallsRecursive(delegate, client, toolCalls, toolResults, index + 1);
+}
+function shouldReturnEarly(processingResult) {
+  return processingResult.isDone || processingResult.shouldBreak;
+}
+function createProcessResult(processingResult, toolResults) {
+  return {
+    toolResults,
+    isDone: processingResult.isDone
+  };
+}
+function createEmptyToolResults() {
+  return [];
+}
+async function processSingleToolCall(delegate, client, toolCall, allToolCalls, toolResults) {
+  if (isToolCallDone(delegate, toolCall)) {
+    return createDoneResult();
+  }
+  const executionResult = await processIndividualToolCall(client, toolCall, allToolCalls, toolResults);
+  return createContinueResult(executionResult.shouldBreak);
+}
+function isToolCallDone(delegate, toolCall) {
+  const doneCheck = checkForDoneToolCall(delegate, toolCall);
+  return doneCheck.isDone;
+}
+function createDoneResult() {
+  return { isDone: true, shouldBreak: false };
+}
+function createContinueResult(shouldBreak) {
+  return { isDone: false, shouldBreak };
+}
+async function processIndividualToolCall(client, toolCall, allToolCalls, toolResults) {
+  const result = await executeToolCall(client, toolCall);
+  toolResults.push(result);
+  if (shouldBreakOnError(result, allToolCalls, toolCall, toolResults)) {
+    return { shouldBreak: true };
+  }
+  return { shouldBreak: false };
+}
+function checkForDoneToolCall(delegate, toolCall) {
+  const doneResult = delegate.checkDoneToolCall(toolCall);
+  return { isDone: doneResult !== null };
+}
+function shouldBreakOnError(result, toolCalls, currentToolCall, toolResults) {
+  if (result.isError) {
+    addSkippedToolResults(toolCalls, currentToolCall, toolResults);
+    return true;
+  }
+  return false;
+}
+async function executeToolCall(client, toolCall) {
+  const { name, arguments: args, id } = toolCall;
+  try {
+    debug("tool")(name, args);
+    const response = await client.callTool({ name, arguments: args });
+    const responseContent = response.content ?? [];
+    debug("tool")(responseContent);
+    const text = extractTextFromResponse(responseContent);
+    return { toolCallId: id, content: text };
+  } catch (error) {
+    debug("tool")(error);
+    return {
+      toolCallId: id,
+      content: `Error while executing tool "${name}": ${getErrorMessage(error)}
+
+Please try to recover and complete the task.`,
+      isError: true
+    };
+  }
+}
+function extractTextFromResponse(responseContent) {
+  return responseContent.filter((part) => part.type === "text").map((part) => part.text).join(`
+`);
+}
+function addSkippedToolResults(toolCalls, currentToolCall, toolResults) {
+  const remainingToolCalls = toolCalls.slice(toolCalls.indexOf(currentToolCall) + 1);
+  for (const remainingToolCall of remainingToolCalls) {
+    toolResults.push({
+      toolCallId: remainingToolCall.id,
+      content: "This tool call is skipped due to previous error.",
+      isError: true
+    });
+  }
+}
+export {
+  runTask
+};

package/lib/loop/main.js

@@ -0,0 +1,46 @@
+// src/loop/main.ts
+import path from "node:path";
+import url from "node:url";
+import { Client } from "@modelcontextprotocol/sdk/client/index.js";
+import { StdioClientTransport } from "@modelcontextprotocol/sdk/client/stdio.js";
+import { program } from "commander";
+import dotenv from "dotenv";
+import { runTask } from "./loop.js";
+import { ClaudeDelegate } from "./loop-claude.js";
+import { OpenAIDelegate } from "./loop-open-ai.js";
+dotenv.config();
+var __filename2 = url.fileURLToPath(import.meta.url);
+async function run(delegate) {
+  const transport = new StdioClientTransport({
+    command: "node",
+    args: [
+      path.resolve(__filename2, "../../../cli.js"),
+      "--save-session",
+      "--output-dir",
+      path.resolve(__filename2, "../../../sessions")
+    ],
+    stderr: "inherit",
+    env: process.env
+  });
+  const client = new Client({ name: "test", version: "1.0.0" });
+  await client.connect(transport);
+  await client.ping();
+  await Promise.all(tasks.map((task) => runTask(delegate, client, task)));
+  await client.close();
+}
+var tasks = ["Open https://playwright.dev/"];
+program.option("--model <model>", "model to use").action(async (options) => {
+  if (options.model === "claude") {
+    await run(new ClaudeDelegate);
+  } else {
+    await run(new OpenAIDelegate);
+  }
+});
+async function startCLI() {
+  try {
+    await program.parseAsync(process.argv);
+  } catch {
+    process.exit(1);
+  }
+}
+startCLI();

package/lib/loopTools/context.js

@@ -0,0 +1,76 @@
+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/loopTools/context.ts
+import { Client } from "@modelcontextprotocol/sdk/client/index.js";
+import { contextFactory } from "../browser-context-factory.js";
+import { BrowserServerBackend } from "../browser-server-backend.js";
+import { Context as BrowserContext } from "../context.js";
+import { runTask } from "../loop/loop.js";
+import { ClaudeDelegate } from "../loop/loop-claude.js";
+import { OpenAIDelegate } from "../loop/loop-open-ai.js";
+import { InProcessTransport } from "../mcp/in-process-transport.js";
+import { createServer } from "../mcp/server.js";
+
+class Context {
+  config;
+  _client;
+  _delegate;
+  constructor(config, client) {
+    this.config = config;
+    this._client = client;
+    if (process.env.OPENAI_API_KEY) {
+      this._delegate = new OpenAIDelegate;
+    } else if (process.env.ANTHROPIC_API_KEY) {
+      this._delegate = new ClaudeDelegate;
+    } else {
+      throw new Error("No LLM API key found. Please set OPENAI_API_KEY or ANTHROPIC_API_KEY environment variable.");
+    }
+  }
+  static async create(config) {
+    const client = new Client({ name: "Playwright Proxy", version: "1.0.0" });
+    const browserContextFactory = contextFactory(config);
+    const server = createServer(new BrowserServerBackend(config, [browserContextFactory]), false);
+    await client.connect(new InProcessTransport(server));
+    await client.ping();
+    return new Context(config, client);
+  }
+  async runTask(task, oneShot = false) {
+    const messages = await runTask(this._delegate, this._client, task, oneShot);
+    const lines = [];
+    for (const message of messages.slice(1)) {
+      if (!message.content.trim()) {
+        continue;
+      }
+      const index = oneShot ? -1 : message.content.indexOf("### Page state");
+      const trimmedContent = index === -1 ? message.content : message.content.substring(0, index);
+      lines.push(`[${message.role}]:`, trimmedContent);
+    }
+    return {
+      content: [{ type: "text", text: lines.join(`
+`) }]
+    };
+  }
+  async close() {
+    await BrowserContext.disposeAll();
+  }
+}
+export {
+  Context
+};

package/lib/loopTools/main.js

@@ -0,0 +1,65 @@
+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/loopTools/main.ts
+import dotenv from "dotenv";
+import { start } from "../mcp/transport.js";
+import { packageJSON } from "../package.js";
+import { Context } from "./context.js";
+import { perform } from "./perform.js";
+import { snapshot } from "./snapshot.js";
+async function runLoopTools(config) {
+  dotenv.config();
+  const serverBackendFactory = () => new LoopToolsServerBackend(config);
+  await start(serverBackendFactory, config.server);
+}
+
+class LoopToolsServerBackend {
+  name = "Playwright";
+  version = packageJSON.version;
+  _config;
+  _context;
+  _tools = [perform, snapshot];
+  constructor(config) {
+    this._config = config;
+  }
+  async initialize() {
+    this._context = await Context.create(this._config);
+  }
+  tools() {
+    return this._tools.map((tool) => tool.schema);
+  }
+  async callTool(schema, rawArguments) {
+    const tool = this._tools.find((t) => t.schema.name === schema.name);
+    if (!tool) {
+      throw new Error(`Tool not found: ${schema.name}`);
+    }
+    if (!this._context) {
+      throw new Error("Context not initialized");
+    }
+    const parsedArguments = schema.inputSchema.parse(rawArguments || {});
+    return await tool.handle(this._context, parsedArguments);
+  }
+  serverClosed() {
+    this._context?.close().catch(() => {});
+  }
+}
+export {
+  runLoopTools
+};

package/lib/loopTools/perform.js

@@ -0,0 +1,40 @@
+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/loopTools/perform.ts
+import { z } from "zod";
+import { defineTool } from "./tool.js";
+var performSchema = z.object({
+  task: z.string().describe("The task to perform with the browser")
+});
+var perform = defineTool({
+  schema: {
+    name: "browser_perform",
+    title: "Perform a task with the browser",
+    description: "Perform a task with the browser. It can click, type, export, capture screenshot, drag, hover, select options, etc.",
+    inputSchema: performSchema,
+    type: "destructive"
+  },
+  handle: async (context, params) => {
+    return await context.runTask(params.task);
+  }
+});
+export {
+  perform
+};

package/lib/loopTools/snapshot.js

@@ -0,0 +1,37 @@
+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/loopTools/snapshot.ts
+import { z } from "zod";
+import { defineTool } from "./tool.js";
+var snapshot = defineTool({
+  schema: {
+    name: "browser_snapshot",
+    title: "Take a snapshot of the browser",
+    description: "Take a snapshot of the browser to read what is on the page.",
+    inputSchema: z.object({}),
+    type: "readOnly"
+  },
+  handle: async (context, _params) => {
+    return await context.runTask("Capture browser snapshot", true);
+  }
+});
+export {
+  snapshot
+};

package/lib/loopTools/tool.js

@@ -0,0 +1,26 @@
+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/loopTools/tool.ts
+function defineTool(tool) {
+  return tool;
+}
+export {
+  defineTool
+};