windows-use 0.1.0 → 0.2.1

package/dist/mcp/server.js

@@ -8,23 +8,14 @@ import crypto from "crypto";
 // src/agent/context-manager.ts
 var ContextManager = class {
   messages = [];
-  maxMessages;
-  constructor(maxMessages) {
-    this.maxMessages = maxMessages;
-  }
   append(message) {
     this.messages.push(message);
   }
-  /** Returns the system prompt + the most recent messages within the window. */
-  getWindow() {
-    if (this.messages.length === 0) return [];
-    const systemPrompt = this.messages[0]?.role === "system" ? this.messages[0] : null;
-    const nonSystem = systemPrompt ? this.messages.slice(1) : this.messages;
-    const windowSize = this.maxMessages - (systemPrompt ? 1 : 0);
-    const windowed = nonSystem.length > windowSize ? nonSystem.slice(-windowSize) : nonSystem;
-    return systemPrompt ? [systemPrompt, ...windowed] : windowed;
+  /** Returns all messages. */
+  getMessages() {
+    return [...this.messages];
   }
-  /** Total messages stored (before windowing). */
+  /** Total messages stored. */
   get length() {
     return this.messages.length;
   }
@@ -78,7 +69,16 @@ Call \`report\` when:
 - **"blocked"**: You cannot proceed (CAPTCHA, login wall, unexpected error). Explain what's blocking you.
 - **"need_guidance"**: You need a decision or clarification. Describe what you need.
 
-Calling \`report\` stops your execution. Include a concise summary and optionally a screenshot as evidence.
+Calling \`report\` stops your execution. The \`content\` field supports a rich document format \u2014 mix text with screenshots using \`[Image:img_X]\` markers:
+
+\`\`\`
+report({
+  status: "completed",
+  content: "Here is what I found:\\n[Image:img_2]\\nThe page shows the search results.\\n[Image:img_3]\\nI also checked the sidebar."
+})
+\`\`\`
+
+Each screenshot tool returns a screenshot ID (e.g. img_1, img_2). Use these IDs to embed images in your report.
 
 ## Important
 - Do NOT keep retrying the same failing action. If something fails twice, call \`report\` with status "blocked".
@@ -94,6 +94,8 @@ var AgentRunner = class {
   config;
   toolContext;
   initialized = false;
+  onStep = null;
+  roundsUsed = 0;
   constructor(llmClient, contextManager, toolRegistry, config, toolContext) {
     this.llmClient = llmClient;
     this.contextManager = contextManager;
@@ -101,7 +103,30 @@ var AgentRunner = class {
     this.config = config;
     this.toolContext = toolContext;
   }
+  /** Register a callback to receive step-by-step progress events */
+  setOnStep(cb) {
+    this.onStep = cb;
+  }
+  emit(event) {
+    this.onStep?.(event);
+  }
+  /** How many instruction rounds have been used in this session */
+  get currentRound() {
+    return this.roundsUsed;
+  }
+  /** Whether this session has exhausted its max rounds */
+  get roundsExhausted() {
+    return this.roundsUsed >= this.config.maxRounds;
+  }
   async run(instruction) {
+    if (this.roundsExhausted) {
+      return {
+        status: "blocked",
+        content: `Session has reached the maximum number of instruction rounds (${this.config.maxRounds}). Create a new session to continue.`,
+        stepsUsed: 0
+      };
+    }
+    this.roundsUsed++;
     if (!this.initialized) {
       this.contextManager.append({
         role: "system",
@@ -117,7 +142,7 @@ var AgentRunner = class {
     while (stepsUsed < this.config.maxSteps) {
       stepsUsed++;
       const remaining = this.config.maxSteps - stepsUsed;
-      const messages = this.contextManager.getWindow();
+      const messages = this.contextManager.getMessages();
       if (remaining <= 3 && remaining >= 0) {
         messages.push({
           role: "system",
@@ -130,9 +155,10 @@ var AgentRunner = class {
         response = await this.llmClient.chat(messages, tools);
       } catch (err) {
         const msg = err instanceof Error ? err.message : String(err);
+        this.emit({ type: "error", step: stepsUsed, message: `LLM API error: ${msg}` });
         return {
           status: "blocked",
-          summary: `LLM API error: ${msg}`,
+          content: `LLM API error: ${msg}`,
           stepsUsed
         };
       }
@@ -140,26 +166,31 @@ var AgentRunner = class {
       if (!choice) {
         return {
           status: "blocked",
-          summary: "LLM returned empty response",
+          content: "LLM returned empty response",
           stepsUsed
         };
       }
       const message = choice.message;
+      if (message.content) {
+        this.emit({ type: "thinking", step: stepsUsed, content: message.content });
+      }
       if (choice.finish_reason === "stop" || !message.tool_calls?.length) {
         const text = message.content ?? "";
         this.contextManager.append({ role: "assistant", content: text });
         return {
           status: "need_guidance",
-          summary: text || "Agent stopped without calling report.",
+          content: text || "Agent stopped without calling report.",
           stepsUsed
         };
       }
       this.contextManager.append(message);
       for (const toolCall of message.tool_calls) {
+        const toolName = toolCall.function.name;
         let args;
         try {
           args = JSON.parse(toolCall.function.arguments);
         } catch {
+          this.emit({ type: "error", step: stepsUsed, message: `Failed to parse args for ${toolName}` });
           this.contextManager.append({
             role: "tool",
             tool_call_id: toolCall.id,
@@ -167,15 +198,17 @@ var AgentRunner = class {
           });
           continue;
         }
+        this.emit({ type: "tool_call", step: stepsUsed, name: toolName, args });
         let result;
         try {
           result = await this.toolRegistry.execute(
-            toolCall.function.name,
+            toolName,
             args,
             this.toolContext
           );
         } catch (err) {
           const msg = err instanceof Error ? err.message : String(err);
+          this.emit({ type: "error", step: stepsUsed, message: `${toolName} failed: ${msg}` });
           this.contextManager.append({
             role: "tool",
             tool_call_id: toolCall.id,
@@ -184,6 +217,7 @@ var AgentRunner = class {
           continue;
         }
         if (result.type === "report") {
+          this.emit({ type: "tool_result", step: stepsUsed, name: toolName, result: `[${result.status}] report submitted` });
           this.contextManager.append({
             role: "tool",
             tool_call_id: toolCall.id,
@@ -191,18 +225,18 @@ var AgentRunner = class {
           });
           return {
             status: result.status,
-            summary: result.summary,
-            screenshot: result.screenshot,
+            content: result.content,
             data: result.data,
             stepsUsed
           };
         }
         if (result.type === "image") {
+          this.emit({ type: "tool_result", step: stepsUsed, name: toolName, result: `Screenshot captured (${result.screenshotId})` });
           this.contextManager.append({
             role: "tool",
             tool_call_id: toolCall.id,
             content: [
-              { type: "text", text: "Screenshot captured." },
+              { type: "text", text: `Screenshot captured. ID: ${result.screenshotId}` },
               {
                 type: "image_url",
                 image_url: {
@@ -212,6 +246,8 @@ var AgentRunner = class {
             ]
           });
         } else {
+          const preview = result.content.length > 200 ? result.content.slice(0, 200) + "..." : result.content;
+          this.emit({ type: "tool_result", step: stepsUsed, name: toolName, result: preview });
           this.contextManager.append({
             role: "tool",
             tool_call_id: toolCall.id,
@@ -222,30 +258,208 @@ var AgentRunner = class {
     }
     return {
       status: "blocked",
-      summary: `Exceeded maximum steps limit (${this.config.maxSteps}). Task may be incomplete.`,
+      content: `Exceeded maximum steps limit (${this.config.maxSteps}). Task may be incomplete.`,
       stepsUsed
     };
   }
 };
 
 // src/tools/browser/client.ts
+import { existsSync, mkdirSync, cpSync, readdirSync } from "fs";
+import { spawn, execSync } from "child_process";
+import { join } from "path";
+import { homedir } from "os";
+var CHROME_PATHS = [
+  // Windows
+  "C:\\Program Files\\Google\\Chrome\\Application\\chrome.exe",
+  "C:\\Program Files (x86)\\Google\\Chrome\\Application\\chrome.exe",
+  `${process.env.LOCALAPPDATA ?? ""}\\Google\\Chrome\\Application\\chrome.exe`,
+  // macOS
+  "/Applications/Google Chrome.app/Contents/MacOS/Google Chrome",
+  // Linux
+  "/usr/bin/google-chrome",
+  "/usr/bin/google-chrome-stable",
+  "/usr/bin/chromium-browser",
+  "/usr/bin/chromium"
+];
+var SKIP_DIRS = /* @__PURE__ */ new Set([
+  "Cache",
+  "Code Cache",
+  "GPUCache",
+  "Service Worker",
+  "CacheStorage",
+  "File System",
+  "blob_storage",
+  "IndexedDB",
+  "DawnCache",
+  "GrShaderCache",
+  "ShaderCache",
+  "optimization_guide_model_store",
+  "BrowserMetrics",
+  "Crashpad",
+  "component_crx_cache"
+]);
+function findChrome() {
+  for (const p of CHROME_PATHS) {
+    if (p && existsSync(p)) return p;
+  }
+  return null;
+}
+function findUserDataDir() {
+  const candidates = [
+    // Windows
+    join(process.env.LOCALAPPDATA ?? "", "Google", "Chrome", "User Data"),
+    // macOS
+    join(homedir(), "Library", "Application Support", "Google", "Chrome"),
+    // Linux
+    join(homedir(), ".config", "google-chrome"),
+    join(homedir(), ".config", "chromium")
+  ];
+  for (const p of candidates) {
+    if (p && existsSync(p)) return p;
+  }
+  return null;
+}
+function getCdpPort(cdpUrl) {
+  try {
+    return parseInt(new URL(cdpUrl).port, 10) || 9222;
+  } catch {
+    return 9222;
+  }
+}
+function isChromeRunning() {
+  try {
+    if (process.platform === "win32") {
+      const out = execSync('tasklist /FI "IMAGENAME eq chrome.exe" /NH', {
+        encoding: "utf-8",
+        windowsHide: true
+      });
+      return out.includes("chrome.exe");
+    } else {
+      execSync('pgrep -x "chrome|chromium|google-chrome"', { encoding: "utf-8" });
+      return true;
+    }
+  } catch {
+    return false;
+  }
+}
+function syncProfile(sourceDir, targetDir) {
+  mkdirSync(targetDir, { recursive: true });
+  const entries = readdirSync(sourceDir, { withFileTypes: true });
+  for (const entry of entries) {
+    const src = join(sourceDir, entry.name);
+    const dst = join(targetDir, entry.name);
+    if (entry.isFile()) {
+      try {
+        cpSync(src, dst, { force: true });
+      } catch {
+      }
+    } else if (entry.isDirectory()) {
+      if (entry.name === "Default" || entry.name.startsWith("Profile ")) {
+        syncProfileDir(src, dst);
+      } else if (!SKIP_DIRS.has(entry.name)) {
+        try {
+          cpSync(src, dst, { recursive: true, force: true });
+        } catch {
+        }
+      }
+    }
+  }
+}
+function syncProfileDir(sourceDir, targetDir) {
+  mkdirSync(targetDir, { recursive: true });
+  let entries;
+  try {
+    entries = readdirSync(sourceDir, { withFileTypes: true });
+  } catch {
+    return;
+  }
+  for (const entry of entries) {
+    if (SKIP_DIRS.has(entry.name)) continue;
+    const src = join(sourceDir, entry.name);
+    const dst = join(targetDir, entry.name);
+    try {
+      if (entry.isFile()) {
+        cpSync(src, dst, { force: true });
+      } else if (entry.isDirectory()) {
+        cpSync(src, dst, { recursive: true, force: true });
+      }
+    } catch {
+    }
+  }
+}
 var BrowserClient = class {
   browser = null;
   context = null;
   _page = null;
   cdpUrl;
+  chromeProcess = null;
   constructor(cdpUrl) {
     this.cdpUrl = cdpUrl;
   }
   async connect() {
     if (this.browser) return;
     const { chromium } = await import("playwright");
-    this.browser = await chromium.connectOverCDP(this.cdpUrl);
+    try {
+      this.browser = await chromium.connectOverCDP(this.cdpUrl);
+    } catch {
+      await this.launchChrome();
+      this.browser = await chromium.connectOverCDP(this.cdpUrl);
+    }
     const contexts = this.browser.contexts();
     this.context = contexts[0] ?? await this.browser.newContext();
     const pages = this.context.pages();
     this._page = pages[0] ?? await this.context.newPage();
   }
+  async launchChrome() {
+    const chromePath = findChrome();
+    if (!chromePath) {
+      throw new Error(
+        "Chrome not found. Please install Chrome or start it manually with: chrome --remote-debugging-port=9222"
+      );
+    }
+    const port = getCdpPort(this.cdpUrl);
+    if (isChromeRunning()) {
+      console.error("[windows-use] Chrome is running without CDP. Restarting with --remote-debugging-port...");
+      try {
+        if (process.platform === "win32") {
+          execSync("taskkill /F /IM chrome.exe /T", { windowsHide: true, stdio: "ignore" });
+        } else {
+          execSync("pkill -f chrome", { stdio: "ignore" });
+        }
+      } catch {
+      }
+      await new Promise((r) => setTimeout(r, 1500));
+    }
+    const targetDir = join(homedir(), ".windows-use", "chrome-profile");
+    const userDir = findUserDataDir();
+    if (userDir) {
+      console.error("[windows-use] Syncing Chrome profile (cookies, login state)...");
+      syncProfile(userDir, targetDir);
+      console.error("[windows-use] Profile synced.");
+    } else {
+      mkdirSync(targetDir, { recursive: true });
+    }
+    console.error(`[windows-use] Launching Chrome with --remote-debugging-port=${port}`);
+    this.chromeProcess = spawn(
+      chromePath,
+      [
+        `--remote-debugging-port=${port}`,
+        `--user-data-dir=${targetDir}`
+      ],
+      { detached: true, stdio: "ignore" }
+    );
+    this.chromeProcess.unref();
+    for (let i = 0; i < 30; i++) {
+      try {
+        const res = await fetch(`http://localhost:${port}/json/version`);
+        if (res.ok) return;
+      } catch {
+      }
+      await new Promise((r) => setTimeout(r, 500));
+    }
+    throw new Error("Chrome launched but CDP endpoint did not become available within 15s");
+  }
   async getPage() {
     await this.connect();
     return this._page;
@@ -380,11 +594,69 @@ var ToolRegistry = class {
 
 // src/tools/windows/screenshot.ts
 import { z } from "zod";
+import sharp2 from "sharp";
+
+// src/tools/windows/grid-overlay.ts
+import sharp from "sharp";
+async function addCoordinateGrid(imageBuffer, width, height, options = {}) {
+  const gridSpacing = options.gridSpacing ?? 100;
+  const labelSpacing = options.labelSpacing ?? 200;
+  const majorSpacing = gridSpacing * 5;
+  const svgParts = [];
+  for (let x = gridSpacing; x < width; x += gridSpacing) {
+    const isMajor = x % majorSpacing === 0;
+    const opacity = isMajor ? 0.35 : 0.15;
+    const sw = isMajor ? 1.5 : 0.5;
+    svgParts.push(
+      `<line x1="${x}" y1="0" x2="${x}" y2="${height}" stroke="rgba(255,50,50,${opacity})" stroke-width="${sw}"/>`
+    );
+  }
+  for (let y = gridSpacing; y < height; y += gridSpacing) {
+    const isMajor = y % majorSpacing === 0;
+    const opacity = isMajor ? 0.35 : 0.15;
+    const sw = isMajor ? 1.5 : 0.5;
+    svgParts.push(
+      `<line x1="0" y1="${y}" x2="${width}" y2="${y}" stroke="rgba(255,50,50,${opacity})" stroke-width="${sw}"/>`
+    );
+  }
+  for (let x = labelSpacing; x < width; x += labelSpacing) {
+    const text = String(x);
+    const tw = text.length * 7.5 + 6;
+    svgParts.push(
+      `<rect x="${x - tw / 2}" y="2" width="${tw}" height="16" fill="rgba(0,0,0,0.65)" rx="3"/>`,
+      `<text x="${x}" y="14" text-anchor="middle" fill="#ff6666" font-size="11" font-family="Consolas,monospace" font-weight="bold">${text}</text>`
+    );
+  }
+  for (let y = labelSpacing; y < height; y += labelSpacing) {
+    const text = String(y);
+    const tw = text.length * 7.5 + 6;
+    svgParts.push(
+      `<rect x="2" y="${y - 8}" width="${tw}" height="16" fill="rgba(0,0,0,0.65)" rx="3"/>`,
+      `<text x="5" y="${y + 4}" fill="#ff6666" font-size="11" font-family="Consolas,monospace" font-weight="bold">${text}</text>`
+    );
+  }
+  svgParts.push(
+    `<rect x="2" y="2" width="22" height="16" fill="rgba(0,0,0,0.65)" rx="3"/>`,
+    `<text x="5" y="14" fill="#ff6666" font-size="11" font-family="Consolas,monospace" font-weight="bold">0,0</text>`
+  );
+  const dimText = `${width}x${height}`;
+  const dimTw = dimText.length * 7.5 + 6;
+  svgParts.push(
+    `<rect x="${width - dimTw - 2}" y="${height - 18}" width="${dimTw}" height="16" fill="rgba(0,0,0,0.65)" rx="3"/>`,
+    `<text x="${width - dimTw / 2 - 2}" y="${height - 6}" text-anchor="middle" fill="#ff6666" font-size="11" font-family="Consolas,monospace" font-weight="bold">${dimText}</text>`
+  );
+  const svg = Buffer.from(
+    `<svg width="${width}" height="${height}" xmlns="http://www.w3.org/2000/svg">${svgParts.join("")}</svg>`
+  );
+  return sharp(imageBuffer).composite([{ input: svg, top: 0, left: 0 }]).jpeg({ quality: 70 }).toBuffer();
+}
+
+// src/tools/windows/screenshot.ts
 var screenshotTool = {
   name: "screenshot",
-  description: "Capture the full screen and return it as an image. Use this to see what is currently displayed.",
+  description: "Capture the full screen with a coordinate grid overlay. The grid shows pixel coordinates that match mouse_click/mouse_move coordinates. Returns a screenshot ID.",
   parameters: z.object({}),
-  async execute() {
+  async execute(_args, ctx) {
     const { Monitor } = await import("node-screenshots");
     const monitors = Monitor.all();
     const primary = monitors.find((m) => m.isPrimary()) ?? monitors[0];
@@ -392,11 +664,24 @@ var screenshotTool = {
       return { type: "text", content: "Error: No monitor found" };
     }
     const image = primary.captureImageSync();
-    const buf = image.toPngSync();
+    const physW = image.width;
+    const physH = image.height;
+    const scaleFactor = primary.scaleFactor ?? 1;
+    const logicalW = Math.round(physW / scaleFactor);
+    const logicalH = Math.round(physH / scaleFactor);
+    const raw = image.toRawSync();
+    const resized = await sharp2(raw, {
+      raw: { width: physW, height: physH, channels: 4 }
+    }).resize(logicalW, logicalH).jpeg({ quality: 70 }).toBuffer();
+    const cleanBase64 = resized.toString("base64");
+    const id = ctx.screenshots.save(cleanBase64, "image/jpeg", "desktop");
+    const gridImage = await addCoordinateGrid(resized, logicalW, logicalH);
+    const gridBase64 = gridImage.toString("base64");
     return {
       type: "image",
-      base64: buf.toString("base64"),
-      mimeType: "image/png"
+      base64: gridBase64,
+      mimeType: "image/jpeg",
+      screenshotId: id
     };
   }
 };
@@ -631,13 +916,46 @@ var fileWriteTool = {
   }
 };
 
-// src/tools/browser/navigate.ts
+// src/tools/file/image.ts
 import { z as z7 } from "zod";
+import { readFileSync, existsSync as existsSync2 } from "fs";
+import { extname } from "path";
+var IMAGE_EXTS = /* @__PURE__ */ new Set([".png", ".jpg", ".jpeg", ".bmp", ".webp"]);
+var useLocalImageTool = {
+  name: "use_local_image",
+  description: "Load a local image file and get a screenshot ID for it. Use this to reference local images in your report via [Image:img_X].",
+  parameters: z7.object({
+    path: z7.string().describe("Absolute path to the image file"),
+    label: z7.string().default("local").describe('Label for the image (e.g. "chart", "photo")')
+  }),
+  async execute(args, ctx) {
+    if (!existsSync2(args.path)) {
+      return { type: "text", content: `Error: File not found: ${args.path}` };
+    }
+    const ext = extname(args.path).toLowerCase();
+    if (!IMAGE_EXTS.has(ext)) {
+      return { type: "text", content: `Error: Not a supported image format (${ext}). Supported: ${[...IMAGE_EXTS].join(", ")}` };
+    }
+    const buf = readFileSync(args.path);
+    const mimeType = ext === ".png" ? "image/png" : "image/jpeg";
+    const base64 = buf.toString("base64");
+    const id = ctx.screenshots.save(base64, mimeType, args.label);
+    return {
+      type: "image",
+      base64,
+      mimeType,
+      screenshotId: id
+    };
+  }
+};
+
+// src/tools/browser/navigate.ts
+import { z as z8 } from "zod";
 var browserNavigateTool = {
   name: "browser_navigate",
   description: "Navigate the browser to a URL.",
-  parameters: z7.object({
-    url: z7.string().describe("The URL to navigate to")
+  parameters: z8.object({
+    url: z8.string().describe("The URL to navigate to")
   }),
   async execute(args, ctx) {
     const browser = await ctx.getBrowser();
@@ -650,12 +968,12 @@ Page title: ${title}` };
 };
 
 // src/tools/browser/click.ts
-import { z as z8 } from "zod";
+import { z as z9 } from "zod";
 var browserClickTool = {
   name: "browser_click",
   description: "Click an element on the web page using a CSS selector or text content.",
-  parameters: z8.object({
-    selector: z8.string().describe('CSS selector or text to find the element (e.g., "button.submit", "text=Login")')
+  parameters: z9.object({
+    selector: z9.string().describe('CSS selector or text to find the element (e.g., "button.submit", "text=Login")')
   }),
   async execute(args, ctx) {
     const browser = await ctx.getBrowser();
@@ -666,14 +984,14 @@ var browserClickTool = {
 };
 
 // src/tools/browser/type.ts
-import { z as z9 } from "zod";
+import { z as z10 } from "zod";
 var browserTypeTool = {
   name: "browser_type",
   description: "Type text into an input field on the web page.",
-  parameters: z9.object({
-    selector: z9.string().describe("CSS selector for the input element"),
-    text: z9.string().describe("Text to type"),
-    clear: z9.boolean().default(true).describe("Whether to clear the field before typing")
+  parameters: z10.object({
+    selector: z10.string().describe("CSS selector for the input element"),
+    text: z10.string().describe("Text to type"),
+    clear: z10.boolean().default(true).describe("Whether to clear the field before typing")
   }),
   async execute(args, ctx) {
     const browser = await ctx.getBrowser();
@@ -688,35 +1006,40 @@ var browserTypeTool = {
 };
 
 // src/tools/browser/screenshot.ts
-import { z as z10 } from "zod";
+import { z as z11 } from "zod";
 var browserScreenshotTool = {
   name: "browser_screenshot",
-  description: "Take a screenshot of the current browser page.",
-  parameters: z10.object({
-    fullPage: z10.boolean().default(false).describe("Whether to capture the full scrollable page")
+  description: "Take a screenshot of the current browser page. Returns a screenshot ID (e.g. img_2) that you can reference later in report.",
+  parameters: z11.object({
+    fullPage: z11.boolean().default(false).describe("Whether to capture the full scrollable page")
   }),
   async execute(args, ctx) {
     const browser = await ctx.getBrowser();
     const page = await browser.getPage();
     const buf = await page.screenshot({
-      type: "png",
-      fullPage: args.fullPage
+      type: "jpeg",
+      quality: 70,
+      fullPage: args.fullPage,
+      scale: "css"
     });
+    const base64 = buf.toString("base64");
+    const id = ctx.screenshots.save(base64, "image/jpeg", "browser");
     return {
       type: "image",
-      base64: buf.toString("base64"),
-      mimeType: "image/png"
+      base64,
+      mimeType: "image/jpeg",
+      screenshotId: id
     };
   }
 };
 
 // src/tools/browser/content.ts
-import { z as z11 } from "zod";
+import { z as z12 } from "zod";
 var MAX_CONTENT_LENGTH = 2e4;
 var browserContentTool = {
   name: "browser_content",
   description: "Get the text content of the current web page. Returns visible text, not HTML.",
-  parameters: z11.object({}),
+  parameters: z12.object({}),
   async execute(_args, ctx) {
     const browser = await ctx.getBrowser();
     const page = await browser.getPage();
@@ -737,13 +1060,13 @@ ${text}`
 };
 
 // src/tools/browser/scroll.ts
-import { z as z12 } from "zod";
+import { z as z13 } from "zod";
 var browserScrollTool = {
   name: "browser_scroll",
   description: "Scroll the current web page.",
-  parameters: z12.object({
-    direction: z12.enum(["up", "down"]).describe("Scroll direction"),
-    amount: z12.number().positive().default(500).describe("Pixels to scroll")
+  parameters: z13.object({
+    direction: z13.enum(["up", "down"]).describe("Scroll direction"),
+    amount: z13.number().positive().default(500).describe("Pixels to scroll")
   }),
   async execute(args, ctx) {
     const browser = await ctx.getBrowser();
@@ -755,38 +1078,22 @@ var browserScrollTool = {
 };
 
 // src/tools/control/report.ts
-import { z as z13 } from "zod";
+import { z as z14 } from "zod";
 var reportTool = {
   name: "report",
-  description: "Report progress back to the caller. Call this when the task is completed, when you are blocked, or when you need guidance. Calling this STOPS your execution immediately.",
-  parameters: z13.object({
-    status: z13.enum(["completed", "blocked", "need_guidance"]).describe(
+  description: 'Report progress back to the caller. Call this when the task is completed, when you are blocked, or when you need guidance. Calling this STOPS your execution immediately.\n\nThe content field supports rich document format: mix text with screenshots using [Image:img_1] markers. Example:\n"Here is the current state:\n[Image:img_2]\nThe page shows..."',
+  parameters: z14.object({
+    status: z14.enum(["completed", "blocked", "need_guidance"]).describe(
       '"completed" = task done, "blocked" = cannot proceed, "need_guidance" = need a decision'
     ),
-    summary: z13.string().describe("Concise human-readable summary of what was accomplished or what the problem is"),
-    include_screenshot: z13.boolean().default(false).describe("Whether to capture and include a screenshot of the current state"),
-    data: z13.unknown().optional().describe("Optional structured data to return")
+    content: z14.string().describe('Rich report content. Use [Image:img_X] to embed screenshots captured earlier. Example: "Task done.\\n[Image:img_1]\\nThe page shows the result."'),
+    data: z14.unknown().optional().describe("Optional structured data to return")
   }),
   async execute(args) {
-    let screenshot;
-    if (args.include_screenshot) {
-      try {
-        const { Monitor } = await import("node-screenshots");
-        const monitors = Monitor.all();
-        const primary = monitors.find((m) => m.isPrimary()) ?? monitors[0];
-        if (primary) {
-          const image = primary.captureImageSync();
-          const buf = image.toPngSync();
-          screenshot = buf.toString("base64");
-        }
-      } catch {
-      }
-    }
     return {
       type: "report",
       status: args.status,
-      summary: args.summary,
-      screenshot,
+      content: args.content,
       data: args.data
     };
   }
@@ -804,6 +1111,7 @@ function createToolRegistry() {
   registry2.register(runCommandTool);
   registry2.register(fileReadTool);
   registry2.register(fileWriteTool);
+  registry2.register(useLocalImageTool);
   registry2.register(browserNavigateTool);
   registry2.register(browserClickTool);
   registry2.register(browserTypeTool);
@@ -814,21 +1122,70 @@ function createToolRegistry() {
   return registry2;
 }
 
+// src/tools/types.ts
+var ScreenshotStore = class {
+  counter = 0;
+  store = /* @__PURE__ */ new Map();
+  save(base64, mimeType, label) {
+    this.counter++;
+    const id = `img_${this.counter}`;
+    this.store.set(id, { id, base64, mimeType, label });
+    return id;
+  }
+  get(id) {
+    return this.store.get(id);
+  }
+  listIds() {
+    return [...this.store.keys()];
+  }
+};
+function parseReportContent(content, store) {
+  const blocks = [];
+  const regex = /\[Image:(img_\d+)\]/g;
+  let lastIndex = 0;
+  let match;
+  while ((match = regex.exec(content)) !== null) {
+    if (match.index > lastIndex) {
+      blocks.push({ type: "text", text: content.slice(lastIndex, match.index) });
+    }
+    const id = match[1];
+    const screenshot = store.get(id);
+    if (screenshot) {
+      blocks.push({
+        type: "image",
+        id: screenshot.id,
+        base64: screenshot.base64,
+        mimeType: screenshot.mimeType,
+        label: screenshot.label
+      });
+    } else {
+      blocks.push({ type: "text", text: match[0] });
+    }
+    lastIndex = regex.lastIndex;
+  }
+  if (lastIndex < content.length) {
+    blocks.push({ type: "text", text: content.slice(lastIndex) });
+  }
+  return blocks;
+}
+
 // src/mcp/session-registry.ts
 var SessionRegistry = class {
   sessions = /* @__PURE__ */ new Map();
   create(config) {
     const id = crypto.randomUUID();
-    const contextManager = new ContextManager(config.contextWindowSize);
+    const contextManager = new ContextManager();
     const llmClient = new LLMClient(config);
     const browserClient = new BrowserClient(config.cdpUrl);
     const toolRegistry = createToolRegistry();
+    const screenshotStore = new ScreenshotStore();
     const toolContext = {
       sessionId: id,
       cdpUrl: config.cdpUrl,
       getBrowser: () => {
         return browserClient.connect().then(() => browserClient);
-      }
+      },
+      screenshots: screenshotStore
     };
     const runner = new AgentRunner(
       llmClient,
@@ -848,6 +1205,7 @@ var SessionRegistry = class {
       config,
       runner,
       browserClient,
+      screenshots: screenshotStore,
       timeoutHandle
     };
     this.sessions.set(id, session);
@@ -882,30 +1240,45 @@ var SessionRegistry = class {
 };
 
 // src/mcp/tools.ts
-import { z as z15 } from "zod";
+import { z as z16 } from "zod";
+
+// src/config/loader.ts
+import { readFileSync as readFileSync2, existsSync as existsSync3 } from "fs";
+import { join as join2 } from "path";
+import { homedir as homedir2 } from "os";
 
 // src/config/schema.ts
-import { z as z14 } from "zod";
-var ConfigSchema = z14.object({
-  apiKey: z14.string().min(1, "API key is required"),
-  baseURL: z14.string().url("Must be a valid URL"),
-  model: z14.string().min(1, "Model name is required"),
-  maxSteps: z14.number().int().positive().default(50),
-  contextWindowSize: z14.number().int().positive().default(20),
-  cdpUrl: z14.string().default("http://localhost:9222"),
-  timeoutMs: z14.number().default(3e5)
+import { z as z15 } from "zod";
+var ConfigSchema = z15.object({
+  apiKey: z15.string().min(1, "API key is required"),
+  baseURL: z15.string().url("Must be a valid URL"),
+  model: z15.string().min(1, "Model name is required"),
+  maxSteps: z15.number().int().positive().default(50),
+  maxRounds: z15.number().int().positive().default(20),
+  cdpUrl: z15.string().default("http://localhost:9222"),
+  timeoutMs: z15.number().default(3e5)
 });
 
 // src/config/loader.ts
+var CONFIG_FILE = join2(homedir2(), ".windows-use.json");
+function loadFileConfig() {
+  if (!existsSync3(CONFIG_FILE)) return {};
+  try {
+    return JSON.parse(readFileSync2(CONFIG_FILE, "utf-8"));
+  } catch {
+    return {};
+  }
+}
 function loadConfig(overrides) {
+  const file = loadFileConfig();
   const raw = {
-    apiKey: overrides?.apiKey ?? process.env.WINDOWS_USE_API_KEY ?? "",
-    baseURL: overrides?.baseURL ?? process.env.WINDOWS_USE_BASE_URL ?? "",
-    model: overrides?.model ?? process.env.WINDOWS_USE_MODEL ?? "",
-    maxSteps: overrides?.maxSteps ?? intEnv("WINDOWS_USE_MAX_STEPS") ?? 50,
-    contextWindowSize: overrides?.contextWindowSize ?? intEnv("WINDOWS_USE_CONTEXT_WINDOW") ?? 20,
-    cdpUrl: overrides?.cdpUrl ?? process.env.WINDOWS_USE_CDP_URL ?? "http://localhost:9222",
-    timeoutMs: overrides?.timeoutMs ?? intEnv("WINDOWS_USE_TIMEOUT_MS") ?? 3e5
+    apiKey: overrides?.apiKey ?? process.env.WINDOWS_USE_API_KEY ?? file.apiKey ?? "",
+    baseURL: overrides?.baseURL ?? process.env.WINDOWS_USE_BASE_URL ?? file.baseURL ?? "",
+    model: overrides?.model ?? process.env.WINDOWS_USE_MODEL ?? file.model ?? "",
+    maxSteps: overrides?.maxSteps ?? intEnv("WINDOWS_USE_MAX_STEPS") ?? file.maxSteps ?? 50,
+    maxRounds: overrides?.maxRounds ?? intEnv("WINDOWS_USE_MAX_ROUNDS") ?? file.maxRounds ?? 20,
+    cdpUrl: overrides?.cdpUrl ?? process.env.WINDOWS_USE_CDP_URL ?? file.cdpUrl ?? "http://localhost:9222",
+    timeoutMs: overrides?.timeoutMs ?? intEnv("WINDOWS_USE_TIMEOUT_MS") ?? file.timeoutMs ?? 3e5
   };
   return ConfigSchema.parse(raw);
 }
@@ -922,12 +1295,13 @@ function registerMcpTools(server2, registry2) {
     "create_session",
     "Create a new automation session with a small LLM agent. Returns a session_id.",
     {
-      api_key: z15.string().optional().describe("LLM API key (or set WINDOWS_USE_API_KEY env)"),
-      base_url: z15.string().optional().describe("OpenAI-compatible base URL (or set WINDOWS_USE_BASE_URL env)"),
-      model: z15.string().optional().describe("Model name (or set WINDOWS_USE_MODEL env)"),
-      cdp_url: z15.string().optional().describe("Chrome CDP URL (default: http://localhost:9222)"),
-      timeout_ms: z15.number().optional().describe("Session inactivity timeout in ms (default: 300000)"),
-      max_steps: z15.number().optional().describe("Max tool-calling steps per instruction (default: 50)")
+      api_key: z16.string().optional().describe("LLM API key (or set WINDOWS_USE_API_KEY env)"),
+      base_url: z16.string().optional().describe("OpenAI-compatible base URL (or set WINDOWS_USE_BASE_URL env)"),
+      model: z16.string().optional().describe("Model name (or set WINDOWS_USE_MODEL env)"),
+      cdp_url: z16.string().optional().describe("Chrome CDP URL (default: http://localhost:9222)"),
+      timeout_ms: z16.number().optional().describe("Session inactivity timeout in ms (default: 300000)"),
+      max_steps: z16.number().optional().describe("Max tool-calling steps per instruction (default: 50)"),
+      max_rounds: z16.number().optional().describe("Max instruction rounds per session (default: 20)")
     },
     async (args) => {
       const config = loadConfig({
@@ -936,7 +1310,8 @@ function registerMcpTools(server2, registry2) {
         model: args.model,
         cdpUrl: args.cdp_url,
         timeoutMs: args.timeout_ms,
-        maxSteps: args.max_steps
+        maxSteps: args.max_steps,
+        maxRounds: args.max_rounds
       });
       const session = registry2.create(config);
       return {
@@ -951,10 +1326,10 @@ function registerMcpTools(server2, registry2) {
   );
   server2.tool(
     "send_instruction",
-    "Send a task instruction to the agent in a session. The agent executes it and returns a status report.",
+    "Send a task instruction to the agent in a session. The agent executes it and returns a rich report with text and images.",
     {
-      session_id: z15.string().describe("Session ID from create_session"),
-      instruction: z15.string().describe("What you want the agent to do, in natural language")
+      session_id: z16.string().describe("Session ID from create_session"),
+      instruction: z16.string().describe("What you want the agent to do, in natural language")
     },
     async (args) => {
       const session = registry2.get(args.session_id);
@@ -974,32 +1349,37 @@ function registerMcpTools(server2, registry2) {
       registry2.touch(args.session_id);
       const result = await session.runner.run(args.instruction);
       registry2.touch(args.session_id);
-      const content = [
-        {
-          type: "text",
-          text: JSON.stringify({
-            status: result.status,
-            summary: result.summary,
-            steps_used: result.stepsUsed,
-            ...result.data !== void 0 ? { data: result.data } : {}
-          })
+      const mcpContent = [];
+      mcpContent.push({
+        type: "text",
+        text: JSON.stringify({
+          status: result.status,
+          steps_used: result.stepsUsed,
+          round: session.runner.currentRound,
+          rounds_remaining: session.config.maxRounds - session.runner.currentRound,
+          ...result.data !== void 0 ? { data: result.data } : {}
+        })
+      });
+      const blocks = parseReportContent(result.content, session.screenshots);
+      for (const block of blocks) {
+        if (block.type === "text") {
+          mcpContent.push({ type: "text", text: block.text });
+        } else {
+          mcpContent.push({
+            type: "image",
+            data: block.base64,
+            mimeType: block.mimeType
+          });
         }
-      ];
-      if (result.screenshot) {
-        content.push({
-          type: "image",
-          data: result.screenshot,
-          mimeType: "image/png"
-        });
       }
-      return { content };
+      return { content: mcpContent };
     }
   );
   server2.tool(
     "done_session",
     "Terminate a session and free all resources.",
     {
-      session_id: z15.string().describe("Session ID to terminate")
+      session_id: z16.string().describe("Session ID to terminate")
     },
     async (args) => {
       await registry2.destroy(args.session_id);