@treegress.com/treegress-browser-core 1.59.0-treegress.3

package/lib/tools/response.js

@@ -0,0 +1,278 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+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 __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var response_exports = {};
+__export(response_exports, {
+  Response: () => Response,
+  parseResponse: () => parseResponse,
+  renderTabMarkdown: () => renderTabMarkdown,
+  renderTabsMarkdown: () => renderTabsMarkdown,
+  requestDebug: () => requestDebug
+});
+module.exports = __toCommonJS(response_exports);
+var import_fs = __toESM(require("fs"));
+var import_path = __toESM(require("path"));
+var import_utilsBundle = require("../utilsBundle");
+var import_tab = require("./tab");
+var import_screenshot = require("./screenshot");
+const requestDebug = (0, import_utilsBundle.debug)("pw:mcp:request");
+class Response {
+  constructor(context, toolName, toolArgs, relativeTo) {
+    this._results = [];
+    this._errors = [];
+    this._code = [];
+    this._includeSnapshot = "none";
+    this._isClose = false;
+    this._imageResults = [];
+    this._context = context;
+    this.toolName = toolName;
+    this.toolArgs = toolArgs;
+    this._clientWorkspace = relativeTo ?? context.options.cwd;
+  }
+  setSnapshotBackend(backend) {
+    this._snapshotBackend = backend;
+  }
+  _computRelativeTo(fileName) {
+    return import_path.default.relative(this._clientWorkspace, fileName);
+  }
+  async resolveClientFile(template, title) {
+    let fileName;
+    if (template.suggestedFilename)
+      fileName = await this._context.workspaceFile(template.suggestedFilename, this._clientWorkspace);
+    else
+      fileName = await this._context.outputFile(template, { origin: "llm" });
+    const relativeName = this._computRelativeTo(fileName);
+    const printableLink = `- [${title}](${relativeName})`;
+    return { fileName, relativeName, printableLink };
+  }
+  addTextResult(text) {
+    this._results.push(text);
+  }
+  async addResult(title, data, file) {
+    if (this._context.config.outputMode === "file" || file.suggestedFilename || typeof data !== "string") {
+      const resolvedFile = await this.resolveClientFile(file, title);
+      await this.addFileResult(resolvedFile, data);
+    } else {
+      this.addTextResult(data);
+    }
+  }
+  async addFileResult(resolvedFile, data) {
+    if (typeof data === "string")
+      await import_fs.default.promises.writeFile(resolvedFile.fileName, data, "utf-8");
+    else if (data)
+      await import_fs.default.promises.writeFile(resolvedFile.fileName, data);
+    this.addTextResult(resolvedFile.printableLink);
+  }
+  addFileLink(title, fileName) {
+    const relativeName = this._computRelativeTo(fileName);
+    this.addTextResult(`- [${title}](${relativeName})`);
+  }
+  async registerImageResult(data, imageType) {
+    this._imageResults.push({ data, imageType });
+  }
+  setClose() {
+    this._isClose = true;
+  }
+  addError(error) {
+    this._errors.push(error);
+  }
+  addCode(code) {
+    this._code.push(code);
+  }
+  setIncludeSnapshot() {
+    this._includeSnapshot = this._context.config.snapshot?.mode || "incremental";
+  }
+  setIncludeFullSnapshot(includeSnapshotFileName) {
+    this._includeSnapshot = "full";
+    this._includeSnapshotFileName = includeSnapshotFileName;
+  }
+  async serialize() {
+    const redactText = (text2) => {
+      for (const [secretName, secretValue] of Object.entries(this._context.config.secrets ?? {}))
+        text2 = text2.replaceAll(secretValue, `<secret>${secretName}</secret>`);
+      return text2;
+    };
+    const sections = await this._build();
+    const text = [];
+    for (const section of sections) {
+      if (!section.content.length)
+        continue;
+      text.push(`### ${section.title}`);
+      if (section.codeframe)
+        text.push(`\`\`\`${section.codeframe}`);
+      text.push(...section.content);
+      if (section.codeframe)
+        text.push("```");
+    }
+    const content = [
+      {
+        type: "text",
+        text: redactText(text.join("\n"))
+      }
+    ];
+    if (this._context.config.imageResponses !== "omit") {
+      for (const imageResult of this._imageResults) {
+        const scaledData = (0, import_screenshot.scaleImageToFitMessage)(imageResult.data, imageResult.imageType);
+        content.push({ type: "image", data: scaledData.toString("base64"), mimeType: imageResult.imageType === "png" ? "image/png" : "image/jpeg" });
+      }
+    }
+    return {
+      content,
+      ...this._isClose ? { isClose: true } : {},
+      ...sections.some((section) => section.isError) ? { isError: true } : {}
+    };
+  }
+  async _build() {
+    const sections = [];
+    const addSection = (title, content, codeframe) => {
+      const section = { title, content, isError: title === "Error", codeframe };
+      sections.push(section);
+      return content;
+    };
+    if (this._errors.length)
+      addSection("Error", this._errors);
+    if (this._results.length)
+      addSection("Result", this._results);
+    if (this._context.config.codegen !== "none" && this._code.length)
+      addSection("Ran Playwright code", this._code, "js");
+    const tabSnapshot = this._context.currentTab() ? await this._context.currentTabOrDie().captureSnapshot(this._clientWorkspace, this._snapshotBackend) : void 0;
+    const tabHeaders = await Promise.all(this._context.tabs().map((tab) => tab.headerSnapshot()));
+    if (this._includeSnapshot !== "none" || tabHeaders.some((header) => header.changed)) {
+      if (tabHeaders.length !== 1)
+        addSection("Open tabs", renderTabsMarkdown(tabHeaders));
+      addSection("Page", renderTabMarkdown(tabHeaders.find((h) => h.current) ?? tabHeaders[0]));
+    }
+    if (this._context.tabs().length === 0)
+      this._isClose = true;
+    if (tabSnapshot?.modalStates.length)
+      addSection("Modal state", (0, import_tab.renderModalStates)(this._context.config, tabSnapshot.modalStates));
+    if (tabSnapshot && this._includeSnapshot !== "none") {
+      const snapshot = this._includeSnapshot === "full" ? tabSnapshot.ariaSnapshot : tabSnapshot.ariaSnapshotDiff ?? tabSnapshot.ariaSnapshot;
+      if (this._context.config.outputMode === "file" || this._includeSnapshotFileName) {
+        const resolvedFile = await this.resolveClientFile({ prefix: "page", ext: "yml", suggestedFilename: this._includeSnapshotFileName }, "Snapshot");
+        await import_fs.default.promises.writeFile(resolvedFile.fileName, snapshot, "utf-8");
+        addSection("Snapshot", [resolvedFile.printableLink]);
+      } else {
+        addSection("Snapshot", [snapshot], "yaml");
+      }
+    }
+    const text = [];
+    if (tabSnapshot?.consoleLink)
+      text.push(`- New console entries: ${tabSnapshot.consoleLink}`);
+    if (tabSnapshot?.events.filter((event) => event.type !== "request").length) {
+      for (const event of tabSnapshot.events) {
+        if (event.type === "console" && this._context.config.outputMode !== "file" && this._context.config.snapshot?.mode !== "none") {
+          if ((0, import_tab.shouldIncludeMessage)(this._context.config.console?.level, event.message.type))
+            text.push(`- ${trimMiddle(event.message.toString(), 100)}`);
+        } else if (event.type === "download-start") {
+          text.push(`- Downloading file ${event.download.download.suggestedFilename()} ...`);
+        } else if (event.type === "download-finish") {
+          text.push(`- Downloaded file ${event.download.download.suggestedFilename()} to "${this._computRelativeTo(event.download.outputFile)}"`);
+        }
+      }
+    }
+    if (text.length)
+      addSection("Events", text);
+    return sections;
+  }
+}
+function renderTabMarkdown(tab) {
+  const lines = [`- Page URL: ${tab.url}`];
+  if (tab.title)
+    lines.push(`- Page Title: ${tab.title}`);
+  if (tab.console.errors || tab.console.warnings)
+    lines.push(`- Console: ${tab.console.errors} errors, ${tab.console.warnings} warnings`);
+  return lines;
+}
+function renderTabsMarkdown(tabs) {
+  if (!tabs.length)
+    return ["No open tabs. Navigate to a URL to create one."];
+  const lines = [];
+  for (let i = 0; i < tabs.length; i++) {
+    const tab = tabs[i];
+    const current = tab.current ? " (current)" : "";
+    lines.push(`- ${i}:${current} [${tab.title}](${tab.url})`);
+  }
+  return lines;
+}
+function trimMiddle(text, maxLength) {
+  if (text.length <= maxLength)
+    return text;
+  return text.slice(0, Math.floor(maxLength / 2)) + "..." + text.slice(-3 - Math.floor(maxLength / 2));
+}
+function parseSections(text) {
+  const sections = /* @__PURE__ */ new Map();
+  const sectionHeaders = text.split(/^### /m).slice(1);
+  for (const section of sectionHeaders) {
+    const firstNewlineIndex = section.indexOf("\n");
+    if (firstNewlineIndex === -1)
+      continue;
+    const sectionName = section.substring(0, firstNewlineIndex);
+    const sectionContent = section.substring(firstNewlineIndex + 1).trim();
+    sections.set(sectionName, sectionContent);
+  }
+  return sections;
+}
+function parseResponse(response) {
+  if (response.content?.[0].type !== "text")
+    return void 0;
+  const text = response.content[0].text;
+  const sections = parseSections(text);
+  const error = sections.get("Error");
+  const result = sections.get("Result");
+  const code = sections.get("Ran Playwright code");
+  const tabs = sections.get("Open tabs");
+  const page = sections.get("Page");
+  const snapshot = sections.get("Snapshot");
+  const events = sections.get("Events");
+  const modalState = sections.get("Modal state");
+  const codeNoFrame = code?.replace(/^```js\n/, "").replace(/\n```$/, "");
+  const isError = response.isError;
+  const attachments = response.content.length > 1 ? response.content.slice(1) : void 0;
+  return {
+    result,
+    error,
+    code: codeNoFrame,
+    tabs,
+    page,
+    snapshot,
+    events,
+    modalState,
+    isError,
+    attachments,
+    text
+  };
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  Response,
+  parseResponse,
+  renderTabMarkdown,
+  renderTabsMarkdown,
+  requestDebug
+});

package/lib/tools/route.js

@@ -0,0 +1,140 @@
+"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 route_exports = {};
+__export(route_exports, {
+  default: () => route_default
+});
+module.exports = __toCommonJS(route_exports);
+var import_mcpBundle = require("../mcpBundle");
+var import_tool = require("./tool");
+const route = (0, import_tool.defineTool)({
+  capability: "network",
+  schema: {
+    name: "browser_route",
+    title: "Mock network requests",
+    description: "Set up a route to mock network requests matching a URL pattern",
+    inputSchema: import_mcpBundle.z.object({
+      pattern: import_mcpBundle.z.string().describe('URL pattern to match (e.g., "**/api/users", "**/*.{png,jpg}")'),
+      status: import_mcpBundle.z.number().optional().describe("HTTP status code to return (default: 200)"),
+      body: import_mcpBundle.z.string().optional().describe("Response body (text or JSON string)"),
+      contentType: import_mcpBundle.z.string().optional().describe('Content-Type header (e.g., "application/json", "text/html")'),
+      headers: import_mcpBundle.z.array(import_mcpBundle.z.string()).optional().describe('Headers to add in "Name: Value" format'),
+      removeHeaders: import_mcpBundle.z.string().optional().describe("Comma-separated list of header names to remove from request")
+    }),
+    type: "action"
+  },
+  handle: async (context, params, response) => {
+    const addHeaders = params.headers ? Object.fromEntries(params.headers.map((h) => {
+      const colonIndex = h.indexOf(":");
+      return [h.substring(0, colonIndex).trim(), h.substring(colonIndex + 1).trim()];
+    })) : void 0;
+    const removeHeaders = params.removeHeaders ? params.removeHeaders.split(",").map((h) => h.trim()) : void 0;
+    const handler = async (route2) => {
+      if (params.body !== void 0 || params.status !== void 0) {
+        await route2.fulfill({
+          status: params.status ?? 200,
+          contentType: params.contentType,
+          body: params.body
+        });
+        return;
+      }
+      const headers = { ...route2.request().headers() };
+      if (addHeaders) {
+        for (const [key, value] of Object.entries(addHeaders))
+          headers[key] = value;
+      }
+      if (removeHeaders) {
+        for (const header of removeHeaders)
+          delete headers[header.toLowerCase()];
+      }
+      await route2.continue({ headers });
+    };
+    const entry = {
+      pattern: params.pattern,
+      status: params.status,
+      body: params.body,
+      contentType: params.contentType,
+      addHeaders,
+      removeHeaders,
+      handler
+    };
+    await context.addRoute(entry);
+    response.addTextResult(`Route added for pattern: ${params.pattern}`);
+    response.addCode(`await page.context().route('${params.pattern}', async route => { /* route handler */ });`);
+  }
+});
+const routeList = (0, import_tool.defineTool)({
+  capability: "network",
+  schema: {
+    name: "browser_route_list",
+    title: "List network routes",
+    description: "List all active network routes",
+    inputSchema: import_mcpBundle.z.object({}),
+    type: "readOnly"
+  },
+  handle: async (context, params, response) => {
+    const routes = context.routes();
+    if (routes.length === 0) {
+      response.addTextResult("No active routes");
+      return;
+    }
+    const lines = [];
+    for (let i = 0; i < routes.length; i++) {
+      const route2 = routes[i];
+      const details = [];
+      if (route2.status !== void 0)
+        details.push(`status=${route2.status}`);
+      if (route2.body !== void 0)
+        details.push(`body=${route2.body.length > 50 ? route2.body.substring(0, 50) + "..." : route2.body}`);
+      if (route2.contentType)
+        details.push(`contentType=${route2.contentType}`);
+      if (route2.addHeaders)
+        details.push(`addHeaders=${JSON.stringify(route2.addHeaders)}`);
+      if (route2.removeHeaders)
+        details.push(`removeHeaders=${route2.removeHeaders.join(",")}`);
+      const detailsStr = details.length ? ` (${details.join(", ")})` : "";
+      lines.push(`${i + 1}. ${route2.pattern}${detailsStr}`);
+    }
+    response.addTextResult(lines.join("\n"));
+  }
+});
+const unroute = (0, import_tool.defineTool)({
+  capability: "network",
+  schema: {
+    name: "browser_unroute",
+    title: "Remove network routes",
+    description: "Remove network routes matching a pattern (or all routes if no pattern specified)",
+    inputSchema: import_mcpBundle.z.object({
+      pattern: import_mcpBundle.z.string().optional().describe("URL pattern to unroute (omit to remove all routes)")
+    }),
+    type: "action"
+  },
+  handle: async (context, params, response) => {
+    const removed = await context.removeRoute(params.pattern);
+    if (params.pattern)
+      response.addTextResult(`Removed ${removed} route(s) for pattern: ${params.pattern}`);
+    else
+      response.addTextResult(`Removed all ${removed} route(s)`);
+  }
+});
+var route_default = [
+  route,
+  routeList,
+  unroute
+];

package/lib/tools/runCode.js

@@ -0,0 +1,76 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+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 __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var runCode_exports = {};
+__export(runCode_exports, {
+  default: () => runCode_default
+});
+module.exports = __toCommonJS(runCode_exports);
+var import_vm = __toESM(require("vm"));
+var import_manualPromise = require("../utils/isomorphic/manualPromise");
+var import_mcpBundle = require("../mcpBundle");
+var import_tool = require("./tool");
+const codeSchema = import_mcpBundle.z.object({
+  code: import_mcpBundle.z.string().describe(`A JavaScript function containing Playwright code to execute. It will be invoked with a single argument, page, which you can use for any page interaction. For example: \`async (page) => { await page.getByRole('button', { name: 'Submit' }).click(); return await page.title(); }\``)
+});
+const runCode = (0, import_tool.defineTabTool)({
+  capability: "core",
+  schema: {
+    name: "browser_run_code",
+    title: "Run Playwright code",
+    description: "Run Playwright code snippet",
+    inputSchema: codeSchema,
+    type: "action"
+  },
+  handle: async (tab, params, response) => {
+    response.addCode(`await (${params.code})(page);`);
+    const __end__ = new import_manualPromise.ManualPromise();
+    const context = {
+      page: tab.page,
+      __end__
+    };
+    import_vm.default.createContext(context);
+    await tab.waitForCompletion(async () => {
+      const snippet = `(async () => {
+        try {
+          const result = await (${params.code})(page);
+          __end__.resolve(JSON.stringify(result));
+        } catch (e) {
+          __end__.reject(e);
+        }
+      })()`;
+      await import_vm.default.runInContext(snippet, context);
+      const result = await __end__;
+      if (typeof result === "string")
+        response.addTextResult(result);
+    });
+  }
+});
+var runCode_default = [
+  runCode
+];

package/lib/tools/screenshot.js

@@ -0,0 +1,87 @@
+"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 screenshot_exports = {};
+__export(screenshot_exports, {
+  default: () => screenshot_default,
+  scaleImageToFitMessage: () => scaleImageToFitMessage
+});
+module.exports = __toCommonJS(screenshot_exports);
+var import_imageUtils = require("../utils/isomorphic/imageUtils");
+var import_utilsBundle = require("../utilsBundle");
+var import_stringUtils = require("../utils/isomorphic/stringUtils");
+var import_mcpBundle = require("../mcpBundle");
+var import_tool = require("./tool");
+const screenshotSchema = import_mcpBundle.z.object({
+  type: import_mcpBundle.z.enum(["png", "jpeg"]).default("png").describe("Image format for the screenshot. Default is png."),
+  filename: import_mcpBundle.z.string().optional().describe("File name to save the screenshot to. Defaults to `page-{timestamp}.{png|jpeg}` if not specified. Prefer relative file names to stay within the output directory."),
+  element: import_mcpBundle.z.string().optional().describe("Human-readable element description used to obtain permission to screenshot the element. If not provided, the screenshot will be taken of viewport. If element is provided, ref must be provided too."),
+  ref: import_mcpBundle.z.string().optional().describe("Exact target element reference from the page snapshot. If not provided, the screenshot will be taken of viewport. If ref is provided, element must be provided too."),
+  fullPage: import_mcpBundle.z.boolean().optional().describe("When true, takes a screenshot of the full scrollable page, instead of the currently visible viewport. Cannot be used with element screenshots.")
+});
+const screenshot = (0, import_tool.defineTabTool)({
+  capability: "core",
+  schema: {
+    name: "browser_take_screenshot",
+    title: "Take a screenshot",
+    description: `Take a screenshot of the current page. You can't perform actions based on the screenshot, use browser_snapshot for actions.`,
+    inputSchema: screenshotSchema,
+    type: "readOnly"
+  },
+  handle: async (tab, params, response) => {
+    if (params.fullPage && params.ref)
+      throw new Error("fullPage cannot be used with element screenshots.");
+    const fileType = params.type || "png";
+    const options = {
+      type: fileType,
+      quality: fileType === "png" ? void 0 : 90,
+      scale: "css",
+      ...tab.actionTimeoutOptions,
+      ...params.fullPage !== void 0 && { fullPage: params.fullPage }
+    };
+    const screenshotTarget = params.ref ? params.element || "element" : params.fullPage ? "full page" : "viewport";
+    const ref = params.ref ? await tab.refLocator({ element: params.element || "", ref: params.ref }) : null;
+    const data = ref ? await ref.locator.screenshot(options) : await tab.page.screenshot(options);
+    const resolvedFile = await response.resolveClientFile({ prefix: ref ? "element" : "page", ext: fileType, suggestedFilename: params.filename }, `Screenshot of ${screenshotTarget}`);
+    response.addCode(`// Screenshot ${screenshotTarget} and save it as ${resolvedFile.relativeName}`);
+    if (ref)
+      response.addCode(`await page.${ref.resolved}.screenshot(${(0, import_stringUtils.formatObject)({ ...options, path: resolvedFile.relativeName })});`);
+    else
+      response.addCode(`await page.screenshot(${(0, import_stringUtils.formatObject)({ ...options, path: resolvedFile.relativeName })});`);
+    await response.addFileResult(resolvedFile, data);
+    await response.registerImageResult(data, fileType);
+  }
+});
+function scaleImageToFitMessage(buffer, imageType) {
+  const image = imageType === "png" ? import_utilsBundle.PNG.sync.read(buffer) : import_utilsBundle.jpegjs.decode(buffer, { maxMemoryUsageInMB: 512 });
+  const pixels = image.width * image.height;
+  const shrink = Math.min(1568 / image.width, 1568 / image.height, Math.sqrt(1.15 * 1024 * 1024 / pixels));
+  if (shrink > 1)
+    return buffer;
+  const width = image.width * shrink | 0;
+  const height = image.height * shrink | 0;
+  const scaledImage = (0, import_imageUtils.scaleImageToSize)(image, { width, height });
+  return imageType === "png" ? import_utilsBundle.PNG.sync.write(scaledImage) : import_utilsBundle.jpegjs.encode(scaledImage, 80).data;
+}
+var screenshot_default = [
+  screenshot
+];
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  scaleImageToFitMessage
+});

package/lib/tools/sessionLog.js

@@ -0,0 +1,75 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+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 __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var sessionLog_exports = {};
+__export(sessionLog_exports, {
+  SessionLog: () => SessionLog
+});
+module.exports = __toCommonJS(sessionLog_exports);
+var import_fs = __toESM(require("fs"));
+var import_path = __toESM(require("path"));
+var import_context = require("./context");
+var import_response = require("./response");
+class SessionLog {
+  constructor(sessionFolder) {
+    this._sessionFileQueue = Promise.resolve();
+    this._folder = sessionFolder;
+    this._file = import_path.default.join(this._folder, "session.md");
+  }
+  static async create(config, cwd) {
+    const sessionFolder = await (0, import_context.outputFile)({ config, cwd }, `session-${Date.now()}`, { origin: "code" });
+    await import_fs.default.promises.mkdir(sessionFolder, { recursive: true });
+    console.error(`Session: ${sessionFolder}`);
+    return new SessionLog(sessionFolder);
+  }
+  logResponse(toolName, toolArgs, responseObject) {
+    const parsed = (0, import_response.parseResponse)(responseObject);
+    if (parsed)
+      delete parsed.text;
+    const lines = [""];
+    lines.push(
+      `### Tool call: ${toolName}`,
+      `- Args`,
+      "```json",
+      JSON.stringify(toolArgs, null, 2),
+      "```"
+    );
+    if (parsed) {
+      lines.push(`- Result`);
+      lines.push("```json");
+      lines.push(JSON.stringify(parsed, null, 2));
+      lines.push("```");
+    }
+    lines.push("");
+    this._sessionFileQueue = this._sessionFileQueue.then(() => import_fs.default.promises.appendFile(this._file, lines.join("\n")));
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  SessionLog
+});